Some context: In 2004, Tim Berners-Lee mentioned a potential
RDF Clipboard as a user model which allowed copying resource descriptions between applications. Depending on the type of the copied resource, the target app would trigger appropriate actions. (See also the
ESW wiki and
Danny's blog for related links and discussion.)
I had a go at an "
RDF data cart" last year which allowed you to "1click"-shop resource descriptions while surfing a site. Before leaving, you could "check out" the collected resource descriptions. However, the functionality was limited to a single session, the resource pointers didn't use globally valid identifiers.
Then, a couple of months ago,
Ray Ozzie announced
Live Clipboard, which uses a neat trick to access the operating system's clipboard for Copy & Paste operations across web pages.
Last week, I finally found the time to combine the Live Clipboard trick with the stuff I'm currently working on: A Semantic Publishing Framework,
Embeddable RDF, and
SPARQL. If you haven't heard of the latter two: eRDF is a microformats-like way to embed
RDF triples in HTML, SPARQL is the W3C's protocol and query language for RDF repositories.
What I came up with so far is a
Web Clipboard that works similar to Live Clipboard (I'm actually thinking about making it fully compatible), with just a few differences:
- Web Clipboard uses a hidden single-line text input instead of a textarea which seemed to be a little bit easier to insert into the document structure, and it makes it work in Opera 8.5. The downside is that input fields don't allow multi-line content to be pasted (which is not needed by Web Clipboard, but will be necessary if I want to add Live Clipboard compatibility)
- Web Clipboard doesn't paste complete resource descriptions, but only pointers to those. This makes it possible to e.g. copy a resource from a simple list of person's names, and display full contact details after a paste operation. (See the demo for an example which does asynchronous calls to a SPARQL endpoint). This "pass by reference" enables things like distributed address books or calendars where changes at one place could be automatically updated in the other apps.
- Instead of XML, Web Clipboard uses a small JSON object which can simply be evaluated by JavaScript applications, or split with a basic regular expression. The pasted object contains 1) a resource identifier, and 2) an endpoint where information about the identified resource is available. The endpoint information consists of a URL and a list of specifications supported by the endpoint.
Complete
documentation is going to be up at the
clipboard site, but I'll first see if I can make things Live Clipboard-compatible (and I'll be travelling for the rest of the week). Here is a simple explanation how the current
SPARQL demo works:
Apart from adding a small javascript library and a CSS file to the page, I specified the clipboard namespace and a default endpoint to be used for any resource pointer embedded in the page (this is eRDF syntax):
<link rel="schema.webclip" href="http://webclip.web-semantics.org/ns/webclip#" />
<link rel="webclip.endpoint" href="http://www.sparqlets.org/clipboard/sparql" />
Then I embedded a sparqlet that generates the list of Planet RDF bloggers (this is done server-side). The important thing is that the HTML contains eRDF hooks like this:
<div id="agent0" class="-webclip-Res">
<span class="webclip-resID" title="_:bb1ed0e67fdb042619f2f20fdc479c3af_id2245787"></span>
<span class="foaf-name">Bob DuCharme</span>
<a rel="foaf-weblog" href="http://www.snee.com/bobdc.blog/">bobdc.blog by Bob DuCharme</a>
</div>
Ideally, the resource ID (
webclip:resID, here again in eRDF notation) is a URI or some other stable identifier. The queried endpoint, however, obviously couldn't find a URI for the rendered resource, so it only provided a bnode ID. This is ok for the SPARQL endpoint the clipboard uses, though. The "foaf:weblog" information could be used to further disambiguate the resource identifier, the demo doesn't use it, however.
(The nice thing about eRDF-encoded hooks is that the information can be read by any HTTP- and eRDF-enabled client, the clipboard functionality could be implemented without having to load the page in a browser.)
Now, when the page is displayed, an onload-handler instantiates a JavaScript Web Clipboard which automatically adds an icon for each resource identified by the "webclip:Res/webvlip:resID"-hooks.
When the icon is clicked, the resource pointer JSON object is created and can be copied to the system's clipboard. It currently looks like this (on a single line):
{
resID : "_:bb1ed0e67fdb042619f2f20fdc479c3af_id2245787",
endpoint: {
url: "http://www.sparqlets.org/clipboard/sparql",
specs: [
"http://www.w3.org/TR/rdf-sparql-protocol/",
"http://bob.pythonmac.org/archives/2005/12/05/remote-json-jsonp/"
]
}
}
We can see that the clipboard uses the default endpoint mentioned at the document level as the embedded hook didn't specify a resource-specific endpoint. We can also see that the endpoint supports two specs, namely the SPARQL protocol and JSONP.
When this JSON object is pasted to another clipboard section, the onpaste-handler can decide what to do. In the demo, any paste section will make an asynchronous
On-Demand-JavaScript call to the resource's SPARQL endpoint to retrieve a custom resource representation. The "Latest blog post" section uses a pre-defined callback, but this can be overwritten (as e.g. done by the "Resource Description" section which uses a custom function to display results).
I've added a
playground area to the clipboard site where you can create your own clipboard sections. Give it a try, it's not too complicated. You can even
bookmark them.
Here is an example JavaScript snippet that adds a clipboard section to a clipboard-enabled page with an 'id="resultCountSection"' HTML element:
window.clipboard.addSection({
id : "resultCountSection",
resIDVar : "myRes",
query : "SELECT ?knowee WHERE "+
"{"+
" ?myRes <http://xmlns.com/foaf/0.1/knows> ?knowee . "+
"}"+
" LIMIT 50",
callback : function(qr){
var rows=(qr.results["bindings"]) ? qr.results.bindings : [];
var result="The pasted resource seems to know "+
rows.length+" persons.";
/* update paste area */
this.item.innerHTML=result;
/* refresh clipboard */
window.clipboard.activate();
}
});
window.clipboard.activate();
Something like this is all that will be needed for the final clipboard. No microformats parsing or similar burdens (although you
could use the Web Clipboard to process microformats). The Clipboard's definition of an endpoint is rather open, too. An RSS file could be considered an endpoint as well as any other Web-accessible document or API.
