Example usage for org.jfree.chart.entity XYItemEntity getDataset

List of usage examples for org.jfree.chart.entity XYItemEntity getDataset

Introduction

In this page you can find the example usage for org.jfree.chart.entity XYItemEntity getDataset.

Prototype

public XYDataset getDataset() 

Source Link

Document

Returns the dataset this entity refers to.

Usage

From source file:com.chart.SwingChart.java

/**
 * /*from w  ww.j av  a 2 s  .c o m*/
 * @param name Chart name
 * @param parent Skeleton parent
 * @param axes Configuration of axes
 * @param abcissaName Abcissa name
 */
public SwingChart(String name, final Skeleton parent, List<AxisChart> axes, String abcissaName) {
    this.skeleton = parent;
    this.axes = axes;
    this.name = name;

    this.abcissaFormat = NumberFormat.getInstance(Locale.getDefault());
    this.ordinateFormat = NumberFormat.getInstance(Locale.getDefault());

    plot = new XYPlot();
    plot.setBackgroundPaint(scene2awtColor(javafx.scene.paint.Color.web(strChartBackgroundColor)));
    plot.setDomainGridlinePaint(scene2awtColor(javafx.scene.paint.Color.web(strGridlineColor)));
    plot.setRangeGridlinePaint(scene2awtColor(javafx.scene.paint.Color.web(strGridlineColor)));
    plot.setAxisOffset(new RectangleInsets(5.0, 5.0, 5.0, 5.0));

    abcissaAxis = new NumberAxis(abcissaName);
    ((NumberAxis) abcissaAxis).setAutoRangeIncludesZero(false);
    abcissaAxis.setTickLabelFont(new Font("SansSerif", Font.PLAIN, 12));
    abcissaAxis.setLabelFont(new Font("SansSerif", Font.PLAIN, 12));
    abcissaAxis.setLabelPaint(scene2awtColor(javafx.scene.paint.Color.web(strTickColor)));
    abcissaAxis.setTickLabelPaint(scene2awtColor(javafx.scene.paint.Color.web(strTickColor)));
    abcissaAxis.setAutoRange(true);
    abcissaAxis.setLowerMargin(0.0);
    abcissaAxis.setUpperMargin(0.0);
    abcissaAxis.setTickLabelsVisible(true);
    abcissaAxis.setLabelFont(abcissaAxis.getLabelFont().deriveFont(fontSize));
    abcissaAxis.setTickLabelFont(abcissaAxis.getLabelFont().deriveFont(fontSize));

    plot.setDomainAxis(abcissaAxis);

    for (int i = 0; i < axes.size(); i++) {
        AxisChart categoria = axes.get(i);
        addAxis(categoria.getName());

        for (int j = 0; j < categoria.configSerieList.size(); j++) {
            SimpleSeriesConfiguration cs = categoria.configSerieList.get(j);
            addSeries(categoria.getName(), cs);
        }
    }
    chart = new JFreeChart("", new Font("SansSerif", Font.BOLD, 16), plot, false);

    chart.setBackgroundPaint(scene2awtColor(javafx.scene.paint.Color.web(strBackgroundColor)));

    chartPanel = new ChartPanel(chart);
    chartPanel.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createEmptyBorder(4, 4, 4, 4),
            BorderFactory.createLineBorder(scene2awtColor(javafx.scene.paint.Color.web(strBackgroundColor)))));

    chartPanel.getInputMap().put(KeyStroke.getKeyStroke("ESCAPE"), "escape");
    chartPanel.getActionMap().put("escape", new AbstractAction() {

        @Override
        public void actionPerformed(java.awt.event.ActionEvent e) {
            for (int i = 0; i < plot.getDatasetCount(); i++) {
                XYDataset test = plot.getDataset(i);
                XYItemRenderer r = plot.getRenderer(i);
                r.removeAnnotations();
            }
        }
    });

    chartPanel.addChartMouseListener(cml = new ChartMouseListener() {
        @Override
        public void chartMouseClicked(ChartMouseEvent event) {
        }

        @Override
        public void chartMouseMoved(ChartMouseEvent event) {
            try {
                XYItemEntity xyitem = (XYItemEntity) event.getEntity(); // get clicked entity
                XYDataset dataset = (XYDataset) xyitem.getDataset(); // get data set    
                double x = dataset.getXValue(xyitem.getSeriesIndex(), xyitem.getItem());
                double y = dataset.getYValue(xyitem.getSeriesIndex(), xyitem.getItem());

                final XYPlot plot = chart.getXYPlot();
                for (int i = 0; i < plot.getDatasetCount(); i++) {
                    XYDataset test = plot.getDataset(i);
                    XYItemRenderer r = plot.getRenderer(i);
                    r.removeAnnotations();
                    if (test == dataset) {
                        NumberAxis ejeOrdenada = AxesList.get(i);
                        double y_max = ejeOrdenada.getUpperBound();
                        double y_min = ejeOrdenada.getLowerBound();
                        double x_max = abcissaAxis.getUpperBound();
                        double x_min = abcissaAxis.getLowerBound();
                        double angulo;
                        if (y > (y_max + y_min) / 2 && x > (x_max + x_min) / 2) {
                            angulo = 3.0 * Math.PI / 4.0;
                        } else if (y > (y_max + y_min) / 2 && x < (x_max + x_min) / 2) {
                            angulo = 1.0 * Math.PI / 4.0;
                        } else if (y < (y_max + y_min) / 2 && x < (x_max + x_min) / 2) {
                            angulo = 7.0 * Math.PI / 4.0;
                        } else {
                            angulo = 5.0 * Math.PI / 4.0;
                        }

                        CircleDrawer cd = new CircleDrawer((Color) r.getSeriesPaint(xyitem.getSeriesIndex()),
                                new BasicStroke(2.0f), null);
                        //XYAnnotation bestBid = new XYDrawableAnnotation(dataset.getXValue(xyitem.getSeriesIndex(), xyitem.getItem()), dataset.getYValue(xyitem.getSeriesIndex(), xyitem.getItem()), 11, 11, cd);
                        String txt = "X:" + abcissaFormat.format(x) + ", Y:" + ordinateFormat.format(y);
                        XYPointerAnnotation anotacion = new XYPointerAnnotation(txt,
                                dataset.getXValue(xyitem.getSeriesIndex(), xyitem.getItem()),
                                dataset.getYValue(xyitem.getSeriesIndex(), xyitem.getItem()), angulo);
                        anotacion.setTipRadius(10.0);
                        anotacion.setBaseRadius(35.0);
                        anotacion.setFont(new Font("SansSerif", Font.PLAIN, 10));

                        if (Long.parseLong((strChartBackgroundColor.replace("#", "")), 16) > 0xffffff / 2) {
                            anotacion.setPaint(Color.black);
                            anotacion.setArrowPaint(Color.black);
                        } else {
                            anotacion.setPaint(Color.white);
                            anotacion.setArrowPaint(Color.white);
                        }

                        //bestBid.setPaint((Color) r.getSeriesPaint(xyitem.getSeriesIndex()));
                        r.addAnnotation(anotacion);
                    }
                }

                //LabelValorVariable.setSize(LabelValorVariable.getPreferredSize());
            } catch (NullPointerException | ClassCastException ex) {

            }
        }
    });

    chartPanel.setPopupMenu(null);
    chartPanel.setBackground(scene2awtColor(javafx.scene.paint.Color.web(strBackgroundColor)));

    SwingNode sn = new SwingNode();
    sn.setContent(chartPanel);
    chartFrame = new VBox();
    chartFrame.getChildren().addAll(sn, legendFrame);
    VBox.setVgrow(sn, Priority.ALWAYS);
    VBox.setVgrow(legendFrame, Priority.NEVER);

    chartFrame.getStylesheets().addAll(SwingChart.class.getResource("overlay-chart.css").toExternalForm());

    legendFrame.setStyle("marco: " + strBackgroundColor + ";-fx-background-color: marco;");

    MenuItem mi;
    mi = new MenuItem("Print");
    mi.setOnAction((ActionEvent t) -> {
        print(chartFrame);
    });
    contextMenuList.add(mi);

    sn.setOnMouseClicked((MouseEvent t) -> {
        if (menu != null) {
            menu.hide();
        }
        if (t.getClickCount() == 2) {
            backgroundEdition();
        }
    });

    mi = new MenuItem("Copy to clipboard");
    mi.setOnAction((ActionEvent t) -> {
        copyClipboard(chartFrame);
    });
    contextMenuList.add(mi);

    mi = new MenuItem("Export values");
    mi.setOnAction((ActionEvent t) -> {
        FileChooser fileChooser = new FileChooser();
        fileChooser.setTitle("Export to file");
        fileChooser.getExtensionFilters()
                .addAll(new FileChooser.ExtensionFilter("Comma Separated Values", "*.csv"));

        Window w = null;
        try {
            w = parent.getScene().getWindow();
        } catch (NullPointerException e) {

        }
        File file = fileChooser.showSaveDialog(w);
        if (file != null) {
            export(file);
        }
    });
    contextMenuList.add(mi);

    chartFrame.setOnContextMenuRequested((ContextMenuEvent t) -> {
        if (menu != null) {
            menu.hide();
        }
        menu = new ContextMenu();
        menu.getItems().addAll(contextMenuList);
        menu.show(chartFrame, t.getScreenX(), t.getScreenY());
    });

}

From source file:com.att.aro.ui.view.diagnostictab.GraphPanel.java

@Override
public void chartMouseClicked(ChartMouseEvent chartmouseevent) {
    Point2D point = chartmouseevent.getTrigger().getPoint();
    Rectangle2D plotArea = getChartPanel().getScreenDataArea();

    XYPlot plot = (XYPlot) getAdvancedGraph().getPlot();
    final double lastChartX = new Double(
            plot.getDomainAxis().java2DToValue(point.getX(), plotArea, plot.getDomainAxisEdge()));

    // setCrossHair(lastChartX);

    // SwingUtilities.invokeLater(new Runnable() {
    // @Override/* w w  w .  j  a v  a 2 s .c  o  m*/
    // public void run() {
    // setCrossHair(lastChartX);
    // }
    // });

    for (GraphPanelListener gpl : listeners) {
        gpl.graphPanelClicked(lastChartX);

        /* New added @Tinbit */
        ChartEntity entity = chartmouseevent.getEntity();

        if (entity instanceof XYItemEntity) {
            XYItemEntity xyItem = (XYItemEntity) entity;

            XYDataset xyDataset = xyItem.getDataset();
            int seriesIndex = xyItem.getSeriesIndex();
            int itemIndex = xyItem.getItem();

            double xDataValue = xyDataset.getXValue(seriesIndex, itemIndex);
            double yDataValue = xyDataset.getYValue(seriesIndex, itemIndex);

            Map<Integer, VideoEvent> veSegment = vcPlot.getChunk(xDataValue);
            int indexKey = 0;
            if (vcPlot.isDataItemPoint(xDataValue, yDataValue)) {

                if (veSegment != null) {

                    for (int key : veSegment.keySet()) {
                        // String value="Chunk "+(key+1)+" at
                        // "+String.format("%.2f",
                        // veSegment.get(key).getDLTimeStamp())+"S";
                        chunkInfo.put(key, veSegment.get(key));
                        // chunkInfo.add(value);
                    }
                    indexKey = (int) veSegment.keySet().toArray()[0];
                }

                launchSliderDialog(indexKey);

            } else if (vcPlot.getBufferTimePlot().isDataItemStallPoint(xDataValue, yDataValue) != null) {
                VideoEvent segmentToPlay = vcPlot.getBufferTimePlot().isDataItemStallPoint(xDataValue,
                        yDataValue);
                veSegment = vcPlot.getSegmentToPlayLocation(segmentToPlay);
                if (veSegment != null) {
                    for (int key : veSegment.keySet()) {
                        chunkInfo.put(key, veSegment.get(key));
                    }
                    indexKey = (int) veSegment.keySet().toArray()[0];
                }
                launchSliderDialog(indexKey);
            }
        }
    }
}

From source file:org.gumtree.vis.hist2d.Hist2DPanel.java

private boolean updateCurrentMaskRectangle(XYItemEntity startEntity, XYItemEntity endEntity) {
    if (currentMaskRectangle != null) {
        if (startEntity != null && endEntity != null) {
            IDataset startDataset = (IDataset) startEntity.getDataset();
            IDataset endDataset = (IDataset) endEntity.getDataset();
            if (startDataset instanceof XYZDataset && endDataset instanceof XYZDataset) {
                XYZDataset start = (XYZDataset) startDataset;
                XYZDataset end = (XYZDataset) endDataset;
                double xStart = start.getXValue(0, startEntity.getItem());
                double yStart = start.getYValue(0, startEntity.getItem());
                double xEnd = end.getXValue(0, endEntity.getItem());
                double yEnd = end.getYValue(0, endEntity.getItem());
                currentMaskRectangle.setRectangleFrame(new Rectangle2D.Double(Math.min(xStart, xEnd),
                        Math.min(yStart, yEnd), Math.abs(xStart - xEnd), Math.abs(yStart - yEnd)));
                //                System.out.println("[" + xStart + ", " + yStart + ", " + xEnd + ", " + yEnd);
                fireMaskUpdateEvent(currentMaskRectangle);
                return true;
            }/* w w  w .java 2s.  c  o m*/
        }
    }
    return false;
}

From source file:org.gumtree.vis.plot1d.Plot1DPanel.java

@Override
public void mouseDragged(MouseEvent e) {
    Insets insets = getInsets();//from w  w w  .  j  a  va2 s .c o m
    int x = (int) ((e.getX() - insets.left) / getScaleX());
    int y = (int) ((e.getY() - insets.top) / getScaleY());

    ChartEntity entity = null;
    EntityCollection entities = null;
    if (getChartRenderingInfo() != null) {
        entities = getChartRenderingInfo().getEntityCollection();
        if (entities != null) {
            entity = entities.getEntity(x, y);
            //                boolean isDirty = false;
            int seriesIndex = -1;
            if (selectedSeriesIndex >= 0) {
                //                   double xInChart = ChartMaskingUtilities.translateScreenX(x, 
                //                         getScreenDataArea(), getChart());
                //                   XYDataset dataset = getChart().getXYPlot().getDataset();
                //                   PatternDataset patternDataset = (PatternDataset) dataset;
                //                   int itemIndex = patternDataset.getItemFromX(selectedSeriesIndex, xInChart);
                //                   if (itemIndex < patternDataset.getItemCount(selectedSeriesIndex)) {
                //                      chartX = patternDataset.getXValue(selectedSeriesIndex, itemIndex);
                //                      chartY = patternDataset.getYValue(selectedSeriesIndex, itemIndex);
                //                      Point2D axisTrace = ChartMaskingUtilities.translateChartPoint(
                //                            new Point2D.Double(chartX, chartY), getScreenDataArea(), getChart());
                //                      horizontalTraceLocation = (int) axisTrace.getX();
                //                      verticalTraceLocation = (int) axisTrace.getY();
                //                      seriesIndex = selectedSeriesIndex;
                //                      isDirty = true;
                //                   }
                seriesIndex = followDomainTrace(selectedSeriesIndex, x);
            } else if (getChart().getXYPlot().getSeriesCount() == 1) {
                //                   int seriesIndex0 = 0;
                //                   double xInChart = ChartMaskingUtilities.translateScreenX(x, 
                //                         getScreenDataArea(), getChart());
                //                   XYDataset dataset = getChart().getXYPlot().getDataset();
                //                   PatternDataset patternDataset = (PatternDataset) dataset;
                //                   int itemIndex = patternDataset.getItemFromX(seriesIndex0, xInChart);
                //                   if (itemIndex < patternDataset.getItemCount(seriesIndex0)) {
                //                      chartX = patternDataset.getXValue(seriesIndex0, itemIndex);
                //                      chartY = patternDataset.getYValue(seriesIndex0, itemIndex);
                //                      Point2D axisTrace = ChartMaskingUtilities.translateChartPoint(
                //                            new Point2D.Double(chartX, chartY), getScreenDataArea(), getChart());
                //                      horizontalTraceLocation = (int) axisTrace.getX();
                //                      verticalTraceLocation = (int) axisTrace.getY();
                //                      seriesIndex = seriesIndex0;
                //                      isDirty = true;
                //                   }
                seriesIndex = followDomainTrace(0, x);
            } else if (entity instanceof XYItemEntity) {
                XYItemEntity xyEntity = (XYItemEntity) entity;
                XYDataset dataset = xyEntity.getDataset();
                int item = ((XYItemEntity) entity).getItem();
                seriesIndex = xyEntity.getSeriesIndex();
                double chartX = dataset.getXValue(seriesIndex, item);
                double chartY = dataset.getYValue(seriesIndex, item);
                Point2D screenPoint = ChartMaskingUtilities.translateChartPoint(
                        new Point2D.Double(chartX, chartY), getScreenDataArea(), getChart());
                setChartX(chartX);
                setChartY(chartY);
                setSeriesIndex(seriesIndex);
                setItemIndex(item);
                if (dataset instanceof IXYErrorDataset) {
                    setChartError(((IXYErrorDataset) dataset).getYError(seriesIndex, item));

                }
                if (getHorizontalAxisTrace()) {
                    setHorizontalTraceLocation((int) screenPoint.getX());
                }
                if (getVerticalAxisTrace()) {
                    setVerticalTraceLocation((int) screenPoint.getY());
                }
                //                   isDirty = true;
            }
            if (seriesIndex >= 0) {
                Object[] listeners = getListeners(ChartMouseListener.class);
                if (getChart() != null) {
                    XYChartMouseEvent event = new XYChartMouseEvent(getChart(), e, entity);
                    event.setXY(getChartX(), getChartY());
                    event.setSeriesIndex(seriesIndex);
                    for (int i = listeners.length - 1; i >= 0; i -= 1) {
                        ((ChartMouseListener) listeners[i]).chartMouseMoved(event);
                    }
                }
            }

        }
    }

    //        if (isMaskingEnabled() && (e.getModifiers() & maskingKeyMask) != 0) {
    if (isInternalLegendEnabled && isInternalLegendSelected) {
        int cursorType = findCursorOnSelectedItem(e.getX(), e.getY());
        setCursor(Cursor.getPredefinedCursor(cursorType));
    } else if (isMaskingEnabled() && (e.getModifiers() & maskingKeyMask) == 0) {
        int cursorType = findCursorOnSelectedItem(e.getX(), e.getY());
        setCursor(Cursor.getPredefinedCursor(cursorType));
    } else if (getCursor() != defaultCursor) {
        setCursor(defaultCursor);
    }

    if (isInternalLegendEnabled && isInternalLegendSelected
            && findCursorOnSelectedItem(e.getX(), e.getY()) != Cursor.DEFAULT_CURSOR
            && (e.getModifiers() & MouseEvent.BUTTON1_MASK) != 0) {
        changeInternalLegend(e);
    } else if (getMaskDragIndicator() != Cursor.DEFAULT_CURSOR && this.getSelectedMask() != null
            && (e.getModifiers() & MouseEvent.BUTTON1_MASK) != 0) {
        changeSelectedMask(e);
    } else if (isMaskingEnabled() && (e.getModifiers() & maskingKeyMask) != 0) {
        // Do masking service
        // if no initial masking point was set, ignore dragging...
        makeNewMask(e);
    } else {
        super.mouseDragged(e);
    }
}

From source file:org.gumtree.vis.plot1d.Plot1DPanel.java

@Override
public void mouseMoved(MouseEvent e) {
    Insets insets = getInsets();/*from   www. ja  va 2s.c  om*/
    int x = (int) ((e.getX() - insets.left) / getScaleX());
    int y = (int) ((e.getY() - insets.top) / getScaleY());

    ChartEntity entity = null;
    if (getChartRenderingInfo() != null) {
        EntityCollection entities = getChartRenderingInfo().getEntityCollection();
        if (entities != null) {
            entity = entities.getEntity(x, y);
            //                   boolean isDirty = false;
            int seriesIndex = -1;
            if (selectedSeriesIndex >= 0) {
                //                      double xInChart = ChartMaskingUtilities.translateScreenX(x, 
                //                            getScreenDataArea(), getChart());
                //                      XYDataset dataset = getChart().getXYPlot().getDataset();
                //                      PatternDataset patternDataset = (PatternDataset) dataset;
                //                      int itemIndex = patternDataset.getItemFromX(selectedSeriesIndex, xInChart);
                //                      if (itemIndex < patternDataset.getItemCount(selectedSeriesIndex)) {
                //                         chartX = patternDataset.getXValue(selectedSeriesIndex, itemIndex);
                //                         chartY = patternDataset.getYValue(selectedSeriesIndex, itemIndex);
                //                         Point2D axisTrace = ChartMaskingUtilities.translateChartPoint(
                //                               new Point2D.Double(chartX, chartY), getScreenDataArea(), getChart());
                //                         horizontalTraceLocation = (int) axisTrace.getX();
                //                         verticalTraceLocation = (int) axisTrace.getY();
                //                         if (getHorizontalAxisTrace() || getVerticalAxisTrace() || isToolTipFollowerEnabled) {
                //                            repaint();
                //                         }
                //                         seriesIndex = selectedSeriesIndex;
                //                         isDirty = true;
                //                      }
                seriesIndex = followDomainTrace(selectedSeriesIndex, x);
                if (seriesIndex >= 0
                        && (getHorizontalAxisTrace() || getVerticalAxisTrace() || isToolTipFollowerEnabled())) {
                    repaint();
                }
            } else if (getChart().getXYPlot().getSeriesCount() == 1) {
                //                      int seriesIndex0 = 0;
                //                      double xInChart = ChartMaskingUtilities.translateScreenX(x, 
                //                            getScreenDataArea(), getChart());
                //                      XYDataset dataset = getChart().getXYPlot().getDataset();
                //                      PatternDataset patternDataset = (PatternDataset) dataset;
                //                      int itemIndex = patternDataset.getItemFromX(seriesIndex0, xInChart);
                //                      if (itemIndex < patternDataset.getItemCount(seriesIndex0)) {
                //                         chartX = patternDataset.getXValue(seriesIndex0, itemIndex);
                //                         chartY = patternDataset.getYValue(seriesIndex0, itemIndex);
                //                         Point2D axisTrace = ChartMaskingUtilities.translateChartPoint(
                //                               new Point2D.Double(chartX, chartY), getScreenDataArea(), getChart());
                ////                         if (getScreenDataArea().contains(axisTrace)) {
                //                         horizontalTraceLocation = (int) axisTrace.getX();
                //                         verticalTraceLocation = (int) axisTrace.getY();
                //                         if (getHorizontalAxisTrace() || getVerticalAxisTrace() || isToolTipFollowerEnabled) {
                //                            repaint();
                //                         }
                //                         seriesIndex = seriesIndex0;
                //                         isDirty = true;
                ////                         }
                //                      }
                seriesIndex = followDomainTrace(0, x);
                if (seriesIndex >= 0
                        && (getHorizontalAxisTrace() || getVerticalAxisTrace() || isToolTipFollowerEnabled())) {
                    repaint();
                }
            } else if (entity instanceof XYItemEntity) {
                XYItemEntity xyEntity = (XYItemEntity) entity;
                XYDataset dataset = xyEntity.getDataset();
                int item = ((XYItemEntity) entity).getItem();
                seriesIndex = xyEntity.getSeriesIndex();
                double chartX = dataset.getXValue(seriesIndex, item);
                double chartY = dataset.getYValue(seriesIndex, item);
                Point2D screenPoint = ChartMaskingUtilities.translateChartPoint(
                        new Point2D.Double(chartX, chartY), getScreenDataArea(), getChart());
                setChartX(chartX);
                setChartY(chartY);
                setSeriesIndex(seriesIndex);
                setItemIndex(item);
                if (dataset instanceof IXYErrorDataset) {
                    setChartError(((IXYErrorDataset) dataset).getYError(seriesIndex, item));

                }
                if (getHorizontalAxisTrace()) {
                    setHorizontalTraceLocation((int) screenPoint.getX());
                }
                if (getVerticalAxisTrace()) {
                    setVerticalTraceLocation((int) screenPoint.getY());
                }
                if (getHorizontalAxisTrace() || getVerticalAxisTrace() || isToolTipFollowerEnabled()) {
                    repaint();
                }
                //                      isDirty = true;
            }
            if (seriesIndex >= 0) {
                Object[] listeners = getListeners(ChartMouseListener.class);
                if (getChart() != null) {
                    XYChartMouseEvent event = new XYChartMouseEvent(getChart(), e, entity);
                    event.setXY(getChartX(), getChartY());
                    event.setSeriesIndex(seriesIndex);
                    for (int i = listeners.length - 1; i >= 0; i -= 1) {
                        ((ChartMouseListener) listeners[i]).chartMouseMoved(event);
                    }
                }
            }

        }
        //              getChart().handleClick(x, y, getChartRenderingInfo());
    }

    if (isInternalLegendEnabled && isInternalLegendSelected) {
        int cursorType = findCursorOnSelectedItem(e.getX(), e.getY());
        setCursor(Cursor.getPredefinedCursor(cursorType));
    } else if (getCursor() != defaultCursor) {
        setCursor(defaultCursor);
    }

    super.mouseMoved(e);
    // we can only generate events if the panel's chart is not null
    // (see bug report 1556951)
}

From source file:com.jtstand.swing.StatsPanel.java

@Override
public void chartMouseClicked(ChartMouseEvent event) {
    ChartEntity entity = event.getEntity();
    if (entity != null) {
        //            System.out.println("clicked entity: " + entity);
        if (entity instanceof XYItemEntity) {
            XYItemEntity xyie = (XYItemEntity) entity;
            //                System.out.println("series: " + xyie.getSeriesIndex() + ", item: " + xyie.getItem());
            XYDataset dset = xyie.getDataset();
            if (dset != null) {
                final Number xNumber = dset.getX(xyie.getSeriesIndex(), xyie.getItem());
                if (xNumber != null) {
                    SwingUtilities.invokeLater(new Runnable() {
                        @Override
                        public void run() {
                            long xLong;
                            switch (chartMode) {
                            case STEP_TIME:
                                xLong = xNumber.longValue();
                                if (xLong != 0L) {
                                    //                                                    System.out.println("Selecting step, which is started at " + new Date(xLong));
                                    for (TestStepInstance step : testStepInstances) {
                                        if (step.getStartTime() != null && step.getStartTime().equals(xLong)) {
                                            testStepInstances.selectStep(step);
                                            cp.requestFocus();
                                            return;
                                        }
                                    }/*from  w  ww .j  av a  2s  . com*/
                                }
                                break;
                            case SEQUENCE_TIME:
                                xLong = xNumber.longValue();
                                if (xLong != 0L) {
                                    //                                                    System.out.println("Selecting sequence, which is started at " + new Date(xLong));
                                    for (TestStepInstance step : testStepInstances) {
                                        if (step.getTestSequenceInstance() != null
                                                && step.getTestSequenceInstance().getCreateTime() == xLong) {
                                            testStepInstances.selectStep(step);
                                            cp.requestFocus();
                                            return;
                                        }
                                    }
                                }
                                break;
                            case LIST:
                                testStepInstances.selectStep(xNumber.intValue() - 1);
                                break;
                            case DISTRIBUTION:
                                double min = xNumber.doubleValue() - barWidth() / 2.0;
                                double max = xNumber.doubleValue() + barWidth() / 2.0;
                                //                                                System.out.println("X: " + xNumber + " min: " + min + " max: " + max);
                                List<TestStepInstance> select = new ArrayList<TestStepInstance>();
                                for (TestStepInstance step : testStepInstances) {
                                    Number number = getNumber(step);
                                    if (number != null) {
                                        Double d = number.doubleValue();
                                        if (d >= min && d < max) {
                                            select.add(step);
                                        }
                                    }

                                }
                                testStepInstances.selectSteps(select);
                                cp.requestFocus();
                                break;
                            }
                        }
                    });
                }
            }
        }
    }
}

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

@Override
public void mouseClicked(MouseEvent event) {

    Insets insets = getInsets();/*w ww. j av  a  2  s. c  o m*/
    int x = (int) ((event.getX() - insets.left) / getScaleX());
    int y = (int) ((event.getY() - insets.top) / getScaleY());

    setAnchor(new Point2D.Double(x, y));
    if (getChart() == null) {
        return;
    }
    //        getChart().setNotify(true);  // force a redraw
    // new entity code...
    //        if (listeners.length == 0) {
    //            return;
    //        }

    ChartEntity entity = null;
    if (getChartRenderingInfo() != null) {
        EntityCollection entities = getChartRenderingInfo().getEntityCollection();
        if (entities != null) {
            entity = entities.getEntity(x, y);
            if (entity instanceof XYItemEntity) {
                XYItemEntity xyEntity = (XYItemEntity) entity;
                //                   XYDataset dataset = xyEntity.getDataset();
                //                   int item = ((XYItemEntity) entity).getItem();
                //                   chartX = dataset.getXValue(xyEntity.getSeriesIndex(), item);
                //                   chartY = dataset.getYValue(xyEntity.getSeriesIndex(), item);
                //                   Point2D screenPoint = ChartMaskingUtilities.translateChartPoint(
                //                         new Point2D.Double(chartX, chartY), getScreenDataArea(), getChart());
                //                   if (getHorizontalAxisTrace()) {
                //                      horizontalTraceLocation = (int) screenPoint.getX();
                //                   }
                //                   if (getVerticalAxisTrace()) {
                //                      verticalTraceLocation = (int) screenPoint.getY();
                //                   }
                if ((event.getModifiers() & seriesSelectionEventMask) != 0
                        && (event.getModifiers() & MouseEvent.BUTTON1_MASK) != 0) {
                    XYDataset dataset = xyEntity.getDataset();
                    if (dataset instanceof IDataset) {
                        selectSeries((IDataset) xyEntity.getDataset(), xyEntity.getSeriesIndex());
                    }
                } else if ((event.getModifiers() & maskingSelectionMask) == 0
                        && (event.getModifiers() & MouseEvent.BUTTON1_MASK) != 0) {
                    if (selectedSeriesIndex != xyEntity.getSeriesIndex()) {
                        selectSeries(null, -1);
                    }
                }
            } else {
                if (selectedSeriesIndex >= 0) {
                    if ((event.getModifiers() & seriesSelectionEventMask) != 0
                            && (event.getModifiers() & maskingSelectionMask) == 0
                            && (event.getModifiers() & MouseEvent.BUTTON1_MASK) != 0) {
                        selectSeries(null, -1);
                    }
                }
            }
        }
    }

    if ((event.getModifiers() & MouseEvent.BUTTON1_MASK) != 0) {
        double chartX = ChartMaskingUtilities.translateScreenX(x, getScreenDataArea(), getChart());
        int selectedDatasetIndex = 0;
        if (selectedDataset != null) {
            selectedDatasetIndex = getXYPlot().indexOf(selectedDataset);
        }
        double chartY = ChartMaskingUtilities.translateScreenY(y, getScreenDataArea(), getChart(),
                selectedDatasetIndex);
        setHorizontalTraceLocation(x);
        setVerticalTraceLocation(y);
        setChartX(chartX);
        setChartY(chartY);
        repaint();
    }

    XYChartMouseEvent chartEvent = new XYChartMouseEvent(getChart(), event, entity);
    chartEvent.setXY(getChartX(), getChartY());
    Object[] listeners = getListeners(ChartMouseListener.class);
    for (int i = listeners.length - 1; i >= 0; i -= 1) {
        ((ChartMouseListener) listeners[i]).chartMouseClicked(chartEvent);
    }
    System.out.println("chartX = " + getChartX() + ", chartY = " + getChartY());
}

From source file:course_generator.frmMain.java

/**
 * This method is called to initialize the form.
 *///from ww w  .j ava2 s .c  o  m
private void initComponents() {
    // -- Main windows
    // ------------------------------------------------------
    setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
    // java.util.ResourceBundle bundle =
    // java.util.ResourceBundle.getBundle("course_generator/Bundle");
    setTitle(bundle.getString("frmMain.title"));
    setIconImages(null);
    // setName("FrameMain");
    // setPreferredSize(new java.awt.Dimension(812, 800));
    addWindowListener(new java.awt.event.WindowAdapter() {
        public void windowClosing(java.awt.event.WindowEvent evt) {
            formWindowClosing(evt);
        }
    });

    // -- Layout
    // ------------------------------------------------------------
    Container paneGlobal = getContentPane();
    // paneGlobal.setLayout(new GridBagLayout());
    paneGlobal.setLayout(new BorderLayout());

    // -- Menu bar
    // ----------------------------------------------------------
    Create_MenuBarMain();

    // -- Main toolbar
    // ------------------------------------------------------
    Create_MainToolbar();
    paneGlobal.add(ToolBarMain, BorderLayout.NORTH);

    // -- Status bar
    // ------------------------------------------------------
    Create_Statusbar();
    paneGlobal.add(StatusBar, BorderLayout.SOUTH);

    // -- Main split bar (vertical)
    // -----------------------------------------
    SplitPaneMain = new javax.swing.JSplitPane();
    paneGlobal.add(SplitPaneMain, BorderLayout.CENTER);

    // -- Left side of the split bar
    // ----------------------------------------
    jPanelLeft = new javax.swing.JPanel();
    jPanelLeft.setLayout(new java.awt.BorderLayout());

    // -- Add the left panel to the main split panel
    // ------------------------
    SplitPaneMain.setLeftComponent(jPanelLeft);

    // -- Content of the tree
    javax.swing.tree.DefaultMutableTreeNode treeNode1 = new javax.swing.tree.DefaultMutableTreeNode(
            "Course Generator");
    javax.swing.tree.DefaultMutableTreeNode treeNode2 = new javax.swing.tree.DefaultMutableTreeNode("Parcours");
    javax.swing.tree.DefaultMutableTreeNode treeNode3 = new javax.swing.tree.DefaultMutableTreeNode(
            "Utmb 2011");
    javax.swing.tree.DefaultMutableTreeNode treeNode4 = new javax.swing.tree.DefaultMutableTreeNode("Prvu");
    treeNode3.add(treeNode4);
    treeNode4 = new javax.swing.tree.DefaultMutableTreeNode("Fait");
    treeNode3.add(treeNode4);
    treeNode2.add(treeNode3);
    treeNode3 = new javax.swing.tree.DefaultMutableTreeNode("Montagnard");
    treeNode4 = new javax.swing.tree.DefaultMutableTreeNode("Prvu");
    treeNode3.add(treeNode4);
    treeNode4 = new javax.swing.tree.DefaultMutableTreeNode("Fait");
    treeNode3.add(treeNode4);
    treeNode2.add(treeNode3);
    treeNode3 = new javax.swing.tree.DefaultMutableTreeNode("UCDHL2008");
    treeNode4 = new javax.swing.tree.DefaultMutableTreeNode("Prvu");
    treeNode3.add(treeNode4);
    treeNode4 = new javax.swing.tree.DefaultMutableTreeNode("Fait");
    treeNode3.add(treeNode4);
    treeNode2.add(treeNode3);
    treeNode3 = new javax.swing.tree.DefaultMutableTreeNode("UCDHL2009");
    treeNode4 = new javax.swing.tree.DefaultMutableTreeNode("Prvu");
    treeNode3.add(treeNode4);
    treeNode4 = new javax.swing.tree.DefaultMutableTreeNode("Fait");
    treeNode3.add(treeNode4);
    treeNode2.add(treeNode3);
    treeNode3 = new javax.swing.tree.DefaultMutableTreeNode("UCDHL2010");
    treeNode4 = new javax.swing.tree.DefaultMutableTreeNode("Prvu");
    treeNode3.add(treeNode4);
    treeNode4 = new javax.swing.tree.DefaultMutableTreeNode("Fait");
    treeNode3.add(treeNode4);
    treeNode2.add(treeNode3);
    treeNode3 = new javax.swing.tree.DefaultMutableTreeNode("UCDHL2011");
    treeNode4 = new javax.swing.tree.DefaultMutableTreeNode("Prvu");
    treeNode3.add(treeNode4);
    treeNode4 = new javax.swing.tree.DefaultMutableTreeNode("Fait");
    treeNode3.add(treeNode4);
    treeNode2.add(treeNode3);
    treeNode3 = new javax.swing.tree.DefaultMutableTreeNode("UCDHL2012");
    treeNode4 = new javax.swing.tree.DefaultMutableTreeNode("Prvu");
    treeNode3.add(treeNode4);
    treeNode4 = new javax.swing.tree.DefaultMutableTreeNode("Fait");
    treeNode3.add(treeNode4);
    treeNode2.add(treeNode3);
    treeNode3 = new javax.swing.tree.DefaultMutableTreeNode("UCDHL2013");
    treeNode4 = new javax.swing.tree.DefaultMutableTreeNode("Prvu");
    treeNode3.add(treeNode4);
    treeNode4 = new javax.swing.tree.DefaultMutableTreeNode("Fait");
    treeNode3.add(treeNode4);
    treeNode2.add(treeNode3);
    treeNode1.add(treeNode2);
    treeNode2 = new javax.swing.tree.DefaultMutableTreeNode("Configuration");
    treeNode1.add(treeNode2);

    // -- Tree
    // --------------------------------------------------------------
    jTreeMain = new javax.swing.JTree();
    jTreeMain.setModel(new javax.swing.tree.DefaultTreeModel(treeNode1));
    jTreeMain.setPreferredSize(new java.awt.Dimension(109, 25));

    // -- Add the tree to a scroll panel
    // ------------------------------------
    jScrollPaneTree = new javax.swing.JScrollPane();
    jScrollPaneTree.setBorder(javax.swing.BorderFactory.createEtchedBorder());
    jScrollPaneTree.setViewportView(jTreeMain);

    // -- Add the scroll panel to the left panel
    // ----------------------------
    jPanelLeft.add(jScrollPaneTree, java.awt.BorderLayout.CENTER);

    // -- Right split pane
    // --------------------------------------------------
    SplitPaneMainRight = new javax.swing.JSplitPane();
    SplitPaneMainRight.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT);
    SplitPaneMain.setRightComponent(SplitPaneMainRight);

    // -- Tabbed panel
    // ------------------------------------------------------
    TabbedPaneMain = new javax.swing.JTabbedPane();
    // -- Create the listener
    ChangeListener changeListener = new ChangeListener() {
        public void stateChanged(ChangeEvent changeEvent) {
            JTabbedPane sourceTabbedPane = (JTabbedPane) changeEvent.getSource();
            int index = sourceTabbedPane.getSelectedIndex();
            if (index == 4) // Tab Resume
                RefreshResume();
        }
    };
    TabbedPaneMain.addChangeListener(changeListener);

    SplitPaneMainRight.setTopComponent(TabbedPaneMain);

    // -- Tab - data (grid)
    // -------------------------------------------------
    TableMain = new javax.swing.JTable();
    TableMain.setModel(ModelTableMain);
    TableMain.getTableHeader()
            .setDefaultRenderer(new MainHeaderRenderer(TableMain.getTableHeader().getDefaultRenderer()));
    TableMain.getTableHeader().setReorderingAllowed(false);

    TableMain.setDefaultRenderer(ElevationClass.class, new ElevationRenderer());
    TableMain.setDefaultRenderer(DistClass.class, new DistRenderer());
    TableMain.setDefaultRenderer(TotalClass.class, new TotalRenderer());
    TableMain.setDefaultRenderer(DiffClass.class, new DiffRenderer());
    TableMain.setDefaultRenderer(CoeffClass.class, new CoeffRenderer());
    TableMain.setDefaultRenderer(LatClass.class, new LatRenderer());
    TableMain.setDefaultRenderer(LonClass.class, new LonRenderer());
    TableMain.setDefaultRenderer(RecupClass.class, new RecupRenderer());
    TableMain.setDefaultRenderer(TimeClass.class, new TimeRenderer());
    TableMain.setDefaultRenderer(TimelimitClass.class, new TimelimitRenderer());
    TableMain.setDefaultRenderer(HourClass.class, new HourRenderer());
    TableMain.setDefaultRenderer(StationClass.class, new StationRenderer());
    TableMain.setDefaultRenderer(TagClass.class, new TagRenderer());

    TableMain.setAutoResizeMode(javax.swing.JTable.AUTO_RESIZE_OFF);
    TableMain.setRowHeight(20);
    TableMain.addMouseListener(new java.awt.event.MouseAdapter() {
        public void mouseClicked(java.awt.event.MouseEvent evt) {
            if (evt.getButton() == evt.BUTTON1 && evt.getClickCount() >= 2 && !evt.isConsumed()) {
                evt.consume();
                int row = TableMain.rowAtPoint(evt.getPoint());
                int col = TableMain.columnAtPoint(evt.getPoint());
                frmEditPosition frm = new frmEditPosition();
                if (frm.showDialog(Settings, Track, row, col)) {
                    Track.isModified = true;
                    RefreshTableMain();
                    RefreshProfil();
                    RefreshStatusbar(Track);
                }
            } else
                TableMainMouseClicked(evt);
        }
    });
    TableMain.addKeyListener(new java.awt.event.KeyAdapter() {
        public void keyReleased(java.awt.event.KeyEvent evt) {
            TableMainKeyReleased(evt);
        }
    });

    // -- Add the grid to a scroll panel
    // ------------------------------------
    jScrollPaneData = new javax.swing.JScrollPane();
    jScrollPaneData.setViewportView(TableMain);

    // -- Add the scroll panel to the tabbed panel
    // --------------------------
    addTab(TabbedPaneMain, jScrollPaneData, bundle.getString("frmMain.TabData.tabTitle"),
            new javax.swing.ImageIcon(getClass().getResource("/course_generator/images/satellite16.png")));

    // -- Tab - Profil
    // ------------------------------------------------------
    jPanelProfil = new javax.swing.JPanel();
    jPanelProfil.setPreferredSize(new java.awt.Dimension(677, 150));
    jPanelProfil.setLayout(new java.awt.BorderLayout());

    // -- Profil tool bar
    // ---------------------------------------------------
    // Create_Profil_Toolbar();
    // jPanelProfil.add(ToolBarProfil, java.awt.BorderLayout.WEST);

    // -- Profil chart
    // ------------------------------------------------------
    jPanelProfilChart = new ChartPanel(chart);
    CrosshairOverlay crosshairOverlay = new CrosshairOverlay();
    xCrosshair = new Crosshair(Double.NaN, Color.DARK_GRAY, new BasicStroke(0f));
    // xCrosshair.setLabelVisible(true);
    xCrosshair.setLabelBackgroundPaint(Color.WHITE);

    yCrosshair = new Crosshair(Double.NaN, Color.DARK_GRAY, new BasicStroke(0f));
    // yCrosshair.setLabelVisible(true);
    yCrosshair.setLabelBackgroundPaint(Color.WHITE);

    crosshairOverlay.addDomainCrosshair(xCrosshair);
    crosshairOverlay.addRangeCrosshair(yCrosshair);

    jPanelProfilChart.addOverlay(crosshairOverlay);
    jPanelProfilChart.setBackground(new java.awt.Color(255, 0, 51));
    jPanelProfilChart.addChartMouseListener(new ChartMouseListener() {
        @Override
        public void chartMouseClicked(ChartMouseEvent event) {

            ChartEntity chartentity = event.getEntity();
            if (chartentity instanceof XYItemEntity) {
                XYItemEntity e = (XYItemEntity) chartentity;
                XYDataset d = e.getDataset();
                int s = e.getSeriesIndex();
                int i = e.getItem();
                double x = d.getXValue(s, i);
                double y = d.getYValue(s, i);
                xCrosshair.setValue(x);
                yCrosshair.setValue(y);
                RefreshProfilInfo(i);
                //Refresh the position on the data grid
                TableMain.setRowSelectionInterval(i, i);
                Rectangle rect = TableMain.getCellRect(i, 0, true);
                TableMain.scrollRectToVisible(rect);
                //Refresh the marker position on the map
                RefreshCurrentPosMarker(Track.data.get(i).getLatitude(), Track.data.get(i).getLongitude());
            }
        }

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

    jPanelProfil.add(jPanelProfilChart, java.awt.BorderLayout.CENTER);

    // -- Profil info bar
    // ---------------------------------------------------
    jPanelProfilInfo = new javax.swing.JPanel();
    jPanelProfilInfo.setLayout(new GridBagLayout());
    jPanelProfil.add(jPanelProfilInfo, java.awt.BorderLayout.SOUTH);

    // -- Line 0
    // -- Distance
    // ----------------------------------------------------------
    lbProfilDistance = new javax.swing.JLabel();
    lbProfilDistance.setText(" " + bundle.getString("frmMain.lbProfilDistance.text") + "=0.000km ");
    lbProfilDistance.setBorder(javax.swing.BorderFactory.createEtchedBorder());
    Utils.addComponent(jPanelProfilInfo, lbProfilDistance, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
            GridBagConstraints.EAST, GridBagConstraints.BOTH);

    // -- Time
    // --------------------------------------------------------------
    lbProfilTime = new javax.swing.JLabel();
    lbProfilTime.setText(" " + bundle.getString("frmMain.lbProfilTime.text") + "=00:00:00 ");
    lbProfilTime.setBorder(javax.swing.BorderFactory.createEtchedBorder());
    Utils.addComponent(jPanelProfilInfo, lbProfilTime, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, GridBagConstraints.EAST,
            GridBagConstraints.BOTH);

    // -- Slope
    // -------------------------------------------------------------
    lbProfilSlope = new javax.swing.JLabel();
    lbProfilSlope.setText(" " + bundle.getString("frmMain.lbProfilSlope.text") + "=0.0% ");
    lbProfilSlope.setBorder(javax.swing.BorderFactory.createEtchedBorder());
    Utils.addComponent(jPanelProfilInfo, lbProfilSlope, 2, 0, 1, 1, 0, 0, 0, 0, 0, 0, GridBagConstraints.EAST,
            GridBagConstraints.BOTH);

    // -- Name
    // --------------------------------------------------------------
    lbProfilName = new javax.swing.JLabel();
    lbProfilName.setText(" " + bundle.getString("frmMain.lbProfilName.text") + "= ");
    lbProfilName.setBorder(javax.swing.BorderFactory.createEtchedBorder());
    Utils.addComponent(jPanelProfilInfo, lbProfilName, 3, 0, 1, 1, 1, 0, 0, 0, 0, 0, GridBagConstraints.EAST,
            GridBagConstraints.BOTH);

    // -- Line 1
    // -- Elevation
    // ---------------------------------------------------------
    lbProfilElevation = new javax.swing.JLabel();
    lbProfilElevation.setText(" " + bundle.getString("frmMain.lbProfilElevation.text") + "=0m ");
    lbProfilElevation.setBorder(javax.swing.BorderFactory.createEtchedBorder());
    Utils.addComponent(jPanelProfilInfo, lbProfilElevation, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0,
            GridBagConstraints.EAST, GridBagConstraints.BOTH);

    // -- Hour
    // --------------------------------------------------------------
    lbProfilHour = new javax.swing.JLabel();
    lbProfilHour.setText(" " + bundle.getString("frmMain.lbProfilHour.text") + "=00:00:00 ");
    lbProfilHour.setBorder(javax.swing.BorderFactory.createEtchedBorder());
    Utils.addComponent(jPanelProfilInfo, lbProfilHour, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, GridBagConstraints.EAST,
            GridBagConstraints.BOTH);

    // -- Speed
    // -------------------------------------------------------------
    lbProfilSpeed = new javax.swing.JLabel();
    lbProfilSpeed.setText(" " + bundle.getString("frmMain.lbProfilSpeed.text") + "=0.0km/h ");
    lbProfilSpeed.setBorder(javax.swing.BorderFactory.createEtchedBorder());
    Utils.addComponent(jPanelProfilInfo, lbProfilSpeed, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, GridBagConstraints.EAST,
            GridBagConstraints.BOTH);

    // -- Comment
    // -----------------------------------------------------------
    lbProfilComment = new javax.swing.JLabel();
    lbProfilComment.setText(" " + bundle.getString("frmMain.lbProfilComment.text") + "= ");
    lbProfilComment.setBorder(javax.swing.BorderFactory.createEtchedBorder());
    Utils.addComponent(jPanelProfilInfo, lbProfilComment, 3, 1, 1, 1, 1, 0, 0, 0, 0, 0, GridBagConstraints.EAST,
            GridBagConstraints.BOTH);
    // -- Distance / Temps / Pente / Nom
    // -- Altitude / Heure / Vitesse / Commentaire

    // -- Add the panel to the tabbed panel
    // ---------------------------------
    addTab(TabbedPaneMain, jPanelProfil, bundle.getString("frmMain.TabProfil.tabTitle"),
            new javax.swing.ImageIcon(getClass().getResource("/course_generator/images/profil.png")));

    // -- Tab - Statistic
    // ---------------------------------------------------
    jPanelStatistic = new javax.swing.JPanel();
    jPanelStatistic.setLayout(new java.awt.BorderLayout());

    // -- Statistic tool bar
    // ---------------------------------------------------
    Create_Statistic_Toolbar();
    jPanelStatistic.add(ToolBarStatistic, java.awt.BorderLayout.NORTH);

    // TODO Add the component to display the statistics

    addTab(TabbedPaneMain, jPanelStatistic, bundle.getString("frmMain.TabStatistic.tabTitle"),
            new javax.swing.ImageIcon(getClass().getResource("/course_generator/images/stat.png")));

    // -- Tab - Analysis
    // ----------------------------------------------------
    jPanelAnalyze = new javax.swing.JPanel();

    // TODO Define this panel

    addTab(TabbedPaneMain, jPanelAnalyze, bundle.getString("frmMain.TabAnalyze.tabTitle"),
            new javax.swing.ImageIcon(getClass().getResource("/course_generator/images/search.png")));

    // -- Tab - Resume
    // ------------------------------------------------------
    jPanelResume = new javax.swing.JPanel();
    jPanelResume.setLayout(new java.awt.BorderLayout());

    // -- Resume tool bar
    // ---------------------------------------------------
    Create_Resume_Toolbar();
    jPanelResume.add(ToolBarResume, java.awt.BorderLayout.NORTH);

    TableResume = new javax.swing.JTable();
    TableResume.setModel(ModelTableResume);
    TableResume.setRowHeight(20);
    TableResume.getTableHeader().setReorderingAllowed(false);

    TableResume.setAutoResizeMode(javax.swing.JTable.AUTO_RESIZE_OFF);

    TableResume.getTableHeader()
            .setDefaultRenderer(new ResumeHeaderRenderer(TableResume.getTableHeader().getDefaultRenderer()));

    // TODO Change the Renderer name. Add Resume...
    TableResume.setDefaultRenderer(ResumeNumClass.class, new ResumeNumRenderer());
    TableResume.setDefaultRenderer(ResumeNameClass.class, new ResumeNameRenderer());
    TableResume.setDefaultRenderer(ResumeLineClass.class, new ResumeLineRenderer());
    TableResume.setDefaultRenderer(ResumeElevationClass.class, new ResumeElevationRenderer());
    TableResume.setDefaultRenderer(ResumeClimbPClass.class, new ResumeClimbPRenderer());
    TableResume.setDefaultRenderer(ResumeClimbNClass.class, new ResumeClimbNRenderer());
    TableResume.setDefaultRenderer(ResumeDistanceClass.class, new ResumeDistanceRenderer());
    TableResume.setDefaultRenderer(ResumeTimeClass.class, new ResumeTimeRenderer());
    TableResume.setDefaultRenderer(ResumeHourClass.class, new ResumeHourRenderer());
    TableResume.setDefaultRenderer(ResumedtTimeClass.class, new ResumedtTimeRenderer());
    TableResume.setDefaultRenderer(ResumeTimeLimitClass.class, new ResumeTimeLimitRenderer());
    TableResume.setDefaultRenderer(ResumeStationTimeClass.class, new ResumeStationTimeRenderer());
    TableResume.setDefaultRenderer(ResumedtDistanceClass.class, new ResumedtDistanceRenderer());
    TableResume.setDefaultRenderer(ResumedtClimbPClass.class, new ResumedtClimbPRenderer());
    TableResume.setDefaultRenderer(ResumedtClimbNClass.class, new ResumedtClimbNRenderer());
    TableResume.setDefaultRenderer(ResumeSpeedPClass.class, new ResumeSpeedPRenderer());
    TableResume.setDefaultRenderer(ResumeSpeedNClass.class, new ResumeSpeedNRenderer());
    TableResume.setDefaultRenderer(ResumeAvgSlopePClass.class, new ResumeAvgSlopePRenderer());
    TableResume.setDefaultRenderer(ResumeAvgSlopeNClass.class, new ResumeAvgSlopeNRenderer());
    TableResume.setDefaultRenderer(ResumeAvgSpeedClass.class, new ResumeAvgSpeedRenderer());
    TableResume.setDefaultRenderer(ResumeCommentClass.class, new ResumeCommentRenderer());

    // TableResume.addMouseListener(new java.awt.event.MouseAdapter() {
    // public void mouseClicked(java.awt.event.MouseEvent evt) {
    // TableMainMouseClicked(evt);
    // }
    // });
    // TableResume.addKeyListener(new java.awt.event.KeyAdapter() {
    // public void keyReleased(java.awt.event.KeyEvent evt) {
    // TableMainKeyReleased(evt);
    // }
    // });

    // -- Add the grid to a scroll panel
    // ------------------------------------
    jScrollPaneResume = new javax.swing.JScrollPane();
    jScrollPaneResume.setViewportView(TableResume);
    jPanelResume.add(jScrollPaneResume, java.awt.BorderLayout.CENTER);

    addTab(TabbedPaneMain, jPanelResume, bundle.getString("frmMain.TabResume.tabTitle"),
            new javax.swing.ImageIcon(getClass().getResource("/course_generator/images/grid.png")));

    // -- Map panel
    // ---------------------------------------------------------
    jPanelMap = new javax.swing.JPanel();
    jPanelMap.setLayout(new java.awt.BorderLayout());

    Create_Map_Toolbar();
    jPanelMap.add(jToolBarMapViewer, java.awt.BorderLayout.WEST);

    MapViewer = new org.openstreetmap.gui.jmapviewer.JMapViewer();
    MapViewer.setMapMarkerVisible(true);
    MapViewer.setScrollWrapEnabled(true);
    MapViewer.setZoomButtonStyle(org.openstreetmap.gui.jmapviewer.JMapViewer.ZOOM_BUTTON_STYLE.VERTICAL);
    MapViewer.addMouseListener(new java.awt.event.MouseAdapter() {
        public void mouseClicked(java.awt.event.MouseEvent evt) {
            MapViewerMouseClicked(evt);
        }
    });
    jPanelMap.add(MapViewer, java.awt.BorderLayout.CENTER);

    jScrollPanelMap = new javax.swing.JScrollPane();
    jScrollPanelMap.setViewportView(jPanelMap);

    SplitPaneMainRight.setRightComponent(jScrollPanelMap);

    // -- Finished - Pack
    // ---------------------------------------------------
    pack();
}