Annotator is a web annotation system. Loaded into a webpage, it provides the user with tools to annotate text (and other elements) in the page. For a simple demonstration, visit the demo page or download a tagged release of Annotator and open demo.html.
The Annotator project also has a simple but powerful plugin architecture. While the core annotator code does the bare minimum, it is easily extended with plugins that perform such tasks as:
- serialization: the
Storeplugin saves all your annotations to a REST API backend (see Storage wiki page for more and a link to a reference implementation) - authentication and authorization: the
AuthandPermissionsplugins allow you to decouple the storage of your annotations from the website on which the annotation happens. In practice, this means that users could edit pages across the web, with all their annotations being saved to one server. - prettification: the
Markdownplugin renders all annotation text as Markdown - tagging: the
Tagsplugin allows you to tag individual annotations
To use Annotator, it's easiest to download a packaged release. The most important files in these packages are annotator.min.js (or annotator-full.min.js), which contains the core Annotator code, and annotator.min.css, which contains all the CSS and embedded images for the annotator.
Annotator requires jQuery. The quickest way to get going with Annotator is to include the following in the <head> of your document (paths relative to the root of the unzipped download):
<script src='http://ajax.googleapis.com/ajax/libs/jquery/1.7/jquery.min.js'></script>
<script src='annotator.min.js'></script>
<link rel='stylesheet' href='annotator.min.css'>
You can then initialize Annotator for the whole document by including the following at the end of the <body> tag:
<script>
$(document.body).annotator()
</script>
See demo.html for an example how to load and interact with plugins.
As mentioned, Annotator has a simple but powerful plugin architecture. In order to write your own plugin, you need only add your plugin to the Annotator.Plugin object, ensuring that the first argument to the constructor is a DOM Element, and the second is an "options" object. Below is a simple Hello World plugin:
Annotator.Plugin.HelloWorld = (function() {
function HelloWorld(element, options) {
this.element = element;
this.options = options;
console.log("Hello World!");
}
HelloWorld.prototype.pluginInit = function() {
console.log("Initialized with annotator: ", this.annotator);
};
return HelloWorld;
})();
Other than the constructor, the only "special" method is pluginInit, which is called after the Annotator has constructed the plugin, and set pluginInstance.annotator to itself. In order to load this plugin into an existing annotator, you would call addPlugin("HelloWorld"). For example:
$(document.body).annotator()
.annotator('addPlugin', 'HelloWorld')
Look at the existing plugins to get a feel for how they work. The Markdown plugin is a good place to start.
Useful events are triggered on the Annotator element (passed to the constructor of the plugin):
| Callback name | Description |
|---|---|
annotationsLoaded(annotations) |
called when annotations are loaded into the DOM. Provides an array of all annotations. |
beforeAnnotationCreated(annotation) |
called immediately before an annotation is created. If you need to modify the annotation before it is saved to the server by the Store plugin, use this event. |
annotationCreated(annotation) |
called when the annotation is created. Used by the Store plugin to save new annotations. |
beforeAnnotationUpdated(annotation) |
as above, but just before an existing annotation is saved. |
annotationUpdated(annotation) |
as above, but for an existing annotation which has just been edited. |
annotationDeleted(annotation) |
called when the user deletes an annotation. |
annotationEditorShown(editor, annotation) |
called when the annotation editor is presented to the user. Allows a plugin to add extra form fields. See the Tags plugin for an example of its use. |
annotationEditorHidden(editor) |
called when the annotation editor is hidden, both when submitted and when editing is cancelled. |
annotationEditorSubmit(editor, annotation) |
called when the annotation editor is submitted. |
annotationViewerShown(viewer, annotations) |
called when the annotation viewer is displayed provides the annotations being displayed |
annotationViewerTextField(field, annotation) |
called when the text field displaying the annotation in the viewer is created |
See HACKING.markdown
The annotator project has a mailing list for developer discussion and community members can sometimes be found in the #annotator channel on freenode IRC.