treerenderer.java

Semantic Web Ontology Editor

		// put class tree in cache
		swoopModel.getClassTreeCache().putTree(ontology, reasoner, classTree);
		System.out.println(ontology.getURI() + " class tree put in cache");
		return classTree;
	}

	SwoopTreeNode createClassTree( Set concepts, Set ancestors ) throws OWLException {
		if (concepts.contains(owlNothing))
			return null;

		SwoopTreeNode root = createNode(concepts);
		
		if (concepts.isEmpty())
			return root;

		SwoopReasoner reasoner = swoopModel.getReasoner();
		Object obj = concepts.iterator().next();
		
		if (obj instanceof OWLClass) 
		{
			OWLClass c = (OWLClass) obj;
//			 filter rules classes Impl, ClassAtom, IndividualPropertyAtom,
			// etc.
			if (c.getURI().getPath().equals("/2003/11/swrl"))
				return null;
			Set subs = reasoner.subClassesOf(c);
			Iterator i = subs.iterator();
			ancestors.add( concepts );
			
			while (i.hasNext()) 
			{
				Set set = (Set) i.next();
				if (set.contains(c))
					continue;

				SortedSet sortedSet = orderedEntities(set);
				
				// if ancestors set contains the subclass set then we have a cycle
				if ( ancestors.contains( set ) )
				{
					root.addUserObject( SwoopTreeNode.IS_IN_CYCLE, SwoopTreeNode.TRUE );
					OWLClass cycleHead = (OWLClass)set.iterator().next();
					root.addUserObject( SwoopTreeNode.CYCLE_HEAD, cycleHead );
					continue;
				}
				SwoopTreeNode node = createClassTree(sortedSet, ancestors);
				
				// do not add owl:Nothing to the tree
				if (node != null) {
					int index = 0;
					for (; index < root.getChildCount(); index++) {
						DefaultMutableTreeNode child = (DefaultMutableTreeNode) root
								.getChildAt(index);
						SortedSet otherSet = (SortedSet) child.getUserObject();

						OWLEntity c1 = (OWLEntity) sortedSet.first();
						OWLEntity c2 = (OWLEntity) otherSet.first();

						if (EntityComparator.INSTANCE.compare(
								sortedSet.first(), otherSet.first()) < 0)
							break;
					}

					root.insert(node, index);
				}
			}
			ancestors.remove( concepts );
		}

		return root;
	}

	/**
	 * Count the number of entities of a given type.
	 * @param ontology The ontology to be inspected.  If swoopModel.getShowImports(),
	 *        use the import closure.
	 * @param entityType '0' for classes, '1' for properties (excluding Annotation 
	 *        properties).
	 * @return The number of entities.
	 */
	private int getEntityCount(OWLOntology ontology, int entityType) {
		int count = 0;
		try {
			Set ontologies = Collections.singleton(ontology);
			if (swoopModel.getShowImports()) {
				ontologies = OntologyHelper.importClosure(ontology);
			}
			for (Iterator iter = ontologies.iterator(); iter.hasNext();) {
				OWLOntology ont = (OWLOntology) iter.next();
				switch (entityType) {
				case 0:// class count
					count += ont.getClasses().size();
					break;
				case 1:// prop count
					count += ont.getDataProperties().size();
					count += ont.getObjectProperties().size();
					break;
				}
			}
		} catch (OWLException ex) {
			ex.printStackTrace();
		}
		return count;
	}

	SwoopTreeNode createNode(OWLEntity entity) {
		return new SwoopTreeNode(Collections.singleton(entity));
	}

	SwoopTreeNode createNode(Set set) {
		return new SwoopTreeNode(set);
	}

	private SortedSet orderedEntities(Set entities) {
		SortedSet ss = new TreeSet(EntityComparator.INSTANCE);
		ss.addAll(entities);
		return ss;
	}

	public JTree getPropertyTree(JTree currentTree) throws Exception {
		System.out.println("Create prop tree");

		SwoopReasoner reasoner = swoopModel.getReasoner();
		OWLOntology ontology = reasoner.getOntology();
		JTree propTree = null;

		Font newFont = new Font(swoopModel.getFontFace(), Font.PLAIN,
				3 + 3 * Integer.parseInt(swoopModel.getFontSize()));

		if (ontology == null)
			return propTree;

		propTree = swoopModel.getPropTreeCache().getTree(ontology, reasoner);

		// check if ontology is in cache -> get property tree from cache
		if (propTree != null) {
			propTree.setFont(newFont);
			System.out.println("loading prop tree from cache");
			return propTree;
		}

		OWLClass owlThing = ontology.getOWLDataFactory().getOWLThing();
		SwoopTreeNode root = createNode(owlThing);

		propTree = new JTree(new DefaultTreeModel(root));
		propTree.setFont(newFont);
		propTree.setCellRenderer(treeCellRenderer);
		propTree.setLargeModel(true); // resize qname toggle node labels

		SortedSet set = orderedEntities(reasoner.getProperties());
//		 filter rules properties argument1, argument2, body, classPredicate,
		// etc.
		for (Iterator it = set.iterator(); it.hasNext();) {
			OWLEntity entity = (OWLEntity) it.next();
			if (entity.getURI().getPath().equals("/2003/11/swrl") )
				it.remove();		
		}
		Iterator i = set.iterator();
		while (i.hasNext()) {
			OWLProperty prop = (OWLProperty) i.next();
			Set eqProps = reasoner.equivalentPropertiesOf(prop);
			Set superProps = reasoner.superPropertiesOf(prop);
			if (superProps.size() > 0)
				continue;
			eqProps.add(prop);
			root.add(createPropertyTree(eqProps));
		}

		propTree.setModel(new DefaultTreeModel(root));

		if (this.getEntityCount(ontology, 1) < Integer.parseInt(swoopModel
				.getTreeThreshold())) {
			// expand each node, if property count < threshold
			for (int row = 1;; row++) {
				if (propTree.getPathForRow(row) != null)
					propTree.expandRow(row);
				else
					break;
			}
		} else {
			// dont expand each node in tree
			// check for current open nodes and expand only those
			if (currentTree != null
					&& this.useOldPropertyTreeReferenceforExpansion) {
				this.useOldPropertyTreeReferenceforExpansion = false;
				Enumeration enu = currentTree
						.getExpandedDescendants(currentTree.getPathForRow(0));
				if (enu != null) {
					while (enu.hasMoreElements()) {
						TreePath path = (TreePath) enu.nextElement();
						int row = currentTree.getRowForPath(path);
						propTree.expandRow(row);
					}
				}
			}
		}

		propTree.setRootVisible(false);
		propTree.setShowsRootHandles(true);
		propTree.setFont(newFont);

		// put property tree in cache
		swoopModel.getPropTreeCache().putTree(ontology, reasoner, propTree);
		System.out.println(ontology.getURI() + " prop tree put in cache");

		return propTree;
	}

	SwoopTreeNode createPropertyTree(Set props) throws OWLException {

		SwoopTreeNode root = createNode(props);

		Object obj = props.iterator().next();
		if (obj instanceof OWLProperty) {

			OWLProperty prop = (OWLProperty) obj;
			SwoopReasoner reasoner = swoopModel.getReasoner();
			Set subs = reasoner.subPropertiesOf(prop);

			Iterator i = subs.iterator();
			while (i.hasNext()) {
				SortedSet set = orderedEntities((Set) i.next());
				if (set.contains(prop))
					continue;

				SwoopTreeNode node = createPropertyTree(set);

				int index = 0;
				for (; index < root.getChildCount(); index++) {
					DefaultMutableTreeNode child = (DefaultMutableTreeNode) root
							.getChildAt(index);
					SortedSet otherSet = (SortedSet) child.getUserObject();

					OWLEntity c1 = (OWLEntity) set.first();
					OWLEntity c2 = (OWLEntity) otherSet.first();

					if (EntityComparator.INSTANCE.compare(set.first(), otherSet
							.first()) < 0)
						break;
				}

				root.insert(node, index);
			}
		}

		return root;
	}

	private String getShortForm(URI uri) {
		return shortFormProvider.shortForm(uri);
	}

	/**
	 * @return Returns the shortFormProvider.
	 */
	public ShortFormProvider getShortFormProvider() {
		return shortFormProvider;
	}

	/**
	 * @param shortFormProvider
	 *            The shortFormProvider to set.
	 */
	public void setShortFormProvider(ShortFormProvider shortFormProvider) {
		this.shortFormProvider = shortFormProvider;
	}

	public void setSwoopModel(SwoopModel swoopModel) {
		this.swoopModel = swoopModel;
	}

	public void removeClassTreeCacheEntry(OWLOntology ont) {
		swoopModel.getClassTreeCache().removeOntology(ont);
	}

	public void removeClassTreeCacheEntry(OWLOntology ont,
			SwoopReasoner reasoner) {
		swoopModel.getClassTreeCache().putTree(ont, reasoner, null);
	}

	public void removePropTreeCacheEntry(OWLOntology ont) {
		swoopModel.getPropTreeCache().removeOntology(ont);
	}

	public void removePropTreeCacheEntry(OWLOntology ont, SwoopReasoner reasoner) {
		swoopModel.getPropTreeCache().putTree(ont, reasoner, null);
	}
	
	public void export( JTree tree, String type, File file, SwoopModel model)
	{ TreeSerializer.export( tree, type, file, model); }
	
}