termsdisplay.java

Semantic Web Ontology Editor

			    answer = JOptionPane.showConfirmDialog(swoopHandler, 
			        debugPanel);
			    
			    if (answer == JOptionPane.YES_OPTION) {		    
					// call swoopmodel method to enable debugging (also turns on icons)
					swoopModel.setEnableDebugging(true);
					// also switch to pellet if it isn't on already
					if (switchPellet.isSelected()) {
						int pellet = 0;
						for (int i=0; i<reasoners.size(); i++) {
							if (reasoners.get(i) instanceof PelletReasoner) {
								pellet = i;
								break;
							}
						}
						if (reasonerCombo.getSelectedIndex()!=pellet) {
							reasonerCombo.setSelectedIndex(pellet);					
						}				
					}
			    }
			    else
			        debugChk.setSelected(false);
			}
			else {
				// user turns off debugging
				swoopModel.setEnableDebugging(false);
				if (swoopModel.getReasoner() instanceof PelletReasoner) {
					int answer = JOptionPane.showConfirmDialog(swoopHandler, 
					        "Switch off Pellet Reasoner as well?");
					    
				    if (answer == JOptionPane.YES_OPTION) {
				    	reasonerCombo.setSelectedIndex(0);
				    }
				}					    
			}
		}
		
		// is user checks on glass box debugging
		if (e.getSource() == debugGlassChk) {
			swoopModel.setDebugGlass(debugGlassChk.isSelected());
//			swoopHandler.sosMenu.setEnabled(debugGlassChk.isSelected());
		}
		
		// is user checks on glass box debugging
		if (e.getSource() == debugBlackChk) {
			swoopModel.setDebugBlack(debugBlackChk.isSelected());
			swoopModel.setEnableDebugging(debugBlackChk.isSelected());			
		}
		
		// if user checks on termEditable
		if (e.getSource()==termEditableChk) {	
			swoopModel.setEditorEnabled(termEditableChk.isSelected());
		}
		
		// if user checks on showInherited
		if (e.getSource()==showInheritedChk) {	
			swoopModel.setShowInherited(showInheritedChk.isSelected());			
		}
		
		if(e.getSource()==applyChangesBtn) {
			
			// remove all discrete changes in swoopModel first
			if(!swoopModel.getUncommittedChanges().isEmpty()) {			
				swoopModel.applyOntologyChanges();				
			}
			
			// if editor is not concise format
			// then its direct text editing
			// and needs to be handled separately
			if (!(renderers.get(termDisplayPane.getSelectedIndex()) instanceof ConciseFormatEntityRenderer)) {
				applyDirectTextChanges();				
			}
			
			undoChangesBtn.setEnabled(false);
			applyChangesBtn.setEnabled(false);			
		}
		
		if(e.getSource()==undoChangesBtn) {
			if(!swoopModel.getUncommittedChanges().isEmpty()) {
				String title = "Undo changes";
				String msg = "Do you want to undo all the changes?";
				int options = JOptionPane.YES_NO_OPTION;
				int result = JOptionPane.showConfirmDialog(this, msg, title, options);
				if(result==JOptionPane.YES_OPTION) {
					
					// remove each uncommitted change from swoop change cache
					for (Iterator iter = swoopModel.getUncommittedChanges().iterator(); iter.hasNext();) {
						OntologyChange removeChange = (OntologyChange) iter.next();
						swoopModel.getChangesCache().removeOntologyChange(removeChange, swoopModel);
					}
					
					swoopModel.setUncommittedChanges(new ArrayList());
					undoChangesBtn.setEnabled(false);
					applyChangesBtn.setEnabled(false);
					
					ConciseFormatEntityRenderer cfRend = (ConciseFormatEntityRenderer) renderers.get(termDisplayPane.getSelectedIndex());
			
					JEditorPane cfEdit = (JEditorPane) editors.get(termDisplayPane.getSelectedIndex());
					StringWriter st = new StringWriter();
					try {
						cfRend.render(swoopModel.selectedEntity, swoopModel, st);
					} catch (RendererException e1) {
						e1.printStackTrace();
					}
					cfEdit.setText(st.toString());
					cfEdit.setCaretPosition(0);					
				}
			}
		}
		
		// filter combo changed
		if (e.getSource()==filterCombo) {
			// set filter param in SwoopModel here but DONT Notify or else infinite loop!
			if (filterCombo.getSelectedItem()!=null) {
				swoopModel.setTermListFilter(filterCombo.getSelectedItem().toString(), false);
				updateListDisplay();
			}			
		}
		
		// reasoner selection chenged
		if (e.getSource()==reasonerCombo) {
			reasonerSelChanged();							
		}
		
		// when user clicks show imports button
		if (e.getSource()==showImportChk) {
			try {
				swoopModel.setShowImports(showImportChk.isSelected());
			} catch (OWLException ex) {
				JOptionPane.showMessageDialog(null, "The selected reasoner cannot process this ontology with the new setting:\n" + ex.getMessage() + "\n\nThe reasoner will be disabled.", "Error!", JOptionPane.ERROR_MESSAGE);
				//TODO: need to switch to default reasoner??
			}	
		}
		
		// when user clicks show qnames button
		if (e.getSource()==showQNamesChk)			
			swoopModel.setShowQNames(showQNamesChk.isSelected());	
		
	}

	public void removeFromCache(OWLOntology ont) {		
		treeRenderer.removeClassTreeCacheEntry(ont);
		treeRenderer.removePropTreeCacheEntry(ont);
		listCache.removeOntology(ont);		
	}
	
	public void reasonerSelChanged() {
		
		if (swoopModel.getSelectedOntology()!=null) {
		    try {
				swoopModel.setReasoner((SwoopReasoner) reasoners.get(reasonerCombo.getSelectedIndex()));
			} 
		    catch (Exception ex) {
				// the first element is the SwoopSimpleReasoner					
				reasonerCombo.setSelectedIndex(0);		
				throw new RuntimeException(ex);
			}					
		}
	}
	
	public void refreshEditorMode() {
		
		swoopHandler.ontDisplay.ontEditableChk.setSelected(termEditableChk.isSelected());
		
		// toggle apply/undo changes button visibility
		termEditButtonPane.setVisible(termEditableChk.isSelected());
		
		// remember currently selected entity renderer tab
		int index = termDisplayPane.getSelectedIndex();
		
		termDisplayPane.removeAll(); // clear UI tab pane
		editors = new ArrayList(); // clear editors array
		
		// enable editable renderers alone
		for (int i=0; i<renderers.size(); i++) {
			SwoopRenderer rend = (SwoopRenderer) renderers.get(i);
			
			if (renderers.get(i) instanceof SwoopEditableRenderer) {										
				SwoopEditableRenderer editRend = (SwoopEditableRenderer) renderers.get(i);
				editRend.setEditorEnabled(termEditableChk.isSelected());
				// add editor enabled component now
				editors.add(rend.getDisplayComponent(this)); 
				termDisplayPane.add(rend.getName(), new JScrollPane((Component) editors.get(i)));
			}
			else {
				// not an editable renderer component (tab)
				if (i==index) index = -1;
				editors.add(rend.getDisplayComponent(this)); 
				termDisplayPane.add(rend.getName(), new JScrollPane((Component) editors.get(i)));
				termDisplayPane.setEnabledAt(i, !termEditableChk.isSelected());
			}			
		}
		
		// if selectedTab is -1, make it select ConciseFormat by default
		if (index==-1) index = 0;
		// select tab again
		termDisplayPane.setSelectedIndex(index);
		
		undoChangesBtn.setEnabled(swoopModel.getUncommittedChanges().size() > 0);
		applyChangesBtn.setEnabled(swoopModel.getUncommittedChanges().size() > 0);
		
		// re-render
		try {
			displayTerm();
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
	}

	public void mouseDragged(MouseEvent arg0) {
	}

	public void mouseMoved(MouseEvent e) {
		
		// if mouse is over previous button, set tooltip text to previous history
		if (e.getSource()==prevBtn) {
			try {
				String prevHist = "";
				for (int i=historyCtr-1; i>=historyCtr-4; i--) {
					if (i<0) break;
					OWLNamedObject namedObj = historyEntity[i][0];
					String owlName = swoopModel.shortForm(namedObj.getURI());					
					prevHist += owlName + "..";
				}
				prevBtn.setToolTipText(prevHist);	
			}
			catch (Exception ex) {
				ex.printStackTrace();
			}
		}
		
		// if mouse is over next button, set tooltip text to next history
		if (e.getSource()==nextBtn) {
			try {
				String nextHist = "";
				for (int i=historyCtr+1; i<historyCtr+5; i++) {
					if (historyEntity[i][0]==null) break;
					OWLNamedObject namedObj = historyEntity[i][0];
					String owlName = swoopModel.shortForm(namedObj.getURI());
					nextHist += owlName + "..";
				}
				nextBtn.setToolTipText(nextHist);
			}
			catch (Exception ex) {
				ex.printStackTrace();
			}
		}
	}

	/**
	 * Show References (i.e. entity usage) of an OWLEntity in an Ontology
	 * TODO: Needs to be extended to arbitrary class expressions (next version)
	 * @param ontology
	 * @param entity
	 */
	private void showReferencesTerm(OWLOntology ontology, OWLEntity entity) {
		
		try {
			Set references = OntologyHelper.entityUsage(ontology, entity);
			Set claSet = new HashSet();
			Set propSet = new HashSet();
			Set indSet = new HashSet();
			for (Iterator iter = references.iterator(); iter.hasNext(); ) {
				Object obj = iter.next();
				if (obj instanceof OWLClass) claSet.add(obj);
				else if (obj instanceof OWLProperty) propSet.add(obj);
				else if (obj instanceof OWLIndividual) indSet.add(obj);
			}
			
			// display referencePanel JFrame
			String scope = swoopModel.shortForm(ontology.getURI());
			referencePanel.printResults(ontology, claSet, propSet, indSet, swoopModel.shortForm(entity.getURI()), scope);
		} 
		catch (OWLException e) {
			e.printStackTrace();
		}		
	}
	
	/**
	 * Perform a lookup for a particular keyword in the an ontology. Returns any OWL named entity
	 * matches in the ontology(s) i.e. classes/properties/individuals 
	 * Currently just does a String matching operation against the URI
	 * and not the QName
	 *
	 */
	private void lookupTerm() {
		
		try {
			String lookup = lookupFld.getText();
			if (lookup.trim().equals("")) return;
			
			// get ontology(s) to search in
			if (swoopModel.selectedOntology==null) return;
			OWLOntology currOnt = swoopModel.selectedOntology;
			List searchOnts = new ArrayList();
			searchOnts.add(currOnt);
			
			// also add transitive closure of its imports
			Set ontologies = OntologyHelper.importClosure(currOnt);
			for (Iterator iter = ontologies.iterator(); iter.hasNext();) {
				OWLOntology ont = (OWLOntology) iter.next();
				if (!ont.getURI().equals(currOnt.getURI())) {
					searchOnts.add(ont);
				}
			}
			
			// also check option
			if (searchAllChk.isSelected()) {
				// search across all ontologies
				for (Iterator iter = swoopModel.getOntologies().iterator(); iter.hasNext();) {
					OWLOntology ont = (OWLOntology) iter.next();
					if (!searchOnts.contains(ont)) {
						searchOnts.add(ont);
					}
				}
			}
			
			Set classSet = new TreeSet(EntityComparator.INSTANCE);
			Set propSet = new TreeSet(EntityComparator.INSTANCE);
			Set instSet = new TreeSet(EntityComparator.INSTANCE);
			for (Iterator ontIter = searchOnts.iterator(); ontIter.hasNext();) {
				
				OWLOntology ont = (OWLOntology) ontIter.next();
				
				// find matching classes
				Set claSet = new HashSet();
				if (lookupPanel.searchImports) claSet.addAll(swoopModel.getEntitySet(ont, SwoopModel.BASE_ONT, SwoopModel.CLASSES));			
				Iterator iter = claSet.iterator();
				while (iter.hasNext()) {
					Object claObj = iter.next();
					if (claObj instanceof OWLClass) {
						if (matchEntity((OWLClass) claObj, lookup)) classSet.add(claObj);
					}
				}
				
				// find matching properties
				Set props = new HashSet();
				if (lookupPanel.searchImports) {
					props.addAll(swoopModel.getEntitySet(ont, SwoopModel.BASE_ONT, SwoopModel.PROPERTIES));				
				}
				iter = props.iterator();
				while (iter.hasNext()) {
					OWLProperty prop = (OWLProperty) iter.next();
					if (matchEntity(prop, lookup)) propSet.add(prop);				
				}
				
				// find matching individuals
				Set inds = new HashSet();
				if (lookupPanel.searchImports) inds.addAll(swoopModel.getEntitySet(ont, SwoopModel.BASE_ONT, SwoopModel.INDIVIDUALS));
				iter = inds.iterator();
				while (iter.hasNext()) {
					OWLIndividual ind = (OWLIndividual) iter.next();
					if (matchEntity(ind, lookup)) instSet.add(ind);				
				}	
			}
			
			// display lookupPanel JFrame
			String scope = "<font color=\"blue\">Ontology: <a href=\""+currOnt.getURI()+"\">"+swoopModel.shortForm(currOnt.getURI())+ "</a> OR in its Imports Closure</font>";
			if (searchAllChk.isSelected()) scope += " <font color=\"green\"><br>OR in External ontologies</font>";
			lookupPanel.printResults(swoopModel.selectedOntology, classS