Copyright © 2004 DERI®, All Rights Reserved. DERI liability, trademark, document use, and software licensing rules apply.
This deliverable describes the implementation of the editing and browsing tool as a part of an ontology management system. Based on the architecture designed in [1] it will be shown which functionalities have been realized and which components implement them.
The described tool has been realized in the shape of two java-based eclipse plug-ins: an instance explorer and a class explorer. Beyond the platform independence of Java and the wide spread of the eclipse environment also the ease of integration and reuse of those plug-ins motivated this decision.
The rational for having two distinct tools for editing ontology schemas and knowledge bases is the target of enhanced usability[2]. The development of two separate plug-ins implements this idea and turned out to increase clarity and flexibility of use.
New versions of the here described implementation are always available both as a source and a binary distribution. While the former is published through the OMWG module of the DERI CVS server (http://cvs.deri.at/cgi-bin/viewcvs.cgi/omwg/) the latter is provided in the shape of an Eclipse Sofware Update at (http://www.omwg.org/update/).
The remainder of this deliverable is structured as follows: In section 2 the funtionalities of the editing and browsing tool will be described. After that section 3 will address the components that realize these functionalities. Finally the deliverable will be concluded in section 4.
In this section the implemented functionalities of the editing and browsing tool are described. Therefore 2.1 shows how the tool allows ontologies to be edited before 2.2 addresses the browsing part of the implementation.
The implementation described in this deliverable allows for editing of ontologies. That is ontologies as well as their contents can be created, removed and modified. Based on the ontology model defined in [4] five of the eight there defined ontology parts can be processed so far. Therefore the following sections address the editing of Concepts, Relations, Functions, Instances and Axioms. Among others non functional properties are not realized yet. That's why they will not be mentioned in the subsequent parts, too.
A new concept can be created using the context menu in the tree view of the class explorer. After right clicking on an ontology node or a concept node the respective menu entry can be chosen. After entering a name for the resulting concept node the operation has to be confirmed by the return key.
An important part of concept definition is their placement in a hierarchy of concept. This determination of sub- and super concept relationships can be realized through drag and drop. That is, a concept that is dragged from its current position and dropped onto another concept gets assigned this other concept as its parent. Currently only this “moving” functionality is realized while the “copy” functionality – i.e. the assignment of a new super concept by keeping the existent super concepts - will be integrated into the next version.
A further way of concept definition is the assignment of attributes and their ranges. In the described tool this can be realized by right-clicking on a concept and choosing the respective entry in a context menu. A new sub node will be added to the concept node which can be given a name as it is known from the Windows Explorer.
Also the removal of concepts can be realized through the context menu. After choosing the appropriate menu entry the respective node and all its sub nodes will disappear.
The creation of relations resembles the concept creation. Either ontology or relation nodes can be right clicked to pop up the context menu.
The definition sub- and super relations is done through drag and drop. As in the case of concepts a “move” operation is performed – i.e. the former position in the hierarchy gets lost.
In order to assign parameters to relations respective sub nodes can be created through the context menu. Comparably to attributes a name can be given and confirmed.
As expected the removal of relations is performed through the context menu, as well. In doing so, all sub nodes will also get lost.
In the current implementation of the editing and browsing tool functions can be created and removed. The modification of their range attribute will be integrated into the next version.
Instances can be created by right clicking the concept to be instantiated and choosing the respective context menu item. In consequence a new node will appear in the instance explorer. The modification of attribute values is not supported so far.
The removal of instances resembles the way described above.
The creation and removal of axioms can already be performed by the current implementation. The modification of the logical expressions that the axioms are defined by will be allowed in the next version of the tool.
The browsing of ontologies as allowed by the here described tool is derived from the functionality of the Windows Explorer. That is – based on a combination of a tree view and a table view – the user can explore the hierarchy of an ontology on the one side and inspect the contents of nodes on the other side. By clicking the “+”/”-“symbols the user can recursively expand or collapse tree nodes and thus reveal or hide ancillary contents. Beyond this the content of the item selected in the tree view is displayed in the table view.
All elements that may appear in an ontology are represented by tree nodes and can be processed respectively. The distinction of the different kinds of ontology elements is realized through different symbols in front of the item's label (see Table 1 ).
Element |
Icon |
Ontologies |
|
Concepts, Instances |
|
Relations, Relation Instances |
|
Functions |
|
Axioms |
|
Attributes |
|
Parameters |
|
Table 1 Visual representation of ontology elements
In this section the components that realize the described functionalities are addressed. First the components visible to the user – namely the class explorer and the instance explorer are described. After that a closer look is taken at the underlying models, views and controllers.
As already mentioned the editing and browsing tool was realized in the shape of two eclipse plug-ins. In the current version they can be started through the eclipse “Window -> Show View” menu where they can be found in the “Ontologies” category. The final version shall be delivered as a customized workbench where the user doesn't even realize that he /she's using the Eclipse environment.
The two plug-ins can run concurrently on the one hand but also separately on the other hand. Whenever the first of the two is started a shared data model is created and will already be available whenever the second one is started, too.
As can be expected from the name the class explorer (see Figure 1 ) is responsible for the schema part of an ontology. Thus beneath the ontology root nodes it displays concepts and their attributes, relations and their parameters, functions and axioms. Respectively the context menu entries are adopted for the creation, modification and removal of these entities.
Figure 1 The Class Explorer plug-in
The instance explorer (see Figure 2 ) is the tool for processing the knowledge base of an ontology. Beneath the ontology root nodes it displays instances and their attribute values as well as relation instances and their parameter values. Also here the context menu entries are adapted to the available entities.
Figure 2 The Instance Explorer plug-in
Because the implementation of the editing and browsing tool sticks to the MVC design pattern [3] the subsequent description will be structured respectively.
The base model utilized in the editing and browsing tool is the set of ontologies currently available. From this, a model especially adopted for tree structures is derived. Because the class explorer and the instance explorer are responsible for different parts of ontologies this tree model has to be refined again - once for ontology schemas and once for knowledge bases.
Finally models for the table views of the class explorer and the instance explorer are required. Because the table view always displays the contents of the item selected in the tree view, these are acquired from the selection of the respective tree views.
The hierarchical relations between the model classes are illustrated in Figure 3 .
Figure 3 Hierarchical position of model classes (red indicates newly created classes)
As already mentioned the editing and browsing tool utilizes a tree view and a table view (see Figure 4 ). Because the models to be displayed are adopted as shown in the last section, no specializations of these two views are necessary. That is, the class explorer as well as the instance explorer uses the same classes for the visualization tasks.
Figure 4 Hierarchical position of view classes (red indicates newly created classes)
Controller objects are the ones that allow for the manipulation of the model. In the case of the editing and browsing tool this manipulation is done through context menus and via drag and drop.
The integration of the context menus is based on predefined classes and interfaces in the eclipse action package (org.eclipse.jface.action). Interfaces like the IMenuListener (gets informed when a menu is about to show) have been implemented and classes like the MenuManager (realizes itself and its items in a menu control) have been instantiated.
The drag and drop functionality utilizes the org.eclipse.swt.dnd package. A drag source adaptor, a transfer object and a drop target adaptor (see Figure 5 ) realize the change of the data model upon the respective mouse operations. Because of the MVC structure the view is updated automatically.
Figure 5 Classes that realize the drag & drop functionality
This document described the implementation of the editing and browsing tool supposed to be part of an ontology management system. As the tool has the status of a first prototype it was described which functionalities have been realized by now and which ones will be added in subsequent versions.
The work is funded by the European Commission under the projects DIP, Knowledge Web, Ontoweb, SEKT, SWWS, Esperonto and h-TechSight; by Science Foundation Ireland under the DERI-Lion project; and by the Vienna city government under the CoOperate programme.
The authors would like to thank to all the members of the OMWG working group for their advices and inputs to this document.
[1] Henke, Jan (2004): OMWG D8.2v0.2: Design of an Editing and Browsing tool
[2] Nielsen, Jakob (1993): Usability Engineering. Morgan Kaufmann - An imprint of Academic Press
[3] Reenskaug, Trygve (1979): Models - Views - Controllers
[4] Roman, Dumitru et. al. (2004): D2v1.1. Web Service Modeling Ontology (WSMO)
$Date: 2004/12/12 14:23:13 $
