2 Funzionalità

Ontology Explorer - Documentazione
DOCUMENTAZIONE
ONTOLOGY EXPLORER
Pagina 1 di 37
Ontology Explorer - Documentazione
Indice
1 INTRODUZIONE
4
1.1 FINALITÀ
4
2 FUNZIONALITÀ
5
2.1 CARICAMENTO DI ONTOLOGIE ON-LINE
2.2 CONFIGURAZIONE E PARAMETRIZZAZIONE DELL’ONTOLOGY EXPLORER
2.3 FUNZIONALITÀ DI NAVIGAZIONE TRAMITE ALBERO DINAMICO
2.4 FUNZIONE DI RICERCA SMART
2.5 VISUALIZZAZIONE DELLE INFORMAZIONI
2.6 CARICAMENTO DI ONTOLOGIE ATTRAVERSO IL PASSAGGIO DI PARAMETRI DA URI
5
5
6
6
6
7
3 ARCHITETTURA
8
3.1 CLIENT-SIDE E SERVER-SIDE
3.1.1 IL PROCESSO DELLE INFORMAZIONI ALL’INTERNO DELL’ARCHITETTURA
3.1.2 STRUTTURA DEL SERVIZIO
3.1.3 FUNZIONAMENTO DEL SERVIZIO
3.2 I WRAPPER
3.2.1 OWLWRAPPER
3.2.2 OWLCLASSWRAPPER
3.2.3 OWLINSTANCEWRAPPER
3.2.4 OWLTAXONOMYWRAPPER
3.3 I CSS
8
8
8
12
14
15
16
16
16
17
4 WIDGET
19
4.1 WIDGET DI BASE
4.1.1 COMPONENTI DI INPUT
4.1.2 COMPONENTI DI VISUALIZZAZIONE
4.1.3 COMPONENTI DI LAYOUT (UTILI ALLA DISPOSIZIONE DI ALTRI WIDGET)
4.2 WIDGET SVILUPPATI
4.2.1 OPTIONBOX
4.2.2 TAXONOMYSEARCH
4.2.3 TAXONOMYTREE
4.2.4 OWLINSTANCEDISCLOSUREPANEL
4.2.5 ONTOLOGYINFOPANEL
19
19
20
21
22
22
24
25
26
28
5 PROGETTO ECLIPSE ED ORGANIZZAZIONE DEL CODICE
29
5.1 PACKAGE JAVA
5.1.1 GWT-OWLWRAPPER
5.1.2 ONTOLOGYEXPLORER
29
29
31
Pagina 2 di 37
Ontology Explorer - Documentazione
5.1.3 SEMANTICWIDGETS
5.2 LIBRERIE
5.2.1 GWT-OWLWRAPPERS
5.2.2 ONTOLOGYEXPLORER
5.2.3 SEMANTICWIDGETS
5.3 ANT FILE
5.3.1 GWT-OWLWRAPPERS
5.3.2 ONTOLOGYEXPLORER
5.3.3 SEMANTICWIDGETS
32
32
33
33
33
34
34
34
34
6 SCREENSHOT
35
Pagina 3 di 37
Ontology Explorer - Documentazione
1 Introduzione
1.1 Finalità
L’Ontology Explorer è un software on-line ideato e sviluppato per la
consultazione e la navigazione di ontologie.
Questo strumento può essere sfruttato da un ampio target di utenti, ma in
particolar modo si rivolge ad esperti di dominio (domain expert). Questi
soggetti possiedono ottime conoscenze riguardo ai concetti inerenti il dominio
di loro competenza, ma non hanno alcuna conoscenza riguardo alla struttura
ed alle caratteristiche dell’ontologia che li vuole rappresentare.
L’Ontology Explorer è stato testato sull’ontologia di Moda-ML1.
L’Ontology Explorer vuole evolversi rispetto ai tool già esistenti sul web
soprattutto in particolari aspetti, quali la semplicità nell’utilizzo da parte
dell’utente (anche quello meno esperto), la configurabilità di visualizzazione e
navigazione, la dinamicità dei componenti e l’alto livello d’interattività. Per
render ciò possibile, questo tool è stato implementato sfruttando tecnologie
quali AJAX2 e GWT3.
Il progetto relativo all’Ontology Explorer è stato implementato (e viene tuttora
sviluppato) in codice Java all’interno dell’ambiente Eclipse, utilizzando, per
compatibilità con GWT e Googlipse, Java 1.3.
1Moda-ML:
Middleware tOols and Documents to enhAnce the textile/clothing supply chain through xML.
Iniziativa, derivata dall’omonimo progetto europeo, con l’obiettivo di mettere a disposizione delle aziende del
settore del Tessile Abbigliamento alcuni servizi, quali un vocabolario di termini comuni ed un insieme di tipi
di documenti XML predefiniti, che possano rendere più agevole la circolazione ed il passaggio di
informazioni tecniche e gestionali ad ogni livello dell’organizzazione.
2Ajax:
Asynchronous Javascript And Xml. Insieme di tecnologie che permette una diversa ed innovativa
interazione tra client e server; la presenza di un motore Ajax, quale intermediario, rende infatti possibile che
l’interazione avvenga in modo asincrono.
3GWT:
Google Web Toolkit. Toolkit open source fornito da Google che dà al programmatore la possibilità di
implementare applicazioni Ajax scrivendo e debuggando semplice codice Java così da evitare le difficoltà
facilmente riscontrabili nella programmazione di puro codice JavaScript.
Pagina 4 di 37
Ontology Explorer - Documentazione
2 Funzionalità
L’Ontology Explorer viene tipicamente utilizzato per poter navigare, in modo
completo ed approfondito ontologie OWL presenti sul Web.
2.1 Caricamento di ontologie on-line
L’utente che andrà ad utilizzare questo tool avrà la possibilità di caricare su di
esso ogni ontologia che gli interessi, semplicemente passandogli l’URI ad essa
associato, ad unica condizione che questa ontologia sia accessibile on-line.
Inoltre, tramite un menu, l’utente potrà scegliere alcune ontologie di default, il
cui indirizzo è già memorizzato all’interno del tool.
2.2 Configurazione e parametrizzazione
dell’Ontology Explorer
La parametrizzazione dell’Ontology Explorer è gestita direttamente attraverso
l’interazione con la sua interfaccia, la quale mette a disposizione un pop-up,
grazie al quale l’utente può esprimere le proprie preferenze di configurazione.
I parametri messi a disposizione dell’utente sono diversi e ricoprono varie aree
concettuali del tool.
Opzioni generali:
 Mostrare (o non mostrare) le istanze durante la navigazione
 Mostrare (o non mostrare) i tool tip rappresentanti le descrizioni dei vari
oggetti esistenti
Opzioni di visualizzazione:
 Rappresentare gli elementi dell’ontologia attraverso i loro nomi
 Rappresentare gli elementi dell’ontologia attraverso le loro label
Opzioni di ricerca:
 Effettuare la ricerca in modalità “Start with” (default)
 Effettuare la ricerca in modalità “Contains” (slow)
 Utilizzo dei prefissi nella ricerca
Opzioni relative al pannello di visualizzazione delle informazioni:
 Rappresentare le istanze di una classe attraverso i loro nomi
 Rappresentare le istanze di una classe attraverso le loro label
 Ordinare alfabeticamente le istanze
 Ordinare alfabeticamente le proprietà
Pagina 5 di 37
Ontology Explorer - Documentazione
2.3 Funzionalità di navigazione tramite albero
dinamico
Volendo mettere a disposizione dell’utente una navigazione completa
dell’ontologia, si è deciso di progettare questo tool in modo tale che esso
presenti, come elemento principale di navigazione, una struttura ad albero,
dinamica, parametrizzabile ed interattiva, rappresentante l’intera tassonomia
o, nel caso ve ne fossero più di una collegate tra loro, l’insieme di queste.
L’Ontology Explorer è stato pensato per dare all’utente la possibilità di
visualizzare dati, caratteristiche e proprietà di ogni classe e istanza presente
all’interno dell’ontologia. L’utente potrà accedere a qualsiasi informazione
semplicemente cliccando sull’elemento corrispondente all’interno della struttura
ad albero; questo farà sì che il tool apra la visualizzazione delle informazioni
riguardanti classi e istanze e che, in tal modo, la navigazione dell’ontologia
continui anche attraverso i collegamenti che saranno presenti all’interno di
questa visualizzazione.
2.4 Funzione di ricerca smart
Allo scopo di aiutare l’utente finale nella navigazione, si è pensato di dotare il
tool di uno strumento di ricerca, così da rendere possibile un più facile
reperimento delle informazioni desiderate. Per questo, l’interfaccia è dotata di
una casella di ricerca smart, ovvero una semplice casella di testo che, al
momento della digitazione, mostra un menu a tendina dove vengono elencati
tutti e solo gli elementi (classi ed istanze) presenti all’interno dell’ontologia che
soddisfano il criterio di ricerca attuale (per esempio la stringa iniziale); questo
permette all’utilizzatore di poter ricercare, all’interno di tassonomie a lui
sconosciute, se esistono elementi di suo interesse, senza correre il rischio di
perdere tempo in inutili ricerche lungo tutta la lunghezza dell’albero.
2.5 Visualizzazione delle informazioni
Infine si è valutata la visualizzazione dei dati relativi alle varie entità presenti
nell’ontologia. L’interfaccia offre una visualizzazione a schede sfruttando la
struttura a tab fornita da GWT; questa permette all’utente di avere a portata di
mano, nello stesso momento, le informazioni relative a più entità, e di gestire
tali informazioni in modo ordinato ed intuitivo (proprio grazie alla particolare
configurazione a schede).
Pagina 6 di 37
Ontology Explorer - Documentazione
2.6 Caricamento di ontologie attraverso il passaggio
di parametri da URI
Oltre alle funzionalità appena presentate, si è deciso di permettere all’Ontology
Explorer di interpretare eventuali parametri passatigli attraverso l’URI. Questo
per poter avere, all’interno di un particolare sito web, un link diretto ad un
determinato concetto appartenente ad una specifica ontologia . In tal modo,
l’utente interessato ad avere informazioni su di un concetto, piuttosto che
aprire l’Ontology Explorer, caricare l’ontologia e cercare il concetto di suo
interesse, potrà semplicemente cliccare su di uno specifico link, il quale,
attraverso il passaggio di opportuni parametri, aprirà l’Ontology Explorer con
l’ontologia necessaria già caricata e la visualizzazione di questa già puntata sul
concetto desiderato.
I parametri appena citati sono:
 ontologyUrl: al quale deve essere assegnato un indirizzo valido relativo
ad un ontologia OWL presente on-line
 concept: al quale deve essere associato un ID OWL valido di un concetto
esistente all’interno dell’ontologia caricata
Per maggior precisione viene qui di seguito mostrato il codice relativo alla
lettura dei parametri:
private boolean readParameters() {
boolean foundParameters = false;
Location location = WindowUtils.getLocation();
String conceptID =location.getParameter(CONCEPT_PARAMETER_NAME);
String ontologyUrl = location.getParameter(ONTOLOGY_URL_PARAMETER_NAME);
String url = location.getPath();
System.out.println("path=" + url);
System.out.println("ontologyUrl=" + ontologyUrl);
System.out.println("concept=" + conceptID);
if (ontologyUrl!="" && ontologyUrl!=null){
currentOntologyURL = ontologyUrl;
foundParameters = true;
if (conceptID!="" && conceptID!=null){
currentConcept = conceptID;
foundParameters = true;
}
}
System.out.println("FoundParameters=" + foundParameters);
return foundParameters;
}
Pagina 7 di 37
Ontology Explorer - Documentazione
3 Architettura
3.1 Client-side e Server-side
GWT fa già una sua suddivisione tra client-side e server-side. Più
precisamente, all’interno della parte server, rappresentata da un GWT Service,
vi è la struttura base dell’applicazione; questa si occupa della ricezione delle
richieste di informazioni effettuate dal client, del reperimento di tali
informazioni e della loro restituzione, tramite Remote Procedure Call (RPC), in
un formato adatto alla compilazione in JavaScript. Per quanto riguarda la parte
client, invece, al suo interno vi risiede l’insieme delle applicazioni che
gestiscono le informazioni ed è qui che vengono sfruttate le proprietà di AJAX,
in particolare grazie ai widget forniti da GWT.
3.1.1 Il processo delle informazioni all’interno dell’architettura
L’architettura dell’Ontology Explorer stabilisce un determinato processo delle
informazioni al suo interno. Prendendo per esempio il caricamento di
un’ontologia, i vari passi di questo procedimento sono:




l’utente, dal client, attraverso i widget componenti l’interfaccia, fa la
richiesta di informazioni sull’ontologia al server;
il server, una volta ricevuta la richiesta, utilizza le Protégé OWL-API per
interrogare l’ontologia e riempie i wrapper necessari con i dati ottenuti;
l’applicazione invia queste strutture dati, denominate wrapper, dal server
al client tramite l’utilizzo di Remote Procedure Call (RPC);
il client, ricevuti i wrapper, analizza i dati e li visualizza a video nel modo
corretto attraverso i CSS.
Il processo appena descritto è quello che avviene ad ogni richiesta di
informazioni effettuata da parte dell’utente.
3.1.2 Struttura del servizio
Il ruolo del GWT Service risulta di fondamentale importanza all’interno
dell’architettura dell’Ontology Explorer. Questo può anche essere visto come il
cuore della struttura del tool. Questo servizio, basato su di una particolare
architettura servlet (non HttpServlet ma RemoteServiceServlet, che ne è una
estensione Java), è utile alla gestione di tutte le informazioni passanti per
l’Ontology Explorer. Il servizio rimane in attesa di richieste effettuate dal client
per poi elaborare le informazioni utili ad inviare una risposta. Queste
informazioni sono ottenute navigando e interrogando l’ontologia tramite le
Protégé OWL-API.
Pagina 8 di 37
Ontology Explorer - Documentazione
Una volta ricavati i dati ottenuti, il servizio procede poi all’impacchettamento di
questi all’interno dei wrapper e all’invio alla parte client che potrà quindi
procedere alla compilazione in JavaScript.
L’OntologyService, il servizio GWT implementato all’interno dell’Ontology
Explorer, è composto da tre particolari interfacce Java, di cui le prime due
utilizzate lato client e la terza lato server:



OWLOntoService;
OWLOntoServiceAsync;
OWLOntoServiceImpl.
L’OWLOntoService è l’interfaccia usata dal client che imposta i principali metodi
utili al servizio durante la gestione delle informazioni. Tra questi metodi vi
sono:

loadOntologyFromURL, utile al caricamento di un ontologia attraverso il
settaggio di un url;
public void loadOntologyFromURL(String url) throws Exception;

getTaxonomy, utile a reperire le informazioni relative alla tassonomia;
public OWLTaxonomy getTaxonomy(String rootClassName);

getInstancesOfClass, utile a reperire tutti i wrapper delle istanze relative
ad una determinata classe;
public Collection getInstancesOfClass(String owlClassName);

getTaxonomyWrapper, utile a reperire il wrapper contenente le
informazioni relative alla tassonomia;
public OWLTaxonomyWrapper getTaxonomyWrapper(String rootClassName);

getInstanceWrapper, utile a reperire il wrapper contenente le
informazioni di una determinata istanza;
public OWLInstanceWrapper getInstanceWrapper(String instanceName);

getClassWrapper, utile a reperire il wrapper contenente le informazioni di
una determinata classe;
public OWLClassWrapper getClassWrapper(String className);
Pagina 9 di 37
Ontology Explorer - Documentazione

getDataTypePropWrapper, utile a reperire il wrapper contenente le
informazioni di una determinata Datatype Property relativa ad una
classe;
public OWLClassDTPWrapper getDataTypePropWrapper(String dataTypePropName);

getObjectPropWrapper, utile a reperire il wrapper contenente le
informazioni di una determinata Object Property relativa ad una classe;
public OWLClassOPWrapper getObjectPropWrapper(String objectPropName);

getInstanseDataTypePropWrapper, utile a reperire il wrapper contenente
le informazioni di una determinata Datatype Property relativa ad
un’istanza;
public OWLInstanceDTPWrapper getInstanceDataTypePropWrapper
(String instanceName, String dataTypePropName);

getInstanceObjectPropWrapper, utile a reperire il wrapper contenente le
informazioni di una determinata Object Property relativa ad un’istanza;
public OWLInstanceOPWrapper getInstanceObjectPropWrapper
(String instanceName, String objectPropName);
L’OWLOntoServiceAsync non è altro che un’interfaccia identica a quella appena
descritta, dotata degli stessi metodi, con l’unica fondamentale particolarità di
rendere ognuno di questi metodi capace di supportare le chiamate asincrone
derivate dall’utilizzo di tecnologie AJAX.
Gli stessi metodi sopra citati vengono quindi presentati anche in questa
interfaccia, ma con l’aggiunta del gestore delle chiamate asincrone, per
esempio:
public void loadOntologyFromURL(String url, AsyncCallback callback);
public void getTaxonomyWrapper(String rootClassName, AsyncCallback callback);
public void getInstanceWrapper(String instanceName, AsyncCallback callback);
public void getClassWrapper(String className, AsyncCallback callback);
public void getDataTypePropWrapper(String dataTypePropName,
AsyncCallback callback);
public void getObjectPropWrapper(String objectPropName, AsyncCallback callback);
public void getInstanceDataTypePropWrapper(String instanceName,
String dataTypePropName, AsyncCallback callback);
public void getInstanceObjectPropWrapper(String instanceName,
String objectPropName, AsyncCallback callback);
Pagina 10 di 37
Ontology Explorer - Documentazione
AsyncCallBack è l’interfaccia principale che un chiamante deve implementare
per poter ricevere una risposta da una Remote Procedure Call. Se una RPC ha
successo, allora verranno eseguite le operazioni stabilite da onSuccess(Object),
in caso contrario, invece, verranno eseguite le operazioni relative ad
onFailure(Throwable).
Infine, l’OWLOntoServiceImpl consiste nella vera e propria implementazione
dei metodi presentati all’interno delle interfacce Java appena descritte.
All’interno di questi il servizio sfrutta l’OWLModel delle Protégé OWLAPI per
poter interrogare l’ontologia e costruisce così gli insiemi delle informazioni poi
utili per rispondere alle richieste del client.
Per mostrare un esempio semplice e chiaro al tempo stesso, si può vedere qui
di seguito come viene implementato il metodo getClassWrapper:
public OWLClassWrapper getClassWrapper(String className) {
OWLClassWrapper classWrapper = new OWLClassWrapper();
classWrapper = WrapOWLClass(OWL_model.getOWLNamedClass(className));
return classWrapper;
}
Questo metodo crea un nuovo wrapper, il quale viene poi riempito attraverso
la chiamata di un metodo statico interno alla classe (WrapOWLClass) che
consiste in:
public static OWLClassWrapper WrapOWLClass(OWLNamedClass owlClass){
OWLClassWrapper classWrapper = new OWLClassWrapper();
classWrapper.setName(owlClass.getName());
if(!owlClass.getLabels().isEmpty())
classWrapper.setLabel(
owlClass.getLabels().iterator().next().toString());
if(!owlClass.getComments().isEmpty())
classWrapper.setDescription(
owlClass.getComments().iterator().next().toString());
Iterator classIte = owlClass.getNamedSuperclasses(false).iterator();
while (classIte.hasNext()) {
classWrapper.addSuperclasses(((OWLNamedClass)classIte.next()).getName());
}
…
…
…
return classWrapper;
}
WrapOWLClass, come si può vedere, dopo aver creato l’istanza di un nuovo
wrapper, attribuisce a questo le informazioni ricavate dall’interrogazione delle
API e lo fa utilizzando i metodi setName, setLabel, setDescription e
addSuperclasses.
Pagina 11 di 37
Ontology Explorer - Documentazione
Un altro metodo utile alla comprensione del contesto è getTaxonomyWrapper:
public OWLTaxonomyWrapper getTaxonomyWrapper(String rootClassName){
TaxonomyClassNode rootClassNode = null;
OWLNamedClass OWLRootClass = null;
OWLRootClass = OWL_model.getOWLNamedClass(rootClassName);
OWLTaxonomyWrapper taxonomy = null;
if (OWLRootClass!=null) {
rootClassNode = getTaxonomyNodesTree(rootClassName);
taxonomy = new OWLTaxonomyWrapper(rootClassNode);
}
return taxonomy;
}
Questo metodo mostra il processo di creazione dell’OWLTaxonomyWrapper.
Questo consiste nell’interrogazione delle Protégé OWL-API, così da trovare
l’elemento radice dell’ontologia, il quale sarà poi, non solo il cuore del wrapper,
ma il punto di partenza per il raggiungimento di tutte le informazioni relative
all’ontologia.
3.1.3 Funzionamento del servizio
Per quanto concerne il funzionamento del servizio, va innanzi tutto detto che
questo deve essere inizializzato dal client. Questa operazione consiste
sostanzialmente nel metodo initializeServiceEntryPoint:
private final OWLOntoServiceAsync initiailizeServiceEntryPoint() {
OWLOntoServiceAsync ontoService =
(OWLOntoServiceAsync) GWT.create(OWLOntoService.class);
ServiceDefTarget target = (ServiceDefTarget) ontoService;
String staticResponseURL = GWT.getModuleBaseURL();
staticResponseURL += "owlOntoService";
target.setServiceEntryPoint(staticResponseURL);
return ontoService;
}
Questo metodo crea un particolare oggetto OWLOntoServiceAsync
(ontoService) attraverso il metodo statico GWT.create poi, tramite un altro
metodo statico (GWT.getModuleBaseURL), ottiene l’url del modulo necessario a
stabilire i punti di entrata per i file RPC presenti all’interno del percorso
pubblico.
Una volta che il servizio è stato correttamente inizializzato ed impostato, il
client può richiamarlo attraverso l’oggetto creato (ontoService) per effettuare
le richieste di cui ha bisogno. Alcuni esempi di queste chiamate possono
essere:
ontoService.loadOntologyFromURL(textBox.getText(), new
OntoService_LoadCallBack());
Pagina 12 di 37
Ontology Explorer - Documentazione
oppure
ontoService.getTaxonomyWrapper("owl:Thing", new
OntoService_GetTaxonomyCallBack());
Come si può notare, i metodi utilizzati richiamano anche le chiamate asincrone
supportate dall’interfaccia OWLOntoServiceAsync. Queste chiamate, come già
anticipato in precedenza, prevedono due evenienze:


onSuccess(Object), in caso di successo della chiamata;
onFailure(Throwable), in caso di fallimento della chiamata.
Esempi significativi di implementazione di questa interfaccia possono essere:

OntoService_LoadCallBack che mostra, in caso di fallimento, la gestione
degli errori, mentre, in caso di successo, la visualizzazione di un
messaggio di conferma rivolto all’utente e l’invio di una chiamata al
server per ottenere le informazioni sulla tassonomia appena caricata.
private class OntoService_LoadCallBack implements AsyncCallback {
public void onFailure(Throwable caught) {
try {
throw caught;
} catch (InvocationException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
} catch (Throwable e) {
// last resort -- a very unexpected exception
}
loadPanel.remove(loadLabel);
loadPanel.add(reloadButton);
}
public void onSuccess(Object result) {
ontoLabel.setText("Stai navigando l’ontologia:
"+textBox.getText());
ontoService.getTaxonomyWrapper("owl:Thing",
new OntoService_GetTaxonomyCallBack());
loadPanel.remove(loadLabel);
loadPanel.add(reloadButton);
}
}
Pagina 13 di 37
Ontology Explorer - Documentazione

OntoService_GetTaxonomyCallBack che mostra, in caso di fallimento, la
sua gestione degli errori, mentre, in caso di successo, il richiamo dei
metodi utili a costruire i widget basati sulla tassonomia caricata, quali il
TaxonomyTree (tree) ed il TaxonomySearch (autoBox).
private class OntoService_GetTaxonomyCallBack implements AsyncCallback {
public void onFailure(Throwable caught) {
try {
throw caught;
} catch (InvocationException e) {
// the call didn’t complete cleanly
} catch (Throwable e) {
// last resort -- a very unexpected exception
}
}
public void onSuccess(Object result) {
OWLTaxonomyWrapper taxonomy = (OWLTaxonomyWrapper)result;
tree.setTaxonomyAndShowIstances(taxonomy, withInstance);
createList(taxonomy);
orderList(list);
autoBox.setCompletionItems(new SimpleAutoCompletionItems(list));
}
}
3.2 I wrapper
Per poter implementare applicazioni AJAX con GWT, è indispensabile passare
informazioni dal server al client e queste informazioni devono poter essere
compilate come JavaScript. Per poter essere compilate come JavaScript,
queste informazioni devono essere contenute in classi Java implementanti
isSerializable, ovvero la serializzazione di GWT (e non la normale
serializzazione di Java). L’Ontology Explorer, ricavando le informazioni relative
alle ontologie attraverso le Protégé OWL-API, non aveva modo di passare tali
informazioni dal server al client in modo corretto, cioè da permettere la
serializzazione e la conseguente compilazione in JavaScript, perciò si è pensato
all’utilizzo di particolari classi implementanti isSerializable, utili unicamente al
passaggio delle informazioni, capaci di essere compilate come JavaScript e da
questo sono stati implementati i wrapper. Questi wrapper, paragonabili ad una
sorta di pacchetto, possono contenere i dati dell’ontologia, quelli di una classe
o di un’istanza e vengono richiamati e spediti al client ogni volta che l’utente fa
una richiesta di informazioni al server.
Pagina 14 di 37
Ontology Explorer - Documentazione
Questi wrapper sono stati costruiti seguendo lo stesso paradigma dei
Javabean, ovvero:





implementano IsSerializable (di GWT), cioè sono serializzabili in XML per
essere passati tramite le Remote Procedure Call (RPC);
il loro scopo unico è quello di trasportare informazioni;
possiedono attributi utili, appunto, al trasporto delle informazioni;
non hanno logica di funzionamento;
espongono metodi get e set per la gestione degli attributi pubblici.
Un problema che si è presentato durante lo sviluppo dei wrapper è stato quello
relativo alla ”autolimitazione”, cioè alla decisione di quali e quante informazioni
raggruppare all’interno di ogni singolo wrapper. Tale problema si è posto in
quanto ogni wrapper rappresentante un elemento appartenente all’ontologia
(come una classe), attraverso le varie relazioni esistenti, avrebbe potuto
contenere anche le informazioni relative agli elementi collegati; così facendo, in
maniera ricorsiva, si sarebbe arrivati al punto di avere all’interno di ogni
wrapper tutti gli altri wrapper rappresentanti gli elementi dell’ontologia. Questo
sarebbe risultato, ovviamente, inutile e controproducente, perciò, per ogni
wrapper sono stati stabiliti limiti di contenimento delle informazioni ed usati,
dove necessario, i dovuti riferimenti, utili per reperire altri wrapper, e relative
informazioni, in un secondo momento tramite una nuova chiamata
all’OntologyService.
Vengono qui di seguito descritti i principali wrapper sviluppati all’interno del
progetto.
3.2.1 OWLWrapper
OWLWrapper è una classe astratta che implementa IsSerializable per
scambiare dati dal Semantic Service al Client GWT. Ogni elemento OWL
scambiato deve ereditare da OWLWrapper. Questa contiene gli attributi:




name
namespace
label
description
Pagina 15 di 37
Ontology Explorer - Documentazione
3.2.2 OWLClassWrapper
OWLClassWrapper contiene tutte le informazioni riguardanti una classe OWL
(owl:class). Questa, oltre alle informazioni ereditate da OWLWrapper,
contiene: la collezione delle superclassi, la collezione delle sottoclassi, la
collezione delle object property, la collezione delle datatype property e la
collezione delle istanze.
Relativamente all’autolimitazione, l’OWLClassWrapper è stato impostato in
modo tale da vedere tutte le classi (superclassi e sottoclassi) e le istanze
collegate alla classe come riferimenti ai nomi (ID) in formato stringa dei loro
rispettivi wrapper.
3.2.3 OWLInstanceWrapper
OWLInstanceWrapper contiene tutte le informazioni riguardanti le istanze di
una classe. Questa, oltre alle informazioni ereditate da OWLWrapper, contiene
la collezione di tutte le classi di cui è istanza. Si vuole sottolineare il fatto
che in OWL un’istanza può essere istanza di più classi. Come già anche per
l’OWLClassWrapper, l’OWLInstanceWrapper è stato impostato in modo da
essere limitato dal punto di vista del contenimento di informazioni, ovvero
gestisce le classi e le istanze a cui è collegato come dei riferimenti ai loro
relativi wrapper. Questi riferimenti, citati anche in altri wrapper, offrono la
possibilità di raggiungere le informazioni desiderate in un secondo momento,
senza doverle possedere ed accumularle ad altre di maggior rilievo in un
determinato istante.
3.2.4 OWLTaxonomyWrapper
OWLTaxonomyWrapper rappresenta una particolare tassonomia OWL (ovvero
un albero di classi). Questa, oltre alle informazioni ereditate da OWLWrapper,
contiene:



rootClass
maxDeep
minDeep
Pagina 16 di 37
Ontology Explorer - Documentazione
3.3 I CSS
Fondamentali per la creazione dell’interfaccia del tool di navigazione sono i CSS
(Cascading Style Sheet), ovvero i fogli di stile per la visualizzazione grafica dei
componenti a browser. L’utilizzo dei CSS, già molto frequente all’interno di
normali pagine web, è risultato di importanza ancora maggiore all’interno
dell’Ontology Explorer in quanto ogni widget deve, per una corretta
rappresentazione, essere formattato tramite CSS.
La formattazione impostata attraverso i CSS non ha solo rilevanza dal punto di
vista della correttezza delle visualizzazione, ma anche dal punto di vista della
logica di programmazione. Si pensi alla differenziazione grafica tra classi ed
istanze effettuata per aiutare l’utente a riconoscere in maniera più rapida e
semplice le diverse entità; questo, dal lato della programmazione in Java,
sarebbe risultato sì possibile, ma sicuramente ben più complesso, mentre,
grazie all’utilizzo dei CSS, si è potuta gestire la visualizzazione in modo
sicuramente più rapido e più semplice, rendendo così le classi (rappresentate
coi nomi scritti in grassetto) facilmente distinguibili dalle istanze
(rappresentate coi nomi scritti in corsivo). Quanto appena detto è un esempio
pratico del concetto base su cui sono stati creati i CSS, ovvero sulla
separazione del contenuto informativo della pagina dalla formattazione di
quest’ultima.
I CSS assumono inoltre un ruolo di rilevante importanza dal punto di vista della
parametrizzazione, in quanto, semplicemente mettendo a disposizione
dell’utente finale diversi file CSS (appositamente sviluppati), questo potrà
scegliere ed ottenere visualizzazioni del tool completamente differenti, magari
volte ad enfatizzare determinate informazioni piuttosto che altre, così da
riuscire a risolvere in modo più semplice particolari problematiche.
I CSS possono essere considerati parte integrante dei widget e quindi anche
dell’Ontology Explorer.
Mostriamo qui di seguito un esempio di applicazione di CSS ad un widget,
prendendo come riferimento il TaxonomyTree.
Innanzi tutto viene scritto il codice all’interno del file CSS associato all’Ontology
Explorer. Per questo caso particolare viene scritto il codice relativo all’albero in
generale (.TaxonomyTree), al singolo nodo rappresentante una classe
(.TaxonomyTree-OWLClass .gwt-TreeItem), al singolo nodo rappresentante
un’istanza (.TaxonomyTree-OWLInstance .gwt-TreeItem) e al singolo nodo
risultante selezionato (.TaxonomyTree .gwt-TreeItem-selected).
.TaxonomyTree{
margin: 3px, 3px, 3px, 3px;
font-size: xx-small;
font-family: Verdana, Arial, Helvetica, sans-serif;
}
Pagina 17 di 37
Ontology Explorer - Documentazione
.TaxonomyTree-OWLClass .gwt-TreeItem{
font-weight: bold;
cursor: hand;
}
.TaxonomyTree-OWLInstance .gwt-TreeItem{
font-weight: normal;
font-style: italic;
color: green;
cursor: hand;
}
.TaxonomyTree .gwt-TreeItem-selected {
background-color: #E8EEF7;
text-decoration: underline;
}
Una volta creato il codice appena mostrato, questo va collegato al widget che
lo usa; per questo, all’interno della classe Java TaxonomyTree.java vengono
create delle variabili statiche utili come riferimenti ai nomi degli stili definiti nel
CSS.
public static String WIDGET_STYLE_NAME_ROOT = "TaxonomyTree";
public static String OWLCLASS_STYLE = WIDGET_STYLE_NAME_ROOT+"-"+"OWLClass";
public static String OWLINSTANCE_STYLE = WIDGET_STYLE_NAME_ROOT+"-"+"OWLInstance";
Le variabili appena mostrate vengono poi utilizzate per assegnare ai vari
widget, ed alle loro parti, lo stile relativo in base alla logica del tool. Va
sottolineato che questo tipo di assegnamenti, come gli esempi riportati di
seguito, sono fattibili anche durante il funzionamento dell’applicazione e quindi
aumentano le potenzialità dello strumento dandogli la capacità di modificarsi in
corso d’opera.
rootItem.setStyleName(OWLCLASS_STYLE);
rootItem.setStyleName(OWLINSTANCE_STYLE);
Pagina 18 di 37
Ontology Explorer - Documentazione
4 Widget
L’Ontology Explorer, dal punto di vista dell’interattività e dell’interfaccia, è
composto per la quasi totalità da widget. Questi ultimi, messi a disposizione da
GWT, non sono altro che componenti grafici capaci di sfruttare la tecnologia
AJAX. Qui di seguito vengono inizialmente introdotti i widget di base già offerti
da GWT e successivamente verranno descritti i widget creati appositamente
per l’Ontology Explorer; tra questi vi sono l’Option Box, il TaxonomySearch, il
TaxonomyTree, l’OWLInstanceDisclosurePanel e l’OntologyInfoPanel.
4.1 Widget di base
GWT mette già a disposizione del programmatore diversi widget di base, i quali
possono essere utilizzati per eseguire le loro specifiche operazioni, oppure
possono essere scelti come fondamenta per l’implementazione di widget
composite. Vengono qui di seguito elencati i widget di base usati dall’Ontology
Explorer.
4.1.1 Componenti di input

Button: un button (o pulsante di comando) è un widget che fornisce
all’utente un modo semplice per innescare un evento, come inviare una
richiesta ad un motore di ricerca, o per interagire con finestre di dialogo,
come confermare determinate azioni. Il tipico button è rettangolare con
un’intestazione descrittiva al centro. Il metodo più comune di premere un
button è cliccare su di esso, ma possono essere utilizzate anche altri
input, quali la battuta dell’invio. Quando premuto, oltre all’esecuzione di
un compito predeterminato impostato tramite la gestione dell’evento, il
button subisce spesso un cambiamento grafico come se questo stesse
temporaneamente abbassato.

RadioButton: un radio button è un tipo di widget grafico di interfaccia
utente, il quale permette all’utente di scegliere una di un insieme
predefinito di opzioni. I radio button sono organizzati in gruppi di due o
più e vengono mostrati su schermo come, ad esempio, dei fori circolari
contenenti spazio bianco (quando non selezionati) o un punto (quando
selezionati). Adiacente ad ogni radio button viene mostrata normalmente
una label che descrive la scelta che questo rappresenta. Quando l’utente
seleziona un radio button, qualsiasi altro scelto precedentemente nello
stesso gruppo si deseleziona. Selezionare un radio button può essere
fatto facendo clic sulla rappresentazione grafica a forma di foro circolare
o sull’intestazione oppure anche utilizzando un tasto di scelta rapida.
Pagina 19 di 37
Ontology Explorer - Documentazione

CheckBox: una check box è un altro tipo di widget grafico di interfaccia
utente; questo consente all’utente di effettuare più scelte da molte
opzioni. Normalmente, le check box vengono mostrate sullo schermo
come piccoli riquadri che possono contenere spazio bianco (quando non
selezionate) o un segno a forma di x (quando selezionate). Adiacente alla
check box viene mostrata normalmente un’intestazione che descrive il
significato di questa. Invertire lo stato di una check box può essere fatto
facendo clic sulla rappresentazione grafica a forma di piccolo riquadro o
sull’intestazione oppure anche utilizzando un tasto di scelta rapida.

TextBox: una casella di testo, un campo o un riquadro di ingresso di
testo è un comune elemento grafico di interfaccia utente. Lo scopo di una
casella di testo è permettere all’utente di immettere informazioni testuali
che devono essere utilizzate dal programma. Le direttive user-interface
(user-interface guidelines) consigliano una casella di testo single-line (a
linea singola) quando è richiesta una sola linea di immissione, mentre
una multiline (a linea multipla) nel caso un sola linea di immissione non
fosse sufficiente. Le caselle di testo non editabili possono servire al
semplice scopo di mostrare del testo. Una tipica casella di testo è un
rettangolo di qualsiasi dimensione, possibilmente con un confine che
separa la casella di testo dal resto dell’interfaccia. Le caselle di testo
possono contenere zero, uno o due barre di scorrimento. Alcune possono
mostrare una linea verticale lampeggiante, indicando la regione corrente
di testo che viene editato. È comune che il cursore del mouse cambi la
sua forma quando si sposta sopra una casella di testo.

ListBox: una list box è un widget che permette all’utente di scegliere uno
o più elementi da un elenco contenuto in una casella di testo a linea
multipla. L’utente clicca, all’interno dell’elenco, sull’elemento che vuole
selezionare, tenendo premuto il tasto Shift nel caso volesse effettuare
più scelte.
4.1.2 Componenti di visualizzazione

Tree: un tree è una struttura dati che emula una struttura ad albero con
un insieme di nodi collegati. Una struttura ad albero è un modo di
rappresentare graficamente la natura gerarchica di una struttura. È
chiamata struttura ad albero perché proprio come un albero possiede la
radice all’inizio e le foglie nel fondo. Dal punto di vista grafico si presenta
come un’insieme di stringhe, rappresentanti i singoli nodi; quando il nodo
risulta chiuso la stringa relativa è accostata ad un simbolo ”+”, utile
all’apertura del nodo stesso, mentre, viceversa, nel caso in cui il nodo
risulti aperto, la stringa sarebbe accostata ad un simbolo ”-”, questo utile
alla chiusura del nodo. Da quanto appena detto, si riesce ad evincere
l’altro grado di interattività fornito dal tree, il quale modifica il proprio
stato ad ogni singolo click. Oltre a questo va infine detto che, grazie alla
Pagina 20 di 37
Ontology Explorer - Documentazione
capacità di supportare la gestione di diversi eventi, il tree riesce ad
incrementare notevolmente le sue funzionalità e quindi la sua utilità.

PopupPanel: un popup panel è un widget fuori dalla gerarchia principale
di gestione delle geometrie di una pagina. È una costruzione fatta
attivare temporaneamente per dare all’utente una parte di informazioni o
per ottenere qualche informazione dall’utente. Un popup è una finestra
che, solitamente, mentre si stata navigando col browser, si può aprire
autonomamente o si può aprire tramite un click sul relativo link. Può
essere utile o fastidiosa. Tipicamente, ma non sempre, si può chiudere
cliccando la x che viene mostrata in un angolo.
4.1.3 Componenti di layout (utili alla disposizione di altri widget)

HorizontalPanel: un horizontal panel (pannello orizzontale) è un widget
che spesso non ha alcuna caratteristica grafica specifica, ma viene
utilizzato principalmente per raggruppare insieme altri widget
(ovviamente in senso orizzontale). Questo permette di avere un controllo
migliore sulla disposizione dei widget.

VerticalPanel: un vertical panel (pannello verticale) è un widget dalle
stesse caratteristiche appena presentate per l’HorizontalPanel, con l’unica
differenza del senso di disposizione dei widget, cioè verticale invece che
orizzontale.

TabPanel: un tab panel è un widget di navigazione per la commutazione
tra documenti. Un singolo tab è solitamente progettato come un’etichetta
di testo all’interno di un riquadro rettangolare. L’attivazione di un tab
(tipicamente dovuta ad un click del mouse) rende visibile il suo
documento associato ed evidenzia il tab stesso, così da distinguerlo dagli
altri tab non attivi. Generalmente, può essere attivo solo un tab alla
volta. Questi tab, dal punto di vista grafica, richiamano le tradizionali
schede cartacee, così da dare all’interfaccia utente un aspetto più
familiare per l’utilizzatore finale.
Pagina 21 di 37
Ontology Explorer - Documentazione
4.2 Widget sviluppati
Al fine di realizzare l’Ontology Explorer come pensato in fase di progettazione,
si è deciso di sviluppare dei widget specifici aventi una loro logica ad hoc.
Questi particolari widget derivano dalla composizione di widget di base, così da
poter assolvere particolari compiti più complessi e specifici rispetto ai widget di
base. Tra questi widget ve ne sono tre molto particolari e di fondamentale
importanza per il raggiungimento degli obiettivi prefissati e sono:





OptionBox
TaxonomySearch
TaxonomyTree
OWLInstanceDisclosurePanel
OntologyInfoPanel
Si rinvia ai paragrafi successivi una loro più specifica descrizione.
4.2.1 OptionBox
L’OptionBox è un widget composto dall’unione di un PopupPanel con una
CheckBox, dei RadioButton, delle Label ed un Button.
Lo scopo di questo widget è quello di mettere a disposizione dell’utente uno
strumento utile a gestire la parametrizzazione relativa alla rappresentazione
dei dati relativi all’ontologia. Il suo costruttore, riportato qui sotto, mostra la
presenza di un metodo apposito, generateOptionBox, utile alla composizione
del widget.
public OptionBox() {
super();
init();
generateOptionBox();
}
I parametri presenti e gestibili dall’utente riguardano (come già detto nel
paragrafo 2.2) diverse aree concettuali dell’Ontology Explorer.
Opzioni generali:


Mostrare (o non mostrare) le istanze durante la navigazione
Mostrare (o non mostrare) i tool tip rappresentanti le descrizioni dei vari
oggetti esistenti
Opzioni di visualizzazione:


Rappresentare gli elementi dell’ontologia attraverso i loro nomi
Rappresentare gli elementi dell’ontologia attraverso le loro label
Pagina 22 di 37
Ontology Explorer - Documentazione
Opzioni di ricerca:



Effettuare la ricerca in modalità “Start with” (default)
Effettuare la ricerca in modalità “Contains” (slow)
Utilizzo dei prefissi nella ricerca
Opzioni relative al pannello di visualizzazione delle informazioni:




Rappresentare le istanze di una classe attraverso i loro nomi
Rappresentare le istanze di una classe attraverso le loro label
Ordinare alfabeticamente le istanze
Ordinare alfabeticamente le proprietà
La modifica dei detti parametri avviene attraverso specifici setters, di cui un
paio di esempi vengono qui di seguito riportati.
public void setLabels(boolean isLabels) {
this.isLabels = isLabels;
if(isLabels){
this.isNames = false;
this.isIDs = false;
}
}
public void setNames(boolean isNames) {
this.isNames = isNames;
if(isNames){
this.isIDs = false;
this.isLabels = false;
}
}
Questo widget dà all’utilizzatore finale dell’Ontology Explorer la possibilità di
gestire la parametrizzazione in modo facile e veloce, senza che esso debba
avere particolari conoscenze o capacità. In tal modo chiunque può utilizzare
questo tool visualizzandolo in base alle proprie esigenze.
public boolean getNameRBValue(){
return rbName.isChecked();
}
Il codice appena presentato mostra la gestione su di un particolare
RadioButton e, più precisamente, fa vedere, in base al controllo dello stato del
widget, come viene modificato il parametro.
L’attuazione del cambiamento dei parametri viene avviata cliccando col mouse
sull’apposito button. Una volta effettuata questa operazione, l’OptionBox viene
chiuso ed i componenti soggetti alla parametrizzazione, quali il
TaxonomySearch ed il TaxonomyTree, vengono rigenerati sulla base delle
modifiche effettuate.
Pagina 23 di 37
Ontology Explorer - Documentazione
In quanto all’architettura dell’OptionBox, questo viene creato al momento
dell’avvio dell’Ontology Explorer ed è capace di gestire la parametrizzazione sia
prima che dopo il caricamento dell’ontologia desiderata.
4.2.2 TaxonomySearch
Il TaxonomySearch è un widget composto dall’unione di una TextBox con una
ListBox ed un PopupPanel.
Lo scopo di questo widget è quello di mettere a disposizione dell’utente una
casella di ricerca intelligente (o smart) simile a quella utilizzata all’interno di
Google Suggest. L’intelligenza di tale casella di ricerca viene data dalla
conoscenza di tutti gli elementi presenti all’interno dell’ontologia caricata.
Conoscendo tutte le entità esistenti, mentre l’utente digita il nome di ciò che
desidera cercare all’interno della tassonomia, la casella di ricerca riesce a
mostrare un pop-up contenente una lista comprendente tutte gli elementi
ricercabili.
La ricerca attraverso il TaxonomySearch può essere avviata sia dopo aver
completato la digitazione dell’elemento da ricercare, cliccando sul button “GO”,
sia durante la digitazione, interrompendola battendo il tasto Invio e
selezionando uno degli elementi presenti nella lista. Nell’esempio seguente
viene mostrata la gestione degli eventi relativi all’input da tastiera; si può
infatti notare la gestione dei tasti KEY_DOWN e KEY_UP, che comportano lo
spostamento della selezione all’interno della lista, KEY_ENTER, che porta alla
scelta ed alla conseguente visualizzazione di un elemento della lista, e
KEY_ESCAPE che chiude la lista senza effettuare alcun tipo di selezione.
if(arg1 == KEY_DOWN){
int selectedIndex = choices.getSelectedIndex();
selectedIndex++;
if(selectedIndex > choices.getItemCount()) {selectedIndex = 0;}
choices.setSelectedIndex(selectedIndex);
return;
} if(arg1 == KEY_UP){
int selectedIndex = choices.getSelectedIndex();
selectedIndex--;
if(selectedIndex < 0) {selectedIndex = choices.getItemCount();}
choices.setSelectedIndex(selectedIndex);
return;
} if(arg1 == KEY_ENTER){
if(visible)
complete();
return;
} if(arg1 == KEY_ESCAPE){
choices.clear();
choicesPopup.hide();
visible = false;
return;
}
Pagina 24 di 37
Ontology Explorer - Documentazione
Avviata la ricerca, se effettuata su di un nome esistente, l’albero
rappresentante la tassonomia si apre in corrispondenza dell’elemento
corrispondente e si apre la relativa scheda di visualizzazione delle informazioni.
Si può vedere come avvenga questo grazie all’esempio qui riportato, dove si
vede il richiamo del metodo all’evento del click.
public void onClick(Widget arg0) {
tree.moveTree(new TreeItem(autoBox.getText()));
}
Questo widget risulta utile per l’utente in quanto gli permette di ricercare
elementi anche a lui sconosciuti e gli evita di perdere tempo nella ricerca di
entità non esistenti all’interno dell’ontologia presa in esame.
Per quanto riguarda l’architettura del TaxonomySearch, questo viene costruito
solo dopo che è avvenuto il caricamento dell’ontologia; una volta avvenuto ciò,
infatti, al widget viene passata l’intera tassonomia, la quale viene utilizzata per
generare la lista di suggerimento all’utente.
Oltre a quanto detto finora, va anche precisato che questo widget è soggetto
alla parametrizzazione e quindi i dati che esso contiene posso essere
visualizzati in modi diversi a seconda delle scelte dell’utente.
4.2.3 TaxonomyTree
Il TaxonomyTree è un widget derivato dalla specializzazione di un Tree.
Lo scopo di questo widget è quello di dare all’utente una struttura dinamica
utile alla visualizzazione di una tassonomia. Qui viene mostrato il metodo
generatore del TaxonomyTree attraverso il quale si può vedere come, dopo
una serie di dovuti controlli sui parametri esistenti, questo richiami i vari
metodi di riempimento dell’albero con la tassonomia passata.
public boolean generateTaxonomyTree() {
if (!taxonomy.isEmpty()) {
treeMap.clear();
rootItem = fillTree(taxonomy.getRootClass());
taxonomyTree.removeItems();
taxonomyTree.addItem(rootItem);
setStyleName(WIDGET_STYLE_NAME_ROOT);
taxonomyTree.addTreeListener(this);
return true;
}
else return false;
}
Ciò che differenzia il TaxonomyTree da un normale Tree sono le azioni che
supporta alla selezione di un suo elemento ed i comportamenti che tiene
all’accadimento di particolari eventi dovuti ad altri widget. In particolare,
riguardo a quanto appena detto, il Taxonomy Tree, quando si clicca su di un
suo elemento, apre la relativa scheda di visualizzazione delle informazioni,
Pagina 25 di 37
Ontology Explorer - Documentazione
mentre, quando durante la navigazione l’utente si muove ed accede a diverse
entità, senza effettuarne la ricerca o comunque senza passare per l’albero,
questo si modifica e si mantiene aperto sempre sull’elemento di cui l’utente sta
visualizzando le informazioni.
private class treeUserTreeListener implements TreeListener{
public void onTreeItemSelected(final TreeItem item) {
if(((TaxonomyNode)item.getUserObject()).isInstanceNode()){
ontoService.getInstanceWrapper(
((TaxonomyNode)item.getUserObject()).getName(),
new OntoService_GetInstanceWrapperCallBack());
}else{
ontoService.getClassWrapper(
((TaxonomyNode)item.getUserObject()).getName(),
new OntoService_GetClassWrapperCallBack());
}
}
}
Nel codice sopra presentato è rappresentata la gestione della selezione di un
elemento del tree. Questo mostra in particolare l’utilizzo dei metodi su
ontoService, getInstanceWrapper e getClassWrapper, ovvero quei metodi utili
a fare richieste al servizio per ottenere informazioni, rispettivamente, su
istanze e classi. Questo widget mette a disposizione dell’utente uno strumento
molto utile alla navigazione dell’ontologia, il quale permette di poter analizzare
quest’ultima e la sua struttura anche senza avere le dovute conoscenze. Come
già detto per il Taxonomy Search, anche il TaxonomyTree viene costruito solo
una volta avvenuto il caricamento dell’ontologia; dopo di ciò, infatti, al widget
viene passata l’intera tassonomia, la quale viene utilizzata per generare la
struttura ad albero poi visualizzata (come già visto nel primo esempio sopra
presentato). Anche per questo widget va precisata la dipendenza dalla
parametrizzazione, ovvero che i dati da esso rappresentati possono essere
visualizzati in modi diversi a seconda delle scelte dell’utente.
4.2.4 OWLInstanceDisclosurePanel
L’OWLInstanceDisclosurePanel è un widget derivato dalla specializzazione di un
DisclosurePanel.
Lo scopo di questo widget è quello di dare all’utente una struttura dinamica
utile alla visualizzazione di tutte le istanze relative ad una determinata classe.
La caratteristica principale del DisclosurePanel consiste nella capacità di
mostrare (o nascondere), con un semplice click, un pannello contenente uno o
più widget. L’OWLInstanceDisclosurePanel è una specializzazione di questo in
quanto, semplicemente prendendo in ingresso una Collection di wrapper
(OWLInstanceWrapper), riempie il pannello con un elenco di label
rappresentanti tutte le istanze della lista; dette label sono tutte cliccabili e
Pagina 26 di 37
Ontology Explorer - Documentazione
consentono (al click dell’utente) la visualizzazione della scheda relativa
all’istanza interessata.
Qui di seguito viene mostrata una parte del codice appartenente al metodo
generatore dell’OWLInstanceDisclosurePanel, dove si può vedere il ciclo dove
avviene l’assegnazione delle label ed il riempimento del pannello con le label
rappresentanti le istanze.
Iterator ite = list.iterator();
while (ite.hasNext()) {
Label lab = new Label();
OWLInstanceWrapper instanceWrapper = (OWLInstanceWrapper)ite.next();
if(name){
lab.setText(instanceWrapper.getName());
}else if(label){
if(instanceWrapper.getLabel()!=null){
if(!instanceWrapper.getLabel().equalsIgnoreCase("")){
lab.setText(instanceWrapper.getLabel());
}else{
lab.setText(instanceWrapper.getName()+NO_LABEL);
}
}else{
lab.setText(instanceWrapper.getName()+NO_LABEL);
}
}
vp.add(lab);
}
Un’ulteriore peculiarità dell’OWLInstanceDisclosurePanel consiste nella capacità
di visualizzare l’elenco delle istanze sopra citato, sia attraverso i loro nomi, sia
attraverso le loro label (a seconda delle decisioni fatte dall’utente attraverso
l’apposita CheckBox).
Viene qui mostrato il metodo che gestisce l’evento onClick sulla CheckBox e
che quindi imposta la configurazione dell’OWLInstanceDisclosurePanel.
showInstancesWithLabelCheckBox.addClickListener(new ClickListener(){
public void onClick(Widget sender){
if(((CheckBox)sender).isChecked()){
instanceOIDP.setName(false);
instanceOIDP.setLabel(true);
instanceOIDP.regenerate();
findInfoAboutInstance(instanceOIDP);
}else{
instanceOIDP.setName(true);
instanceOIDP.setLabel(false);
instanceOIDP.regenerate();
findInfoAboutInstance(instanceOIDP);
}
}
});
Visto quanto appena detto, anche per questo widget viene evidenziata la
dipendenza dalla parametrizzazione, ovvero che i dati da esso rappresentati
possono essere visualizzati in modi diversi a seconda delle scelte dell’utente.
Pagina 27 di 37
Ontology Explorer - Documentazione
4.2.5 OntologyInfoPanel
L’OntologyInfoPanel consiste in un semplice popup che prende in ingresso un
wrapper, più precisamente un OWLOntologyInfo, e che da questo ricava tutte
le informazioni riguardanti l’ontologia caricata (quali nome, label, description,
ecc…). Una volta assunte queste informazioni, l’OntologyInfoPanel può essere
visualizzato semplicemente cliccando sul relativo bottone presente all’interno
dell’OntologyExplorer.
Viene qui di seguito mostrato il codice relativo al metodo generatore
dell’OntologyInfo panel.
private void generatePanel() {
this.clear();
this.setStyleName(WIDGET_STYLE_NAME_ROOT);
closeButton.setStyleName(INFO_CLOSEBUTTON_STYLE);
vPanel.clear();
vPanel.setStyleName(VPANEL_STYLE);
vPanel.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_CENTER);
caption.setStyleName(INFO_CAPTION_STYLE);
closeXButton.setStyleName(INFO_CLOSEXBUTTON_STYLE);
hPanel.setStyleName(HPANEL_STYLE);
hPanel.add(caption); hPanel.add(closeXButton);
hPanel.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);
this.setCaption(hPanel);
String label = new String(ONTOLOGYINFO_NONE_VALUE_LABEL);
String description = new String(ONTOLOGYINFO_NONE_VALUE_LABEL);
if (ontologyInfo!=null) {
if (ontologyInfo.getLabel()!=null)
label = ontologyInfo.getLabel();
if (ontologyInfo.getDescription()!=null)
description = ontologyInfo.getDescription();
HTML row1 = new HTML("<span class=\""+INFO_LABEL_STYLE+"\">"
+ONTOLOGYINFO_LABEL_LABEL+"</span>"
+"<span class=\""+INFO_VALUE_STYLE+"\">"
+label+"</span>");
HTML row3 = new HTML("<span class=\""+INFO_LABEL_STYLE+"\">"
+ONTOLOGYINFO_NAMESPACE_LABEL+"</span>"
+"<span class=\""+INFO_VALUE_STYLE+"\">"
+ontologyInfo.getNamespace()+"</span>");
HTML row4 = new HTML("<span class=\""+INFO_LABEL_STYLE+"\">"
+ONTOLOGYINFO_DESCRITPION_LABEL+"</span>"
+"<span class=\""+INFO_VALUE_STYLE+"\">"
+description+"</span>");
row1.setStyleName(INFO_ROW_STYLE);
row3.setStyleName(INFO_ROW_STYLE);
row4.setStyleName(INFO_ROW_STYLE);
vPanel.add(row1); vPanel.add(row3); vPanel.add(row4);
}
else vPanel.add(new HTML("<span class=\""+NO_INFO_LABEL_STYLE+"\">"
+ONTOLOGYINFO_NOINFO_LABEL+"</span>"));
vPanel.add(closeButton);
this.add(vPanel);
}
Pagina 28 di 37
Ontology Explorer - Documentazione
5 Progetto Eclipse ed organizzazione del
codice
Come già anticipato all’interno del paragrafo 1.1, il progetto dell’Ontology
Explorer è stato interamente sviluppato all’interno dell’ambiente Eclipse. In
questo capitolo viene mostrata l’organizzazione e la struttura dell’intero
progetto all’interno, appunto, di Eclipse.
5.1 Package Java
Il progetto globale dell’Ontology Explorer, all’interno di Eclipse è in realtà
composto da tre mini progetti collegati tra loro. Questi tre mini progetti sono:



GWT-OWLWrapper
OntologyExplorer
SemanticWidgets
Ognuno di questi progetti contiene al suo interno diversi package utili a
suddividere, a seconda delle diverse utilità e delle diverse funzioni, le classi
sviluppate all’interno del progetto stesso. Questi package possono contenere,
non solo classi java, ma anche i file GWT-Module in formato xml e cartelle
contenenti tutti i file necessari per la pubblicazione del progetto sul web, quali
pagine html, fogli di stile css o immagini. Vengono ora mostrati i vari package
in relazione al mini progetto a cui appartengono.
5.1.1 GWT-OWLWrapper
org.xlab.semantic.gwt
Package contenente il GWT-Module del progetto in formato xml.
Al suo interno vi si può trovare:
 gwt-OWLWrappers.gwt.xml
org.xlab.semantic.gwt.client.owlUtility.info
Package contenente una classe utile a racchiudere le informazioni globali
riguardanti l’ontologia.
Al suo interno vi si può trovare:
 OntologyInfo.java
Pagina 29 di 37
Ontology Explorer - Documentazione
org.xlab.semantic.gwt.client.owlUtility.interface
Package contenente due interfacce utili a racchiudere particolari informazioni
riguardanti le proprietà.
Al suo interno vi si può trovare:
 PropertyWithDatatypeValues.java
 PropertyWithInstanceValues.java
org.xlab.semantic.gwt.client.owlUtility.utility
Package contenente due classi utili a racchiudere le informazioni riguardanti le
tipologie dei wrapper e delle proprietà.
Al suo interno vi si può trovare:
 OWLPropertyType.java
 OWLWrapperType.java
org xlab.semantic.gwt.client.owlUtility.wrappers
Package contenente tutti i wrapper esistenti utili al trasporto delle informazioni
dal service al client.
Al suo interno vi si può trovare:
 OWLClassDTPHasValueRestrWrapper.java
 OWLClassDTPWrapper.java
 OWLClassOPHasValueRestrWrapper.java
 OWLClassOPWrapper.java
 OWLClassPropertyWrapper.java
 OWLClassWrapper.java
 OWLInstanceDTPHasValueRestrWrapper.java
 OWLInstanceDTPWrapper.java
 OWLInstanceOPHasValueRestrWrapper.java
 OWLInstanceOPWrapper.java
 OWLInstancePropertyWrapper.java
 OWLInstanceWrapper.java
 OWLOntologyInfo.java
 OWLPropertyWrapper.java
 OWLTaxonomyWrapper.java
 OWLWrapper.java
 TaxonomyClassNode.java
 TaxonomyInstanceNode.java
 TaxonomyNode.java
Pagina 30 di 37
Ontology Explorer - Documentazione
5.1.2 OntologyExplorer
org.xlab.semantic.gwt
Package contenente i GWT-Module del progetto (client e service) in formato
xml e la cartella Public contenente tutti i file utili alla pubblicazione del progetto
sul web (file html, css, immagini, ecc…)
Al suo interno vi si può trovare:
 OntologyExplorer.gwt.xml
 OntologyService.gwt.xml
 Public (cartella)
org.xlab.semantic.gwt.client
Package contenente la main class del client del progetto.
Al suo interno vi si può trovare:
 OntologyExplorer.java
org.xlab.semantic.gwt.client.configuration
Package contenente la classe utile a gestire i parametri, e quindi la
configurazione dell’Ontology Explorer.
Al suo interno vi si può trovare:
 OBConfiguration.java
org.xlab.semantic.gwt.client.utility
Package contenente le classi utili ad assolvere particolari compiti in interazione
con l’Ontology Explorer.
Al suo interno vi si può trovare:
 SemanticHashMap.java
org.xlab.semantic.gwt.client.widgets
Package contenente i widget non semantici utili all’interno dell’Ontology
Explorer.
Al suo interno vi si può trovare:
 DefaultOntologiesMenu.java
 OptionBox.java
org.xlab.semantic.gwt.client.interfaces
Package contenente le interfacce (sincrona ed asincrona) relative al service del
progetto.
Al suo interno vi si può trovare:
 OWLOntoService.java
 OWLOntoServiceAsync.java
org.xlab.semantic.gwt.server
Package contenente la main class del service del progetto.
Al suo interno vi si può trovare:
 OWLOntoServiceImpl.java
Pagina 31 di 37
Ontology Explorer - Documentazione
5.1.3 SemanticWidgets
org.xlab.semantic.gwt.semanticWidgets
Package contenente il GWT-Module del progetto in formato xml.
Al suo interno vi si può trovare:
 SemanticWidgets.gwt.xml
org.xlab.semantic.gwt.semanticWidgets.client
Package contenente tutti i widget semantici utili all’Ontology Explorer e da esso
utilizzabili.
Al suo interno vi si può trovare:
 OntologyInfoPanel.java
 OWLDatatypePropertyDisclosurePanel.java
 OWLInstanceDisclosurePanel.java
 OWLObjectPropertyDisclosurePanel.java
 OWLPropertiesDisclosurePanel.java
 OWLPropertiesInstanceDisclosurePanel.java
 OWLPropertiesPopup.java
 OWLRestrictionDisclosurePanel.java
 SemanticLabel.java
 SemanticWidget.java
 SemanticWidgets.java
 TaxonomySearch.java
 TaxonomySearchAutoCompletation.java
 TaxonomySuggestBox.java
 TaxonomyTree.java
org.xlab.semantic.gwt.semanticWidgets.client.notUsed
 Package contenente tutti i widget semantici creati ed utilizzati durante lo
sviluppo del progetto ma non più utili all’Ontology Explorer.
5.2 Librerie
Come già detto precedentemente, il progetto globale dell’Ontology Explorer si
compone da tre mini progetti collegati tra loro. Ognuno di questi progetti
necessita di importare al suo interno particolari librerie (che siano esse interne
al progetto dell’Ontology Explorer o esterne) al fine di raggiungere gli obiettivi
prefissati. Vengono qui di seguito mostrate le librerie importate ed utilizzate da
ogni mini progetto.
Pagina 32 di 37
Ontology Explorer - Documentazione
5.2.1 GWT-OWLWrappers
Le librerie contenute sono:
 JRE System Library (libreria Java)
 gwt-user.jar (libreria di GWT)
5.2.2 OntologyExplorer
Le librerie contenute sono:
 JRE System Library (libreria Java)
 gwt-user.jar (libreria di GWT – per l’utilizzo di GWT)
 gwt-OWLWrappers.jar (libreria dei wrapper – per l’utilizzo dei wrapper)
 OntologyService.jar (libreria del service – per l’accesso al servizio)
 semanticWidgets.jar (libreria dei semantic widget – per l’utilizzo dei
semantic widget)
 gwttk-0.2.1.jar (libreria del progetto esterno GWT TK – per l’utilizzo di
alcuni componenti presenti all’interno del progetto GWT TK)
 protege-owl.jar (libreria delle protégé owl-api – per l’utilizzo delle
protégé owl-api)
 protege.jar (libreria di protégé)
 jena.jar (libreria di jena)
 xercesImpl.jar (libreria di xerces)
 icu4j.jar
 gwt-widgets-0.1.4.jar (libreria di widget – per l’utilizzo di widget messi a
disposizione dal progetto esterno gwt-widgets-0.1.4)
 gwt-servlet.jar (libreria di servlet GWT – per l’utilizzo di servlet messi a
disposizione da GWT)
 OntologyService.interfaces.jar (libreria delle interfacce del servizio)
5.2.3 SemanticWidgets
Le librerie contenute sono:
 JRE System Library (libreria Java)
 gwt-user.jar (libreria di GWT – per l’utilizzo di GWT)
 gwt-OWLWrappers.jar (libreria dei wrapper – per l’utilizzo dei wrapper)
 gwttk-0.2.1.jar (libreria del progetto esterno GWT TK – per l’utilizzo di
alcuni componenti presenti all’interno del progetto GWT TK)
Pagina 33 di 37
Ontology Explorer - Documentazione
5.3 Ant file
Infine, anche per quanto riguarda i file ant, va sottolineato che ognuno dei tre
progetti componenti il progetto globale dell’Ontology Explorer possiede ed
usufruisce di un suo file build.xml (un file ant appunto). Vengono qui di seguito
mostrate le caratteristiche e le funzionalità dei file ant appartenenti ad ogni
progetto.
5.3.1 GWT-OWLWrappers
Funzionalità dell’ant file build.xml:
 clean (cancella tutti i file .class e .war)
 CreateJAR (crea il file .jar del progetto che verrà poi utilizzato come una
libreria da altri progetti)
 CreateAndCopy-JAR [default] (crea il file .jar e lo copia direttamente
all’interno della cartella ‘lib’ relativa al progetto che lo vuole utilizzare in
qualità di libreria)
5.3.2 OntologyExplorer
Funzionalità dell’ant file build.xml
 clean (cancella tutti i file .class e .war)
 Compile Javascript (compila il progetto come Javascript)
 CompileAndCreateWAR [default] (compila il progetto e crea il WAR per
l’esportazione)
 CreateJAR (crea il file .jar del progetto che verrà poi utilizzato come una
libreria da altri progetti)
 CreateAndCopy-JAR (crea il file .jar e lo copia direttamente all’interno
della cartella ‘lib’ relativa al progetto che lo vuole utilizzare in qualità di
libreria)
 CreateWAR (crea il file .war che verrà poi utilizzato per far girare il
progetto su server)
deploy to server (esegue il procedimento di sostituzione del WAR sul server)
5.3.3 SemanticWidgets
Funzionalità dell’ant file build.xml:
 clean (cancella tutti i file .class e .war)
 CreateJAR [default] (crea il file .jar del progetto che verrà poi utilizzato
come una libreria da altri progetti)
 CreateAndCopy-JAR (crea il file .jar e lo copia direttamente all’interno
della cartella ‘lib’ relativa al progetto che lo vuole utilizzare in qualità di
libreria)
Pagina 34 di 37
Ontology Explorer - Documentazione
6 Screenshot
Figura 1 – Screenshot relativo all’Ontology Explorer dopo il caricamento
dell’ontologia UBL2
Pagina 35 di 37
Ontology Explorer - Documentazione
Figura 2 - Screenshot relativo all’Ontology Explorer durante una ricerca all’interno
dell’ontologia UBL2
Pagina 36 di 37
Ontology Explorer - Documentazione
Figura 3 - Screenshot relativo all’Ontology Explorer durante la navigazione
dell’ontologia UBL”
Pagina 37 di 37