We assume you are familiar with terms such as superimposed information, mark, and context.
The Superimposed Pluggable Architecture for Contexts and Excerpts (SPARCE) is a middleware-based approach for mark and context management. It is designed to be extensible in terms of supporting new base-layer types and context-elements, without adversely affecting existing superimposed applications.
Figure 1 shows the SPARCE reference model. The Mark Manager provides operations such as creating marks and storing them in a marks repository that it maintains. The Context Manager retrieves context information for a mark. Superimposed applications use the managers to create marks and access context (the managers in turn use base applications).
The Mark Manager supports three operations for marks: creation, retrieval,
and activation. Mark creation is the operation of generating a new mark
corresponding to a selection in a base layer. This operation consists of
three steps: generating the address of base information (and other
auxiliary information), using the information generated to create a mark
object, and storing the mark object in the mark repository. Details of
each mark, such as the address of the base document and the selection
inside it, are stored as an XML file. The mark repository is a database of
such XML files.
SPARCE uses mediators called context agents to retrieve context information for a mark from the base layer. A context agent interacts with a base application to retrieve context. The name of the context agent to use for each mark instance is one of the details stored in the mark repository. SPARCE uses this information to instantiate an appropriate context agent for a mark instance. A superimposed application receives a reference to the instance of context agent from SPARCE, and then works directly with the agent instance to retrieve context.
We have implemented marks and developed context agents for base types such as Microsoft Excel, PowerPoint and Word, PDF with Adobe Acrobat, HTML with Internet Explorer, XML, and a variety of audio/video file formats with the Microsoft Media Player. We have also developed add-ins for these applications to easily select sub-document regions and create marks.
A superimposed application is any application that incorporates marks in its information model. Superimposed application designers are free to choose any information model and user interface model based--they only need to include the ID (a string value) of each mark used in their information model. The application will need to initiate one or more of the operations on marks. It may retrieve none, some, or all of the context elements defined for marks. We have developed a couple of demonstrative superimposed applications.
Figure 2 shows the SPARCE class diagram. The parts in the red bubble represent a superimposed application and its information repository. The parts in the blue bubble represent the context agent implementations used to interact with base applications. The other parts represent SPARCE Proper. The SPARCE Manager class manages the mark repository. Superimposed applications use it to retrieve mark and context objects.
SPARCE is able to provide context information for three classes of objects: marks, containers, and applications (using the classes Mark, Container, and Application respectively). A Container is an abstraction for a base document (or a portion of that document). An Application is an abstraction for a base application. SPARCE also defines the interface Context-Aware Object to any base-layer element that supports context. The classes Mark, Container, and Application all implement this interface.
SPARCE treats context as a property set (a collection of name-value pairs). Context is the entire set of properties of a base-layer element and a context element is any one property. For example, the text excerpt and font name of a mark are context elements. Modelling context as a property set makes it possible to support a variety of contexts, both across and within base layers, without affecting existing superimposed applications.
SPARCE uses the interface Context Agent to achieve its extensibility goal. A class that implements this interface takes a context-aware object and returns its context. That is, SPARCE does not access base-layer elements or their contexts directly. It uses external agents to do so on its behalf. However, SPARCE is responsible for associating a context-aware object with an appropriate context agent. SPARCE Manager obtains the name of the class that will be the context agent for a mark from the description of the marks. It instantiates the context agent class by name whenever a superimposed application accesses the context of a context-aware object. Typically, there is one implementation of the context agent interface per base-layer type (but more than one implementation could be defined for a base type, and the same implementation could work wit multiple base types). For example, a PDF Agent is an implementation of this interface for use with PDF documents. A context agent implementation determines the constitution of context for its context-aware objects. SPARCE does not require an implementation to support particular context elements (nor does it prevent an implementation from defining any context element).
The extensibility property of SPARCE has been proven empirically. The implementation of SPARCE Proper has essentially remained unchanged since it was first implemented (we have extended it over time to meet different research goals). We have added new context agent implementations, and altered existing ones, and in each case we have not had to change (or even recompile for that matter) SPARCE Proper or the superimposed applications. Similarly, we have built new superimposed applications and altered existing ones, without having to change (or recompile) SPARCE proper or the context agents.
Page modified: 13 Sep 2006 10:05 AM