edu.uci.ics.jung.visualization.VisualizationViewer.java Source code

Introduction

Here is the source code for edu.uci.ics.jung.visualization.VisualizationViewer.java

Source

/*
* Copyright (c) 2003, the JUNG Project and the Regents of the University 
* of California
* All rights reserved.
*
* This software is open-source under the BSD license; see either
* "license.txt" or
* http://jung.sourceforge.net/license.txt for a description.
*/
package edu.uci.ics.jung.visualization;

import java.awt.Dimension;
import java.awt.event.KeyListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.MouseWheelListener;
import java.awt.geom.Point2D;

import javax.swing.ToolTipManager;

import org.apache.commons.collections15.Transformer;

import edu.uci.ics.jung.algorithms.layout.Layout;
import edu.uci.ics.jung.visualization.control.GraphMouseListener;
import edu.uci.ics.jung.visualization.control.MouseListenerTranslator;

/**
 * Adds mouse behaviors and tooltips to the graph visualization base class
 * 
 * @author Joshua O'Madadhain
 * @author Tom Nelson 
 * @author Danyel Fisher
 */
@SuppressWarnings("serial")
public class VisualizationViewer<V, E> extends BasicVisualizationServer<V, E> {

    protected Transformer<V, String> vertexToolTipTransformer;
    protected Transformer<E, String> edgeToolTipTransformer;
    protected Transformer<MouseEvent, String> mouseEventToolTipTransformer;

    /**
     * provides MouseListener, MouseMotionListener, and MouseWheelListener
     * events to the graph
     */
    protected GraphMouse graphMouse;

    protected MouseListener requestFocusListener = new MouseAdapter() {
        public void mouseClicked(MouseEvent e) {
            requestFocusInWindow();
        }
    };

    /**
     * Create an instance with passed parameters.
     * 
     * @param layout      The Layout to apply, with its associated Graph
     * @param renderer      The Renderer to draw it with
     */
    public VisualizationViewer(Layout<V, E> layout) {
        this(new DefaultVisualizationModel<V, E>(layout));
    }

    /**
     * Create an instance with passed parameters.
     * 
     * @param layout      The Layout to apply, with its associated Graph
     * @param renderer      The Renderer to draw it with
     * @param preferredSize the preferred size of this View
     */
    public VisualizationViewer(Layout<V, E> layout, Dimension preferredSize) {
        this(new DefaultVisualizationModel<V, E>(layout, preferredSize), preferredSize);
    }

    /**
     * Create an instance with passed parameters.
     * 
     * @param model
     * @param renderer
     */
    public VisualizationViewer(VisualizationModel<V, E> model) {
        this(model, new Dimension(600, 600));
    }

    /**
     * Create an instance with passed parameters.
     * 
     * @param model
     * @param renderer
     * @param preferredSize initial preferred size of the view
     */
    @SuppressWarnings("unchecked")
    public VisualizationViewer(VisualizationModel<V, E> model, Dimension preferredSize) {
        super(model, preferredSize);
        setFocusable(true);
        addMouseListener(requestFocusListener);
    }

    /**
     * a setter for the GraphMouse. This will remove any
     * previous GraphMouse (including the one that
     * is added in the initMouseClicker method.
     * @param graphMouse new value
     */
    public void setGraphMouse(GraphMouse graphMouse) {
        this.graphMouse = graphMouse;
        MouseListener[] ml = getMouseListeners();
        for (int i = 0; i < ml.length; i++) {
            if (ml[i] instanceof GraphMouse) {
                removeMouseListener(ml[i]);
            }
        }
        MouseMotionListener[] mml = getMouseMotionListeners();
        for (int i = 0; i < mml.length; i++) {
            if (mml[i] instanceof GraphMouse) {
                removeMouseMotionListener(mml[i]);
            }
        }
        MouseWheelListener[] mwl = getMouseWheelListeners();
        for (int i = 0; i < mwl.length; i++) {
            if (mwl[i] instanceof GraphMouse) {
                removeMouseWheelListener(mwl[i]);
            }
        }
        addMouseListener(graphMouse);
        addMouseMotionListener(graphMouse);
        addMouseWheelListener(graphMouse);
    }

    /**
     * @return the current <code>GraphMouse</code>
     */
    public GraphMouse getGraphMouse() {
        return graphMouse;
    }

    /**
     * This is the interface for adding a mouse listener. The GEL
     * will be called back with mouse clicks on vertices.
     * @param gel
     */
    public void addGraphMouseListener(GraphMouseListener<V> gel) {
        addMouseListener(new MouseListenerTranslator<V, E>(gel, this));
    }

    /** 
     * Override to request focus on mouse enter, if a key listener is added
     * @see java.awt.Component#addKeyListener(java.awt.event.KeyListener)
     */
    @Override
    public synchronized void addKeyListener(KeyListener l) {
        super.addKeyListener(l);
        //      setFocusable(true);
        //      addMouseListener(requestFocusListener);
    }

    /**
     * @param edgeToolTipTransformer the edgeToolTipTransformer to set
     */
    public void setEdgeToolTipTransformer(Transformer<E, String> edgeToolTipTransformer) {
        this.edgeToolTipTransformer = edgeToolTipTransformer;
        ToolTipManager.sharedInstance().registerComponent(this);
    }

    /**
     * @param mouseEventToolTipTransformer the mouseEventToolTipTransformer to set
     */
    public void setMouseEventToolTipTransformer(Transformer<MouseEvent, String> mouseEventToolTipTransformer) {
        this.mouseEventToolTipTransformer = mouseEventToolTipTransformer;
        ToolTipManager.sharedInstance().registerComponent(this);
    }

    /**
     * @param vertexToolTipTransformer the vertexToolTipTransformer to set
     */
    public void setVertexToolTipTransformer(Transformer<V, String> vertexToolTipTransformer) {
        this.vertexToolTipTransformer = vertexToolTipTransformer;
        ToolTipManager.sharedInstance().registerComponent(this);
    }

    /**
     * called by the superclass to display tooltips
     */
    public String getToolTipText(MouseEvent event) {
        Layout<V, E> layout = getGraphLayout();
        Point2D p = null;
        if (vertexToolTipTransformer != null) {
            p = event.getPoint();
            //renderContext.getBasicTransformer().inverseViewTransform(event.getPoint());
            V vertex = getPickSupport().getVertex(layout, p.getX(), p.getY());
            if (vertex != null) {
                return vertexToolTipTransformer.transform(vertex);
            }
        }
        if (edgeToolTipTransformer != null) {
            if (p == null)
                p = renderContext.getMultiLayerTransformer().inverseTransform(Layer.VIEW, event.getPoint());
            E edge = getPickSupport().getEdge(layout, p.getX(), p.getY());
            if (edge != null) {
                return edgeToolTipTransformer.transform(edge);
            }
        }
        if (mouseEventToolTipTransformer != null) {
            return mouseEventToolTipTransformer.transform(event);
        }
        return super.getToolTipText(event);
    }

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

}