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

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

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.collections15.*
  5. Transformer
  6. 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:mavn.network.view.JUNGPanelAdapter.java

public void fireNodes(final double[] result) {
    Transformer<Number, Paint> vertexPaint = new Transformer<Number, Paint>() {

        private final Color[] palette = { new Color(51, 181, 229), Color.BLACK, new Color(255, 68, 68) };

        @Override//  w  w w.  j ava  2s .c  om
        public Paint transform(Number i) {
            if (i.doubleValue() == inputX || i.doubleValue() == inputY) {
                if (result[inputX] == 1) {
                    return palette[0];
                }
                if (result[inputY] == -1) {
                    return palette[0];
                }
            }
            if (i.doubleValue() >= andMin && i.doubleValue() <= andMax) {
                if (result[i.intValue()] == 1) {
                    return palette[0];
                }
                if (result[i.intValue()] == -1) {
                    return palette[1];
                }
            }
            if (i.doubleValue() >= orMin && i.doubleValue() <= orMax) {
                if (result[i.intValue()] == 1) {
                    return palette[0];
                }
                if (result[i.intValue()] == -1) {
                    return palette[1];
                }
            }
            if (i.doubleValue() == output) {
                if (result[output] == 1) {
                    return palette[0];
                }
                if (result[output] == -1) {
                    return palette[1];
                }
            }
            return palette[2];
        }
    };

    vv.getRenderContext().setVertexFillPaintTransformer(vertexPaint);
}

From source file:com.diversityarrays.kdxplore.curate.TraitsAndInstancesPanel2.java

public TraitsAndInstancesPanel2(CurationContext cc, Font smallFont, TIStatsTableModel tistm,
        boolean anyInstanceNumbers, int nInvalidRules, String tAndIpanelLabel,
        CurationMenuProvider curationMenuProvider, Consumer<List<OutlierSelection>> outlierConsumer) {
    super(new BorderLayout());

    this.curationContext = cc;
    this.outlierConsumer = outlierConsumer;
    this.curationMenuProvider = curationMenuProvider;

    this.tiStatsModel = tistm;

    curationContext.addPropertyChangeListener(propertyChangeListener);

    traitInstanceStatsTable = new TraitInstanceStatsTable(tiStatsModel);

    traitInstanceStatsTable.addPropertyChangeListener("rowSorter", rowSorterChangeListener);
    traitInstanceStatsTable.setAutoCreateRowSorter(true);

    traitInstanceStatsTable.addMouseListener(new MouseAdapter() {
        @Override/*from  w w w.j  av a  2s.  com*/
        public void mouseClicked(MouseEvent me) {
            int clickCount = me.getClickCount();

            if (SwingUtilities.isRightMouseButton(me) && 1 == clickCount) {
                me.consume();
                showContextMenu(me);
            } else if (SwingUtilities.isLeftMouseButton(me) && 2 == clickCount) {
                showTraitInstanceInfo(me);
            }
        }
    });

    Map<String, TableColumn[]> tableColumnsByChoice = createInstanceTableColumnsByChoice();
    TableColumnSelectionButton tcsb = new TableColumnSelectionButton(traitInstanceStatsTable,
            tableColumnsByChoice);

    StringCellRenderer scRenderer = new StringCellRenderer();
    scRenderer.setHorizontalAlignment(SwingConstants.CENTER);

    statDetailRenderer.setHorizontalAlignment(SwingConstants.CENTER);

    traitInstanceStatsTable.setDefaultRenderer(String.class, scRenderer);
    Transformer<TraitInstance, String> instanceNameTransformer = new Transformer<TraitInstance, String>() {
        @Override
        public String transform(TraitInstance ti) {
            return curationContext.makeTraitInstanceName(ti);
        }
    };
    TraitInstanceCellRenderer tiRenderer = new TraitInstanceCellRenderer(
            curationContext.getTraitColorProvider(), instanceNameTransformer);
    tiRenderer.setName("FOR-STATS-TABLE"); //$NON-NLS-1$
    traitInstanceStatsTable.setDefaultRenderer(TraitInstance.class, tiRenderer);
    traitInstanceStatsTable.setDefaultRenderer(Comparable.class, statDetailRenderer);

    TableColumnModel tcm = traitInstanceStatsTable.getColumnModel();
    Integer viewColumnIndex = tistm.getViewColumnIndex();
    if (viewColumnIndex != null) {
        TableColumn viewColumn = tcm.getColumn(viewColumnIndex);
        viewColumn.setMaxWidth(40);
        viewColumn.setCellRenderer(new OptionalCheckboxRenderer("No Values"));
    }

    if (nInvalidRules <= 0) {
        // Hide that column!
        int columnIndex = tistm.getValRuleErrorColumnIndex();
        columnIndex = traitInstanceStatsTable.convertColumnIndexToView(columnIndex);
        if (columnIndex >= 0) {
            TableColumn c = tcm.getColumn(columnIndex);
            tcm.removeColumn(c);
        }
    }

    TableColumn dataTypeTableColumn = traitInstanceStatsTable.getColumnModel()
            .getColumn(tistm.getTraitInstanceDatatypeColumnIndex());
    dataTypeTableColumn.setCellRenderer(new TraitDataTypeRenderer());

    Function<JTable, JScrollPane> scrollMaker = new Function<JTable, JScrollPane>() {
        @Override
        public JScrollPane apply(JTable t) {
            return new PromptScrollPane(t, "Select Trait in the Panel: " + tAndIpanelLabel);
        }
    };
    TitledTablePanelWithResizeControls ttp = new TitledTablePanelWithResizeControls("Trait Instances",
            traitInstanceStatsTable, smallFont, scrollMaker);
    ttp.scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
    ttp.scrollPane.setCorner(JScrollPane.UPPER_RIGHT_CORNER, tcsb);

    new CurationContextOptionsPopup(curationContext, ttp.separator);

    if (anyInstanceNumbers) {
        tcsb.setSelectedColumns(SimpleStatistics.GROUP_BASIC_STATS);
    } else {
        Set<Object> headerValues = new HashSet<>();
        for (TableColumn tc : tableColumnsByChoice.get(SimpleStatistics.GROUP_BASIC_STATS)) {
            headerValues.add(tc.getHeaderValue());
        }
        headerValues.remove(tistm.getInstanceHeading());
        tcsb.initialiseSelectedColumns(new Predicate<Object>() {
            @Override
            public boolean evaluate(Object hvalue) {
                return headerValues.contains(hvalue);
            }
        });
    }

    add(ttp, BorderLayout.CENTER);
}

From source file:edu.purdue.cc.bionet.ui.GraphVisualizer.java

/**
 * Performs the necessary actions to set up the Graph.
 *//*  w  ww  .  j  ava  2  s  .c o  m*/
protected void setup() {
    this.graph = (UndirectedSparseGraph<V, E>) this.getGraphLayout().getGraph();
    this.getRenderContext().setVertexLabelTransformer(new ToStringLabeller<V>());
    //      this.getRenderContext( ).setEdgeLabelTransformer( new ToStringLabeller<E>( ));
    this.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR);
    PluggableGraphMouse mouse = new PluggableGraphMouse() {
        public void mouseWheelMoved(MouseWheelEvent e) {
            scale((float) Math.pow(1.25, -e.getWheelRotation()), e.getPoint());
        }
    };
    mouse.add(new PickingGraphMousePlugin());
    mouse.add(new PickingGraphMousePlugin(-1, InputEvent.BUTTON1_MASK | InputEvent.CTRL_MASK));
    this.setGraphMouse(mouse);
    this.getPickedVertexState().addItemListener(this);
    this.getPickedEdgeState().addItemListener(this);
    this.addMouseListener(this);
    this.addComponentListener(new LayoutScaler());

    // set up coloring
    Transformer v = new Transformer<V, Paint>() {
        public Paint transform(V v) {
            if (getPickedVertexState().isPicked(v)) {
                return pickedVertexPaint;
            } else {
                if (commonNeighborIndicator && isCommonNeighbor(v)) {
                    return commonNeighborPaint;
                } else {
                    return vertexPaint;
                }
            }
        }
    };
    Transformer vo = new Transformer<V, Paint>() {
        public Paint transform(V v) {
            if (getPickedVertexState().isPicked(v)) {
                return pickedVertexOutline;
            } else {
                if (commonNeighborIndicator && isCommonNeighbor(v)) {
                    return commonNeighborOutline;
                } else {
                    return vertexOutline;
                }
            }
        }
    };

    this.getRenderContext().setVertexFillPaintTransformer(v);
    this.getRenderContext().setVertexDrawPaintTransformer(vo);

    Transformer e = new Transformer<E, Paint>() {
        public Paint transform(E e) {
            if (getPickedEdgeState().isPicked(e)) {
                return pickedEdgePaint;
            } else {
                return edgePaint;
            }
        }
    };
    this.getRenderContext().setEdgeDrawPaintTransformer(e);
    this.setPickedLabelColor(this.pickedLabelColor);
    this.commonNeighbors = new NeighborCollection<V, E>(this);
}

From source file:net.schweerelos.parrot.ui.GraphViewComponent.java

@SuppressWarnings("serial")
private void setupRenderContext(final VisualizationViewer<NodeWrapper, NodeWrapper> vis) {
    vis.setRenderer(new ParrotGraphRenderer());
    vis.setPickSupport(new ParrotPickSupport(vis));

    RenderContext<NodeWrapper, NodeWrapper> renderContext = vis.getRenderContext();

    final PickedInfo<NodeWrapper> vertexPickInfo = vis.getPickedVertexState();
    final PickedState<NodeWrapper> edgePickInfo = vis.getPickedEdgeState();

    // hide all edge arrows except for those on outgoing edges of picked
    // nodes//  w ww.j a va 2  s.c o m
    renderContext.setEdgeArrowPredicate(new Predicate<Context<Graph<NodeWrapper, NodeWrapper>, NodeWrapper>>() {
        @Override
        public boolean evaluate(Context<Graph<NodeWrapper, NodeWrapper>, NodeWrapper> context) {
            NodeWrapper edge = context.element;
            NodeWrapper source = graph.getSource(edge);
            return vertexPickInfo.isPicked(source);
        }
    });

    // make edges straight lines to collapse parallel edges
    renderContext.setEdgeShapeTransformer(new EdgeShape.Line<NodeWrapper, NodeWrapper>());

    // hide text of all edges except for outgoing edges of picked nodes
    renderContext.setEdgeLabelTransformer(new Transformer<NodeWrapper, String>() {
        @Override
        public String transform(NodeWrapper edge) {
            NodeWrapper source = graph.getSource(edge);
            NodeWrapper destination = graph.getDest(edge);
            if (vertexPickInfo.isPicked(source) && !vertexPickInfo.isPicked(destination)) {
                return edge.toString();
            } else {
                return "";
            }
        }
    });
    renderContext.setEdgeLabelRenderer(new DefaultEdgeLabelRenderer(COLOR_EDGE_LABEL) {
        @Override
        public <E> Component getEdgeLabelRendererComponent(JComponent vv, Object value, Font font,
                boolean isSelected, E edge) {
            Component component = super.getEdgeLabelRendererComponent(vv, value, font, isSelected, edge);
            component.setForeground(COLOR_EDGE_LABEL);
            return component;
        }

    });

    // start from VertexLabelAsShapeDemo

    // this class will provide both label drawing and vertex shapes
    VertexLabelAsShapeRenderer<NodeWrapper, NodeWrapper> vlasr = new VertexLabelAsShapeRenderer<NodeWrapper, NodeWrapper>(
            renderContext);
    renderContext.setVertexShapeTransformer(vlasr);

    vis.setForeground(COLOR_NODE_TEXT);

    // customize the render context

    renderContext.setVertexLabelTransformer(new ToStringLabeller<NodeWrapper>());

    renderContext.setVertexLabelRenderer(new DefaultVertexLabelRenderer(COLOR_NODE_PICKED_TEXT) {
        @Override
        public <V> Component getVertexLabelRendererComponent(JComponent vv, Object value, Font font,
                boolean isSelected, V vertexToRender) {
            Component component = super.getVertexLabelRendererComponent(vv, value, font, isSelected,
                    vertexToRender);
            if (component instanceof JLabel) {
                JLabel label = (JLabel) component;
                // add a little bit of padding around the text
                Border originalBorder = label.getBorder();
                label.setBorder(BorderFactory.createCompoundBorder(originalBorder,
                        BorderFactory.createEmptyBorder(3, 2, 4, 2)));
            }
            // now set the colour/font too
            if (vertexToRender instanceof NodeWrapper) {
                NodeWrapper vertex = (NodeWrapper) vertexToRender;
                if (vertexPickInfo.isPicked(vertex)) {
                    component.setForeground(COLOR_NODE_PICKED_TEXT);
                } else if (vertex.isHighlighted()) {
                    component.setForeground(COLOR_NODE_HIGHLIGHTED_TEXT);
                    component.setFont(font.deriveFont(Font.BOLD));
                } else if (GraphViewHelper.hasPickedNeighbour(vertex, vertexPickInfo, graph)) {
                    component.setForeground(COLOR_NODE_WITH_PICKED_NEIGHBOUR_TEXT);
                } else if (GraphViewHelper.hasPickedAdjacentEdge(vertex, edgePickInfo, graph)) {
                    component.setForeground(COLOR_NODE_ADJACENT_EDGE_PICKED_TEXT);
                } else if (GraphViewHelper.hasHighlightedNeighbour(vertex, graph)) {
                    component.setForeground(COLOR_NODE_WITH_HIGHLIGHTED_NEIGHBOUR_TEXT);
                } else {
                    component.setForeground(COLOR_NODE_TEXT);
                }
            }

            return component;
        }
    });

    // end from VertexLabelAsShapeDemo

    vis.getRenderer().getVertexLabelRenderer().setPosition(Renderer.VertexLabel.Position.CNTR);

    vis.setVertexToolTipTransformer(new Transformer<NodeWrapper, String>() {
        @Override
        public String transform(NodeWrapper vertex) {
            return vertex.getToolTipText(model);
        }
    });

    // inspired by PluggableRendererDemo
    Transformer<NodeWrapper, Paint> vertexOutline = new Transformer<NodeWrapper, Paint>() {
        @Override
        public Paint transform(NodeWrapper vertex) {
            if (vertexPickInfo.isPicked(vertex)) {
                return COLOR_NODE_PICKED_BORDER;
            } else if (vertex.isHighlighted()) {
                return COLOR_NODE_HIGHLIGHTED_BORDER;
            } else {
                if (GraphViewHelper.hasPickedAdjacentEdge(vertex, edgePickInfo, graph)) {
                    return COLOR_NODE_ADJACENT_EDGE_PICKED_BORDER;
                }
                if (GraphViewHelper.hasPickedNeighbour(vertex, vertexPickInfo, graph)) {
                    return COLOR_NODE_WITH_PICKED_NEIGHBOUR_BORDER;
                } else if (GraphViewHelper.hasHighlightedNeighbour(vertex, graph)) {
                    return COLOR_NODE_WITH_HIGHLIGHTED_NEIGHBOUR_BORDER;
                }
                // will get here only if no neighbour is picked/highlighted
                return COLOR_NODE_BORDER;
            }
        }
    };
    renderContext.setVertexDrawPaintTransformer(vertexOutline);

    Transformer<NodeWrapper, Paint> vertexBackground = new Transformer<NodeWrapper, Paint>() {
        @Override
        public Paint transform(NodeWrapper vertex) {
            if (vertexPickInfo.isPicked(vertex)) {
                return COLOR_NODE_PICKED_BG;
            } else if (vertex.isHighlighted()) {
                return COLOR_NODE_HIGHLIGHTED_BG;
            } else {
                if (GraphViewHelper.hasPickedAdjacentEdge(vertex, edgePickInfo, graph)) {
                    return COLOR_NODE_ADJACENT_EDGE_PICKED_BG;
                }
                if (GraphViewHelper.hasPickedNeighbour(vertex, vertexPickInfo, graph)) {
                    return COLOR_NODE_WITH_PICKED_NEIGHBOUR_BG;
                } else if (GraphViewHelper.hasHighlightedNeighbour(vertex, graph)) {
                    return COLOR_NODE_WITH_HIGHLIGHTED_NEIGHBOUR_BG;
                }
                return COLOR_NODE_BG;
            }
        }
    };
    renderContext.setVertexFillPaintTransformer(vertexBackground);

    Transformer<NodeWrapper, Stroke> vertexStroke = new Transformer<NodeWrapper, Stroke>() {
        @Override
        public Stroke transform(NodeWrapper vertex) {
            if (vertexPickInfo.isPicked(vertex)) {
                return STROKE_VERTEX_PICKED;
            } else if (vertex.isHighlighted()) {
                return STROKE_VERTEX_HIGHLIGHTED;
            }

            Collection<NodeWrapper> edges = graph.getInEdges(vertex);
            for (NodeWrapper edge : edges) {
                if (edgePickInfo.isPicked(edge)) {
                    return STROKE_VERTEX_INCOMING_EDGE_PICKED;
                }
            }
            edges = graph.getOutEdges(vertex);
            for (NodeWrapper edge : edges) {
                if (edgePickInfo.isPicked(edge)) {
                    return STROKE_VERTEX_OUTGOING_EDGE_PICKED;
                }
            }

            // we'll only get here if none of the cases above applies
            return STROKE_VERTEX_DEFAULT;
        }
    };
    renderContext.setVertexStrokeTransformer(vertexStroke);

    Transformer<NodeWrapper, Stroke> edgeStroke = new Transformer<NodeWrapper, Stroke>() {
        @Override
        public Stroke transform(NodeWrapper edge) {
            NodeWrapper edgeSource = graph.getSource(edge);
            if (edgePickInfo.isPicked(edge)) {
                return STROKE_EDGE_PICKED;
            } else if (vertexPickInfo.isPicked(edgeSource)) {
                return STROKE_EDGE_ADJACENT_NODE_PICKED;
            } else {
                return STROKE_EDGE_DEFAULT;
            }
        }
    };
    renderContext.setEdgeStrokeTransformer(edgeStroke);

    Transformer<NodeWrapper, Paint> edgeColor = new Transformer<NodeWrapper, Paint>() {
        @Override
        public Paint transform(NodeWrapper edge) {
            if (edgePickInfo.isPicked(edge)) {
                return COLOR_EDGE_PICKED;
            } else if (GraphViewHelper.hasPickedAdjacentVertex(edge, vertexPickInfo, graph)) {
                return COLOR_EDGE_ADJACENT_VERTEX_PICKED;
            } else if (edge.isHighlighted()) {
                return COLOR_EDGE_HIGHLIGHTED;
            } else if (GraphViewHelper.hasHighlightedAdjacentVertex(edge, graph)) {
                return COLOR_EDGE_ADJACENT_VERTEX_HIGHLIGHTED;
            } else {
                return COLOR_EDGE;
            }
        }
    };
    renderContext.setEdgeDrawPaintTransformer(edgeColor);
    // draw arrows in the same colour as edges
    renderContext.setArrowDrawPaintTransformer(edgeColor);
    renderContext.setArrowFillPaintTransformer(edgeColor);

    includePredicate = new IncludePredicate<Context<Graph<NodeWrapper, NodeWrapper>, NodeWrapper>>();
    renderContext.setEdgeIncludePredicate(includePredicate);
    renderContext.setVertexIncludePredicate(includePredicate);

    vis.setBackground(COLOR_BACKGROUND);

    mouse = new DoubleClickPickingModalGraphMouse<NodeWrapper, NodeWrapper>();
    mouse.add(new AbstractPopupGraphMousePlugin() {
        @Override
        protected void handlePopup(MouseEvent e) {
            if (!e.isPopupTrigger()) {
                return;
            }
            GraphElementAccessor<NodeWrapper, NodeWrapper> pickSupport = vis.getPickSupport();
            if (pickSupport == null) {
                return;
            }

            NodeWrapper node = pickSupport.getVertex(layout, e.getX(), e.getY());
            if (node == null) {
                node = pickSupport.getEdge(layout, e.getX(), e.getY());
            }
            if (node == null) {
                return;
            }
            popup.setNodeWrapper(node);
            popup.show(vis, e.getX(), e.getY());
        }
    });
    mouse.setDoubleClickPickingPlugin(new DoubleClickPickingPlugin() {
        @Override
        void doubleClickOccurred(MouseEvent e) {
            GraphElementAccessor<NodeWrapper, NodeWrapper> pickSupport = vis.getPickSupport();
            if (pickSupport == null) {
                return;
            }

            NodeWrapper node = pickSupport.getVertex(layout, e.getX(), e.getY());
            if (node == null) {
                return;
            }
            fireNodeSelected(node);
        }
    });
    vis.setGraphMouse(mouse);

}

From source file:com.diversityarrays.kdxplore.trialmgr.TrialManagerApp.java

public TrialManagerApp(KdxPluginInfo pluginInfo) throws IOException {
    super(new BorderLayout());

    this.messagesPanel = pluginInfo.getMessagePrinter();
    this.backgroundRunner = pluginInfo.getBackgroundRunner();
    this.userDataFolder = pluginInfo.getUserDataFolder();
    this.clientProvider = pluginInfo.getClientProvider();
    this.offlineData = pluginInfo.getSingletonSharedResource(OfflineData.class);

    KDSmartApplication.getInstance().setMessagePrinter(pluginInfo.getMessagePrintStream());

    this.driverType = DriverType.getDriverTypeFromSystemProperties(DriverType.H2);

    offlineData.addOfflineDataChangeListener(offlineDataChangeListener);

    linkedIcon = KDClientUtils.getIcon(ImageId.CONNECTED_24);
    unlinkedIcon = KDClientUtils.getIcon(ImageId.DISCONNECTED_24);
    barcodeIcon = KDClientUtils.getIcon(ImageId.BARCODE_PAGE);

    updateDatabaseUrlLabel();/*from w w  w .  j  av  a2s . co m*/

    this.clientProvider.addChangeListener(new ChangeListener() {
        @Override
        public void stateChanged(ChangeEvent e) {
            handleClientChanged();
        }
    });

    explorerProperties = ExplorerProperties.getInstance();

    PreferenceCollection pc = TrialManagerPreferences.getInstance().getPreferenceCollection(this,
            Msg.APPNAME_TRIAL_MANAGER());
    KdxplorePreferences.getInstance().addPreferenceCollection(pc);

    TraitValue.DISPLAY_DATE_DIFF_AS_NDAYS = explorerProperties.getDisplayElapsedDaysAsCount();

    ExplorerServices explorerServices = new ExplorerServices(pluginInfo, offlineData
    //              , clientProvider
    );

    trialExplorerPanel = new TrialExplorerPanel(this, // KdxApp
            pluginInfo, explorerServices.getKdxDeviceService(), this, // as TrialExplorerManager
            offlineData, driverType, barcodeIcon, clientUrlChanger, trialsLoadedConsumer, traitRemovalHandler);

    tabbedPane.addTab(TAB_TRIALS, KDClientUtils.getIcon(ImageId.KDS_TRIALS), trialExplorerPanel);

    Transformer<Trial, Boolean> checkIfEditorIsActive = new Transformer<Trial, Boolean>() {
        @Override
        public Boolean transform(Trial trial) {
            return trialExplorerPanel.isEditorActiveForTrial(trial);
        }
    };
    traitExplorerPanel = new TraitExplorerPanel(messagesPanel, offlineData, clientProvider,
            //            uploadHandler,
            backgroundRunner, barcodeIcon, checkIfEditorIsActive);

    tabbedPane.addTab(TAB_TRAITS, KDClientUtils.getIcon(ImageId.KDS_TRAITS), traitExplorerPanel);

    tagExplorerPanel = new TagExplorerPanel(offlineData);
    tabbedPane.addTab(TAB_TAGS, KDClientUtils.getIcon(ImageId.BLACK_TAG), tagExplorerPanel);

    // Now tie together those panels that need to talk to each other
    trialExplorerPanel.setTraitExplorer(traitExplorerPanel);

    Box box = Box.createHorizontalBox();

    explorerServices.addActions(box);
    box.add(Box.createHorizontalGlue());
    box.add(databaseUrlLabel);
    box.add(Box.createHorizontalGlue());
    Action action = offlineData.getOfflineDataAction();
    if (action != null) {
        JButton button = new JButton(pluginInfo.getKdxploreIcon());
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                if (RunMode.getRunMode().isDeveloper()) {
                    if (0 != (ActionEvent.SHIFT_MASK & e.getModifiers())) {
                        openJdbcExplorer();
                        return;
                    }
                }
                action.actionPerformed(e);
            }
        });
        box.add(button);
    }

    add(box, BorderLayout.NORTH);
    add(tabbedPane, BorderLayout.CENTER);
}

From source file:MyLink.java

public JPanel printableKSGenerate() {
    // create a simple graph for the demo
    graph = new SparseMultigraph<Integer, MyLink>();

    Integer[] v = createVertices(getTermNum());
    createEdges(v);/* w ww . ja  va2s  .  co  m*/

    vv = new VisualizationViewer<Integer, MyLink>(new KKLayout<Integer, MyLink>(graph));
    vv.setPreferredSize(new Dimension(520, 520)); // 570, 640 | 565, 640 

    vv.getRenderContext().setVertexLabelTransformer(new UnicodeVertexStringer<Integer>(v));
    vv.getRenderContext().setVertexLabelRenderer(new DefaultVertexLabelRenderer(Color.magenta));
    vv.getRenderContext().setEdgeLabelRenderer(new DefaultEdgeLabelRenderer(Color.magenta));
    VertexIconShapeTransformer<Integer> vertexIconShapeFunction = new VertexIconShapeTransformer<Integer>(
            new EllipseVertexShapeTransformer<Integer>());
    DefaultVertexIconTransformer<Integer> vertexIconFunction = new DefaultVertexIconTransformer<Integer>();
    vv.getRenderContext().setVertexShapeTransformer(vertexIconShapeFunction);
    vv.getRenderContext().setVertexIconTransformer(vertexIconFunction);
    loadImages(v, vertexIconFunction.getIconMap());
    vertexIconShapeFunction.setIconMap(vertexIconFunction.getIconMap());
    vv.getRenderContext().setVertexFillPaintTransformer(new PickableVertexPaintTransformer<Integer>(
            vv.getPickedVertexState(), new Color(0, 102, 255), Color.red));
    vv.getRenderContext().setEdgeDrawPaintTransformer(
            new PickableEdgePaintTransformer<MyLink>(vv.getPickedEdgeState(), Color.orange, Color.cyan));
    vv.setBackground(Color.white);

    final int maxSize = findMaxSizeNumber();

    File file = new File("./output/DESC_TERM_COUNT.txt");
    String s;

    try {
        BufferedReader fis = new BufferedReader(new InputStreamReader(new FileInputStream(file)));

        s = fis.readLine();
        userSelectedTermsCount = Integer.parseInt(s);
        termIndex = new int[userSelectedTermsCount];

        int i = 0;
        while ((s = fis.readLine()) != null) {
            String[] tmp = s.split("=");
            termIndex[i] = Integer.parseInt(tmp[1].trim());
            i++;
        }

    } catch (IOException e) {
        System.out.println(e.getMessage());
    }

    Transformer<Integer, Shape> vertexSize = new Transformer<Integer, Shape>() {
        public Shape transform(Integer i) {
            double sizeInt = termIndex[i];
            sizeInt = (double) sizeInt / (double) maxSize;
            sizeInt = (double) sizeInt * (double) 30 + 10;
            Ellipse2D circle = new Ellipse2D.Double(sizeInt / 2 * (-1), sizeInt / 2 * (-1), sizeInt, sizeInt);
            return circle;
        }
    };
    vv.getRenderContext().setVertexShapeTransformer(vertexSize);
    vv.getRenderer().getVertexLabelRenderer().setPosition(Position.N);

    // add my listener for ToolTips
    vv.setVertexToolTipTransformer(new ToStringLabeller<Integer>());

    // create a frome to hold the graph
    APanel = new JPanel();
    APanel.setLayout(new BoxLayout(APanel, BoxLayout.Y_AXIS));

    final GraphZoomScrollPane panel = new GraphZoomScrollPane(vv);

    final ModalGraphMouse gm = new DefaultModalGraphMouse<Integer, Number>();
    vv.setGraphMouse(gm);

    final ScalingControl scaler = new CrossoverScalingControl();

    JButton plus = new JButton("+");
    plus.addActionListener(new ActionListener() {
        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());
        }
    });

    JCheckBox lo = new JCheckBox("Show Labels");
    lo.addItemListener(new ItemListener() {
        public void itemStateChanged(ItemEvent e) {
            showLabels = e.getStateChange() == ItemEvent.SELECTED;

            vv.repaint();
        }
    });
    lo.setSelected(true);

    JPanel controls = new JPanel();
    controls.add(plus);
    controls.add(minus);
    controls.add(lo);
    controls.add(((DefaultModalGraphMouse<Integer, Number>) gm).getModeComboBox());
    APanel.add(vv);
    APanel.add(controls);

    return APanel;
}

From source file:com.diversityarrays.kdxplore.data.kdx.CurationDataCollector.java

private void loadSampleGroups(KdxploreDatabase kdxdb, int trialId, boolean fullDetails)
        throws IOException, KdxploreConfigException {
    int databaseDeviceIdentifierId = KdxploreDatabase.DEVICE_ID_NOT_FOUND;
    int editedDeviceIdentifierId = KdxploreDatabase.DEVICE_ID_NOT_FOUND;
    for (DeviceIdentifier devid : kdxdb.getDeviceIdentifiers()) {
        switch (devid.getDeviceType()) {
        case DATABASE:
            databaseDeviceIdentifierId = devid.getDeviceIdentifierId();
            break;
        case EDITED:
            editedDeviceIdentifierId = devid.getDeviceIdentifierId();
            break;
        case KDSMART:
            break;
        case FOR_SCORING:
            break;
        default://ww w  .  j a  v  a  2 s.  c  om
            break;
        }
    }
    if (databaseDeviceIdentifierId == KdxploreDatabase.DEVICE_ID_NOT_FOUND) {
        throw new KdxploreConfigException("No Device Identifier for DATABASE");
    }

    if (editedDeviceIdentifierId == KdxploreDatabase.DEVICE_ID_NOT_FOUND) {
        throw new KdxploreConfigException("No Device Identifier for EDITED");
    }

    databaseSampleGroup = null;
    editedSampleGroup = null;
    sampleGroups.clear();

    final int f_databaseDeviceIdentifierId = databaseDeviceIdentifierId;
    final int f_editedDeviceIdentifierId = editedDeviceIdentifierId;

    Transformer<SampleGroup, KdxploreConfigException> sampleGroupVisitor = new Transformer<SampleGroup, KdxploreConfigException>() {
        @Override
        public KdxploreConfigException transform(SampleGroup sg) {
            addSampleGroup(sg, fullDetails, kdxdb, f_databaseDeviceIdentifierId, f_editedDeviceIdentifierId);

            return null;
        }
    };

    KdxploreConfigException error = kdxdb.visitSampleGroups(trialId, sampleGroupVisitor);
    if (error != null) {
        throw error;
    }

    Date now = new Date();
    if (databaseSampleGroup == null) {
        // We need one.
        SampleGroup sampleGroup = new SampleGroup();
        sampleGroup.setTrialId(trialId);
        sampleGroup.setDeviceIdentifierId(databaseDeviceIdentifierId);
        sampleGroup.setDateLoaded(now);
        kdxdb.saveSampleGroup(sampleGroup);

        addSampleGroup(sampleGroup, fullDetails, kdxdb, f_databaseDeviceIdentifierId,
                f_editedDeviceIdentifierId);
    }

    if (editedSampleGroup == null) {
        // We need one
        SampleGroup sampleGroup = new SampleGroup();
        sampleGroup.setTrialId(trialId);
        sampleGroup.setDeviceIdentifierId(editedDeviceIdentifierId);
        sampleGroup.setDateLoaded(now);
        kdxdb.saveSampleGroup(sampleGroup);

        addSampleGroup(sampleGroup, fullDetails, kdxdb, f_databaseDeviceIdentifierId,
                f_editedDeviceIdentifierId);
    }
}

From source file:net.itransformers.topologyviewer.gui.MyVisualizationViewer.java

private Transformer<String, Paint> createEdgeDrawPaintTransformer() {
    return new Transformer<String, Paint>() {
        final Color defaultColor = new Color(0x0000ff);

        public Paint transform(String edge) {
            if (edgesColorMap.containsKey(edge)) {
                return edgesColorMap.get(edge);
            } else {
                return defaultColor;
            }//from   w w w .j a  v a  2 s .c  om
            //                for (Map<String, GraphMLMetadata<String>> edgeMetadata : edgeMetadatas.values()) {
            //                    final GraphMLMetadata<String> color1 = edgeMetadata.get("color");
            //                    if (color1 == null) {
            //                        logger.error("color metadata is not defined in edge metadata");
            //                        continue;
            //                        //throw new RuntimeException("color metadata is not defined in edge metadata");
            //                    }
            //                    final String value = color1.transformer.transform(edge);
            //                    if (value != null) {
            //                        color = Integer.parseInt(value, 16);
            //                        break;
            //                    }
            //                }
            //                return new Color(color);
        }
    };
}

From source file:edu.uci.ics.jung.io.graphml.TestGraphMLReader2.java

@Test
public void testHypergraphFile() throws Exception {

    Transformer<GraphMetadata, Hypergraph<Number, Number>> graphFactory = new Transformer<GraphMetadata, Hypergraph<Number, Number>>() {
        public Hypergraph<Number, Number> transform(GraphMetadata md) {
            return new SetHypergraph<Number, Number>();
        }//from   w w  w  .j av a2s .  c om
    };

    Transformer<NodeMetadata, Number> vertexFactory = new Transformer<NodeMetadata, Number>() {
        int n = 0;

        public Number transform(NodeMetadata md) {
            return n++;
        }
    };

    Transformer<EdgeMetadata, Number> edgeFactory = new Transformer<EdgeMetadata, Number>() {
        int n = 100;

        public Number transform(EdgeMetadata md) {
            return n++;
        }
    };

    Transformer<HyperEdgeMetadata, Number> hyperEdgeFactory = new Transformer<HyperEdgeMetadata, Number>() {
        int n = 0;

        public Number transform(HyperEdgeMetadata md) {
            return n++;
        }
    };

    // Read the graph object.        
    Reader fileReader = new InputStreamReader(getClass().getResourceAsStream("hyper.graphml"));
    GraphMLReader2<Hypergraph<Number, Number>, Number, Number> hyperreader = new GraphMLReader2<Hypergraph<Number, Number>, Number, Number>(
            fileReader, graphFactory, vertexFactory, edgeFactory, hyperEdgeFactory);

    // Read the graph.
    Hypergraph<Number, Number> graph = hyperreader.readGraph();

    Assert.assertEquals(graph.getVertexCount(), 7);
    Assert.assertEquals(graph.getEdgeCount(), 4);

    // n0
    Set<Number> incident = new HashSet<Number>();
    incident.add(0);
    incident.add(100);
    Assert.assertEquals(incident, graph.getIncidentEdges(0));

    // n1
    incident.clear();
    incident.add(0);
    incident.add(2);
    Assert.assertEquals(incident, graph.getIncidentEdges(1));

    // n2
    incident.clear();
    incident.add(0);
    Assert.assertEquals(incident, graph.getIncidentEdges(2));

    // n3
    incident.clear();
    incident.add(1);
    incident.add(2);
    Assert.assertEquals(incident, graph.getIncidentEdges(3));

    // n4
    incident.clear();
    incident.add(1);
    incident.add(100);
    Assert.assertEquals(incident, graph.getIncidentEdges(4));

    // n5
    incident.clear();
    incident.add(1);
    Assert.assertEquals(incident, graph.getIncidentEdges(5));

    // n6
    incident.clear();
    incident.add(1);
    Assert.assertEquals(incident, graph.getIncidentEdges(6));
}

From source file:de.unisb.cs.st.javaslicer.jung.ShowJungGraph.java

public void displayGraph(DirectedGraph<VertexType, SliceEdge<VertexType>> graph) {
    JFrame mainFrame = new JFrame("slice graph display");
    mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    Layout<VertexType, SliceEdge<VertexType>> layout = new KKLayout<VertexType, SliceEdge<VertexType>>(graph);
    final VisualizationViewer<VertexType, SliceEdge<VertexType>> viewer = new VisualizationViewer<VertexType, SliceEdge<VertexType>>(
            layout);//from   w w w. j a v  a2 s . c o m

    viewer.getRenderContext().setVertexLabelTransformer(this.vertexLabelTransformer);
    viewer.setVertexToolTipTransformer(this.vertexTooltipTransformer);
    viewer.getRenderContext().setEdgeLabelTransformer(new Transformer<SliceEdge<VertexType>, String>() {
        @Override
        public String transform(SliceEdge<VertexType> edge) {
            Variable var = edge.getVariable();
            if (var instanceof ArrayElement) {
                ArrayElement elem = (ArrayElement) var;
                return "arr" + elem.getArrayId() + "[" + elem.getArrayIndex() + "]";
            } else if (var instanceof LocalVariable) {
                LocalVariable localVar = (LocalVariable) var;
                if (localVar.getVarName() != null)
                    return localVar.getVarName();
                return "local" + localVar.getVarIndex();
            } else if (var instanceof StackEntry) {
                return "stack";
            } else if (var instanceof ObjectField) {
                ObjectField objField = (ObjectField) var;
                return "obj" + objField.getObjectId() + "." + objField.getFieldName();
            } else if (var instanceof StaticField) {
                StaticField objField = (StaticField) var;
                String ownerInternalClassName = objField.getOwnerInternalClassName();
                String simpleClassName = getSimpleClassName(ownerInternalClassName);
                return simpleClassName + "." + objField.getFieldName();
            } else {
                assert var == null;
                return "";
            }
        }
    });
    viewer.setEdgeToolTipTransformer(new Transformer<SliceEdge<VertexType>, String>() {
        @Override
        public String transform(SliceEdge<VertexType> edge) {
            Variable var = edge.getVariable();
            if (var instanceof ArrayElement) {
                ArrayElement elem = (ArrayElement) var;
                return "Array element " + elem.getArrayIndex() + " of array #" + elem.getArrayId();
            } else if (var instanceof LocalVariable) {
                LocalVariable localVar = (LocalVariable) var;
                if (localVar.getVarName() != null)
                    return "Local variable \"" + localVar.getVarName() + "\"";
                return "Local variable #" + localVar.getVarIndex();
            } else if (var instanceof StackEntry) {
                return "Dependency over the operand stack";
            } else if (var instanceof ObjectField) {
                ObjectField objField = (ObjectField) var;
                return "Field \"" + objField.getFieldName() + "\" of object #" + objField.getObjectId();
            } else if (var instanceof StaticField) {
                StaticField objField = (StaticField) var;
                String ownerInternalClassName = objField.getOwnerInternalClassName();
                return "Static field \"" + objField.getFieldName() + "\" of class \""
                        + Type.getType(ownerInternalClassName).getClassName();
            } else {
                assert var == null;
                return "Control dependency";
            }
        }
    });
    viewer.getRenderContext().setEdgeDrawPaintTransformer(new Transformer<SliceEdge<VertexType>, Paint>() {
        @Override
        public Paint transform(SliceEdge<VertexType> edge) {
            return edge.getVariable() == null ? Color.red : Color.black;
        }
    });

    viewer.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR);
    viewer.getRenderContext().setVertexShapeTransformer(new Transformer<VertexType, Shape>() {
        @Override
        public Shape transform(VertexType inst) {
            Font font = viewer.getFont();
            String text = viewer.getRenderContext().getVertexLabelTransformer().transform(inst);
            FontRenderContext fontRenderContext = ((Graphics2D) viewer.getGraphics()).getFontRenderContext();
            Rectangle2D bounds = font.getStringBounds(text, fontRenderContext);
            return new RoundRectangle2D.Double(-.6 * bounds.getWidth(), -.6 * bounds.getHeight(),
                    1.2 * bounds.getWidth(), 1.2 * bounds.getHeight(), 8, 8);
        }
    });

    viewer.setBackground(Color.white);

    DefaultModalGraphMouse<InstructionInstance, SliceEdge<VertexType>> mouse = new DefaultModalGraphMouse<InstructionInstance, SliceEdge<VertexType>>();
    mouse.setMode(Mode.ANNOTATING);
    viewer.setGraphMouse(mouse);

    mainFrame.getContentPane().add(viewer);
    mainFrame.pack();

    mainFrame.setVisible(true);
}