ontologyvisualizationviewer.java

来自「Semantic Web Ontology Editor」· Java 代码 · 共 1,510 行 · 第 1/3 页

		this.statusCallback = scb;
	}

	/**
	 *  
	 */
	public synchronized void stop() {
		manualSuspend = false;
		suspended = false;
		stop = true;
		synchronized (pauseObject) {
			pauseObject.notifyAll();
		}
	}

	public void setToolTipListener(ToolTipListener listener) {
		this.toolTipListener = listener;
		setToolTipText("VisViewer"); // something to make tool tips happen at
									 // all
	}

	public String getToolTipText(MouseEvent event) {
		if (toolTipListener != null) {
			return toolTipListener.getToolTipText(event);
		} else {
			return getToolTipText();
		}
	}

	public void resetSelectedNode() 
	{
		if (previousSelectedNodes != null) 
		{
			for (Iterator it = previousSelectedNodes.iterator(); it.hasNext();) 
			{
				ClassTreeNode previousSelectedNode = (ClassTreeNode) it.next();
				previousSelectedNode.setIsSelected(false);
			}
		}
	}

	// used when user traverses through the Class list history
	public void setSelectedNodeWithoutAddingHistory(ClassTreeNode node) {
		resetSelectedNode(); // reset selectred nodes
		resetHighlightedNode(); // reset highlighted nodes
		resetListBrowsedNode(); // reset listbrowsed node
		currentSelectedNode = node; // set selected node
		previousSelectedNodes = new HashSet(); // clean up old vector
		previousSelectedNodes = node.getOntologyNode().findNodesBy( node.getURI() ); // set new node to be previous
		// set new nodes to be selected
		for (Iterator it = previousSelectedNodes.iterator(); it.hasNext();) {
			ClassTreeNode previousSelectedNode = (ClassTreeNode) it.next();
			previousSelectedNode.setIsSelected(true);
		}
	}

	public void setSelectedNode(ClassTreeNode node) 
	{
		if ( node == currentSelectedNode )
			return; // don't the new node is the same as the current one
			
		resetSelectedNode(); // reset selectred nodes
		resetHighlightedNode(); // reset highlighted nodes
		resetListBrowsedNode(); // reset listbrowsed node
		previousSelectedNodes = new HashSet(); // clean up old vector

		currentSelectedNode = node; // set selected node
		
		// set new node to be previous
		DirectedSparseGraph graph = myGraph.getVisualGraph();
		Set vertexSet = graph.getVertices();
		if (node.getParent() == null) // selected node is a OWL:Thing
		{
			OntologyGraphNode graphNode = node.getOntologyNode();
			previousSelectedNodes.addAll(graphNode.findNodesBy(node.getURI()));
		} else {
			for (Iterator it = vertexSet.iterator(); it.hasNext();) {
				DirectedSparseVertex vertex = (DirectedSparseVertex) it.next();
				OntologyGraphNode graphNode = (OntologyGraphNode) vertex.getUserDatum(OntologyWithClassHierarchyGraph.DATA);
				previousSelectedNodes.addAll(graphNode.findNodesBy(node.getURI()));
			}
		}

		// set new nodes to be selected
		for (Iterator it = previousSelectedNodes.iterator(); it.hasNext();) {
			ClassTreeNode previousSelectedNode = (ClassTreeNode) it.next();
			previousSelectedNode.setIsSelected(true);
		}
		myGraph.populateClassList(node); // reload classList tree
	}

	public void resetHighlightedNode() {
		if (previousHighlightedNodes != null) {
			for (Iterator it = previousHighlightedNodes.iterator(); it
					.hasNext();) {
				ClassTreeNode previousHighlighteddNode = (ClassTreeNode) it
						.next();
				previousHighlighteddNode.setIsHighlighted(false);
			}
		}
	}

	public void resetListBrowsedNode() {
		if (listBrowsedNode != null)
			listBrowsedNode.setIsListBrowsed(false);
	}

	public void setHighlightedNodeWithoutAddingHistory(Set nodes) {
		resetSelectedNode(); // reset selectred nodes
		resetHighlightedNode(); // reset highlighted nodes
		resetListBrowsedNode(); // reset listbrowsed node
		previousHighlightedNodes = nodes; // clean up old vector
		for (Iterator it = previousHighlightedNodes.iterator(); it.hasNext();) {
			ClassTreeNode previousHighlightedNode = (ClassTreeNode) it.next();
			previousHighlightedNode.setIsHighlighted(true);
		}
	}

	public void setHighlightedNode(Set nodes, String subText) {
		resetSelectedNode(); // reset selectred nodes
		resetHighlightedNode(); // reset highlighted nodes
		resetListBrowsedNode(); // reset listbrowsed node
		previousHighlightedNodes = nodes;
		for (Iterator it = previousHighlightedNodes.iterator(); it.hasNext();) {
			ClassTreeNode previousHighlightedNode = (ClassTreeNode) it.next();
			previousHighlightedNode.setIsHighlighted(true);
		}
		myGraph.populateClassListWithSearchTerm(nodes, subText); // reload
																 // classList
																 // tree
	}

	public SwoopOntologyVertex getSelectedVertex() {
		return previousSelectedVertex;
	}

	public ClassTreeNode getListBrowsedNode() {
		return listBrowsedNode;
	}

	public void setListBrowsedNode(ClassTreeNode node) {
		if (listBrowsedNode != null)
			listBrowsedNode.setIsListBrowsed(false);
		listBrowsedNode = node;
		node.setIsListBrowsed(true);
	}

	public ClassTreeNode getRightSelectedNode() {
		return rightSelectedNode;
	}
	
	public ClassTreeNode getCurrentSelectedNode()
	{ return currentSelectedNode; }
	
	
	public boolean isNodeOnScreen( ClassTreeNode targetNode )
	{
		int screenWidth = this.getWidth();
		int screenHeight = this.getHeight();
		Point2D.Double point = targetNode.getGlobalCenter();
		
		
		int ulx = (int)(point.x - (targetNode.getRadius() * this.getScaleX()) );
		int uly = (int)(point.y - (targetNode.getRadius()* this.getScaleX()) );
		int brx = (int)(point.x + (targetNode.getRadius()* this.getScaleX()) );
		int bry = (int)(point.y + (targetNode.getRadius()* this.getScaleX()) );
		
		//System.out.println("Parent Center: " + point.x + " " + point.y );
		//System.out.println( "(" + ulx + "," + uly + ") , (" + brx + "," + bry + ")" );
		if ( (ulx > 0) && (uly > 0) && (brx < screenWidth) && (bry < screenHeight) )
			return true;
		return false;
	}
	
	public void smartPanZoomToNode( ClassTreeNode targetNode, ClassTreeNode topNode )
	{
		int screenWidth = this.getWidth();
		int screenHeight = this.getHeight();
		Point2D.Double point = targetNode.getGlobalCenter();
		if (targetNode == topNode)
			point = (Point2D.Double) this.transformGraph2Screen(targetNode.getLocalCenter());

		if (  ( targetNode.getSubtreeDepth() > 6 ) || (targetNode.getNumChildren() > 75)  )
		{
			panZoomToFitNode( targetNode, topNode );
			return;
		}
		
		double r = targetNode.getRadius();
		double screenR = r * this.getScaleX();
		double screenD = 2 * screenR;
		if ( ((screenD) > screenWidth) && ((screenD) > screenHeight) )
		{
			panZoomToFitNode( targetNode, topNode ); 
		}
		else if ( screenD < 75 )
		{
			panZoomToFitNode( targetNode, topNode );
		}
	}

	public void panZoomToFitNode( ClassTreeNode targetNode, ClassTreeNode topNode )
	{
		//System.out.println("targetNode: " + targetNode.getURI() );
		//System.out.println("topNode:    " + topNode.getURI() );
		int screenWidth = this.getWidth();
		int screenHeight = this.getHeight();
		Point2D.Double point = targetNode.getGlobalCenter();
		if (targetNode == topNode)
			point = (Point2D.Double) this.transformGraph2Screen(targetNode.getLocalCenter());

		double r = targetNode.getRadius();
		if (targetNode == topNode)
			r = topNode.getOntologyNode().getRadius();
		
		double min = Math.min(screenHeight, screenWidth);
		double scaleX = min / (2 * r) / this.getScaleX();
		double scaleY = scaleX;

		double hw = screenWidth / 2;
		double hh = screenHeight / 2;
		double translateOffsetX = (hw - point.x)/ this.getScaleX();
		double translateOffsetY = (hh - point.y)/ this.getScaleX();
		this.translate(translateOffsetX, translateOffsetY);
		this.scale(scaleX, scaleY);
		//System.out.println(" translate x, y = " + translateOffsetX + " " + translateOffsetY);
		//System.out.println(" scalex = " + scaleX );
	}

	
	/**
	 * an interface for the preRender and postRender
	 */
	public interface Paintable {
		public void paint(Graphics g);

		public boolean useTransform();
	}

	/**
	 * a convenience type to represent a class that processes all types of mouse
	 * events for the graph
	 */
	public interface GraphMouse extends MouseListener, MouseMotionListener,
			MouseWheelListener {
	}

	/**
	 * this is the original GraphMouse class, renamed to use GraphMouse as the
	 * interface name, and updated to correctly apply the vv transform to the
	 * point point
	 *  
	 */
	protected final class GraphMouseImpl extends MouseAdapter implements GraphMouse 
	{
		protected Vertex picked;

		protected OntologyVisualizationViewer myViewer = null;

		public GraphMouseImpl(OntologyVisualizationViewer v) {
			myViewer = v;
		}

		public void mouseClicked(MouseEvent e)
		{}
		
		public void mousePressed(MouseEvent e) 
		{
			if (DEBUG)
			{
				System.out.println("mousePressed (screenspace): " + e.getX() + " " + e.getY() );
				Point2D gp = transform( new Point2D.Double( e.getX(), e.getY() ));
				System.out.println("mousePressed (graph space): " + gp.getX() + " " + gp.getY() );
			}
			// find the circle that's picked, if any
			Point2D p = transform(e.getPoint());
			Vertex v = pickSupport.getVertex(p.getX(), p.getY());
			picked = v;
			previousSelectedVertex = (SwoopOntologyVertex) v;
			OntologyWithClassHierarchyRenderer rend = (OntologyWithClassHierarchyRenderer) renderer;

			// refit the vertices into the viewport when double-clicked on whitespace
			if (SwingUtilities.isLeftMouseButton(e) && (e.getClickCount() == 2)) 
			{
				if (!rend.getIsDrawContent() || picked == null) {
					autoPanZoomTest();
					return;
				}
			}
			
			
			if (rend.getIsDrawContent()) 
			{
				// if no vertex selected, we exit
				if (v == null) 
				{
					previousSelectedVertex = null;
					return;
				}

				// left click...
				if (SwingUtilities.isLeftMouseButton(e)) 
				{
					int shiftmask = MouseEvent.SHIFT_DOWN_MASK;
					if ((e.getModifiersEx() & shiftmask) == shiftmask) 
						handleRightClick(e, rend, p, v);
					else 
					{
						ClassTreeNode topNode = ((OntologyGraphNode) v.getUserDatum(OntologyWithClassHierarchyGraph.DATA)).getTreeNode();
						ClassTreeNode selectedNode = topNode.getSelectedChild(p);

						if (selectedNode == null)  // null selectedNode means user clicked on owl:Thing
							selectedNode = topNode;

						if (e.getClickCount() == 2) // zoom into the node
							panZoomToFitNode( selectedNode, topNode );
						
						myViewer.setSelectedNode( selectedNode );
					}
					pick(picked, true);
				}
				// right click...
				else if (SwingUtilities.isRightMouseButton(e)) {
					handleRightClick(e, rend, p, v);
				}
			}
			
			repaint();
		}

		private void handleRightClick(MouseEvent e,
				OntologyWithClassHierarchyRenderer rend, Point2D p, Vertex v) {
			ClassTreeNode selectedNode = null;
			if (rend.getIsDrawContent()) {
				ClassTreeNode topNode = ((OntologyGraphNode) v
						.getUserDatum(OntologyWithClassHierarchyGraph.DATA))
						.getTreeNode();
				selectedNode = topNode.getSelectedChild(p);
			}
			if (selectedNode == null)
				myGraph.showOntologyPopupMenu(e, v);
			else
				myGraph.showClassPopupMenu(e, selectedNode);
			rightSelectedNode = selectedNode;
		}

		public void mouseReleased(MouseEvent e) {
			if (picked == null)
				return;
			pick(picked, false);
			picked = null;
			repaint();
		}

		public void mouseDragged(MouseEvent e) {
			if (picked == null)
				return;
			Point2D p = transform(e.getPoint());

			layout.forceMove(picked, (int) p.getX(), (int) p.getY());
			repaint();
			//			drawSpot( e.getX(), e.getY() );
		}

		public void mouseMoved(MouseEvent e) {
			return;
		}

		public void mouseWheelMoved(MouseWheelEvent e) {
			return;
		}
	}

	/**
	 * @param paintable
	 *            The paintable to add.
	 */
	public void addPreRenderPaintable(Paintable paintable) {
		if (preRenderers == null) {
			preRenderers = new ArrayList();
		}
		preRenderers.add(paintable);
	}

	/**
	 * @param paintable
	 *            The paintable to remove.
	 */
	public void removePreRenderPaintable(Paintable paintable) {
		if (preRenderers != null) {
			preRenderers.remove(paintable);
		}
	}

	/**
	 * @param paintable
	 *            The paintable to add.
	 */
	public void addPostRenderPaintable(Paintable paintable) {
		if (postRenderers == null) {
			postRenderers = new ArrayList();
		}
		postRenderers.add(paintable);
	}

	/**
	 * @param paintable
	 *            The paintable to remove.
	 */
	public void removePostRenderPaintable(Paintable paintable) {
		if (postRenderers != null) {
			postRenderers.remove(paintable);
		}
	}

	/**
	 * Adds a <code>ChangeListener</code>.
	 * 
	 * @param l
	 *            the listener to be added
	 */
	public void addChangeListener(ChangeListener l) {
		listenerList.add(ChangeListener.class, l);
	}

	/**
	 * Removes a ChangeListener.
	 * 
	 * @param l
	 *            the listener to be removed
	 */
	public void removeChangeListener(ChangeListener l) {
		listenerList.remove(ChangeListener.class, l);
	}

	/**
	 * Returns an array of all the <code>ChangeListener</code> s added with
	 * addChangeListener().
	 * 
	 * @return all of the <code>ChangeListener</code> s added or an empty
	 *         array if no listeners have been added
	 */
	public ChangeListener[] getChangeListeners() {
		return (ChangeListener[]) (listenerList
				.getListeners(ChangeListener.class));
	}

	/**
	 * Notifies all listeners that have registered interest for notification on
	 * this event type. The event instance is lazily created.
	 * 
	 * @see EventListenerList
	 */
	protected void fireStateChanged() {
		// Guaranteed to return a non-null array
		Object[] listeners = listenerList.getListenerList();
		// Process the listeners last to first, notifying
		// those that are interested in this event
		for (int i = listeners.length - 2; i >= 0; i -= 2) {
			if (listeners[i] == ChangeListener.class) {
				// Lazily create the event:
				if (changeEvent == null)
					changeEvent = new ChangeEvent(this);
				((ChangeListener) listeners[i + 1]).stateChanged(changeEvent);
			}
		}
	}

	/**
	 * @return Returns the pickedState.
	 */
	public PickedState getPickedState() {
		return pickedState;
	}

	/**
	 * @param pickedState
	 *            The pickedState to set.
	 */
	public void setPickedState(PickedState pickedState) {
		this.pickedState = pickedState;
		if (layout instanceof PickEventListener)
			pickedState.addListener((PickEventListener) layout);
	}

	/**
	 * @return Returns the pickSupport.
	 */
	public PickSupport getPickSupport() {
		return pickSupport;
	}

	/**
	 * @param pickSupport
	 *            The pickSupport to set.
	 */
	public void setPickSupport(PickSupport pickSupport) {
		this.pickSupport = pickSupport;
	}	

}