Example usage for org.jfree.chart ChartMouseListener ChartMouseListener

List of usage examples for org.jfree.chart ChartMouseListener ChartMouseListener

Introduction

In this page you can find the example usage for org.jfree.chart ChartMouseListener ChartMouseListener.

Prototype

ChartMouseListener

Source Link

Usage

From source file:ec.util.chart.swing.JTimeSeriesChart.java

private void enableObsTriggering() {
    chartPanel.addChartMouseListener(new ChartMouseListener() {
        @Override/*from www  .  j a v a2  s  .c  om*/
        public void chartMouseClicked(ChartMouseEvent event) {
            if (isInteractive()) {
                setSelectedObs(getObsIndex(event));
            }
        }

        @Override
        public void chartMouseMoved(ChartMouseEvent event) {
            if (isInteractive()) {
                setHoveredObs(getObsIndex(event));
            }
        }

        private ObsIndex getObsIndex(ChartMouseEvent event) {
            if (event.getEntity() instanceof XYItemEntity) {
                XYItemEntity xxx = (XYItemEntity) event.getEntity();
                int series = ((FilteredXYDataset) xxx.getDataset()).originalIndexOf(xxx.getSeriesIndex());
                int obs = xxx.getItem();
                return ObsIndex.valueOf(series, obs);
            } else {
                return ObsIndex.NULL;
            }
        }
    });
}

From source file:org.gumtree.vis.swt.PlotComposite.java

private void addListeners() {
    if (plot != null) {
        //         mouseWheelListener = new MouseWheelListener() {
        ////w  ww .j ava  2 s. c o  m
        //            @Override
        //            public void mouseScrolled(MouseEvent event) {
        //               JPanel panel = null;
        //               if (plot instanceof JPanel) {
        //                  panel = (JPanel) plot;
        //               }
        //               MouseWheelEvent awtEvent = org.gumtree.vis.listener.SWT_AWT.toMouseWheelEvent(
        //                     event, panel);
        //               plot.processMouseWheelEvent(awtEvent);
        //            }
        //         };
        //         addMouseWheelListener(mouseWheelListener);

        keyListener = new KeyListener() {

            boolean keyPressed = false;

            @Override
            public void keyReleased(KeyEvent event) {
                switch (event.keyCode) {
                case SWT.DEL:
                    plot.removeSelectedMask();
                    plot.removeSelectedText();
                    break;
                default:
                    break;
                }
                switch (event.character) {
                default:
                    break;
                }
                keyPressed = false;
            }

            @Override
            public void keyPressed(KeyEvent event) {
                switch (event.stateMask) {
                case SWT.CTRL:
                    if (event.keyCode == 'c' || event.keyCode == 'C') {
                        if (!keyPressed) {
                            plot.doCopy();
                        }
                    } else if (event.keyCode == 'z' || event.keyCode == 'Z' || event.keyCode == 'r'
                            || event.keyCode == 'R') {
                        if (!keyPressed) {
                            plot.restoreAutoBounds();
                        }
                    } else if (event.keyCode == 'p' || event.keyCode == 'P') {
                        if (!keyPressed) {
                            Thread newThread = new Thread(new Runnable() {

                                @Override
                                public void run() {
                                    plot.createChartPrintJob();
                                }
                            });
                            newThread.start();
                        }
                    } else if (event.keyCode == 'e' || event.keyCode == 'E') {
                        if (!keyPressed) {
                            Thread newThread = new Thread(new Runnable() {

                                @Override
                                public void run() {
                                    try {
                                        plot.doSaveAs();
                                    } catch (IOException e) {
                                        handleException(e);
                                    }
                                }
                            });
                            newThread.start();
                        }
                    }
                    keyPressed = true;
                    break;
                case SWT.ALT:
                    break;
                default:
                    switch (event.keyCode) {
                    case SWT.ARROW_UP:
                        plot.moveSelectedMask(event.keyCode);
                        if (plot.isCurrentlyInputtingText()) {
                            if (plot.getTextInputContent() != null) {
                                if (plot.getTextInputCursorIndex() > 0) {
                                    String text = plot.getTextInputContent();
                                    int cursorIndex = plot.getTextInputCursorIndex();
                                    String[] lines = text.split("\n", 100);
                                    int cursorX = 0;
                                    int charCount = 0;
                                    int newCursorIndex = cursorIndex;
                                    for (int i = 0; i < lines.length; i++) {
                                        if (cursorIndex > charCount
                                                && cursorIndex < charCount + lines[i].length() + 1) {
                                            cursorX = cursorIndex - charCount;
                                            if (i > 0) {
                                                if (cursorX <= lines[i - 1].length()) {
                                                    newCursorIndex = charCount - lines[i - 1].length() - 1
                                                            + cursorX;
                                                } else {
                                                    newCursorIndex = charCount - 1;
                                                }
                                                plot.setTextInputCursorIndex(newCursorIndex);
                                            }
                                            break;
                                        } else if (cursorIndex == charCount + lines[i].length() + 1) {
                                            newCursorIndex = charCount;
                                            plot.setTextInputCursorIndex(newCursorIndex);
                                            break;
                                        }
                                        charCount += lines[i].length() + 1;
                                    }
                                }
                            }
                        }
                        break;
                    case SWT.ARROW_LEFT:
                        plot.moveSelectedMask(event.keyCode);
                        if (plot.isCurrentlyInputtingText()) {
                            if (plot.getTextInputContent() != null) {
                                if (plot.getTextInputCursorIndex() > 0) {
                                    plot.setTextInputCursorIndex(plot.getTextInputCursorIndex() - 1);
                                }
                            }
                        }
                        break;
                    case SWT.ARROW_RIGHT:
                        plot.moveSelectedMask(event.keyCode);
                        if (plot.isCurrentlyInputtingText()) {
                            if (plot.getTextInputContent() != null) {
                                if (plot.getTextInputCursorIndex() < plot.getTextInputContent().length()) {
                                    plot.setTextInputCursorIndex(plot.getTextInputCursorIndex() + 1);
                                }
                            }
                        }
                        break;
                    case SWT.ARROW_DOWN:
                        plot.moveSelectedMask(event.keyCode);
                        if (plot.isCurrentlyInputtingText()) {
                            if (plot.getTextInputContent() != null) {
                                if (plot.getTextInputCursorIndex() >= 0) {
                                    String text = plot.getTextInputContent();
                                    int cursorIndex = plot.getTextInputCursorIndex();
                                    String[] lines = text.split("\n", 100);
                                    int cursorX = 0;
                                    int charCount = 0;
                                    int newCursorIndex = cursorIndex;
                                    for (int i = 0; i < lines.length; i++) {
                                        if (cursorIndex >= charCount
                                                && cursorIndex < charCount + lines[i].length() + 1) {
                                            cursorX = cursorIndex - charCount;
                                            if (i < lines.length - 1) {
                                                if (cursorX <= lines[i + 1].length()) {
                                                    newCursorIndex = charCount + lines[i].length() + 1
                                                            + cursorX;
                                                } else {
                                                    newCursorIndex = charCount + lines[i].length() + 1
                                                            + lines[i + 1].length();
                                                }
                                                plot.setTextInputCursorIndex(newCursorIndex);
                                            }
                                            break;
                                        }
                                        charCount += lines[i].length() + 1;
                                    }
                                }
                            }
                        }
                        break;
                    case SWT.ESC:
                        plot.cancelTextInput();
                    case SWT.SHIFT:
                        break;
                    case SWT.CTRL:
                        break;
                    case SWT.ALT:
                        break;
                    case SWT.F1:
                        break;
                    case SWT.F2:
                        break;
                    case SWT.F3:
                        break;
                    case SWT.F4:
                        break;
                    case SWT.F5:
                        break;
                    case SWT.F6:
                        break;
                    case SWT.F7:
                        break;
                    case SWT.F8:
                        break;
                    case SWT.F9:
                        break;
                    case SWT.F10:
                        break;
                    case SWT.F11:
                        break;
                    case SWT.F12:
                        break;
                    case SWT.PAGE_UP:
                        if (plot.isCurrentlyInputtingText()) {
                            if (plot.getTextInputContent() != null) {
                                if (plot.getTextInputCursorIndex() >= 0) {
                                    String text = plot.getTextInputContent();
                                    int cursorIndex = plot.getTextInputCursorIndex();
                                    String[] lines = text.split("\n", 100);
                                    int cursorX = 0;
                                    int charCount = 0;
                                    int newLine = 0;
                                    for (int i = 0; i < lines.length; i++) {
                                        if (cursorIndex >= charCount
                                                && cursorIndex < charCount + lines[i].length() + 1) {
                                            cursorX = cursorIndex - charCount;
                                            if (i > 0) {
                                                newLine = i - 5;
                                                if (newLine < 0) {
                                                    newLine = 0;
                                                }
                                                jumpToPosition(newLine, cursorX);
                                            }
                                            break;
                                        }
                                        charCount += lines[i].length() + 1;
                                    }
                                }
                            }
                        }
                        break;
                    case SWT.PAGE_DOWN:
                        if (plot.isCurrentlyInputtingText()) {
                            if (plot.getTextInputContent() != null) {
                                if (plot.getTextInputCursorIndex() >= 0) {
                                    String text = plot.getTextInputContent();
                                    int cursorIndex = plot.getTextInputCursorIndex();
                                    String[] lines = text.split("\n", 100);
                                    int cursorX = 0;
                                    int charCount = 0;
                                    int newLine = 0;
                                    for (int i = 0; i < lines.length; i++) {
                                        if (cursorIndex >= charCount
                                                && cursorIndex < charCount + lines[i].length() + 1) {
                                            cursorX = cursorIndex - charCount;
                                            if (i < lines.length - 1) {
                                                newLine = i + 5;
                                                if (newLine >= lines.length) {
                                                    newLine = lines.length - 1;
                                                }
                                                jumpToPosition(newLine, cursorX);
                                            }
                                            break;
                                        }
                                        charCount += lines[i].length() + 1;
                                    }
                                }
                            }
                        }
                        break;
                    case SWT.HOME:
                        if (plot.isCurrentlyInputtingText()) {
                            if (plot.getTextInputContent() != null) {
                                if (plot.getTextInputCursorIndex() >= 0) {
                                    String text = plot.getTextInputContent();
                                    int cursorIndex = plot.getTextInputCursorIndex();
                                    String[] lines = text.split("\n", 100);
                                    int charCount = 0;
                                    for (int i = 0; i < lines.length; i++) {
                                        if (cursorIndex >= charCount
                                                && cursorIndex <= charCount + lines[i].length()) {
                                            plot.setTextInputCursorIndex(charCount);
                                            break;
                                        }
                                        charCount += lines[i].length() + 1;
                                    }
                                }
                            }
                        }
                        break;
                    case SWT.END:
                        if (plot.isCurrentlyInputtingText()) {
                            if (plot.getTextInputContent() != null) {
                                if (plot.getTextInputCursorIndex() >= 0) {
                                    String text = plot.getTextInputContent();
                                    int cursorIndex = plot.getTextInputCursorIndex();
                                    String[] lines = text.split("\n", 100);
                                    int charCount = 0;
                                    for (int i = 0; i < lines.length; i++) {
                                        if (cursorIndex >= charCount
                                                && cursorIndex <= charCount + lines[i].length()) {
                                            plot.setTextInputCursorIndex(charCount + lines[i].length());
                                            break;
                                        }
                                        charCount += lines[i].length() + 1;
                                    }
                                }
                            }
                        }
                        break;
                    case SWT.BS:
                        if (plot.isCurrentlyInputtingText()) {
                            String inputText;
                            String textInputContent = plot.getTextInputContent();
                            int cursorIndex = plot.getTextInputCursorIndex();
                            int newIndex;
                            if (textInputContent == null || cursorIndex <= 0
                                    || textInputContent.length() == 0) {
                                return;
                            } else if (cursorIndex == 1) {
                                inputText = textInputContent.substring(1);
                                newIndex = 0;
                            } else if (cursorIndex < textInputContent.length()) {
                                newIndex = cursorIndex - 1;
                                inputText = textInputContent.substring(0, newIndex)
                                        + textInputContent.substring(cursorIndex);
                            } else {
                                inputText = textInputContent.substring(0, textInputContent.length() - 1);
                                newIndex = inputText.length();
                            }
                            plot.setTextInputContent(inputText);
                            plot.setTextInputCursorIndex(newIndex);
                        }
                        break;
                    case SWT.DEL:
                        if (plot.isCurrentlyInputtingText()) {
                            String inputText;
                            String textInputContent = plot.getTextInputContent();
                            int cursorIndex = plot.getTextInputCursorIndex();
                            int newIndex = cursorIndex;
                            if (textInputContent == null || textInputContent.length() == 0
                                    || cursorIndex >= textInputContent.length()) {
                                return;
                            } else if (cursorIndex == 0) {
                                inputText = textInputContent.substring(1);
                            } else {
                                inputText = textInputContent.substring(0, cursorIndex)
                                        + textInputContent.substring(cursorIndex + 1);
                            }
                            plot.setTextInputContent(inputText);
                            plot.setTextInputCursorIndex(newIndex);
                        }
                        break;
                    case SWT.CAPS_LOCK:
                        break;
                    case SWT.INSERT:
                        break;
                    case SWT.NUM_LOCK:
                        break;
                    case SWT.PRINT_SCREEN:
                        break;
                    case SWT.SCROLL_LOCK:
                        break;
                    case SWT.PAUSE:
                        break;
                    default:
                        if (plot.isCurrentlyInputtingText()) {
                            if (Character.isWhitespace(event.character) && event.keyCode != SWT.SPACE) {
                                if (event.keyCode == SWT.CR || event.keyCode == SWT.LF
                                        || event.keyCode == 16777296) {
                                    addStringToTextInput("\n", plot.getTextInputCursorIndex());
                                }
                            } else {
                                addStringToTextInput(String.valueOf(event.character),
                                        plot.getTextInputCursorIndex());
                            }
                        }
                        break;
                    }
                    plot.repaint();
                }
            }

        };
        addKeyListener(keyListener);

        final Composite composite = this;

        chartMouseListener = new ChartMouseListener() {

            @Override
            public void chartMouseMoved(ChartMouseEvent event) {

            }

            @Override
            public void chartMouseClicked(ChartMouseEvent event) {
                Display.getDefault().asyncExec(new Runnable() {

                    @Override
                    public void run() {
                        if (!composite.isDisposed() && !composite.isFocusControl()) {
                            composite.setFocus();
                        }
                    }
                });
            }
        };
        plot.addChartMouseListener(chartMouseListener);
    }
}

From source file:com.rapidminer.gui.plotter.charts.Abstract2DChartPlotter.java

@Override
public void updatePlotter() {
    prepareData();//from   ww w  .  j  a v a2 s .c o m
    JFreeChart chart;
    if (axis[X_AXIS] >= 0 && axis[Y_AXIS] >= 0) {
        if (nominal) {
            int size = dataSet.getSeriesCount();
            chart = ChartFactory.createScatterPlot(null, // chart title
                    null, // domain axis label
                    null, // range axis label
                    dataSet, // data
                    PlotOrientation.VERTICAL, // orientation
                    colorColumn >= 0 && size < 100 ? true : false, // include legend
                    true, // tooltips
                    false // URLs
            );

            // renderer settings
            try {
                chart.getXYPlot().setRenderer(getItemRenderer(nominal, size, this.minColor, this.maxColor));
            } catch (Exception e) {
                // do nothing
            }

            // legend settings
            LegendTitle legend = chart.getLegend();
            if (legend != null) {
                legend.setPosition(RectangleEdge.TOP);
                legend.setFrame(BlockBorder.NONE);
                legend.setHorizontalAlignment(HorizontalAlignment.LEFT);
                legend.setItemFont(LABEL_FONT);

                BlockContainer wrapper = new BlockContainer(new BorderArrangement());

                LabelBlock title = new LabelBlock(getDataTable().getColumnName(colorColumn),
                        new Font("SansSerif", Font.BOLD, 12));
                title.setPadding(0, 5, 5, 5);
                wrapper.add(title, RectangleEdge.LEFT);

                BlockContainer items = legend.getItemContainer();
                wrapper.add(items, RectangleEdge.RIGHT);

                legend.setWrapper(wrapper);
            }
        } else {

            chart = ChartFactory.createScatterPlot(null, // chart title
                    null, // domain axis label
                    null, // range axis label
                    dataSet, // data
                    PlotOrientation.VERTICAL, // orientation
                    false, // include legend
                    true, // tooltips
                    false // URLs
            );

            // renderer settings
            try {
                chart.getXYPlot().setRenderer(getItemRenderer(nominal, -1, minColor, maxColor));
            } catch (Exception e) {
                // do nothing
            }

            LegendTitle legendTitle = new LegendTitle(chart.getXYPlot().getRenderer()) {

                private static final long serialVersionUID = 1288380309936848376L;

                @Override
                public Object draw(java.awt.Graphics2D g2, java.awt.geom.Rectangle2D area,
                        java.lang.Object params) {
                    if (dataTable.isDate(colorColumn) || dataTable.isTime(colorColumn)
                            || dataTable.isDateTime(colorColumn)) {
                        drawSimpleDateLegend(g2, (int) (area.getCenterX() - 170), (int) (area.getCenterY() + 7),
                                dataTable, colorColumn, minColor, maxColor);
                        return new BlockResult();
                    } else {
                        final String minColorString = Tools.formatNumber(minColor);
                        final String maxColorString = Tools.formatNumber(maxColor);
                        drawSimpleNumericalLegend(g2, (int) (area.getCenterX() - 75),
                                (int) (area.getCenterY() + 7), getDataTable().getColumnName(colorColumn),
                                minColorString, maxColorString);
                        return new BlockResult();
                    }
                }

                @Override
                public void draw(java.awt.Graphics2D g2, java.awt.geom.Rectangle2D area) {
                    draw(g2, area, null);
                }

            };

            BlockContainer wrapper = new BlockContainer(new BorderArrangement());

            LabelBlock title = new LabelBlock(getDataTable().getColumnName(colorColumn),
                    new Font("SansSerif", Font.BOLD, 12));
            title.setPadding(0, 5, 5, 5);
            wrapper.add(title, RectangleEdge.LEFT);

            BlockContainer items = legendTitle.getItemContainer();
            wrapper.add(items, RectangleEdge.RIGHT);

            legendTitle.setWrapper(wrapper);

            chart.addLegend(legendTitle);
        }
    } else {
        chart = ChartFactory.createScatterPlot(null, // chart title
                null, // domain axis label
                null, // range axis label
                dataSet, // data
                PlotOrientation.VERTICAL, // orientation
                false, // include legend
                true, // tooltips
                false // URLs
        );
    }

    // GENERAL CHART SETTINGS

    // set the background colors for the chart...
    chart.setBackgroundPaint(Color.WHITE);
    chart.getPlot().setBackgroundPaint(Color.WHITE);
    chart.setAntiAlias(false);

    // general plot settings
    XYPlot plot = chart.getXYPlot();
    plot.setDomainGridlinePaint(Color.LIGHT_GRAY);
    plot.setRangeGridlinePaint(Color.LIGHT_GRAY);

    // domain axis
    if (axis[X_AXIS] >= 0) {
        if (dataTable.isNominal(axis[X_AXIS])) {
            String[] values = new String[dataTable.getNumberOfValues(axis[X_AXIS])];
            for (int i = 0; i < values.length; i++) {
                values[i] = dataTable.mapIndex(axis[X_AXIS], i);
            }
            plot.setDomainAxis(new SymbolAxis(dataTable.getColumnName(axis[X_AXIS]), values));
        } else if (dataTable.isDate(axis[X_AXIS]) || dataTable.isDateTime(axis[X_AXIS])) {
            DateAxis domainAxis = new DateAxis(dataTable.getColumnName(axis[X_AXIS]));
            domainAxis.setTimeZone(Tools.getPreferredTimeZone());
            plot.setDomainAxis(domainAxis);
        } else {
            if (logScales[X_AXIS]) {
                LogAxis domainAxis = new LogAxis(dataTable.getColumnName(axis[X_AXIS]));
                domainAxis.setStandardTickUnits(NumberAxis.createStandardTickUnits(Locale.US));
                plot.setDomainAxis(domainAxis);
            } else {
                NumberAxis domainAxis = new NumberAxis(dataTable.getColumnName(axis[X_AXIS]));
                domainAxis.setAutoRangeStickyZero(false);
                domainAxis.setAutoRangeIncludesZero(false);
                plot.setDomainAxis(domainAxis);
            }
        }
    }

    if (axis[X_AXIS] >= 0) {
        Range range = getRangeForDimension(axis[X_AXIS]);
        if (range != null) {
            plot.getDomainAxis().setRange(range, true, false);
        } else {
            plot.getDomainAxis().setAutoRange(true);
        }
    }

    plot.getDomainAxis().setLabelFont(LABEL_FONT_BOLD);
    plot.getDomainAxis().setTickLabelFont(LABEL_FONT);

    // rotate labels
    if (isLabelRotating()) {
        plot.getDomainAxis().setTickLabelsVisible(true);
        plot.getDomainAxis().setVerticalTickLabels(true);
    }

    // range axis
    if (axis[Y_AXIS] >= 0) {
        if (dataTable.isNominal(axis[Y_AXIS])) {
            String[] values = new String[dataTable.getNumberOfValues(axis[Y_AXIS])];
            for (int i = 0; i < values.length; i++) {
                values[i] = dataTable.mapIndex(axis[Y_AXIS], i);
            }
            plot.setRangeAxis(new SymbolAxis(dataTable.getColumnName(axis[Y_AXIS]), values));
        } else if (dataTable.isDate(axis[Y_AXIS]) || dataTable.isDateTime(axis[Y_AXIS])) {
            DateAxis rangeAxis = new DateAxis(dataTable.getColumnName(axis[Y_AXIS]));
            rangeAxis.setTimeZone(Tools.getPreferredTimeZone());
            plot.setRangeAxis(rangeAxis);
        } else {
            if (logScales[Y_AXIS]) {
                LogAxis rangeAxis = new LogAxis(dataTable.getColumnName(axis[Y_AXIS]));
                rangeAxis.setStandardTickUnits(NumberAxis.createStandardTickUnits(Locale.US));
                plot.setRangeAxis(rangeAxis);
            } else {
                NumberAxis rangeAxis = new NumberAxis(dataTable.getColumnName(axis[Y_AXIS]));
                rangeAxis.setAutoRangeStickyZero(false);
                rangeAxis.setAutoRangeIncludesZero(false);
                plot.setRangeAxis(rangeAxis);
            }
        }
    }
    plot.getRangeAxis().setLabelFont(LABEL_FONT_BOLD);
    plot.getRangeAxis().setTickLabelFont(LABEL_FONT);

    if (axis[Y_AXIS] >= 0) {
        Range range = getRangeForDimension(axis[Y_AXIS]);
        if (range != null) {
            plot.getRangeAxis().setRange(range, true, false);
        } else {
            plot.getRangeAxis().setAutoRange(true);
        }
    }

    // Chart Panel Settings
    AbstractChartPanel panel = getPlotterPanel();
    if (panel == null) {
        panel = createPanel(chart);

        // react to mouse clicks
        panel.addChartMouseListener(new ChartMouseListener() {

            @Override
            public void chartMouseClicked(ChartMouseEvent e) {
                if (e.getTrigger().getClickCount() > 1) {
                    if (e.getEntity() instanceof XYItemEntity) {
                        XYItemEntity entity = (XYItemEntity) e.getEntity();
                        if (entity != null) {
                            String id = idMap.get(new SeriesAndItem(entity.getSeriesIndex(), entity.getItem()));
                            if (id != null) {
                                ObjectVisualizer visualizer = ObjectVisualizerService
                                        .getVisualizerForObject(dataTable);
                                visualizer.startVisualization(id);
                            }
                        }
                    }
                }
            }

            @Override
            public void chartMouseMoved(ChartMouseEvent e) {
            }
        });

    } else {
        panel.setChart(chart);
    }

    // tooltips
    class CustomXYToolTipGenerator implements XYToolTipGenerator {

        public CustomXYToolTipGenerator() {
        }

        private String formatValue(int axis, double value) {
            if (dataTable.isNominal(axis)) {
                // TODO add mapping of value to nominal value
                return Tools.formatIntegerIfPossible(value);
            } else if (dataTable.isNumerical(axis)) {
                return Tools.formatIntegerIfPossible(value);
            } else if (dataTable.isDate(axis)) {
                return Tools.createDateAndFormat(value);
            } else if (dataTable.isTime(axis)) {
                return Tools.createTimeAndFormat(value);
            } else if (dataTable.isDateTime(axis)) {
                return Tools.createDateTimeAndFormat(value);
            }
            return "?";
        }

        @Override
        public String generateToolTip(XYDataset dataset, int row, int column) {
            String id = idMap.get(new SeriesAndItem(row, column));
            if (id != null) {
                return "<html><b>Id: " + id + "</b> (" + dataset.getSeriesKey(row) + ", "
                        + formatValue(axis[X_AXIS], dataset.getXValue(row, column)) + ", "
                        + formatValue(axis[Y_AXIS], dataset.getYValue(row, column)) + ")</html>";

            } else {
                return "<html>(" + dataset.getSeriesKey(row) + ", "
                        + formatValue(axis[X_AXIS], dataset.getXValue(row, column)) + ", "
                        + formatValue(axis[Y_AXIS], dataset.getYValue(row, column)) + ")</html>";
            }
        }
    }

    for (int i = 0; i < dataSet.getSeriesCount(); i++) {
        plot.getRenderer().setSeriesToolTipGenerator(i, new CustomXYToolTipGenerator());
    }
}

From source file:com.vgi.mafscaling.LogView.java

private void createGraghPanel() {
    JFreeChart chart = ChartFactory.createXYLineChart(null, null, null, null, PlotOrientation.VERTICAL, false,
            true, false);//ww w  .ja  v  a2s .  co  m
    chartPanel = new ChartPanel(chart, true, true, true, true, true);
    chartPanel.setAutoscrolls(true);
    chartPanel.setPopupMenu(null);
    chart.setBackgroundPaint(new Color(60, 60, 65));

    rpmDataset = new XYSeriesCollection();
    rpmPlotRenderer = new XYLineAndShapeRenderer();
    dataset = new XYSeriesCollection();
    plotRenderer = new XYLineAndShapeRenderer();

    NumberAxis xAxis = new NumberAxis();
    xAxis.setTickLabelsVisible(false);
    xAxis.setTickLabelPaint(Color.WHITE);
    xAxis.setAutoRangeIncludesZero(false);
    NumberAxis yAxis = new NumberAxis();
    yAxis.setTickLabelsVisible(false);
    yAxis.setTickLabelPaint(Color.WHITE);
    yAxis.setAutoRangeIncludesZero(false);
    NumberAxis y2Axis = new NumberAxis();
    y2Axis.setTickLabelsVisible(false);
    y2Axis.setTickLabelPaint(Color.WHITE);
    y2Axis.setAutoRangeIncludesZero(false);

    plot = chartPanel.getChart().getXYPlot();
    plot.setRangePannable(true);
    plot.setDomainPannable(true);
    plot.setDomainGridlinePaint(Color.LIGHT_GRAY);
    plot.setRangeGridlinePaint(Color.LIGHT_GRAY);
    plot.setBackgroundPaint(new Color(80, 80, 85));

    plot.setDataset(0, rpmDataset);
    plot.setRenderer(0, rpmPlotRenderer);
    plot.setDomainAxis(0, xAxis);
    plot.setRangeAxis(0, yAxis);
    plot.mapDatasetToDomainAxis(0, 0);
    plot.mapDatasetToRangeAxis(0, 0);

    plot.setDataset(1, dataset);
    plot.setRenderer(1, plotRenderer);
    plot.setRangeAxis(1, y2Axis);
    plot.mapDatasetToDomainAxis(1, 0);
    plot.mapDatasetToRangeAxis(1, 1);

    LegendTitle legend = new LegendTitle(plot);
    legend.setItemFont(new Font("Arial", 0, 10));
    legend.setPosition(RectangleEdge.TOP);
    legend.setItemPaint(Color.WHITE);
    chart.addLegend(legend);

    xyMarker = new XYDomainMutilineAnnotation();
    plot.addAnnotation(xyMarker);

    chartMouseListener = new ChartMouseListener() {
        @Override
        public void chartMouseMoved(ChartMouseEvent event) {
            try {
                Rectangle2D dataArea = chartPanel.getChartRenderingInfo().getPlotInfo().getDataArea();
                Point2D p = chartPanel.translateScreenToJava2D(event.getTrigger().getPoint());
                double x = plot.getDomainAxis().java2DToValue(p.getX(), dataArea, plot.getDomainAxisEdge());
                boolean isLeft = (p.getX() < (dataArea.getMaxX() - dataArea.getMinX()) / 2) ? true : false;
                if (setMarkers(x, isLeft)) {
                    try {
                        int selectedCol = logDataTable.getTable().getSelectedColumn();
                        if (selectedCol < 0)
                            selectedCol = 0;
                        if (logPlayWindow == null || startMarker != null || endMarker != null) {
                            logDataTable.getTable().setRowSelectionInterval((int) x, (int) x);
                            logDataTable.getTable().changeSelection((int) x, selectedCol, false, false);
                        } else {
                            logPlayWindow.setProgressBar((int) x);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        @Override
        public void chartMouseClicked(ChartMouseEvent event) {
            if (logPlayWindow == null)
                return;
            if (xyMarker.count() == 0)
                return;
            Rectangle2D dataArea = chartPanel.getChartRenderingInfo().getPlotInfo().getDataArea();
            Point2D p = chartPanel.translateScreenToJava2D(event.getTrigger().getPoint());
            double x = plot.getDomainAxis().java2DToValue(p.getX(), dataArea, plot.getDomainAxisEdge());
            if (x < 0 || (int) x >= logDataTable.getRowCount())
                return;
            if (SwingUtilities.isLeftMouseButton(event.getTrigger())) {
                if (startMarker == null) {
                    startMarker = new ValueMarker(x);
                    startMarker.setPaint(Color.GREEN);
                    startMarker.setStroke(new BasicStroke(1.5f));
                    plot.addDomainMarker(startMarker);
                } else {
                    plot.removeDomainMarker(startMarker);
                    startMarker = null;
                }
            } else if (SwingUtilities.isRightMouseButton(event.getTrigger())) {
                if (endMarker == null) {
                    endMarker = new ValueMarker(x);
                    endMarker.setPaint(Color.GREEN);
                    endMarker.setStroke(new BasicStroke(1.5f));
                    plot.addDomainMarker(endMarker);
                } else {
                    plot.removeDomainMarker(endMarker);
                    endMarker = null;
                }
            }
            chartPanel.repaint();
            logPlayWindow.setStartEndArea(startMarker, endMarker);
        }
    };

    chartPanel.addChartMouseListener(chartMouseListener);
}

From source file:uk.ac.lkl.cram.ui.ModuleFrame.java

private JXTaskPane createLearnerFeedbackChartPane() {
    JXTaskPane feedbackChartPane = new JXTaskPane();
    feedbackChartPane.setScrollOnExpand(true);
    feedbackChartPane.setTitle("Learner Feedback");
    FeedbackChartMaker maker = new FeedbackChartMaker(module);
    final ChartPanel chartPanel = maker.getChartPanel();
    //Add a mouselistener, listening for a double click on a bar of the stacked bar
    chartPanel.addChartMouseListener(new ChartMouseListener() {
        @Override/*from  w w w . ja va 2 s  .c om*/
        public void chartMouseClicked(ChartMouseEvent cme) {
            //Get the mouse event
            MouseEvent trigger = cme.getTrigger();
            //Test if the mouse event is a left-button
            if (trigger.getButton() == MouseEvent.BUTTON1 && trigger.getClickCount() == 2) {

                //Create a pop up dialog containing that the tlalineitems
                FeedbackPopupDialog popup = new FeedbackPopupDialog(
                        (Frame) SwingUtilities.getWindowAncestor(chartPanel), true, module.getTLALineItems());
                //Set the title of the popup 
                popup.setTitle("All Activities");
                //Centre the popup at the location of the mouse click
                Point location = trigger.getLocationOnScreen();
                int w = popup.getWidth();
                int h = popup.getHeight();
                popup.setLocation(location.x - w / 2, location.y - h / 2);
                popup.setVisible(true);
                int returnStatus = popup.getReturnStatus();
                if (returnStatus == LearningTypePopupDialog.RET_OK) {
                    modifyTLALineItem(popup.getSelectedTLALineItem(), 1);
                }
            }
        }

        @Override
        public void chartMouseMoved(ChartMouseEvent cme) {
            //Set the cursor shape according to the location of the cursor
            if (cme.getEntity() instanceof CategoryItemEntity) {
                chartPanel.setCursor(HAND);
            } else {
                chartPanel.setCursor(Cursor.getDefaultCursor());
            }
        }
    });
    chartPanel.setPreferredSize(new Dimension(150, 200));
    feedbackChartPane.add(chartPanel);
    return feedbackChartPane;
}

From source file:velocitekProStartAnalyzer.MainWindow.java

private void createChartPanel() {
    XYSeriesCollection dataset = JDBCPointDao.dataSet;
    JFreeChart chart = createChart(dataset);
    ChartPanel chartPanel = new ChartPanel(chart, true, false, false, true, false);
    chartPanel.setMinimumDrawWidth(0);//from  w w w  .  ja  v  a 2 s.  c o m
    chartPanel.setMinimumDrawHeight(0);
    chartPanel.setMaximumDrawWidth(1920);
    chartPanel.setMaximumDrawHeight(1200);
    chartPanel.getPopupMenu().addSeparator();
    chartPanel.getPopupMenu().add(btnAvgSpeedChart);
    chartPanel.getPopupMenu().add(btnMedianSpeedChart);
    chartPanel.getPopupMenu().add(btnResetSpeedChart);
    chartPanel.getPopupMenu().addSeparator();
    btnMenuSaveSubmenuForChart = new JMenu("Save");
    chartPanel.getPopupMenu().add(btnMenuSaveSubmenuForChart);

    if (JDBCPointDao.points.isEmpty()) {
        btnSaveAsVCC.setEnabled(false);
    }
    saveChartAsPng(chartPanel);

    btnMenuSaveSubmenuForChart.add(btnSaveChartAsPngForChart);
    btnMenuSaveSubmenuForChart.add(btnSaveTableAsPngForChart);
    btnMenuSaveSubmenuForChart.add(btnSaveMapAsPngForChart);
    btnMenuSaveSubmenuForChart.addSeparator();
    btnMenuSaveSubmenuForChart.add(btnSaveAsVCC);
    chartPanel.addChartMouseListener(new ChartMouseListener() {

        @Override
        public void chartMouseClicked(ChartMouseEvent event) {
            Rectangle2D dataArea = chartPanel.getScreenDataArea();
            JFreeChart chart = event.getChart();
            XYPlot plot = (XYPlot) chart.getPlot();
            ValueAxis xAxis = plot.getDomainAxis();
            double x = xAxis.java2DToValue(event.getTrigger().getX(), dataArea, RectangleEdge.BOTTOM);
            // make the crosshairs disappear if the mouse is out of range
            if (!xAxis.getRange().contains(x)) {
                x = Double.NaN;
            }

            x = Math.round(x);

            if (SwingUtilities.isLeftMouseButton(event.getTrigger()) && event.getTrigger().isShiftDown()) {
                for (PointDto cord : JDBCPointDao.points) {
                    {
                        if (cord.getPointID() == x) {
                            if (pointTable.getSelectionModel() == null) {
                                for (int i = 0; i < pointTable.getModel().getRowCount(); i++) {
                                    if (pointTable.getModel().getValueAt(i, 0).equals(cord.getPointID())) {
                                        pointTable.setRowSelectionInterval(i, i);
                                    }
                                }
                            } else {
                                for (int i = 0; i < pointTable.getModel().getRowCount(); i++) {
                                    if (pointTable.getModel().getValueAt(i, 0).equals(cord.getPointID())) {
                                        pointTable.addRowSelectionInterval(pointTable.getSelectedRow(), i);
                                    }
                                }
                            }
                            pointTable.scrollRectToVisible(
                                    pointTable.getCellRect(pointTable.getSelectedRow(), 0, true));
                        }
                    }
                }
            } else {
                for (PointDto cord : JDBCPointDao.points) {
                    {
                        if (cord.getPointID() == x) {
                            if (pointTable.getSelectionModel() != null) {
                                pointTable.getSelectionModel().clearSelection();
                            }
                            for (int i = 0; i < pointTable.getModel().getRowCount(); i++) {
                                if (pointTable.getModel().getValueAt(i, 0).equals(cord.getPointID())) {
                                    pointTable.setRowSelectionInterval(i, i);
                                }
                            }
                            pointTable.scrollRectToVisible(
                                    pointTable.getCellRect(pointTable.getSelectedRow(), 0, true));
                            //MainWindow.pointTable.revalidate();                      
                        }
                    }

                }
            }
        }

        @Override
        public void chartMouseMoved(ChartMouseEvent event) {

            Rectangle2D dataArea = chartPanel.getScreenDataArea();
            JFreeChart chart = event.getChart();
            XYPlot plot = (XYPlot) chart.getPlot();
            ValueAxis xAxis = plot.getDomainAxis();
            double x = xAxis.java2DToValue(event.getTrigger().getX(), dataArea, RectangleEdge.BOTTOM);
            // make the crosshairs disappear if the mouse is out of range
            if (!xAxis.getRange().contains(x)) {
                x = Double.NaN;
            }
            double y = DatasetUtilities.findYValue(plot.getDataset(), 0, x);
            xCrosshair.setValue(x);
            yCrosshair.setValue(y);
            x = Math.round(x);
            for (PointDto cord : JDBCPointDao.points) {

                if (cord.getPointID() == x) {
                    mapPanel.map().removeMapMarker(mapPanel.getMapPoint());
                    mapPanel.setMapPoint(
                            new MapMarkerDot(null, null, cord.getPointLatidude(), cord.getPointLongtidude()));
                    mapPanel.setMapPoint(mapPanel.getMapPoint());
                    mapPanel.getMapPoint().setColor(colorMapMarkerCircle);
                    mapPanel.getMapPoint().setBackColor(colorMapMarkerHover);
                    mapPanel.map().addMapMarker(mapPanel.getMapPoint());
                }

            }
        }

    });
    XYPlot xyPlot = (XYPlot) chart.getPlot();
    ValueAxis rangeAxis = xyPlot.getRangeAxis();
    NavigableMap<Double, PointDto> pointDtoSortedSpeedMap = new TreeMap<Double, PointDto>();

    if (!JDBCPointDao.points.isEmpty()) {
        for (PointDto pointDto : JDBCPointDao.points) {
            pointDtoSortedSpeedMap.put(pointDto.getPointSpeed(), pointDto);
        }
        rangeAxis.setRange(pointDtoSortedSpeedMap.firstEntry().getKey() - 0.1,
                pointDtoSortedSpeedMap.lastEntry().getKey() + 0.1);
    }

    CrosshairOverlay crosshairOverlay = new CrosshairOverlay();
    xCrosshair = new Crosshair(Double.NaN, Color.GRAY, new BasicStroke(0f));
    xCrosshair.setLabelVisible(true);
    yCrosshair = new Crosshair(Double.NaN, Color.GRAY, new BasicStroke(0f));
    yCrosshair.setLabelVisible(true);
    crosshairOverlay.addDomainCrosshair(xCrosshair);
    crosshairOverlay.addRangeCrosshair(yCrosshair);
    chartPanel.addOverlay(crosshairOverlay);
    graphPanel.removeAll();
    graphPanel.add(chartPanel, BorderLayout.CENTER);
    graphPanel.revalidate();
    graphPanel.repaint();
    graphMapSplitPanel.revalidate();
}

From source file:logdruid.ui.chart.GraphPanel.java

public void load(JPanel panel_2) {
    startDateJSpinner = (JSpinner) panel_2.getComponent(2);
    endDateJSPinner = (JSpinner) panel_2.getComponent(3);
    // scrollPane.setV
    panel.removeAll();//w  w w.  j ava  2s. co  m
    Dimension panelSize = this.getSize();
    add(scrollPane, BorderLayout.CENTER);
    panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
    // scrollPane.set trying to replace scroll where it was
    JCheckBox relativeCheckBox = (JCheckBox) panel_2.getComponent(5);
    estimatedTime = System.currentTimeMillis() - startTime;
    logger.info("gathering time: " + estimatedTime);
    startTime = System.currentTimeMillis();
    //   Map<Source, Map<String, MineResult>>
    Map<Source, Map<String, MineResult>> treeMap = new TreeMap<Source, Map<String, MineResult>>(
            mineResultSet.mineResults);
    Iterator mineResultSetIterator = treeMap.entrySet().iterator();
    int ite = 0;
    logger.debug("mineResultSet size: " + mineResultSet.mineResults.size());
    while (mineResultSetIterator.hasNext()) {
        final Map.Entry pairs = (Map.Entry) mineResultSetIterator.next();
        logger.debug("mineResultSet key/source: " + ((Source) pairs.getKey()).getSourceName());
        JCheckBox checkBox = (JCheckBox) panel_1.getComponent(ite++);
        logger.debug("checkbox: " + checkBox.getText() + ", " + checkBox.isSelected());
        if (checkBox.isSelected()) {

            Map mrArrayList = (Map<String, MineResult>) pairs.getValue();
            ArrayList<String> mineResultGroup = new ArrayList<String>();
            Set<String> mrss = mrArrayList.keySet();

            mineResultGroup.addAll(mrss);
            Collections.sort(mineResultGroup, new AlphanumComparator());
            Iterator mrArrayListIterator = mineResultGroup.iterator();
            while (mrArrayListIterator.hasNext()) {

                String key = (String) mrArrayListIterator.next();
                logger.debug(key);
                final MineResult mr = (MineResult) mrArrayList.get(key);
                Map<String, ExtendedTimeSeries> statMap = mr.getStatTimeseriesMap();
                Map<String, ExtendedTimeSeries> eventMap = mr.getEventTimeseriesMap();
                // logger.info("mineResultSet hash size: "
                // +mr.getTimeseriesMap().size());
                // logger.info("mineResultSet hash content: " +
                // mr.getStatTimeseriesMap());
                logger.debug("mineResultSet mr.getStartDate(): " + mr.getStartDate()
                        + " mineResultSet mr.getEndDate(): " + mr.getEndDate());
                logger.debug("mineResultSet (Date)jsp.getValue(): " + (Date) startDateJSpinner.getValue());
                logger.debug("mineResultSet (Date)jsp2.getValue(): " + (Date) endDateJSPinner.getValue());
                if (mr.getStartDate() != null && mr.getEndDate() != null) {
                    if ((mr.getStartDate().before((Date) endDateJSPinner.getValue()))
                            && (mr.getEndDate().after((Date) startDateJSpinner.getValue()))) {

                        ArrayList<String> mineResultGroup2 = new ArrayList<String>();
                        Set<String> mrss2 = statMap.keySet();
                        mineResultGroup2.addAll(mrss2);
                        Collections.sort(mineResultGroup2, new AlphanumComparator());
                        Iterator statMapIterator = mineResultGroup2.iterator();

                        //            Iterator statMapIterator = statMap.entrySet().iterator();
                        if (!statMap.entrySet().isEmpty() || !eventMap.entrySet().isEmpty()) {
                            JPanel checkboxPanel = new JPanel(new WrapLayout());

                            checkboxPanel.setBackground(Color.white);

                            int count = 1;
                            chart = ChartFactory.createXYAreaChart(// Title
                                    mr.getSourceID() + " " + mr.getGroup(), // +
                                    null, // X-Axis
                                    // label
                                    null, // Y-Axis label
                                    null, // Dataset
                                    PlotOrientation.VERTICAL, false, // Show
                                    // legend
                                    true, // tooltips
                                    false // url
                            );
                            TextTitle my_Chart_title = new TextTitle(mr.getSourceID() + " " + mr.getGroup(),
                                    new Font("Verdana", Font.BOLD, 17));
                            chart.setTitle(my_Chart_title);
                            XYPlot plot = (XYPlot) chart.getPlot();
                            ValueAxis range = plot.getRangeAxis();
                            range.setVisible(false);

                            final DateAxis domainAxis1 = new DateAxis();
                            domainAxis1.setTickLabelsVisible(true);
                            // domainAxis1.setTickMarksVisible(true);

                            logger.debug("getRange: " + domainAxis1.getRange());
                            if (relativeCheckBox.isSelected()) {
                                domainAxis1.setRange((Date) startDateJSpinner.getValue(),
                                        (Date) endDateJSPinner.getValue());
                            } else {
                                Date startDate = mr.getStartDate();
                                Date endDate = mr.getEndDate();
                                if (mr.getStartDate().before((Date) startDateJSpinner.getValue())) {
                                    startDate = (Date) startDateJSpinner.getValue();
                                    logger.debug("setMinimumDate: " + (Date) startDateJSpinner.getValue());
                                }
                                if (mr.getEndDate().after((Date) endDateJSPinner.getValue())) {
                                    endDate = (Date) endDateJSPinner.getValue();
                                    logger.debug("setMaximumDate: " + (Date) endDateJSPinner.getValue());
                                }
                                if (startDate.before(endDate)) {
                                    domainAxis1.setRange(startDate, endDate);
                                }
                            }
                            XYToolTipGenerator tt1 = new XYToolTipGenerator() {
                                public String generateToolTip(XYDataset dataset, int series, int item) {
                                    StringBuffer sb = new StringBuffer();
                                    String htmlStr = "<html>";
                                    Number x;
                                    FastDateFormat sdf = FastDateFormat.getInstance("dd-MMM-yyyy HH:mm:ss");
                                    x = dataset.getX(series, item);
                                    sb.append(htmlStr);
                                    if (x != null) {
                                        sb.append("<p style='color:#000000;'>" + (sdf.format(x)) + "</p>");
                                        sb.append("<p style='color:#000000;'>"
                                                + dataset.getSeriesKey(series).toString() + ": "
                                                + form.format(dataset.getYValue(0, item)) + "</p>");
                                        if (mr.getFileLineForDate(new Date(x.longValue()),
                                                dataset.getSeriesKey(series).toString()) != null) {
                                            sb.append(
                                                    "<p style='color:#0000FF;'>"
                                                            + cd.sourceFileArrayListMap
                                                                    .get(pairs.getKey()).get(mr
                                                                            .getFileLineForDate(
                                                                                    new Date(x.longValue()),
                                                                                    dataset.getSeriesKey(series)
                                                                                            .toString())
                                                                            .getFileId())
                                                                    .getFile().getName()
                                                            + ":"
                                                            + mr.getFileLineForDate(new Date(x.longValue()),
                                                                    dataset.getSeriesKey(series).toString())
                                                                    .getLineNumber()
                                                            + "</p>");

                                        }
                                    }
                                    return sb.toString();
                                }
                            };

                            while (statMapIterator.hasNext()) {

                                TimeSeriesCollection dataset = new TimeSeriesCollection();
                                String me = (String) statMapIterator.next();

                                ExtendedTimeSeries ts = (ExtendedTimeSeries) statMap.get(me);
                                // logger.info(((TimeSeries)
                                // me.getValue()).getMaxY());
                                if (((ExtendedTimeSeries) statMap.get(me)).getTimeSeries().getMaxY() > 0)
                                    dataset.addSeries(ts.getTimeSeries());
                                logger.debug("mineResultSet group: " + mr.getGroup() + ", key: " + me
                                        + " nb records: " + ((ExtendedTimeSeries) statMap.get(me))
                                                .getTimeSeries().getItemCount());
                                logger.debug("(((TimeSeries) me.getValue()).getMaxY(): "
                                        + (((ExtendedTimeSeries) statMap.get(me)).getTimeSeries().getMaxY()));
                                logger.debug("(((TimeSeries) me.getValue()).getMinY(): "
                                        + (((ExtendedTimeSeries) statMap.get(me)).getTimeSeries().getMinY()));
                                XYPlot plot1 = chart.getXYPlot();
                                //   LogarithmicAxis axis4 = new LogarithmicAxis(me.toString());
                                NumberAxis axis4 = new NumberAxis(me.toString());
                                axis4.setAutoRange(true);
                                axis4.setAxisLineVisible(true);
                                axis4.setAutoRangeIncludesZero(false);
                                plot1.setDomainCrosshairVisible(true);
                                plot1.setRangeCrosshairVisible(true);
                                axis4.setRange(new Range(
                                        ((ExtendedTimeSeries) statMap.get(me)).getTimeSeries().getMinY(),
                                        ((ExtendedTimeSeries) statMap.get(me)).getTimeSeries().getMaxY()));
                                axis4.setLabelPaint(colors[count]);
                                axis4.setTickLabelPaint(colors[count]);
                                plot1.setRangeAxis(count, axis4);
                                final ValueAxis domainAxis = domainAxis1;
                                domainAxis.setLowerMargin(0.0);
                                domainAxis.setUpperMargin(0.0);
                                plot1.setDomainAxis(domainAxis);
                                plot1.setForegroundAlpha(0.5f);
                                plot1.setDataset(count, dataset);
                                plot1.mapDatasetToRangeAxis(count, count);
                                final XYAreaRenderer renderer = new XYAreaRenderer(); // XYAreaRenderer2
                                // also
                                // nice
                                if ((((ExtendedTimeSeries) statMap.get(me)).getTimeSeries().getMaxY()
                                        - ((ExtendedTimeSeries) statMap.get(me)).getTimeSeries()
                                                .getMinY()) > 0) {

                                    // renderer.setToolTipGenerator(new
                                    // StandardXYToolTipGenerator(StandardXYToolTipGenerator.DEFAULT_TOOL_TIP_FORMAT,new
                                    // FastDateFormat("d-MMM-yyyy HH:mm:ss"),
                                    // new DecimalFormat("#,##0.00")));
                                }
                                renderer.setSeriesPaint(0, colors[count]);
                                renderer.setSeriesVisible(0, true);
                                renderer.setSeriesToolTipGenerator(0, tt1);
                                plot1.setRenderer(count, renderer);
                                int hits = 0; // ts.getStat()[1]
                                int matchs = 0;
                                if (((ExtendedTimeSeries) statMap.get(me)).getStat() != null) {
                                    hits = ((ExtendedTimeSeries) statMap.get(me)).getStat()[1];
                                    //   matchs= ((ExtendedTimeSeries) statMap.get(me)).getStat()[0];
                                }
                                JCheckBox jcb = new JCheckBox(new VisibleAction(panel, checkboxPanel, axis4,
                                        me.toString() + "(" + hits + ")", 0));
                                Boolean selected = true;
                                jcb.setSelected(true);
                                jcb.setBackground(Color.white);
                                jcb.setBorderPainted(true);
                                jcb.setBorder(BorderFactory.createLineBorder(colors[count], 1, true));
                                jcb.setFont(new Font("Sans-serif", oldSmallFont.getStyle(),
                                        oldSmallFont.getSize()));
                                checkboxPanel.add(jcb);
                                count++;
                            }
                            Iterator eventMapIterator = eventMap.entrySet().iterator();
                            while (eventMapIterator.hasNext()) {

                                //   HistogramDataset histoDataSet=new HistogramDataset();

                                TimeSeriesCollection dataset = new TimeSeriesCollection();
                                Map.Entry me = (Map.Entry) eventMapIterator.next();
                                // if (dataset.getEndXValue(series, item))
                                if (((ExtendedTimeSeries) me.getValue()).getTimeSeries().getMaxY() > 0)
                                    dataset.addSeries(((ExtendedTimeSeries) me.getValue()).getTimeSeries());

                                logger.debug("mineResultSet group: " + mr.getGroup() + ", key: " + me.getKey()
                                        + " nb records: "
                                        + ((ExtendedTimeSeries) me.getValue()).getTimeSeries().getItemCount());
                                logger.debug("mineResultSet hash content: " + mr.getEventTimeseriesMap());
                                logger.debug("(((TimeSeries) me.getValue()).getMaxY(): "
                                        + (((ExtendedTimeSeries) me.getValue()).getTimeSeries().getMaxY()));
                                logger.debug("(((TimeSeries) me.getValue()).getMinY(): "
                                        + (((ExtendedTimeSeries) me.getValue()).getTimeSeries().getMinY()));
                                XYPlot plot2 = chart.getXYPlot();
                                //   LogarithmicAxis axis4 = new LogarithmicAxis(me.toString());
                                NumberAxis axis4 = new NumberAxis(me.getKey().toString());
                                axis4.setAutoRange(true);
                                // axis4.setInverted(true);
                                axis4.setAxisLineVisible(true);
                                axis4.setAutoRangeIncludesZero(true);

                                // axis4.setRange(new Range(((TimeSeries)
                                // axis4.setRange(new Range(((TimeSeries)
                                // me.getValue()).getMinY(), ((TimeSeries)
                                // me.getValue()).getMaxY()));
                                axis4.setLabelPaint(colors[count]);
                                axis4.setTickLabelPaint(colors[count]);
                                plot2.setRangeAxis(count, axis4);
                                final ValueAxis domainAxis = domainAxis1;

                                // domainAxis.setLowerMargin(0.001);
                                // domainAxis.setUpperMargin(0.0);
                                plot2.setDomainCrosshairVisible(true);
                                plot2.setRangeCrosshairVisible(true);
                                //plot2.setRangeCrosshairLockedOnData(true);
                                plot2.setDomainAxis(domainAxis);
                                plot2.setForegroundAlpha(0.5f);
                                plot2.setDataset(count, dataset);
                                plot2.mapDatasetToRangeAxis(count, count);
                                XYBarRenderer rend = new XYBarRenderer(); // XYErrorRenderer

                                rend.setShadowVisible(false);
                                rend.setDrawBarOutline(true);
                                Stroke stroke = new BasicStroke(5);
                                rend.setBaseStroke(stroke);
                                final XYItemRenderer renderer = rend;
                                renderer.setSeriesToolTipGenerator(0, tt1);
                                // renderer.setItemLabelsVisible(true);
                                renderer.setSeriesPaint(0, colors[count]);
                                renderer.setSeriesVisible(0, true);
                                plot2.setRenderer(count, renderer);
                                int hits = 0;
                                int matchs = 0;

                                if (((ExtendedTimeSeries) me.getValue()).getStat() != null) {
                                    hits = ((ExtendedTimeSeries) me.getValue()).getStat()[1];
                                    //   matchs= ((ExtendedTimeSeries) me.getValue()).getStat()[0];
                                }
                                JCheckBox jcb = new JCheckBox(new VisibleAction(panel, checkboxPanel, axis4,
                                        me.getKey().toString() + "(" + hits + ")", 0));

                                jcb.setSelected(true);
                                jcb.setBackground(Color.white);
                                jcb.setBorderPainted(true);
                                jcb.setBorder(BorderFactory.createLineBorder(colors[count], 1, true));
                                jcb.setFont(new Font("Sans-serif", oldSmallFont.getStyle(),
                                        oldSmallFont.getSize()));
                                checkboxPanel.add(jcb);
                                count++;
                            }

                            JPanel pan = new JPanel();

                            pan.setLayout(new BorderLayout());
                            pan.setPreferredSize(new Dimension(600,
                                    Integer.parseInt((String) Preferences.getPreference("chartSize"))));
                            // pan.setPreferredSize(panelSize);
                            panel.add(pan);
                            final ChartPanel cpanel = new ChartPanel(chart);
                            cpanel.setMinimumDrawWidth(0);
                            cpanel.setMinimumDrawHeight(0);
                            cpanel.setMaximumDrawWidth(1920);
                            cpanel.setMaximumDrawHeight(1200);
                            // cpanel.setInitialDelay(0);
                            cpanel.setDismissDelay(9999999);
                            cpanel.setInitialDelay(50);
                            cpanel.setReshowDelay(200);
                            cpanel.setPreferredSize(new Dimension(600, 350));
                            // cpanel.restoreAutoBounds(); fix the tooltip
                            // missing problem but then relative display is
                            // broken
                            panel.add(new JSeparator(SwingConstants.HORIZONTAL));
                            pan.add(cpanel, BorderLayout.CENTER);
                            // checkboxPanel.setPreferredSize(new Dimension(600,
                            // 0));
                            cpanel.addChartMouseListener(new ChartMouseListener() {

                                public void chartMouseClicked(ChartMouseEvent chartmouseevent) {
                                    // chartmouseevent.getEntity().

                                    ChartEntity entity = chartmouseevent.getEntity();
                                    if (entity instanceof XYItemEntity) {
                                        XYItemEntity item = ((XYItemEntity) entity);
                                        if (item.getDataset() instanceof TimeSeriesCollection) {

                                            TimeSeriesCollection data = (TimeSeriesCollection) item
                                                    .getDataset();
                                            TimeSeries series = data.getSeries(item.getSeriesIndex());
                                            TimeSeriesDataItem dataitem = series.getDataItem(item.getItem());

                                            // logger.info(" Serie: "+series.getKey().toString()
                                            // +
                                            // " Period : "+dataitem.getPeriod().toString());
                                            // mr.getFileForDate(new Date
                                            // (x.longValue())
                                            ;
                                            int x = chartmouseevent.getTrigger().getX();
                                            // logger.info(mr.getFileForDate(dataitem.getPeriod().getEnd()));
                                            int y = chartmouseevent.getTrigger().getY();
                                            String myString = "";
                                            if (dataitem.getPeriod() != null) {
                                                logger.info(dataitem.getPeriod().getEnd());
                                                //                                    myString = mr.getFileForDate(dataitem.getPeriod().getEnd()).toString();
                                                String lineString = ""
                                                        + mr.getFileLineForDate(dataitem.getPeriod().getEnd(),
                                                                item.getDataset()
                                                                        .getSeriesKey(item.getSeriesIndex())
                                                                        .toString())
                                                                .getLineNumber();
                                                String fileString = cd.sourceFileArrayListMap
                                                        .get(pairs.getKey())
                                                        .get(mr.getFileLineForDate(
                                                                dataitem.getPeriod().getEnd(),
                                                                item.getDataset()
                                                                        .getSeriesKey(item.getSeriesIndex())
                                                                        .toString())
                                                                .getFileId())
                                                        .getFile().getAbsolutePath();
                                                String command = Preferences.getPreference("editorCommand");
                                                command = command.replace("$line", lineString);
                                                command = command.replace("$file", fileString);
                                                logger.info(command);
                                                Runtime rt = Runtime.getRuntime();
                                                try {
                                                    rt.exec(command);
                                                } catch (IOException e1) {
                                                    // TODO Auto-generated catch block
                                                    e1.printStackTrace();
                                                }
                                                StringSelection stringSelection = new StringSelection(
                                                        fileString);
                                                Clipboard clpbrd = Toolkit.getDefaultToolkit()
                                                        .getSystemClipboard();
                                                clpbrd.setContents(stringSelection, null);
                                                //      cpanel.getGraphics().drawString("file name copied", x - 5, y - 5);
                                                try {
                                                    Thread.sleep(500);
                                                } catch (InterruptedException e) {
                                                    // TODO Auto-generated catch
                                                    // block
                                                    e.printStackTrace();
                                                }
                                            }

                                            // logger.info(mr.getFileForDate(dataitem.getPeriod().getStart()));
                                        }
                                    }
                                }

                                public void chartMouseMoved(ChartMouseEvent e) {
                                }

                            });

                            pan.add(checkboxPanel, BorderLayout.SOUTH);

                        }
                    }
                } else {
                    logger.debug("mr dates null: " + mr.getGroup() + mr.getSourceID() + mr.getLogFiles());
                }
            }
        }
    }
    // Map=miner.mine(sourceFiles,repo);
    estimatedTime = System.currentTimeMillis() - startTime;

    revalidate();
    logger.info("display time: " + estimatedTime);
}

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

@Override
public void addSpecifiedListenersForCorrelationChart(Object chartcomp, final Object chart, final boolean isAvg,
        final boolean isDate, final Map<Integer, Object> keyWithAdapter) {
    final ChartComposite chartComp = (ChartComposite) chartcomp;
    chartComp.addChartMouseListener(new ChartMouseListener() {

        @Override/* w  w  w  . j a v a  2  s.com*/
        public void chartMouseClicked(ChartMouseEvent event) {

            chartComp.setRangeZoomable(event.getTrigger().getButton() == 1);
            chartComp.setDomainZoomable(event.getTrigger().getButton() == 1);

            if (event.getTrigger().getButton() != 3) {
                return;
            }
            final Menu menu = new Menu(chartComp.getShell(), SWT.POP_UP);
            MenuItem itemShowInFullScreen = new MenuItem(menu, SWT.PUSH);
            itemShowInFullScreen.setText(Messages.getString("HideSeriesChartComposite.ShowInFullScreen")); //$NON-NLS-1$
            itemShowInFullScreen.addSelectionListener(new SelectionAdapter() {

                @Override
                public void widgetSelected(SelectionEvent e) {
                    Display.getDefault().asyncExec(new Runnable() {

                        @Override
                        public void run() {
                            showChartInFillScreen(chart, isAvg, isDate);
                        }
                    });
                }
            });

            chartComp.setMenu(menu);
            ChartEntity chartEntity = event.getEntity();
            if (chartEntity != null) {
                if (isAvg) {
                    addMenuOnBubbleChart(menu, chartEntity);
                } else if (isDate) {
                    addMenuOnGantChart(menu, chartEntity);
                }
            }
            menu.setVisible(true);
        }

        private void addMenuOnBubbleChart(Menu menu, ChartEntity chartEntity) {
            if (chartEntity instanceof XYItemEntity) {
                XYItemEntity xyItemEntity = (XYItemEntity) chartEntity;
                createMenuItem(menu, xyItemEntity.getItem());
            }
        }

        private void addMenuOnGantChart(Menu menu, ChartEntity chartEntity) {

            if (chartEntity instanceof CategoryItemEntity) {
                CategoryItemEntity itemEntity = (CategoryItemEntity) chartEntity;
                createMenuItem(menu, itemEntity.getCategoryIndex());
            }
        }

        private void createMenuItem(Menu menu, final int seriesK) {
            final SelectionAdapter selectionAdapter = (SelectionAdapter) keyWithAdapter.get(seriesK);
            MenuItem item;
            item = new MenuItem(menu, SWT.PUSH);
            item.setText(Messages.getString("HideSeriesChartComposite.ViewRow")); //$NON-NLS-1$
            item.addSelectionListener(selectionAdapter);
        }

        @Override
        public void chartMouseMoved(ChartMouseEvent event) {
            // no need to implement
        }

    });
}

From source file:de.bfs.radon.omsimulation.gui.OMPanelResults.java

/**
 * Creates a panel displaying the distribution chart of certain selected
 * statistical values.//from   w  w w.  j a v  a 2s  . c o m
 * 
 * @param title
 *          The headline of the chart. Will be hidden if set to null.
 * @param statistics
 *          The selected statistics of a campaign containing all needed
 *          values.
 * @param roomType
 *          The room type to determine the colour of the chart.
 * @param preview
 *          Will hide annotations, labels and headlines if set true.
 * @param fullscreen
 *          Will correctly adjust the preferred size to screen resolution if
 *          true.
 * @param mouseEvent
 *          Will enable mouseClickedEvent if set true. Use with care, and only
 *          inside the results panel. Set to false if you are unsure what you
 *          are doing.
 * @return A chart displaying the distribution of certain selected statistical
 *         values.
 */
public JPanel createDistributionPanel(String title, DescriptiveStatistics statistics, OMRoomType roomType,
        boolean preview, boolean fullscreen, boolean mouseEvent) {
    JFreeChart chart = OMCharts.createDistributionChart(title, statistics, roomType, preview);
    ChartPanel chartPanel = new ChartPanel(chart);
    Dimension dim;
    if (fullscreen) {
        dim = Toolkit.getDefaultToolkit().getScreenSize();
    } else {
        dim = new Dimension(730, 347);
    }
    chartPanel.setPreferredSize(dim);
    if (mouseEvent) {
        chartPanel.addChartMouseListener(new ChartMouseListener() {
            @Override
            public void chartMouseClicked(ChartMouseEvent e) {
                OMSimulation simulation = (OMSimulation) comboBoxSimulations.getSelectedItem();
                OMCampaign[] campaigns = simulation.getCampaigns();
                try {
                    XYItemEntity entity = (XYItemEntity) e.getEntity();
                    XYDataset dataset = entity.getDataset();
                    int item = entity.getItem();
                    double x = dataset.getXValue(0, item);
                    double comparable = 0.0;
                    OMCampaign result = null;
                    OMStatistics selectedType = (OMStatistics) comboBoxStatistics.getSelectedItem();
                    for (int i = 0; i < campaigns.length; i++) {
                        switch (selectedType) {
                        case RoomArithmeticMeans:
                            comparable = campaigns[i].getRoomAverage();
                            break;
                        case RoomGeometricMeans:
                            comparable = campaigns[i].getRoomLogAverage();
                            break;
                        case RoomMedianQ50:
                            comparable = campaigns[i].getRoomMedian();
                            break;
                        case RoomMaxima:
                            comparable = campaigns[i].getRoomMaximum();
                            break;
                        case CellarArithmeticMeans:
                            comparable = campaigns[i].getCellarAverage();
                            break;
                        case CellarGeometricMeans:
                            comparable = campaigns[i].getCellarLogAverage();
                            break;
                        case CellarMedianQ50:
                            comparable = campaigns[i].getCellarMedian();
                            break;
                        case CellarMaxima:
                            comparable = campaigns[i].getCellarMaximum();
                            break;
                        default:
                            comparable = campaigns[i].getRoomAverage();
                            break;
                        }
                        if (comparable == x) {
                            result = campaigns[i];
                        }
                    }
                    if (result != null) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException ie) {
                            ie.printStackTrace();
                        }
                        JTabbedPane tab = (JTabbedPane) getParent();
                        tab.remove(tab.getComponentAt(4));
                        JPanel jpanelTesting = new OMPanelTesting(simulation, result);
                        tab.add(jpanelTesting, "Analyse", 4);
                        tab.updateUI();
                        tab.setSelectedIndex(4);
                    }
                } catch (Exception x) {
                    x.printStackTrace();
                }
            }

            @Override
            public void chartMouseMoved(ChartMouseEvent ignore) {
            }
        });
    }
    JPanel distPanel = (JPanel) chartPanel;
    return distPanel;
}

From source file:UI.SecurityDashboard.java

private void performMetric1(MainViewPanel mvp) {
    Metric1 metric1 = new Metric1();

    JPanel graphPanel1 = new JPanel();
    graphPanel1.setLayout(new BorderLayout());
    graphPanel1.add(metric1.run(), BorderLayout.NORTH);

    DevicePanel.setLayout(new BorderLayout());
    JTextArea header = new JTextArea(
            "\nThe Network Vulnerability test scans the entire network for all existing vulnerabilities that may "
                    + "exist within and display the vulnerabilities (if any) for each device (computer, tablet or mobile device).\n");
    //header.setLineWrap(true);
    //header.setWrapStyleWord(true);
    header.setEditable(false);/*from www. j  a v a  2  s.  c  om*/
    header.setMaximumSize(new Dimension(DevicePanel.getWidth(), 3));
    DevicePanel.add(header, BorderLayout.NORTH);
    DevicePanel.add(graphPanel1, BorderLayout.CENTER);

    ChartPanel firstPanel = mvp.getPanel1(metric1);

    firstPanel.addChartMouseListener(new ChartMouseListener() {

        @Override
        public void chartMouseClicked(ChartMouseEvent cme) {
            dashboardTabs.setSelectedIndex(1);
        }

        @Override
        public void chartMouseMoved(ChartMouseEvent cme) {
        }
    });
    Metric1Panel.setLayout(new BorderLayout());
    Font titleFont = new Font("Calibri", Font.BOLD, 27);
    JLabel vulnerabilitiesTitleLabel = new JLabel("              Vulnerabilities");
    vulnerabilitiesTitleLabel.setFont(titleFont);
    Metric1Panel.add(vulnerabilitiesTitleLabel, BorderLayout.PAGE_START);

    Font devCountFont = new Font("Calibri", Font.BOLD, 16);
    String devCount = "  Device Count: " + metric1.deviceCount;
    JLabel devCountLabel = new JLabel(devCount);
    devCountLabel.setFont(devCountFont);
    Metric1Panel.add(devCountLabel, BorderLayout.SOUTH);
    Metric1Panel.add(firstPanel, BorderLayout.CENTER);
    Metric1Panel.setBackground(Color.white);
    Metric1Panel.setEnabled(false);
}