Example usage for org.jfree.chart.renderer.xy XYItemRenderer setSeriesVisible

List of usage examples for org.jfree.chart.renderer.xy XYItemRenderer setSeriesVisible

Introduction

In this page you can find the example usage for org.jfree.chart.renderer.xy XYItemRenderer setSeriesVisible.

Prototype

public void setSeriesVisible(Boolean visible, boolean notify);

Source Link

Document

Sets the flag that controls the visibility of ALL series and sends a RendererChangeEvent to all registered listeners.

Usage

From source file:at.granul.mason.collector.ChartFileScalarDataWriter.java

public static void exportGraph(XYChartGenerator chart, String prefix, int width, int height) {
    try {/*  w  ww  . j  a  va2s  . com*/
        Document document = new Document(new com.lowagie.text.Rectangle(width, height));

        PdfWriter writer = PdfWriter.getInstance(document,
                new FileOutputStream(new File(prefix + "_" + DataWriter.DF.format(new Date()) + ".pdf")));

        document.addAuthor("MASON");
        document.open();
        PdfContentByte cb = writer.getDirectContent();
        //PdfTemplate tp = cb.createTemplate(width, height);

        //Write the chart with all datasets
        chart.addLegend();
        /*LegendTitle title = new LegendTitle(chart.getChart().getPlot());
        title.setLegendItemGraphicPadding(new org.jfree.ui.RectangleInsets(0,8,0,4));
        chart.addLegend(title);*/
        LegendTitle legendTitle = chart.getChart().getLegend();
        legendTitle.setPosition(RectangleEdge.BOTTOM);

        Graphics2D g2 = cb.createGraphics(width, height, new DefaultFontMapper());
        Rectangle2D rectangle2D = new Rectangle2D.Double(0, 0, width, height);
        chart.getChart().draw(g2, rectangle2D);
        g2.dispose();

        //PNG Output
        ChartUtilities.saveChartAsJPEG(new File(prefix + "_" + DataWriter.DF.format(new Date()) + ".png"),
                chart.getChart(), width, height);

        chart.getChart().removeLegend();
        //tp = cb.createTemplate(width, height);

        //All invisible
        final XYItemRenderer renderer = chart.getChartPanel().getChart().getXYPlot().getRenderer();
        for (int a = 0; a < chart.getSeriesCount(); a++) {
            renderer.setSeriesVisible(a, false);
        }

        final Dataset seriesDataset = chart.getSeriesDataset();
        XYSeriesCollection series = ((XYSeriesCollection) seriesDataset);
        for (int a = 0; a < chart.getSeriesCount(); a++) {
            renderer.setSeriesVisible(a, true);
            final String seriesName = series.getSeries(a).getKey() + "";
            chart.setYAxisLabel(seriesName);
            document.newPage();
            g2 = cb.createGraphics(width, height * (a + 2), new DefaultFontMapper());
            g2.translate(0, height * (a + 1));
            chart.getChart().draw(g2, rectangle2D);
            g2.dispose();

            //PNG Output
            ChartUtilities.saveChartAsJPEG(
                    new File(prefix + "_" + seriesName + DataWriter.DF.format(new Date()) + ".png"),
                    chart.getChart(), width, height);

            renderer.setSeriesVisible(a, false);
        }
        //cb.addTemplate(tp, 0, 0);

        document.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

From source file:eu.kprod.gui.chart.MwChartPanel.java

public void setVisible(final int l, final boolean b) {
    final XYItemRenderer renderer = super.getChart().getXYPlot().getRenderer();
    // for (int i = 0; i < super.getChart().getXYPlot().getDataset()
    // .getSeriesCount(); i++) {
    // super.getChart().getXYPlot().getSeriesCount();
    // }//from   w w  w.  ja  va 2 s  . c  o  m
    super.getChart().setAntiAlias(true);

    renderer.setSeriesVisible(l, b);
    if (b) {
        renderer.setSeriesPaint(l, conf.color.getColorGraph(l));
    }

}

From source file:net.sf.maltcms.chromaui.charts.events.ChartPanelMouseListener.java

/**
 *
 * @param arg0//from   w ww . j  a  va  2  s. c  o  m
 */

@Override
public void chartMouseClicked(final ChartMouseEvent arg0) {
    final ChartPanelMouseListener cpml = this;
    if (arg0.getEntity() != null) {
        if (arg0.getEntity() instanceof XYItemEntity) {
            XYItemEntity xyie = (XYItemEntity) arg0.getEntity();

            if (arg0.getTrigger().getButton() == MouseEvent.BUTTON1) {
                //                
                if (arg0.getTrigger().isAltDown() && arg0.getTrigger().isShiftDown()) {
                    //                        System.out.println("Item removed");
                    fireEvent(new XYItemEntityRemovedEvent((XYItemEntity) arg0.getEntity(), cpml));
                } else if (arg0.getTrigger().isAltDown()) {
                    //                        System.out.println("Item added");
                    fireEvent(new XYItemEntityAddedEvent((XYItemEntity) arg0.getEntity(), cpml));
                } else {
                    setTarget(arg0);
                    //                        System.out.println("Item clicked");
                    fireEvent(new XYItemEntityClickedEvent((XYItemEntity) arg0.getEntity(), cpml));
                }
            }
        } else if (arg0.getEntity() instanceof LegendItemEntity) {
            JPopupMenu jpm = new JPopupMenu();
            final LegendItemEntity lie = (LegendItemEntity) arg0.getEntity();
            Dataset ds = lie.getDataset();
            Comparable skey = lie.getSeriesKey();
            Plot plot = arg0.getChart().getPlot();
            if (plot instanceof XYPlot) {
                XYPlot xyplot = arg0.getChart().getXYPlot();
                if (xyplot.getSeriesCount() > 1) {
                    XYDataset xyds = (XYDataset) ds;
                    XYItemRenderer xyir = xyplot.getRendererForDataset(xyds);

                    xyir.setSeriesVisible(xyds.indexOf(skey), !xyir.isSeriesVisible(xyds.indexOf(skey)));
                    xyir.setSeriesVisibleInLegend(xyds.indexOf(skey), Boolean.TRUE);
                }
            } else if (plot instanceof CategoryPlot) {
                CategoryPlot cplot = arg0.getChart().getCategoryPlot();
                if (cplot.getDatasetCount() > 1) {
                    CategoryDataset cds = (CategoryDataset) ds;
                    CategoryItemRenderer xyir = cplot.getRendererForDataset(cds);
                    int seriesIndex = cds.getColumnIndex(skey);
                    if (seriesIndex == -1) {
                        seriesIndex = cds.getRowIndex(skey);
                    }
                    xyir.setSeriesVisible(seriesIndex, !xyir.isSeriesVisible(seriesIndex));
                    xyir.setSeriesVisibleInLegend(seriesIndex, Boolean.TRUE);
                }
            }
            //                AbstractAction hse = new AbstractAction("Hide") {
            //
            //                    @Override
            //                    public void actionPerformed(ActionEvent ae) {
            //                        
            //                    }
            //                };
            //                AbstractAction hse = new AbstractAction("Show") {
            //
            //                    @Override
            //                    public void actionPerformed(ActionEvent ae) {
            //                        
            //                    }
            //                };
            //                AbstractAction hse = new AbstractAction("Remove") {
            //
            //                    @Override
            //                    public void actionPerformed(ActionEvent ae) {
            //                        
            //                    }
            //                };
        }
    }
}

From source file:org.kepler.plotting.Plot.java

private void addEntry(final TimePeriodValues series) {
    String menuEntryName = "Toggle line '" + series.getKey() + "'";
    final Plot me = this;
    toggleMenu.add(new JMenuItem(new FigureAction(menuEntryName) {
        @Override//  ww w. j  av  a 2 s .  co  m
        public void actionPerformed(ActionEvent e) {
            // Get series number
            int seriesIndex = -1;
            for (int i = 0; i < dataset.getSeriesCount(); i++) {
                TimePeriodValues currentSeries = dataset.getSeries(i);
                if (series == currentSeries) {
                    seriesIndex = i;
                    break;
                }
            }
            if (seriesIndex == -1) {
                return;
            }

            XYItemRenderer renderer = me.getXYPlot().getRendererForDataset(dataset);
            Boolean currentVisibility = renderer.getSeriesVisible(seriesIndex);
            if (currentVisibility == null) {
                currentVisibility = true;
            }
            renderer.setSeriesVisible(seriesIndex, !currentVisibility);
        }
    }));
}

From source file:net.sf.maltcms.chromaui.chromatogram1Dviewer.ui.Chromatogram1DViewTopComponent.java

private void hideShowSeriesActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_hideShowSeriesActionPerformed
    SeriesItem s = (SeriesItem) seriesComboBox.getSelectedItem();
    Chromatogram1DDataset dataset = getLookup().lookup(Chromatogram1DDataset.class);
    ChartPanel cp = jp.getLookup().lookup(ChartPanel.class);
    for (int i = 0; i < dataset.getSeriesCount(); i++) {
        if (dataset.getSeriesKey(i).equals(s.getSeriesKey())) {
            XYPlot p = cp.getChart().getXYPlot();
            if (p != null) {
                XYItemRenderer renderer = p.getRenderer();
                if (renderer != null) {
                    boolean isVisible = renderer.isSeriesVisible(i);
                    renderer.setSeriesVisible(i, !isVisible);
                    s.setVisible(!isVisible);
                } else {
                    Logger.getLogger(Chromatogram1DViewTopComponent.class.getName())
                            .fine("XYItemRenderer is null!");
                }/*from  w w w  .  j a  v  a2 s  . c o  m*/
            } else {
                Logger.getLogger(Chromatogram1DViewTopComponent.class.getName()).fine("XYPlot is null!");
            }
        }
    }
}

From source file:ch.algotrader.client.chart.ChartTab.java

private void initTimeSeries(int datasetNumber, XYDataset dataset, SeriesDefinitionVO seriesDefinition) {

    IndicatorDefinitionVO indicatorDefinition = (IndicatorDefinitionVO) seriesDefinition;
    TimeSeriesCollection timeSeriesCollection = (TimeSeriesCollection) dataset;

    // create the TimeSeries
    TimeSeries series = new TimeSeries(indicatorDefinition.getLabel());
    timeSeriesCollection.addSeries(series);
    this.indicators.put(indicatorDefinition.getName(), series);

    // get the seriesNumber & color
    final int seriesNumber = timeSeriesCollection.getSeriesCount() - 1;

    // configure the renderer
    final XYItemRenderer renderer = getPlot().getRenderer(datasetNumber);
    renderer.setSeriesPaint(seriesNumber, getColor(indicatorDefinition.getColor()));
    renderer.setSeriesVisible(seriesNumber, seriesDefinition.isSelected());
    renderer.setBaseToolTipGenerator(StandardXYToolTipGenerator.getTimeSeriesInstance());

    if (seriesDefinition.isDashed()) {
        renderer.setSeriesStroke(seriesNumber, new BasicStroke(0.5f, BasicStroke.CAP_BUTT,
                BasicStroke.JOIN_MITER, 10.0f, new float[] { 5.0f }, 0.0f));
    } else {/*  www  .j  a  va 2s.co  m*/
        renderer.setSeriesStroke(seriesNumber, new BasicStroke(0.5f));
    }

    // add the menu item
    JCheckBoxMenuItem menuItem = new JCheckBoxMenuItem(seriesDefinition.getLabel());
    menuItem.setSelected(seriesDefinition.isSelected());
    menuItem.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            resetAxis();
            renderer.setSeriesVisible(seriesNumber, ((JCheckBoxMenuItem) e.getSource()).isSelected());
            initAxis();
        }
    });
    this.getPopupMenu().add(menuItem);
}

From source file:org.talend.dataprofiler.chart.TOPChartService.java

@Override
public Object createSelectionAdapterForButton(final Object chart, final boolean isCountAvg,
        final boolean isMinMax) {
    return new SelectionAdapter() {

        private static final String SERIES_KEY_ID = "SERIES_KEY"; //$NON-NLS-1$

        @Override//  w ww  . j a  v a  2s.c o m
        public void widgetSelected(SelectionEvent e) {

            Button checkBtn = (Button) e.getSource();
            int seriesid = (Integer) checkBtn.getData(SERIES_KEY_ID);

            if (isCountAvg) {
                XYPlot plot = ((JFreeChart) chart).getXYPlot();
                XYItemRenderer xyRenderer = plot.getRenderer();
                xyRenderer.setSeriesVisible(seriesid, checkBtn.getSelection());
            }

            if (isMinMax) {
                CategoryPlot plot = (CategoryPlot) ((JFreeChart) chart).getPlot();
                CategoryItemRenderer render = plot.getRenderer();
                render.setSeriesVisible(seriesid, checkBtn.getSelection());
            }
        }
    };
}

From source file:dbseer.gui.panel.DBSeerLiveMonitorPanel.java

@Override
public synchronized void actionPerformed(ActionEvent event) {
    for (int i = 0; i < transactionRenameButtons.size(); ++i) {
        if (event.getSource() == transactionRenameButtons.get(i)) {
            String newName = (String) JOptionPane.showInputDialog(this,
                    "Enter the new name for this transaction type", "New Dataset", JOptionPane.PLAIN_MESSAGE,
                    null, null, transactionNames.get(i));

            if (newName == null || newName.trim().isEmpty()) {
                return;
            } else {
                newName = newName.trim();
                transactionNames.set(i, newName);
                transactionLabels.get(i).setText(newName);

                DefaultTableModel model = (DefaultTableModel) monitorTable.getModel();
                model.setValueAt(String.format("Current TPS of '%s' transactions", transactionNames.get(i)),
                        2 + (i * ROW_PER_TX_TYPE), 0);
                model.setValueAt(//w  w w  .  ja va2  s.  co m
                        String.format("Current average latency of '%s' transactions", transactionNames.get(i)),
                        2 + (i * ROW_PER_TX_TYPE) + 1, 0);

                //               TimeSeriesCollection collection = (TimeSeriesCollection) throughputChartPanel.getChart().getXYPlot().getDataset();
                throughputCollection.getSeries(i).setKey(newName);
                latencyCollection.getSeries(i).setKey(newName);

                //               if (DBSeerGUI.currentDataset != null)
                //               {
                //                  DBSeerGUI.currentDataset.setTransactionTypeName(i, newName);
                //               }

                for (DBSeerDataSet dataset : DBSeerGUI.liveDatasets) {
                    dataset.setTransactionTypeName(i, newName);
                }

                return;
            }
        }
    }

    for (int i = 0; i < transactionViewSampleButtons.size(); ++i) {
        if (event.getSource() == transactionViewSampleButtons.get(i)) {
            final int type = i;
            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    DBSeerShowTransactionExampleFrame sampleFrame = new DBSeerShowTransactionExampleFrame(type);
                    sampleFrame.pack();
                    sampleFrame.setLocationRelativeTo(DBSeerGUI.mainFrame);
                    sampleFrame.setVisible(true);
                }
            });
        }
    }

    for (int i = 0; i < transactionEnableDisableButtons.size(); ++i) {
        if (event.getSource() == transactionEnableDisableButtons.get(i)) {
            final XYItemRenderer throughputRenderer = throughputChartPanel.getChart().getXYPlot().getRenderer();
            final XYItemRenderer latencyRenderer = latencyChartPanel.getChart().getXYPlot().getRenderer();
            final int type = i;
            final JButton button = transactionEnableDisableButtons.get(i);
            final DBSeerDataSet dataset = DBSeerGUI.liveDataset;

            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    if (button.getText() == "Disable") {
                        dataset.disableTransaction(type);
                        throughputRenderer.setSeriesVisible(type, false);
                        latencyRenderer.setSeriesVisible(type, false);
                        button.setText("Enable");
                    } else if (button.getText() == "Enable") {
                        dataset.enableTransaction(type);
                        throughputRenderer.setSeriesVisible(type, true);
                        latencyRenderer.setSeriesVisible(type, true);
                        button.setText("Disable");
                    }
                }
            });
        }
    }

    for (int i = 0; i < transactionDeleteButtons.size(); ++i) {
        if (event.getSource() == transactionDeleteButtons.get(i)) {
            synchronized (LiveMonitorInfo.LOCK) {
                try {
                    DBSeerGUI.middlewareSocket.removeTransactionType(i);
                } catch (IOException e) {
                    DBSeerExceptionHandler.handleException(e);
                }

                throughputCollection.removeSeries(i);
                latencyCollection.removeSeries(i);

                DefaultTableModel model = (DefaultTableModel) monitorTable.getModel();
                int newTxSize = transactionNames.size() - 1;
                for (int j = 0; j < transactionNames.size(); ++j) {
                    model.setValueAt(String.format("Current TPS of '%s' transactions", transactionNames.get(j)),
                            2 + (j * ROW_PER_TX_TYPE), 0);
                    model.setValueAt(String.format("Current average latency of '%s' transactions",
                            transactionNames.get(j)), 2 + (j * ROW_PER_TX_TYPE) + 1, 0);
                    model.setValueAt("", 2 + (j * ROW_PER_TX_TYPE), 1);
                    model.setValueAt("", 2 + (j * ROW_PER_TX_TYPE) + 1, 1);
                }
                model.setValueAt("", 2 + (newTxSize * ROW_PER_TX_TYPE), 0);
                model.setValueAt("", 2 + (newTxSize * ROW_PER_TX_TYPE), 1);
                model.setValueAt("", 2 + (newTxSize * ROW_PER_TX_TYPE) + 1, 0);
                model.setValueAt("", 2 + (newTxSize * ROW_PER_TX_TYPE) + 1, 1);

                final JPanel panel = transactionTypesPanel;
                final JLabel label = transactionLabels.remove(i);
                final JButton renameButton = transactionRenameButtons.remove(i);
                final JButton exampleButton = transactionViewSampleButtons.remove(i);
                final JButton deleteButton = transactionDeleteButtons.remove(i);
                transactionNames.remove(i);

                SwingUtilities.invokeLater(new Runnable() {
                    @Override
                    public void run() {
                        panel.remove(label);
                        panel.remove(renameButton);
                        panel.remove(exampleButton);
                        panel.remove(deleteButton);

                        panel.revalidate();
                        panel.repaint();
                    }
                });
            }
            break;
        }
    }

}

From source file:windows.sensorWindow.java

/**
 * creates all relevant data and adds it into the corresponding maps
 * //w w w  .jav a 2 s  .c  o  m
 * @param UID
 *            UID of the plotting sensor
 */
@SuppressWarnings("deprecation")
public static void addPlot(Brick newBrick) {
    // create series
    TimeSeries newSeries = new TimeSeries("" + 0, Millisecond.class);
    TimeSeries newSeries2 = new TimeSeries("" + 0, Millisecond.class);
    TimeSeries newSeries3 = new TimeSeries("" + 0, Millisecond.class);
    TimeSeries newSeries4 = new TimeSeries("" + 0, Millisecond.class);
    TimeSeries newSeries5 = new TimeSeries("" + 0, Millisecond.class);
    TimeSeries newSeries6 = new TimeSeries("" + 0, Millisecond.class);

    Measurement m1 = new Measurement(maxValues, maxCycles, newBrick.uid, 0);
    valuesMap.put(newBrick.uid, m1);
    if (newBrick.checked3 == true) {
        Measurement m2 = new Measurement(maxValues, maxCycles, newBrick.uid, 1);
        values2Map.put(newBrick.uid, m2);
    }

    // create entry in state map
    plot1StateMap.put(newBrick.uid, 0);
    plot2StateMap.put(newBrick.uid, 0);

    // create index map entry
    tmplindex.put(newBrick.uid, 0);

    // create avrgCtrlEnabled maps
    if (newBrick.controlAverage == true)
        avrgCtrl1Enabled.put(newBrick.uid, true);
    else
        avrgCtrl1Enabled.put(newBrick.uid, false);
    if (newBrick.controlAverage2 == true)
        avrgCtrl2Enabled.put(newBrick.uid, true);
    else
        avrgCtrl2Enabled.put(newBrick.uid, false);

    // create series map entry
    seriesMap.put(newBrick.uid, newSeries);
    seriesMap2.put(newBrick.uid, newSeries2);
    seriesMap3.put(newBrick.uid, newSeries3);
    seriesMap4.put(newBrick.uid, newSeries4);
    seriesMap5.put(newBrick.uid, newSeries3);
    seriesMap6.put(newBrick.uid, newSeries4);

    // create collection map entry
    seriesCollectionMap.put(newBrick.uid, new TimeSeriesCollection(newSeries));
    seriesCollectionMap2.put(newBrick.uid, new TimeSeriesCollection(newSeries2));
    tmplCollection1_1.put(newBrick.uid, new TimeSeriesCollection(newSeries3));
    tmplCollection1_2.put(newBrick.uid, new TimeSeriesCollection(newSeries4));
    tmplCollection2_1.put(newBrick.uid, new TimeSeriesCollection(newSeries5));
    tmplCollection2_2.put(newBrick.uid, new TimeSeriesCollection(newSeries6));

    // create plot map entry, special case for current/voltage brick, since
    // it has 2 parallel measurements and therefore 2 graphs must be treated
    XYPlot tmpSubPlot;
    tmpSubPlot = new XYPlot(seriesCollectionMap.get(newBrick.uid), null, null, new StandardXYItemRenderer());

    // create the 1st graph
    if (newBrick.checked2 == true) {
        // create plot map entry
        NumberAxis rangeAxis = new NumberAxis(
                String.valueOf(constants.brickUnitMap.get(newBrick.deviceIdentifier)));
        rangeAxis.setAutoRangeIncludesZero(true);
        tmpSubPlot.setRangeAxis(0, rangeAxis);
        rangeAxis.setLabelPaint(Color.BLUE);
        rangeAxis.setVisible(newBrick.checked2);
        tmpSubPlot.setDataset(0, seriesCollectionMap.get(newBrick.uid));

        // set dot - shape
        // Shape cross = ShapeUtilities.createDiagonalCross(3, 1);

        // create and store renderer
        XYItemRenderer renderer1 = new XYLineAndShapeRenderer();
        renderer1 = tmpSubPlot.getRenderer();
        renderer1.setSeriesPaint(0, Color.BLUE);
        renderer1.setSeriesStroke(0, new BasicStroke(3));
        // line = dashes:
        // float dash[] = {5.0f};
        // renderer1.setSeriesStroke( 0, new
        // BasicStroke(3,BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER,
        // 10.0f, dash, 0.0f));
        // renderer1.setSeriesShape(0, cross);
        tmpSubPlot.setRenderer(0, renderer1);

        // set colors
        tmpSubPlot.setBackgroundPaint(Color.white);
        tmpSubPlot.setDomainGridlinePaint(Color.lightGray);
        tmpSubPlot.setRangeGridlinePaint(Color.lightGray);
        // tmpSubPlot.setRenderer(renderer2);

        // set font
        rangeAxis.setLabelFont(customFonts.get("axisLabelFont"));
        rangeAxis.setTickLabelFont(customFonts.get("axisValueFont"));

        // create template graph
        // if (newBrick.ctrlTmpl[0] == true)
        // {
        tmpSubPlot.setDataset(2, tmplCollection1_1.get(newBrick.uid));

        XYItemRenderer renderer3 = new XYLineAndShapeRenderer();
        int width = computeTmplPlotWidth(newBrick.tmpl1Width);
        BasicStroke stroke = new BasicStroke(width, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND);// , 10.0f, dash, 0.0f);
        renderer3.setSeriesPaint(0, Color.GREEN);
        // renderer3.setSeriesStroke( 0, new BasicStroke( 1 ) );
        renderer3.setSeriesStroke(0, stroke);
        renderer3.setSeriesVisible(0, newBrick.ctrlTmpl[0]);
        rendererMap3.put(newBrick.uid, renderer3);
        tmpSubPlot.setRenderer(2, rendererMap3.get(newBrick.uid));
        // }

        // put everything to the maps
        rendererMap.put(newBrick.uid, renderer1);
        plotMap.put(newBrick.uid, tmpSubPlot);
        axisMap.put(newBrick.uid, rangeAxis);
    }

    // create the 2nd graph
    if (newBrick.checked3 == true) {
        // set second axis for voltage/ampere brick
        NumberAxis secondaryAxis = new NumberAxis(
                String.valueOf(constants.brick2ndUnitMap.get(newBrick.deviceIdentifier)));
        secondaryAxis.setAutoRangeIncludesZero(true);
        tmpSubPlot.setRangeAxis(1, secondaryAxis);
        secondaryAxis.setLabelPaint(Color.RED);
        secondaryAxis.setVisible(newBrick.checked3);
        tmpSubPlot.setDataset(1, seriesCollectionMap2.get(newBrick.uid));
        tmpSubPlot.mapDatasetToRangeAxis(1, 1);

        // set font
        secondaryAxis.setLabelFont(customFonts.get("axisLabelFont"));
        secondaryAxis.setTickLabelFont(customFonts.get("axisValueFont"));

        // create and store renderer
        XYItemRenderer renderer2 = new StandardXYItemRenderer();
        // renderer2 = tmpSubPlot.getRenderer();
        renderer2.setSeriesPaint(1, Color.RED);
        renderer2.setSeriesStroke(0, new BasicStroke(3));
        tmpSubPlot.setRenderer(1, renderer2);

        // set colors
        tmpSubPlot.setBackgroundPaint(Color.white);
        tmpSubPlot.setDomainGridlinePaint(Color.lightGray);
        tmpSubPlot.setRangeGridlinePaint(Color.lightGray);

        // ----------------------------------------------------------------------------------
        // create min1 critical map value
        ValueMarker vm5 = new ValueMarker(newBrick.tresholdMin2);
        markerMapMin2Critical.put(newBrick.uid, vm5);
        // set critical line
        markerMapMin2Critical.get(newBrick.uid).setPaint(Color.red);
        markerMapMin2Critical.get(newBrick.uid).setLabel(
                String.valueOf(constants.brick2ndUnitMap.get(newBrick.deviceIdentifier)) + " critical min");
        markerMapMin2Critical.get(newBrick.uid).setLabelAnchor(RectangleAnchor.TOP_RIGHT);
        markerMapMin2Critical.get(newBrick.uid).setLabelTextAnchor(TextAnchor.TOP_RIGHT);
        tmpSubPlot.addRangeMarker(1, markerMapMin2Critical.get(newBrick.uid), Layer.BACKGROUND);

        // create min1 warning map value
        ValueMarker vm6 = new ValueMarker(
                newBrick.tresholdMin2 + newBrick.tresholdMin2 * warningPercentage / 100);
        markerMapMin2Warning.put(newBrick.uid, vm6);
        // set warning line
        markerMapMin2Warning.get(newBrick.uid).setPaint(Color.orange);
        markerMapMin2Warning.get(newBrick.uid).setLabel(
                String.valueOf(constants.brick2ndUnitMap.get(newBrick.deviceIdentifier)) + " warning min");
        markerMapMin2Warning.get(newBrick.uid).setLabelAnchor(RectangleAnchor.TOP_RIGHT);
        markerMapMin2Warning.get(newBrick.uid).setLabelTextAnchor(TextAnchor.TOP_RIGHT);
        // tmpSubPlot.addRangeMarker(markerMapMin2Warning.get(newBrick.uid));
        tmpSubPlot.addRangeMarker(1, markerMapMin2Warning.get(newBrick.uid), Layer.BACKGROUND);

        // create max1 critical map value
        ValueMarker vm7 = new ValueMarker(newBrick.tresholdMax2);
        markerMapMax2Critical.put(newBrick.uid, vm7);
        // set critical line
        markerMapMax2Critical.get(newBrick.uid).setPaint(Color.red);
        markerMapMax2Critical.get(newBrick.uid).setLabel(
                String.valueOf(constants.brick2ndUnitMap.get(newBrick.deviceIdentifier)) + " critical max");
        markerMapMax2Critical.get(newBrick.uid).setLabelAnchor(RectangleAnchor.TOP_RIGHT);
        markerMapMax2Critical.get(newBrick.uid).setLabelTextAnchor(TextAnchor.TOP_RIGHT);
        tmpSubPlot.addRangeMarker(1, markerMapMax2Critical.get(newBrick.uid), Layer.BACKGROUND);

        // create max1 warning map value
        ValueMarker vm8 = new ValueMarker(
                newBrick.tresholdMax2 + newBrick.tresholdMax2 * warningPercentage / 100);
        markerMapMax2Warning.put(newBrick.uid, vm8);
        // set warning line
        markerMapMax2Warning.get(newBrick.uid).setPaint(Color.orange);
        markerMapMax2Warning.get(newBrick.uid).setLabel(
                String.valueOf(constants.brick2ndUnitMap.get(newBrick.deviceIdentifier)) + " warning max");
        markerMapMax2Warning.get(newBrick.uid).setLabelAnchor(RectangleAnchor.TOP_RIGHT);
        markerMapMax2Warning.get(newBrick.uid).setLabelTextAnchor(TextAnchor.TOP_RIGHT);
        tmpSubPlot.addRangeMarker(1, markerMapMax2Warning.get(newBrick.uid), Layer.BACKGROUND);

        // create and add min, max and average markers
        // create maxima marker
        ValueMarker vmMax = new ValueMarker(0);
        vmMax.setPaint(Color.orange);
        vmMax.setLabel("max");
        vmMax.setLabelAnchor(RectangleAnchor.TOP_RIGHT);
        vmMax.setLabelTextAnchor(TextAnchor.TOP_RIGHT);
        // create minima marker
        ValueMarker vmMin = new ValueMarker(0);
        vmMin.setPaint(Color.orange);
        vmMin.setLabel("min");
        vmMin.setLabelAnchor(RectangleAnchor.TOP_RIGHT);
        vmMin.setLabelTextAnchor(TextAnchor.TOP_RIGHT);
        // create average marker
        ValueMarker vmAvg = new ValueMarker(0);
        vmAvg.setPaint(Color.red);
        vmAvg.setLabel("average");
        vmAvg.setLabelAnchor(RectangleAnchor.TOP_RIGHT);
        vmAvg.setLabelTextAnchor(TextAnchor.TOP_RIGHT);
        // add to maps
        marker2Maxima.put(newBrick.uid, vmMax);
        marker2Minima.put(newBrick.uid, vmMin);
        marker2Average.put(newBrick.uid, vmAvg);
        // add to plot
        tmpSubPlot.addRangeMarker(1, vmMax, Layer.BACKGROUND);
        tmpSubPlot.addRangeMarker(1, vmMin, Layer.BACKGROUND);
        tmpSubPlot.addRangeMarker(1, vmAvg, Layer.BACKGROUND);

        // create and add avrgCntrMarkers
        // create upper marker
        ValueMarker avrgCtrl2high = new ValueMarker(newBrick.getAvg2high());
        avrgCtrl2high.setPaint(Color.orange);
        avrgCtrl2high.setLabel("avrg high");
        avrgCtrl2high.setLabelAnchor(RectangleAnchor.TOP_RIGHT);
        avrgCtrl2high.setLabelTextAnchor(TextAnchor.TOP_RIGHT);
        // create lower marker
        ValueMarker avrgCtrl2low = new ValueMarker(newBrick.getAvg2low());
        avrgCtrl2low.setPaint(Color.orange);
        avrgCtrl2low.setLabel("avrg low");
        avrgCtrl2low.setLabelAnchor(RectangleAnchor.TOP_RIGHT);
        avrgCtrl2low.setLabelTextAnchor(TextAnchor.TOP_RIGHT);
        // add both markers
        avrg2High.put(newBrick.uid, avrgCtrl2high);
        avrg2Low.put(newBrick.uid, avrgCtrl2low);
        // add both to plot
        if (newBrick.controlAverage2) {
            tmpSubPlot.addRangeMarker(1, avrgCtrl2high, Layer.BACKGROUND);
            tmpSubPlot.addRangeMarker(1, avrgCtrl2low, Layer.BACKGROUND);
        }
        // ----------------------------------------------------------------------------------

        // put everything to the map
        rendererMap2.put(newBrick.uid, renderer2);
        plotMap.put(newBrick.uid, tmpSubPlot);
        axisMap2.put(newBrick.uid, secondaryAxis);
    }

    // 1st graph
    // markers--------------------------------------------------------------------------------------------------
    // create min1 critical map value
    ValueMarker vm1 = new ValueMarker(newBrick.tresholdMin1);
    markerMapMin1Critical.put(newBrick.uid, vm1);
    // set critical line
    markerMapMin1Critical.get(newBrick.uid).setPaint(Color.red);
    // / .setLabel("critical");
    // markerMapMin1Critical.get(newBrick.uid).setLabelAnchor(RectangleAnchor.BOTTOM);
    markerMapMin1Critical.get(newBrick.uid)
            .setLabel(String.valueOf(constants.brickUnitMap.get(newBrick.deviceIdentifier)) + " critical min");
    markerMapMin1Critical.get(newBrick.uid).setLabelAnchor(RectangleAnchor.TOP_LEFT);
    markerMapMin1Critical.get(newBrick.uid).setLabelTextAnchor(TextAnchor.TOP_LEFT);
    plotMap.get(newBrick.uid).addRangeMarker(markerMapMin1Critical.get(newBrick.uid));

    // create min1 warning map value
    ValueMarker vm2 = new ValueMarker(newBrick.tresholdMin1 + newBrick.tresholdMin1 * warningPercentage / 100);
    markerMapMin1Warning.put(newBrick.uid, vm2);
    // set warning line
    markerMapMin1Warning.get(newBrick.uid).setPaint(Color.orange);
    // marker2Map.get(newBrick.uid).setPaint(Color.);
    // / marker2Map.get(newBrick.uid).setLabel("warning");
    markerMapMin1Warning.get(newBrick.uid)
            .setLabel(String.valueOf(constants.brickUnitMap.get(newBrick.deviceIdentifier)) + " warning min");
    markerMapMin1Warning.get(newBrick.uid).setLabelAnchor(RectangleAnchor.TOP_LEFT);
    markerMapMin1Warning.get(newBrick.uid).setLabelTextAnchor(TextAnchor.TOP_LEFT);
    plotMap.get(newBrick.uid).addRangeMarker(markerMapMin1Warning.get(newBrick.uid));

    // create max1 critical map value
    ValueMarker vm3 = new ValueMarker(newBrick.tresholdMax1);
    markerMapMax1Critical.put(newBrick.uid, vm3);
    // set critical line
    markerMapMax1Critical.get(newBrick.uid).setPaint(Color.red);
    // / .setLabel("critical");
    // markerMapMax1Critical.get(newBrick.uid).setLabelAnchor(RectangleAnchor.BOTTOM);
    markerMapMax1Critical.get(newBrick.uid)
            .setLabel(String.valueOf(constants.brickUnitMap.get(newBrick.deviceIdentifier)) + " critical max");
    markerMapMax1Critical.get(newBrick.uid).setLabelAnchor(RectangleAnchor.TOP_LEFT);
    markerMapMax1Critical.get(newBrick.uid).setLabelTextAnchor(TextAnchor.TOP_LEFT);
    plotMap.get(newBrick.uid).addRangeMarker(markerMapMax1Critical.get(newBrick.uid));

    // create max1 warning map value
    ValueMarker vm4 = new ValueMarker(newBrick.tresholdMax1 + newBrick.tresholdMax1 * warningPercentage / 100);
    markerMapMax1Warning.put(newBrick.uid, vm4);
    // set warning line
    markerMapMax1Warning.get(newBrick.uid).setPaint(Color.orange);
    markerMapMax1Warning.get(newBrick.uid)
            .setLabel(String.valueOf(constants.brickUnitMap.get(newBrick.deviceIdentifier)) + " warning max");
    markerMapMax1Warning.get(newBrick.uid).setLabelAnchor(RectangleAnchor.TOP_LEFT);
    markerMapMax1Warning.get(newBrick.uid).setLabelTextAnchor(TextAnchor.TOP_LEFT);
    plotMap.get(newBrick.uid).addRangeMarker(markerMapMax1Warning.get(newBrick.uid));

    // create and add min, max and average markers
    // create maxima marker
    ValueMarker vmMax = new ValueMarker(0);
    vmMax.setPaint(Color.cyan);
    vmMax.setLabel("max");
    vmMax.setLabelAnchor(RectangleAnchor.TOP_LEFT);
    vmMax.setLabelTextAnchor(TextAnchor.TOP_LEFT);
    // create minima marker
    ValueMarker vmMin = new ValueMarker(0);
    vmMin.setPaint(Color.cyan);
    vmMin.setLabel("min");
    vmMin.setLabelAnchor(RectangleAnchor.TOP_LEFT);
    vmMin.setLabelTextAnchor(TextAnchor.TOP_LEFT);
    // create average marker
    ValueMarker vmAvg = new ValueMarker(0);
    vmAvg.setPaint(Color.blue);
    vmAvg.setLabel("average");
    vmAvg.setLabelAnchor(RectangleAnchor.TOP_LEFT);
    vmAvg.setLabelTextAnchor(TextAnchor.TOP_LEFT);
    // add to maps
    markerMaxima.put(newBrick.uid, vmMax);
    markerMinima.put(newBrick.uid, vmMin);
    markerAverage.put(newBrick.uid, vmAvg);
    // add to plot
    plotMap.get(newBrick.uid).addRangeMarker(vmMax);
    plotMap.get(newBrick.uid).addRangeMarker(vmMin);
    plotMap.get(newBrick.uid).addRangeMarker(vmAvg);

    // create and add avrgCntrMarkers
    // create upper marker
    ValueMarker avrgCtrl1high = new ValueMarker(newBrick.getAvg1high());
    avrgCtrl1high.setPaint(Color.orange);
    avrgCtrl1high.setLabel("avrg high");
    avrgCtrl1high.setLabelAnchor(RectangleAnchor.TOP_LEFT);
    avrgCtrl1high.setLabelTextAnchor(TextAnchor.TOP_LEFT);
    // create lower marker
    ValueMarker avrgCtrl1low = new ValueMarker(newBrick.getAvg1low());
    avrgCtrl1low.setPaint(Color.orange);
    avrgCtrl1low.setLabel("avrg low");
    avrgCtrl1low.setLabelAnchor(RectangleAnchor.TOP_LEFT);
    avrgCtrl1low.setLabelTextAnchor(TextAnchor.TOP_LEFT);
    // add both markers
    avrg1High.put(newBrick.uid, avrgCtrl1high);
    avrg1Low.put(newBrick.uid, avrgCtrl1low);
    // add both to plot
    if (newBrick.controlAverage) {
        plotMap.get(newBrick.uid).addRangeMarker(avrgCtrl1high);
        plotMap.get(newBrick.uid).addRangeMarker(avrgCtrl1low);
    }
    // -----------------------------------------------------------------------------------------------------

    // set title
    NumberAxis axisForTitleOnly = new NumberAxis(
            data.constants.brickIdMap.get(newBrick.deviceIdentifier) + " (" + newBrick.uid + ")");
    axisForTitleOnly.setLabelFont(customFonts.get("titleFont"));
    axisForTitleOnly.setTickLabelsVisible(false);
    axisForTitleOnly.setTickMarksVisible(false);
    axisForTitleOnly.setMinorTickMarksVisible(false);
    axisForTitleOnly.setAxisLineVisible(false);
    plotMap.get(newBrick.uid).setDomainAxis(1, axisForTitleOnly);

    // add subplot to the main plot
    plot.add(plotMap.get(newBrick.uid));
}

From source file:org.gumtree.vis.awt.time.TimePlotChartEditor.java

@Override
public void updateChart(JFreeChart chart) {
    super.updateChart(chart);
    if (currentDataset != null && currentSeriesIndex >= 0) {
        XYItemRenderer renderer = chart.getXYPlot().getRendererForDataset(currentDataset);
        if (renderer instanceof XYLineAndShapeRenderer) {
            renderer.setSeriesPaint(currentSeriesIndex, curveColorPaint.getPaint());
            Stroke stroke = curveStrokeSample.getStroke();
            if (stroke == null) {
                ((XYLineAndShapeRenderer) renderer).setSeriesLinesVisible(currentSeriesIndex, false);
            } else {
                ((XYLineAndShapeRenderer) renderer).setSeriesLinesVisible(currentSeriesIndex, true);
                renderer.setSeriesStroke(currentSeriesIndex, stroke);
            }/*from w ww . j a v  a  2s  .  co m*/

            //             if (!isMarkerVisible) {
            //                for (int i = 0; i < chart.getXYPlot().getSeriesCount(); i++) {
            //                   ((XYLineAndShapeRenderer) renderer).setSeriesShapesVisible(i, 
            //                         isMarkerVisible);
            //                }
            //             }
            //             ((XYLineAndShapeRenderer) renderer).setBaseShapesVisible(
            //                   isMarkerVisible);

            ((XYLineAndShapeRenderer) renderer).setSeriesShapesVisible(currentSeriesIndex,
                    showMarker.isSelected());

            Shape shape = currentShape.getShape();
            if (shape == null) {
                ((XYLineAndShapeRenderer) renderer).setSeriesShapesVisible(currentSeriesIndex, false);
            } else {
                //                ((XYLineAndShapeRenderer) renderer).setSeriesShapesVisible(
                //                      currentSeriesIndex,  true);
                renderer.setSeriesShape(currentSeriesIndex, shape);
            }

            ((XYLineAndShapeRenderer) renderer).setSeriesShapesFilled(currentSeriesIndex,
                    markerFilled.isSelected());

            renderer.setSeriesVisible(currentSeriesIndex, curveVisable.isSelected());

            //Update logarithm X filed
            ValueAxis axis = chart.getXYPlot().getDomainAxis();
            if (showAllHistory.isSelected()) {
                axis.setFixedAutoRange(0d);
            }
            if (showPartHistory.isSelected()) {
                double fixedTimeSec = 0;
                try {
                    fixedTimeSec = Double.valueOf(timeField.getText());
                } catch (Exception e) {
                    // TODO: handle exception
                }
                if (fixedTimeSec <= 0) {
                    fixedTimeSec = 60;
                }
                axis.setFixedAutoRange(fixedTimeSec * 1000);
            }

            //Update logarithm Y filed
            axis = chart.getXYPlot().getRangeAxis();
            if (axis instanceof LogarithmizableAxis) {
                //                if (logarithmY.isSelected() != initialLogarithmY) {
                //                   ((LogarithmizableAxis) axis).setLogarithmic(
                //                         logarithmY.isSelected());
                //                   ((LogarithmizableAxis) axis).autoAdjustRange();
                //                }
            }

        }
    }
}