Example usage for org.apache.commons.collections15 Transformer Transformer

List of usage examples for org.apache.commons.collections15 Transformer Transformer

Introduction

In this page you can find the example usage for org.apache.commons.collections15 Transformer Transformer.

Prototype

Transformer

Source Link

Usage

From source file:eu.cassandra.csn.gui.CSN.java

/**
 * /*from w w  w.  jav a  2 s  .c om*/
 */
private static void setUpVV() {
    vv.setBackground(Color.white);
    vv.getRenderContext()
            .setVertexFillPaintTransformer(MapTransformer.<MyNode, Paint>getInstance(vertexPaints));
    vv.getRenderContext().setVertexShapeTransformer(vertexSize);
    vv.getRenderContext().setVertexLabelTransformer(new ToStringLabeller<MyNode>());
    vv.getRenderContext().setEdgeLabelTransformer(new ToStringLabeller<MyLink>());
    vv.getRenderContext().setVertexDrawPaintTransformer(new Transformer<MyNode, Paint>() {
        public Paint transform(MyNode v) {
            if (vv.getPickedVertexState().isPicked(v)) {
                return Color.cyan;
            } else {
                return Color.BLACK;
            }
        }
    });
    vv.getRenderContext().setEdgeDrawPaintTransformer(MapTransformer.<MyLink, Paint>getInstance(edgePaints));
    vv.getRenderContext().setEdgeStrokeTransformer(new Transformer<MyLink, Stroke>() {
        protected final Stroke THIN = new BasicStroke((float) 0.5);
        protected final Stroke THICK = new BasicStroke(1);

        public Stroke transform(MyLink e) {
            Paint c = edgePaints.get(e);
            if (c == Color.LIGHT_GRAY) {
                return THIN;
            } else {
                return THICK;
            }
        }
    });
    vv.setGraphMouse(gm);
    vv.getPickedVertexState().addItemListener(new VertexPickListener());

}

From source file:de.uniba.wiai.kinf.pw.projects.lillytab.reasoner.abox.RABox.java

@Override
public Collection<IABoxNode<I, L, K, R>> getPredecessorNodes() {
    return ExtractorCollection.decorate(getPredecessors(), new Transformer<NodeID, IABoxNode<I, L, K, R>>() {
        @Override/*  w w w  .  ja v  a 2s . c  om*/
        public IABoxNode<I, L, K, R> transform(NodeID input) {
            return _node.getABox().getNode(input);
        }
    });
}

From source file:de.naoth.xabsleditor.graphpanel.AgentVisualizer.java

private void doSetGraph(final XABSLContext context, final String selectedNodeName, String selectedAgentName) {

    // build graph
    final DirectedGraph<XabslNode, XabslEdge> graph = new DirectedSparseGraph<XabslNode, XabslEdge>();
    selectedNode = createAgentGraph(context, graph, selectedNodeName, selectedAgentName);

    if (selectedAgentName == null) {
        layout = new SuperDAGLayout<XabslNode, XabslEdge>(graph);
    } else {/* w  w  w  . java 2s.c o  m*/
        layout = new SuperDAGLayout<XabslNode, XabslEdge>(graph, 80, 120);
    }

    layout.initialize();

    if (scrollPane != null) {
        remove(scrollPane);
        scrollPane = null;
    }

    vv = new VisualizationViewer<XabslNode, XabslEdge>(layout);
    DefaultModalGraphMouse<XabslNode, XabslEdge> mouse = new DefaultModalGraphMouse<XabslNode, XabslEdge>();
    vv.setGraphMouse(mouse);

    // enable selecting the nodes
    mouse.setMode(ModalGraphMouse.Mode.TRANSFORMING);
    // add external mouse listener
    if (externalMouseListener != null) {
        vv.addGraphMouseListener(externalMouseListener);
    }

    vv.getRenderContext().setVertexShapeTransformer(new VertexTransformer(graph));
    vv.getRenderContext().setVertexLabelTransformer(new Transformer<XabslNode, String>() {

        @Override
        public String transform(XabslNode n) {
            return "<html><center>" + n.getName().replaceAll("_", "_<br>") + "</center></html>";
        }
    });
    vv.getRenderContext().setVertexFillPaintTransformer(new Transformer<XabslNode, Paint>() {

        @Override
        public Paint transform(XabslNode n) {
            if (n == selectedNode) {
                return Color.green;
            }
            if (selectedNode != null && graph.getSuccessors(selectedNode).contains(n)) {
                return Color.red;
            }
            if (selectedNode != null && graph.getPredecessors(selectedNode).contains(n)) {
                return Color.orange;
            }
            if (graph.getOutEdges(n).size() == 0) {
                return Color.lightGray;
            }
            return Color.white;
        }
    });

    // label is placed in the center of the node
    vv.getRenderer().getVertexLabelRenderer().setPosition(Renderer.VertexLabel.Position.CNTR);

    vv.getRenderContext().setEdgeShapeTransformer(new EdgeShape.QuadCurve<XabslNode, XabslEdge>());
    vv.getRenderContext().setEdgeDrawPaintTransformer(new Transformer<XabslEdge, Paint>() {

        @Override
        public Paint transform(XabslEdge e) {
            if (selectedNode != null && graph.getSource(e) == selectedNode) {
                return Color.red;
            } else if (selectedNode != null && graph.getDest(e) == selectedNode) {
                return Color.ORANGE;
            } else {
                return Color.black;
            }
        }
    });

    // add to a zoomable container
    scrollPane = new GraphZoomScrollPane(vv);
    panelGraph.add(scrollPane, BorderLayout.CENTER);

    validate();

    fitGraphinPanel();
    recreateAgentSelector(context);
}

From source file:graphviewer.GraphCreate.java

/**
 * Create an instance of a directed graph
 *///from  w ww.  j a  v  a  2 s  .com
public GraphCreate() {
    super("SCCFinder");
    this.graph = new DirectedSparseMultigraph<Integer, Integer>();
    this.layout = new StaticLayout<Integer, Integer>(this.graph, new Dimension(600, 600));
    final Transformer<Integer, Paint> redVertexPaint = new Transformer<Integer, Paint>() {
        public Paint transform(Integer i) {
            return Color.RED;
        }
    };

    this.vv = new VisualizationViewer<Integer, Integer>(this.layout);
    this.vv.setBackground(Color.white);
    this.vv.getRenderContext().setVertexLabelTransformer(new ToStringLabeller<Integer>());
    this.vv.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR);
    Container content = getContentPane();
    content.add(this.vv);
    this.vv.getRenderContext().setVertexFillPaintTransformer(redVertexPaint);

    // add listeners to our visual component
    Factory<Integer> vertexFactory = new VertexFactory();
    Factory<Integer> edgeFactory = new EdgeFactory();
    this.graphMouse = new EditingModalGraphMouse<Integer, Integer>(this.vv.getRenderContext(), vertexFactory,
            edgeFactory);
    this.vv.setGraphMouse(this.graphMouse);
    this.vv.addKeyListener(new MyKeyListener());
    final MouseListener[] mls = (MouseListener[]) (this.vv.getListeners(MouseListener.class));
    final MouseListener wrapper = new MyWrapperMouseListener(mls[1]);

    this.graphMouse.setMode(ModalGraphMouse.Mode.EDITING);
    this.vv.setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
    this.controls = new JPanel();
    final ScalingControl scaler = new CrossoverScalingControl();
    // add some buttons
    this.plus = new JButton("+");
    this.plus.setToolTipText("Press this button or use the mouse wheel to zoom out");
    this.plus.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            scaler.scale(vv, 1.1f, vv.getCenter());
            setFocusable(false);
        }
    });
    this.minus = new JButton("-");
    this.minus.setToolTipText("Press this button or use the mouse wheel to zoom in");
    this.minus.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            scaler.scale(vv, 1 / 1.1f, vv.getCenter());
            setFocusable(false);
        }
    });
    this.edit = new JRadioButton("Editing");
    this.edit.setToolTipText("You can just press 'e' to select this radiobutton");
    this.edit.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            graphMouse.setMode(ModalGraphMouse.Mode.EDITING);
            vv.setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
            setFocusable(false);
        }
    });
    this.transform = new JRadioButton("Transforming");
    this.transform.setToolTipText("You can just press 't' to select this radiobutton");
    this.transform.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            graphMouse.setMode(ModalGraphMouse.Mode.TRANSFORMING);
            vv.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
            setFocusable(false);
        }
    });
    this.pick = new JRadioButton("Picking");
    this.pick.setToolTipText("You can just press 'p' to select this radiobutton");
    this.pick.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            graphMouse.setMode(ModalGraphMouse.Mode.PICKING);
            vv.setCursor(new Cursor(Cursor.HAND_CURSOR));
            setFocusable(false);
        }
    });
    GraphCreate.scc = new JButton("SCC");
    GraphCreate.scc.setToolTipText("Strongly Connected Components algorithm");
    GraphCreate.scc.setEnabled(false);
    GraphCreate.scc.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            createMathgraph();
            GraphCreate.scc.setEnabled(false);
            edit.setEnabled(false);
            pick.setSelected(true);
            setFocusable(false);
            sccButtonPressed = true;
            graphMouse.setMode(ModalGraphMouse.Mode.PICKING);
            vv.setCursor(new Cursor(Cursor.HAND_CURSOR));
            vv.removeMouseListener(mls[1]);
            vv.addMouseListener(wrapper);
        }
    });
    GraphCreate.clear = new JButton("Clear");
    GraphCreate.clear.setToolTipText("Clears our graph");
    GraphCreate.clear.setEnabled(false);
    GraphCreate.clear.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            for (int k = 0; k <= numberOfVertices; k++) {
                graph.removeVertex(k);
            }

            GraphCreate.scc.setEnabled(false);
            GraphCreate.clear.setEnabled(false);
            edit.setEnabled(true);
            edit.setSelected(true);
            setFocusable(false);
            graphMouse.setMode(ModalGraphMouse.Mode.EDITING);
            vv.setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
            vv.getRenderContext().setVertexFillPaintTransformer(redVertexPaint);

            if (sccButtonPressed) {
                vv.removeMouseListener(wrapper);
                vv.addMouseListener(mls[1]);
            }

            vv.repaint();
            // calling garbage collector here
            Runtime r = Runtime.getRuntime();
            r.gc();
            GraphCreate.numberOfEdges = 0;
            GraphCreate.numberOfVertices = 0;
            sccButtonPressed = false;
        }
    });

    ButtonGroup actions = new ButtonGroup();
    actions.add(this.edit);
    actions.add(this.transform);
    actions.add(this.pick);
    this.edit.setSelected(true);
    this.controls.add(this.plus);
    this.controls.add(this.minus);
    this.controls.add(this.edit);
    this.controls.add(this.transform);
    this.controls.add(this.pick);
    this.controls.add(GraphCreate.scc);
    controls.add(GraphCreate.clear);
    this.help = new JButton("Help");
    this.help.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            JOptionPane.showMessageDialog(vv, instructions);
            setFocusable(false);
        }
    });
    this.controls.add(this.help);
    content.add(this.controls, BorderLayout.SOUTH);
}

From source file:gui.WikiCorpusClusteringView.java

/**
 *
 * @param br//  ww w.  j  a  v a 2  s . c  o  m
 * @throws IOException
 */
private void setUpView(Graph graph) throws IOException {

    //Create a simple layout frame
    //specify the Fruchterman-Rheingold layout algorithm
    //        final AggregateLayout<Number, Number> layout =
    //                new AggregateLayout<Number, Number>(new FRLayout<Number, Number>(graph));

    //layout = new TreeLayout<String,Integer>(graph);
    Layout<Number, Number> layout = new KKLayout<Number, Number>(graph);
    layout.setSize(new Dimension(900, 900));

    vv = new VisualizationViewer<Number, Number>(layout);
    vv.setBackground(Color.white);
    //Tell the renderer to use our own customized color rendering
    vv.getRenderContext()
            .setVertexFillPaintTransformer(MapTransformer.<Number, Paint>getInstance(vertexPaints));
    vv.getRenderContext().setVertexDrawPaintTransformer(new Transformer<Number, Paint>() {
        public Paint transform(Number v) {
            if (vv.getPickedVertexState().isPicked(v)) {
                return Color.cyan;
            } else {
                return Color.BLACK;
            }
        }
    });

    vv.getRenderContext().setEdgeDrawPaintTransformer(MapTransformer.<Number, Paint>getInstance(edgePaints));

    vv.getRenderContext().setEdgeStrokeTransformer(new Transformer<Number, Stroke>() {
        protected final Stroke THIN = new BasicStroke(1);
        protected final Stroke THICK = new BasicStroke(2);

        public Stroke transform(Number e) {
            Paint c = edgePaints.get(e);
            if (c == Color.LIGHT_GRAY) {
                return THIN;
            } else {
                return THICK;
            }
        }
    });

    //add restart button
    JButton scramble = new JButton("Restart");
    scramble.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            Layout layout = vv.getGraphLayout();
            layout.initialize();
            Relaxer relaxer = vv.getModel().getRelaxer();
            if (relaxer != null) {
                relaxer.stop();
                relaxer.prerelax();
                relaxer.relax();
            }
        }
    });

    DefaultModalGraphMouse gm = new DefaultModalGraphMouse();
    vv.setGraphMouse(gm);

    final JToggleButton groupVertices = new JToggleButton("Group Clusters");

    //Create slider to adjust the number of edges to remove when clustering
    final JSlider edgeBetweennessSlider = new JSlider(JSlider.HORIZONTAL);
    edgeBetweennessSlider.setBackground(Color.WHITE);
    edgeBetweennessSlider.setPreferredSize(new Dimension(210, 50));
    edgeBetweennessSlider.setPaintTicks(true);
    edgeBetweennessSlider.setMaximum(graph.getEdgeCount());
    edgeBetweennessSlider.setMinimum(0);
    edgeBetweennessSlider.setValue(0);
    edgeBetweennessSlider.setMajorTickSpacing(10);
    edgeBetweennessSlider.setPaintLabels(true);
    edgeBetweennessSlider.setPaintTicks(true);

    //      edgeBetweennessSlider.setBorder(BorderFactory.createLineBorder(Color.black));
    //TO DO: edgeBetweennessSlider.add(new JLabel("Node Size (PageRank With Priors):"));
    //I also want the slider value to appear
    final JPanel eastControls = new JPanel();
    eastControls.setOpaque(true);
    eastControls.setLayout(new BoxLayout(eastControls, BoxLayout.Y_AXIS));
    eastControls.add(Box.createVerticalGlue());
    eastControls.add(edgeBetweennessSlider);

    final String COMMANDSTRING = "Edges removed for clusters: ";
    final String eastSize = COMMANDSTRING + edgeBetweennessSlider.getValue();

    final TitledBorder sliderBorder = BorderFactory.createTitledBorder(eastSize);
    eastControls.setBorder(sliderBorder);
    //eastControls.add(eastSize);
    eastControls.add(Box.createVerticalGlue());

    groupVertices.addItemListener(new ItemListener() {
        public void itemStateChanged(ItemEvent e) {

            //clusterAndRecolor(layout, edgeBetweennessSlider.getValue(),
            //        similarColors, e.getStateChange() == ItemEvent.SELECTED);
            vv.repaint();
        }
    });

    //clusterAndRecolor(layout, 0, similarColors, groupVertices.isSelected());

    edgeBetweennessSlider.addChangeListener(new ChangeListener() {
        public void stateChanged(ChangeEvent e) {
            JSlider source = (JSlider) e.getSource();
            if (!source.getValueIsAdjusting()) {
                int numEdgesToRemove = source.getValue();
                //clusterAndRecolor(layout, numEdgesToRemove, similarColors,
                //        groupVertices.isSelected());
                sliderBorder.setTitle(COMMANDSTRING + edgeBetweennessSlider.getValue());
                eastControls.repaint();
                vv.validate();
                vv.repaint();
            }
        }
    });

    Container content = getContentPane();
    content.add(new GraphZoomScrollPane(vv));
    JPanel south = new JPanel();
    JPanel grid = new JPanel(new GridLayout(2, 1));
    grid.add(scramble);
    grid.add(groupVertices);
    south.add(grid);
    south.add(eastControls);
    JPanel p = new JPanel();
    p.setBorder(BorderFactory.createTitledBorder("Mouse Mode"));
    p.add(gm.getModeComboBox());
    south.add(p);
    content.add(south, BorderLayout.SOUTH);
}

From source file:de.uniba.wiai.kinf.pw.projects.lillytab.reasoner.abox.RABox.java

@Override
public Collection<IABoxNode<I, L, K, R>> getSuccessorNodes() {
    return ExtractorCollection.decorate(getSuccessors(), new Transformer<NodeID, IABoxNode<I, L, K, R>>() {
        @Override// ww w .  java2s .  c  o  m
        public IABoxNode<I, L, K, R> transform(NodeID input) {
            return _node.getABox().getNode(input);
        }
    });
}

From source file:edu.memphis.ccrg.lida.framework.gui.panels.NodeStructurePanel.java

private void draw() {
    // The Layout<V, E> is parameterized by the vertex and edge types

    Layout<Linkable, GuiLink> layout = new FRLayout<Linkable, GuiLink>(guiGraph);
    layout.setSize(new Dimension(300, 300)); // Sets initial size of the
    // The BasicVisualizationServer<V,E> is parameterized by the edge types
    vizViewer = new VisualizationViewer<Linkable, GuiLink>(layout);
    vizViewer.setPreferredSize(new Dimension(350, 350)); // Sets viewing area size
    // Show vertex and edge labels
    vizViewer.getRenderContext().setVertexLabelTransformer(new Transformer<Linkable, String>() {

        @Override/*from   w  w w.ja v  a2s . c  o  m*/
        public String transform(final Linkable linkable) {
            if (linkable instanceof Link) {
                return ((Link) linkable).getCategory().getLabel();
            }
            return linkable.getLabel();
        }
    });

    // vv.getRenderContext().setEdgeLabelTransformer(new
    // ToStringLabeller<GuiLink>());
    // Create a graph mouse and add it to the visualization component
    DefaultModalGraphMouse<Linkable, GuiLink> gm2 = new DefaultModalGraphMouse<Linkable, GuiLink>();
    gm2.setMode(ModalGraphMouse.Mode.TRANSFORMING);
    vizViewer.getRenderContext().setVertexIconTransformer(new Transformer<Linkable, Icon>() {
        /*
         * Implements the Icon interface to draw an Icon with
         * background color
         */

        @Override
        public Icon transform(final Linkable v) {
            if (v instanceof Node) {
                return NodeIcon.NODE_ICON;
            } else {
                return NodeIcon.LINK_ICON;
            }
        }
    });
    vizViewer.setVertexToolTipTransformer(new Transformer<Linkable, String>() {
        //TODO use the toString of the linkable

        @Override
        public String transform(final Linkable l) {
            String tip = null;
            if (l instanceof Activatible) {
                if (l instanceof PamNode) {
                    PamNode pn = (PamNode) l;
                    tip = String.format(
                            "<html><b>%s</b><br/>Activation: %06.4f"
                                    + "<br /> BaseActivation: %06.4f<br /> Threshold:  %06.4f </html>",
                            pn, pn.getActivation(), pn.getBaseLevelActivation(),
                            PerceptualAssociativeMemoryImpl.getPerceptThreshold());
                } else {
                    Activatible n = (Activatible) l;
                    tip = String.format("<html><b>%s</b><br/>Activation: %06.4f</html>", n, n.getActivation());
                }
            }
            return tip;
        }
    });
    vizViewer.setEdgeToolTipTransformer(new Transformer<GuiLink, String>() {

        @Override
        public String transform(final GuiLink l) {
            String tip = null;
            GuiLink gl = l;
            Link n = gl.getLink();
            tip = String.format("<html><b>%s</b><br/>Activation: %06.4f</html>", n, n.getActivation());
            return tip;
        }
    });

    vizViewer.setGraphMouse(gm2);

    jScrollPane1.setViewportView(vizViewer);
    vizViewer.fireStateChanged();
}

From source file:net.panthema.BispanningGame.GamePanel.java

public GamePanel() throws IOException {

    makeActions();//from w  w  w .j a  v a 2 s .c o m

    setBackground(Color.WHITE);

    ImageAlice = ImageIO.read(
            getClass().getClassLoader().getResourceAsStream("net/panthema/BispanningGame/images/Alice.png"));
    ImageBob = ImageIO.read(
            getClass().getClassLoader().getResourceAsStream("net/panthema/BispanningGame/images/Bob.png"));

    logTextArea = new JTextArea();

    makeNewRandomGraph(8);
    mLayout = MyGraphLayoutFactory(mGraph);

    mVV = new VisualizationViewer<Integer, MyEdge>(mLayout);
    mVV.setSize(new Dimension(1000, 800));
    mVV.setBackground(Color.WHITE);

    // Bob's play does not repeat.
    mPlayBob.setRepeats(false);

    // set up mouse handling
    PluggableGraphMouse gm = new PluggableGraphMouse();
    gm.add(new MyEditingGraphMousePlugin<Integer, MyEdge>(MouseEvent.CTRL_MASK, new MyVertexFactory(),
            new MyEdgeFactory()));
    gm.add(new TranslatingGraphMousePlugin(MouseEvent.BUTTON3_MASK));
    gm.add(new MyGraphMousePlugin(MouseEvent.BUTTON1_MASK | MouseEvent.BUTTON3_MASK));
    gm.add(new PickingGraphMousePlugin<Integer, MyEdge>());
    gm.add(new ScalingGraphMousePlugin(new LayoutScalingControl(), 0, 1.1f, 0.9f));
    mVV.setGraphMouse(gm);

    // set vertex and label drawing
    mVV.getRenderContext().setVertexLabelRenderer(new DefaultVertexLabelRenderer(Color.black));
    mVV.getRenderContext().setVertexLabelTransformer(new Transformer<Integer, String>() {
        public String transform(Integer v) {
            return "v" + v;
        }
    });
    mVV.getRenderContext().setVertexLabelTransformer(new ToStringLabeller<Integer>());
    mVV.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR);

    mVV.getRenderer().setEdgeRenderer(new MyEdgeRenderer());
    mVV.getRenderContext().setVertexDrawPaintTransformer(new MyVertexDrawPaintTransformer<Integer>());
    mVV.getRenderContext().setVertexFillPaintTransformer(new MyVertexFillPaintTransformer());

    mVV.getRenderContext().setEdgeStrokeTransformer(new MyEdgeStrokeTransformer());
    MyQuadCurve<Integer, MyEdge> quadcurve = new MyQuadCurve<Integer, MyEdge>();
    mVV.getRenderContext().setEdgeShapeTransformer(quadcurve);
    mVV.getRenderContext().setParallelEdgeIndexFunction(quadcurve);

    mVV.getRenderContext().setEdgeDrawPaintTransformer(new MyEdgeDrawPaintTransformer());
    mVV.getRenderContext().setEdgeFillPaintTransformer(new MyEdgeFillPaintTransformer());
    mVV.getRenderContext().setEdgeArrowStrokeTransformer(new MyEdgeInnerStrokeTransformer());

    mVV.getRenderContext().setEdgeLabelRenderer(new DefaultEdgeLabelRenderer(Color.black));
    mVV.getRenderContext().setEdgeLabelTransformer(new Transformer<MyEdge, String>() {
        public String transform(MyEdge e) {
            return e.toString();
        }
    });
    mVV.getRenderContext().setLabelOffset(6);

    // create pick support to select closest nodes and edges
    mPickSupport = new ShapePickSupport<Integer, MyEdge>(mVV, mPickDistance);

    // add pre renderer to draw Alice and Bob
    mVV.addPreRenderPaintable(new MyGraphPreRenderer());

    // add post renderer to show error messages in background
    mVV.addPostRenderPaintable(new MyGraphPostRenderer());

    setLayout(new BorderLayout());
    add(mVV, BorderLayout.CENTER);

    JPanel panelSouth = new JPanel();
    add(panelSouth, BorderLayout.SOUTH);
    panelSouth.setLayout(new GridLayout(0, 2, 0, 0));

    JPanel panelButtons = new JPanel();
    panelSouth.add(panelButtons);
    panelButtons.setLayout(new GridLayout(2, 2, 0, 0));
    panelSouth.setPreferredSize(new Dimension(800, 60));

    final JButton btnNewRandomGraph = new JButton("New Random Graph");
    btnNewRandomGraph.addMouseListener(new MouseAdapter() {
        @Override
        public void mouseClicked(MouseEvent e) {
            JPopupMenu popup = new JPopupMenu();

            for (int i = 0; i < actionRandomGraph.length; ++i) {
                if (actionRandomGraph[i] != null)
                    popup.add(actionRandomGraph[i]);
            }
            popup.addSeparator();
            popup.add(getActionNewGraphType());

            popup.show(btnNewRandomGraph, e.getX(), e.getY());
        }
    });
    panelButtons.add(btnNewRandomGraph);

    final JButton btnNewNamedGraph = new JButton("New Named Graph");
    btnNewNamedGraph.addMouseListener(new MouseAdapter() {
        @Override
        public void mouseClicked(MouseEvent e) {
            JPopupMenu popup = new JPopupMenu();

            for (int i = 0; i < actionNamedGraph.size(); ++i) {
                if (actionNamedGraph.get(i) != null)
                    popup.add(actionNamedGraph.get(i));
            }

            popup.show(btnNewNamedGraph, e.getX(), e.getY());
        }
    });
    panelButtons.add(btnNewNamedGraph);

    final JButton btnRelayout = new JButton("Relayout");
    btnRelayout.addMouseListener(new MouseAdapter() {
        @Override
        public void mouseClicked(MouseEvent e) {
            relayoutGraph();
        }
    });
    panelButtons.add(btnRelayout);

    final JButton btnOptions = new JButton("Options");
    btnOptions.addMouseListener(new MouseAdapter() {
        @Override
        public void mouseClicked(MouseEvent e) {
            JPopupMenu popup = new JPopupMenu();

            addPopupActions(popup);
            popup.addSeparator();

            popup.show(btnOptions, e.getX(), e.getY());
        }
    });
    panelButtons.add(btnOptions);

    JScrollPane scrollPane = new JScrollPane(logTextArea);
    panelSouth.add(scrollPane);

    logTextArea.setEditable(false);

    setSize(new Dimension(1000, 800));
    relayoutGraph();
}

From source file:es.urjc.ia.fia.genericSearch.statistics.JUNGStatistics.java

@Override
public void showStatistics() {

    // Layout: tree and radial
    treeLayout = new TreeLayout<AuxVertex, ACTION>(this.tree, 35, 100);
    radialLayout = new RadialTreeLayout<AuxVertex, ACTION>(this.tree, 35, 130);

    radialLayout.setSize(new Dimension(200 * (this.tree.getHeight() + 1), 200 * (this.tree.getHeight() + 1)));

    // The BasicVisualizationServer<V,E> is parameterized by the edge types
    vv = new VisualizationViewer<AuxVertex, ACTION>(treeLayout);
    vv.setPreferredSize(new Dimension(800, 600)); //Sets the viewing area size
    vv.setBackground(Color.white); // Background color

    vv.getRenderContext().setVertexLabelTransformer(new ToStringLabeller<AuxVertex>());
    vv.getRenderContext().setEdgeShapeTransformer(new EdgeShape.Line<AuxVertex, ACTION>());

    // Setup up a new vertex to paint transformer
    Transformer<AuxVertex, Paint> vertexPaint = new Transformer<AuxVertex, Paint>() {
        @Override/*w  w w .j a va  2s  . co m*/
        public Paint transform(AuxVertex arg0) {
            if (arg0.getState().isSolution() && arg0.isExplored()) {
                return Color.GREEN;
            } else if (arg0.isExplored()) {
                return Color.CYAN;
            } else if (arg0.isDuplicated()) {
                return Color.GRAY;
            } else {
                return Color.WHITE;
            }
        }
    };

    // Tooltip for vertex
    Transformer<AuxVertex, String> toolTipsState = new Transformer<AuxVertex, String>() {

        @Override
        public String transform(AuxVertex arg0) {
            String sortInfo = "";
            if (arg0.isExplored()) {
                if (arg0.getState().isSolution() && arg0.isExplored()) {
                    sortInfo = "<u><i>Solution state " + arg0.getExplored() + "</i></u>";
                } else {
                    sortInfo = "<u><i>Explored state " + arg0.getExplored() + "</i></u>";
                }
            } else if (arg0.isDuplicated()) {
                sortInfo = "<u><i>Duplicated state </i></u>";
            } else {
                sortInfo = "<u><i>Unexplored state</i></u>";
            }
            return "<html><p>" + sortInfo + "</p>" + "<p>State: " + arg0.getState().toString() + "</p>"
                    + "<p>Cost: " + arg0.getState().getSolutionCost() + "</p></html>";
        }

    };
    vv.setVertexToolTipTransformer(toolTipsState);

    // Tooltip for edge
    Transformer<ACTION, String> toolTipsAction = new Transformer<ACTION, String>() {

        @Override
        public String transform(ACTION arg0) {
            return "Cost: " + arg0.cost();
        }

    };
    vv.setEdgeToolTipTransformer(toolTipsAction);

    vv.getRenderContext().setEdgeShapeTransformer(new EdgeShape.Line<AuxVertex, ACTION>());
    vv.getRenderContext().setEdgeLabelTransformer(new ToStringLabeller<ACTION>());

    vv.getRenderContext().setVertexFillPaintTransformer(vertexPaint);
    vv.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR);

    // Create a graph mouse and add it to the visualization component
    DefaultModalGraphMouse<State<ACTION>, ACTION> gm = new DefaultModalGraphMouse<State<ACTION>, ACTION>();
    gm.setMode(ModalGraphMouse.Mode.TRANSFORMING);
    vv.setGraphMouse(gm);
    vv.addKeyListener(gm.getModeKeyListener());

    JFrame vFrame = new JFrame("Statistics Tree View");
    vFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    /*
    vFrame.getContentPane().add(vv);
    vFrame.pack();
    vFrame.setVisible(true);
    */

    rings = new Rings();
    Container content = vFrame.getContentPane();
    final GraphZoomScrollPane panel = new GraphZoomScrollPane(vv);
    content.add(panel);

    JComboBox modeBox = gm.getModeComboBox();
    modeBox.addItemListener(gm.getModeListener());
    gm.setMode(ModalGraphMouse.Mode.TRANSFORMING);

    final ScalingControl scaler = new CrossoverScalingControl();

    JButton plus = new JButton("+");
    plus.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            scaler.scale(vv, 1.1f, vv.getCenter());
        }
    });
    JButton minus = new JButton("-");
    minus.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            scaler.scale(vv, 1 / 1.1f, vv.getCenter());
        }
    });

    JToggleButton radial = new JToggleButton("Radial");
    radial.addItemListener(new ItemListener() {

        public void itemStateChanged(ItemEvent e) {
            if (e.getStateChange() == ItemEvent.SELECTED) {

                LayoutTransition<AuxVertex, ACTION> lt = new LayoutTransition<AuxVertex, ACTION>(vv, treeLayout,
                        radialLayout);
                Animator animator = new Animator(lt);
                animator.start();
                vv.getRenderContext().getMultiLayerTransformer().setToIdentity();
                vv.addPreRenderPaintable(rings);
            } else {
                LayoutTransition<AuxVertex, ACTION> lt = new LayoutTransition<AuxVertex, ACTION>(vv,
                        radialLayout, treeLayout);
                Animator animator = new Animator(lt);
                animator.start();
                vv.getRenderContext().getMultiLayerTransformer().setToIdentity();
                vv.removePreRenderPaintable(rings);
            }
            vv.repaint();
        }
    });

    JPanel scaleGrid = new JPanel(new GridLayout(1, 0));
    scaleGrid.setBorder(BorderFactory.createTitledBorder("Zoom"));

    /*
     * Statistics 
     */
    JLabel stats = new JLabel();
    long totalTime = endTime.getTime() - initTime.getTime();
    stats.setText("<html>" + "<b>Total States:</b> " + this.totalStates + "<br>" + "<b>Explored States:</b> "
            + this.explorerStates + "<br>" + "<b>Duplicated States (detected):</b> " + this.duplicatedStates
            + "<br>" + "<b>Solution States:</b> " + this.solutionStates + "<br>" + "<b>Total time: </b>"
            + totalTime + " milliseconds" + "</html>");

    JPanel legend = new JPanel();
    legend.setLayout(new BoxLayout(legend, BoxLayout.Y_AXIS));

    JLabel len = new JLabel("<html><b>Lengend</b></html>");
    JLabel lexpl = new JLabel("Explored state");
    lexpl.setBackground(Color.CYAN);
    lexpl.setOpaque(true);
    JLabel lune = new JLabel("Unexplored state");
    lune.setBackground(Color.WHITE);
    lune.setOpaque(true);
    JLabel ldupl = new JLabel("Duplicated state");
    ldupl.setBackground(Color.GRAY);
    ldupl.setOpaque(true);
    JLabel lsol = new JLabel("Solution state");
    lsol.setBackground(Color.GREEN);
    lsol.setOpaque(true);

    legend.add(len);
    legend.add(lexpl);
    legend.add(lune);
    legend.add(ldupl);
    legend.add(lsol);

    JPanel controls = new JPanel();
    controls.add(stats);
    scaleGrid.add(plus);
    scaleGrid.add(minus);
    controls.add(radial);
    controls.add(scaleGrid);
    //controls.add(modeBox);
    controls.add(legend);

    content.add(controls, BorderLayout.SOUTH);

    vFrame.pack();
    vFrame.setVisible(true);
}

From source file:lu.lippmann.cdb.graph.GenericGraphViewImpl.java

/**
 * {@inheritDoc}//from w w w  .j  a va2s  .com
 */
@Override
public void highlightPath(final List<E> path) {
    vv.getRenderContext().setEdgeDrawPaintTransformer(new Transformer<E, Paint>() {
        @Override
        public Paint transform(E input) {
            if (path.contains(input)) {
                return Color.RED;
            } else {
                return Color.BLACK;
            }
        }
    });
    vv.updateUI();
}