Example usage for org.jfree.chart.renderer.category AbstractCategoryItemRenderer setBaseToolTipGenerator

List of usage examples for org.jfree.chart.renderer.category AbstractCategoryItemRenderer setBaseToolTipGenerator

Introduction

In this page you can find the example usage for org.jfree.chart.renderer.category AbstractCategoryItemRenderer setBaseToolTipGenerator.

Prototype

@Override
public void setBaseToolTipGenerator(CategoryToolTipGenerator generator) 

Source Link

Document

Sets the base tool tip generator and sends a RendererChangeEvent to all registered listeners.

Usage

From source file:org.openfaces.component.chart.impl.configuration.TooltipsConfigurator.java

private void setupTooltips(final GridChartView chartView, AbstractCategoryItemRenderer renderer) {
    if (chartView.getTooltip() != null) {
        renderer.setBaseToolTipGenerator(new CategoryToolTipGenerator() {
            public String generateToolTip(CategoryDataset categoryDataset, int i, int i1) {
                return chartView.getTooltip();
            }//from  www .  j  a va 2 s . co  m
        });
    } else if (chartView.getDynamicTooltip() != null) {
        renderer.setBaseToolTipGenerator(
                new DynamicCategoryGenerator(chartView, chartView.getDynamicTooltip()));
    }
}

From source file:hudson.plugins.plot.Plot.java

/**
 * Generates the plot and stores it in the plot instance variable.
 *
 * @param forceGenerate//from ww w  .  ja v a  2  s.c o m
 *            if true, force the plot to be re-generated even if the on-disk
 *            data hasn't changed
 */
private void generatePlot(boolean forceGenerate) {
    class Label implements Comparable<Label> {
        final private Integer buildNum;
        final private String buildDate;
        final private String text;

        public Label(String buildNum, String buildTime, String text) {
            this.buildNum = Integer.parseInt(buildNum);
            synchronized (DATE_FORMAT) {
                this.buildDate = DATE_FORMAT.format(new Date(Long.parseLong(buildTime)));
            }
            this.text = text;
        }

        public Label(String buildNum, String buildTime) {
            this(buildNum, buildTime, null);
        }

        public int compareTo(Label that) {
            return this.buildNum - that.buildNum;
        }

        @Override
        public boolean equals(Object o) {
            return o instanceof Label && ((Label) o).buildNum.equals(buildNum);
        }

        @Override
        public int hashCode() {
            return buildNum.hashCode();
        }

        public String numDateString() {
            return "#" + buildNum + " (" + buildDate + ")";
        }

        @Override
        public String toString() {
            return text != null ? text : numDateString();
        }
    }
    // LOGGER.info("Determining if we should generate plot " +
    // getCsvFileName());
    File csvFile = new File(project.getRootDir(), getCsvFileName());
    if (csvFile.lastModified() == csvLastModification && plot != null && !forceGenerate) {
        // data hasn't changed so don't regenerate the plot
        return;
    }
    if (rawPlotData == null || csvFile.lastModified() > csvLastModification) {
        // data has changed or has not been loaded so load it now
        loadPlotData();
    }
    // LOGGER.info("Generating plot " + getCsvFileName());
    csvLastModification = csvFile.lastModified();
    PlotCategoryDataset dataset = new PlotCategoryDataset();
    for (String[] record : rawPlotData) {
        // record: series y-value, series label, build number, build date,
        // url
        int buildNum;
        try {
            buildNum = Integer.valueOf(record[2]);
            if (!reportBuild(buildNum) || buildNum > getRightBuildNum()) {
                continue; // skip this record
            }
        } catch (NumberFormatException nfe) {
            LOGGER.log(Level.SEVERE, "Exception converting to integer", nfe);
            continue; // skip this record all together
        }
        Number value = null;
        try {
            value = Integer.valueOf(record[0]);
        } catch (NumberFormatException nfe) {
            try {
                value = Double.valueOf(record[0]);
            } catch (NumberFormatException nfe2) {
                LOGGER.log(Level.SEVERE, "Exception converting to number", nfe2);
                continue; // skip this record all together
            }
        }
        String series = record[1];
        Label xlabel = getUrlUseDescr() ? new Label(record[2], record[3], descriptionForBuild(buildNum))
                : new Label(record[2], record[3]);
        String url = null;
        if (record.length >= 5)
            url = record[4];
        dataset.setValue(value, url, series, xlabel);
    }

    String urlNumBuilds = getURLNumBuilds();
    int numBuilds;
    if (StringUtils.isBlank(urlNumBuilds)) {
        numBuilds = Integer.MAX_VALUE;
    } else {
        try {
            numBuilds = Integer.parseInt(urlNumBuilds);
        } catch (NumberFormatException nfe) {
            LOGGER.log(Level.SEVERE, "Exception converting to integer", nfe);
            numBuilds = Integer.MAX_VALUE;
        }
    }

    dataset.clipDataset(numBuilds);
    plot = createChart(dataset);
    CategoryPlot categoryPlot = (CategoryPlot) plot.getPlot();
    categoryPlot.setDomainGridlinePaint(Color.black);
    categoryPlot.setRangeGridlinePaint(Color.black);
    categoryPlot.setDrawingSupplier(Plot.supplier);
    CategoryAxis domainAxis = new ShiftedCategoryAxis(Messages.Plot_Build());
    categoryPlot.setDomainAxis(domainAxis);
    domainAxis.setCategoryLabelPositions(CategoryLabelPositions.UP_90);
    domainAxis.setLowerMargin(0.0);
    domainAxis.setUpperMargin(0.03);
    domainAxis.setCategoryMargin(0.0);
    for (Object category : dataset.getColumnKeys()) {
        Label label = (Label) category;
        if (label.text != null) {
            domainAxis.addCategoryLabelToolTip(label, label.numDateString());
        } else {
            domainAxis.addCategoryLabelToolTip(label, descriptionForBuild(label.buildNum));
        }
    }
    // Replace the range axis by a logarithmic axis if the option is
    // selected
    if (isLogarithmic()) {
        LogarithmicAxis logAxis = new LogarithmicAxis(getYaxis());
        logAxis.setExpTickLabelsFlag(true);
        categoryPlot.setRangeAxis(logAxis);
    }

    // optionally exclude zero as default y-axis value
    ValueAxis rangeAxis = categoryPlot.getRangeAxis();
    if ((rangeAxis != null) && (rangeAxis instanceof NumberAxis)) {
        if (hasYaxisMinimum()) {
            ((NumberAxis) rangeAxis).setLowerBound(getYaxisMinimum());
        }
        if (hasYaxisMaximum()) {
            ((NumberAxis) rangeAxis).setUpperBound(getYaxisMaximum());
        }
        ((NumberAxis) rangeAxis).setAutoRangeIncludesZero(!getExclZero());
    }

    AbstractCategoryItemRenderer renderer = (AbstractCategoryItemRenderer) categoryPlot.getRenderer();
    int numColors = dataset.getRowCount();
    for (int i = 0; i < numColors; i++) {
        renderer.setSeriesPaint(i, new Color(Color.HSBtoRGB((1f / numColors) * i, 1f, 1f)));
    }
    renderer.setBaseStroke(new BasicStroke(2.0f));
    renderer.setBaseToolTipGenerator(new StandardCategoryToolTipGenerator(Messages.Plot_Build() + " {1}: {2}",
            NumberFormat.getInstance()));
    renderer.setBaseItemURLGenerator(new PointURLGenerator());
    if (renderer instanceof LineAndShapeRenderer) {
        String s = getUrlStyle();
        LineAndShapeRenderer lasRenderer = (LineAndShapeRenderer) renderer;
        if ("lineSimple".equalsIgnoreCase(s)) {
            lasRenderer.setShapesVisible(false); // TODO: deprecated, may be unnecessary
        } else {
            lasRenderer.setShapesVisible(true); // TODO: deprecated, may be unnecessary
        }
    }
}

From source file:com.naryx.tagfusion.cfm.tag.awt.cfCHART.java

private CategoryPlot getCategoryPlot(List<cfCHARTSERIESData> series, String xAxisTitle, String yAxisTitle,
        String labelFormat, boolean bShowMarkers, int markerSize, boolean bShow3D, String tipStyle,
        String drillDownUrl, int xOffset, int yOffset, int yAxisUnits, String seriesPlacement,
        boolean bSortXAxis, int height, String[] yAxisSymbols, int gridLines) throws cfmRunTimeException {
    // Create a category plot
    CategoryPlot plot = new CategoryPlot();

    // Set the domain axis (the x-axis)
    org.jfree.chart.axis.CategoryAxis categoryAxis;
    if (bShow3D)//w w w .j  a va2 s . c  om
        categoryAxis = new CategoryAxis3D(xAxisTitle);
    else
        categoryAxis = new CategoryAxis(xAxisTitle);
    plot.setDomainAxis(categoryAxis);

    // Set the range axis (the y-axis)
    ValueAxis valueAxis;
    DateFormat dateFormat = null;
    NumberFormat numberFormat = null;

    // Ignore a label format of date if the y-axis is using symbols
    if (labelFormat.equals("date") && (yAxisSymbols == null)) {
        valueAxis = new DateAxis(yAxisTitle);
        dateFormat = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
        ((DateAxis) valueAxis).setDateFormatOverride(dateFormat);
    } else {
        if (yAxisSymbols != null) {
            valueAxis = new SymbolAxis(yAxisTitle, yAxisSymbols);
            ((SymbolAxis) valueAxis).setGridBandsVisible(false);
            ((SymbolAxis) valueAxis).setAutoRangeStickyZero(true);
        } else if (bShow3D) {
            valueAxis = new NumberAxis3D(yAxisTitle);
        } else {
            valueAxis = new NumberAxis(yAxisTitle);
        }

        if (labelFormat.equals("currency")) {
            ((NumberAxis) valueAxis).setNumberFormatOverride(NumberFormat.getCurrencyInstance());
            numberFormat = NumberFormat.getCurrencyInstance();
        } else if (labelFormat.equals("percent")) {
            numberFormat = NumberFormat.getPercentInstance();
            numberFormat.setMaximumFractionDigits(3); // without this change .11443
                                                      // would be displayed as 11%
                                                      // instead of 11.443%
            ((NumberAxis) valueAxis).setNumberFormatOverride(numberFormat);
        } else {
            numberFormat = NumberFormat.getInstance();
        }

        if (yAxisUnits != 0)
            ((NumberAxis) valueAxis).setTickUnit(new NumberTickUnit(yAxisUnits));
    }
    plot.setRangeAxis(valueAxis);

    // Add a dataset and renderer for each series
    int barChartDatasetIndex = -1;
    int hBarChartDatasetIndex = -1;
    int num = 0;
    MinMaxData minMax = new MinMaxData();
    for (int i = 0; i < series.size(); i++) {
        cfCHARTSERIESData seriesData = series.get(i);

        // If the sortXAxis attribute was set to "yes" then sort the data.
        // NOTE: this attribute is only used with category charts.
        if (bSortXAxis)
            seriesData.sort();

        DefaultCategoryDataset dataset;
        if ((barChartDatasetIndex != -1) && (seriesData.getType().equals("bar"))) {
            dataset = (DefaultCategoryDataset) plot.getDataset(barChartDatasetIndex);

            addSeriesDataToDataset(seriesData, dataset, minMax);

            // Set the paint style for this series
            setPaintStyle(seriesData.getPaintStyle(), plot.getRenderer(barChartDatasetIndex),
                    dataset.getRowCount() - 1, height);

            // Add the color list for this series to the custom color renderer
            CustomColorRenderer cr = (CustomColorRenderer) plot.getRenderer(barChartDatasetIndex);
            cr.addColors(getColorList(seriesData));

            continue;
        } else if ((hBarChartDatasetIndex != -1) && (seriesData.getType().equals("horizontalbar"))) {
            dataset = (DefaultCategoryDataset) plot.getDataset(hBarChartDatasetIndex);

            addSeriesDataToDataset(seriesData, dataset, minMax);

            // Set the paint style for this series
            setPaintStyle(seriesData.getPaintStyle(), plot.getRenderer(hBarChartDatasetIndex),
                    dataset.getRowCount() - 1, height);

            // Add the color list for this series to the custom color renderer
            CustomColorRenderer cr = (CustomColorRenderer) plot.getRenderer(hBarChartDatasetIndex);
            cr.addColors(getColorList(seriesData));

            continue;
        } else {
            dataset = new DefaultCategoryDataset();

            addSeriesDataToDataset(seriesData, dataset, minMax);
        }

        plot.setDataset(num, dataset);

        AbstractCategoryItemRenderer renderer = null;
        if (seriesData.getType().equals("bar")) {
            plot.setOrientation(PlotOrientation.VERTICAL);
            renderer = getBarRenderer(seriesPlacement, bShow3D, xOffset, yOffset, getColorList(seriesData));
            ItemLabelPosition position1 = new ItemLabelPosition(ItemLabelAnchor.OUTSIDE12,
                    TextAnchor.BOTTOM_CENTER);
            renderer.setPositiveItemLabelPosition(position1);
            ItemLabelPosition position2 = new ItemLabelPosition(ItemLabelAnchor.OUTSIDE6,
                    TextAnchor.TOP_CENTER);
            renderer.setNegativeItemLabelPosition(position2);
            ((BarRenderer) renderer).setItemMargin(0.0); // The margin between items
                                                         // in the same category
            categoryAxis.setCategoryMargin(0.2); // The margin between each category

            barChartDatasetIndex = num;
        } else if (seriesData.getType().equals("horizontalbar")) {
            plot.setOrientation(PlotOrientation.HORIZONTAL);
            plot.setRangeAxisLocation(AxisLocation.BOTTOM_OR_LEFT);
            renderer = getBarRenderer(seriesPlacement, bShow3D, xOffset, yOffset, getColorList(seriesData));
            if (bShow3D) {
                // change rendering order to ensure that bar overlapping is the
                // right way around
                plot.setRowRenderingOrder(org.jfree.util.SortOrder.DESCENDING);
                plot.setColumnRenderingOrder(org.jfree.util.SortOrder.DESCENDING);
            }
            ItemLabelPosition position1 = new ItemLabelPosition(ItemLabelAnchor.OUTSIDE3,
                    TextAnchor.CENTER_LEFT);
            renderer.setPositiveItemLabelPosition(position1);
            ItemLabelPosition position2 = new ItemLabelPosition(ItemLabelAnchor.OUTSIDE9,
                    TextAnchor.CENTER_RIGHT);
            renderer.setNegativeItemLabelPosition(position2);
            ((BarRenderer) renderer).setItemMargin(0.0); // The margin between items
                                                         // in the same category
            categoryAxis.setCategoryMargin(0.2); // The margin between each category

            hBarChartDatasetIndex = num;
        } else if (seriesData.getType().equals("line")) {
            if (bShow3D) {
                renderer = new LineRenderer3D();
                ((LineRenderer3D) renderer).setXOffset(xOffset);
                ((LineRenderer3D) renderer).setYOffset(yOffset);
            } else {
                renderer = new LineAndShapeRenderer(true, false);
            }

            // Enable/Disable displaying of markers
            ((LineAndShapeRenderer) renderer).setShapesVisible(bShowMarkers);

            // Set the shape of the markers based on the markerSize value
            ((LineAndShapeRenderer) renderer).setShape(getMarker(seriesData.getMarkerStyle(), markerSize));
        } else if (seriesData.getType().equals("area")) {
            if (seriesPlacement.equals("stacked"))
                renderer = new StackedAreaRenderer(); // this doesn't work for some
                                                      // reason
            else
                renderer = new AreaRenderer();

            // Truncate the first and last values to match CFMX 7
            ((AreaRenderer) renderer).setEndType(AreaRendererEndType.TRUNCATE);

            categoryAxis.setCategoryMargin(0.0);
        } else if (seriesData.getType().equals("step")) {
            renderer = new CategoryStepRenderer(true);
        } else if (seriesData.getType().equals("scatter")) {
            renderer = new LineAndShapeRenderer(false, true);

            // Set the shape of the markers based on the markerSize value
            ((LineAndShapeRenderer) renderer).setShape(getMarker(seriesData.getMarkerStyle(), markerSize));
        }

        if (!tipStyle.equals("none")) {
            if (dateFormat != null)
                renderer.setBaseToolTipGenerator(
                        new StandardCategoryToolTipGenerator("({0}, {1}) = {2}", dateFormat));
            else
                renderer.setBaseToolTipGenerator(
                        new StandardCategoryToolTipGenerator("({0}, {1}) = {2}", numberFormat));
        }

        if (drillDownUrl != null) {
            if (dateFormat != null)
                renderer.setBaseItemURLGenerator(
                        new com.newatlanta.bluedragon.CategoryURLGenerator(drillDownUrl, dateFormat));
            else
                renderer.setBaseItemURLGenerator(
                        new com.newatlanta.bluedragon.CategoryURLGenerator(drillDownUrl, numberFormat));
        }

        if (seriesData.getSeriesColor() != null)
            renderer.setSeriesPaint(0, convertStringToColor(seriesData.getSeriesColor()));

        String dataLabelStyle = seriesData.getDataLabelStyle();
        if (labelFormat.equals("date")) {
            if (dataLabelStyle.equals("none")) {
                renderer.setItemLabelsVisible(false);
            } else {
                setCategoryItemLabelsData(renderer, seriesData);
                if (dataLabelStyle.equals("value"))
                    renderer.setItemLabelGenerator(
                            new CategoryItemLabelGenerator("{2}", dateFormat, yAxisSymbols));
                else if (dataLabelStyle.equals("rowlabel"))
                    renderer.setItemLabelGenerator(
                            new CategoryItemLabelGenerator("{0}", dateFormat, yAxisSymbols));
                else if (dataLabelStyle.equals("columnlabel"))
                    renderer.setItemLabelGenerator(
                            new CategoryItemLabelGenerator("{1}", dateFormat, yAxisSymbols));
                else if (dataLabelStyle.equals("pattern"))
                    renderer.setItemLabelGenerator(
                            new CategoryItemLabelGenerator("{1} {2}", dateFormat, yAxisSymbols));
                else
                    renderer.setItemLabelGenerator(
                            new CategoryItemLabelGenerator(dataLabelStyle, dateFormat, yAxisSymbols));
            }
        } else {
            if (dataLabelStyle.equals("none")) {
                renderer.setItemLabelsVisible(false);
            } else {
                setCategoryItemLabelsData(renderer, seriesData);
                if (dataLabelStyle.equals("value"))
                    renderer.setItemLabelGenerator(
                            new CategoryItemLabelGenerator("{2}", numberFormat, yAxisSymbols));
                else if (dataLabelStyle.equals("rowlabel"))
                    renderer.setItemLabelGenerator(
                            new CategoryItemLabelGenerator("{0}", numberFormat, yAxisSymbols));
                else if (dataLabelStyle.equals("columnlabel"))
                    renderer.setItemLabelGenerator(
                            new CategoryItemLabelGenerator("{1}", numberFormat, yAxisSymbols));
                else if (dataLabelStyle.equals("pattern"))
                    renderer.setItemLabelGenerator(
                            new CategoryItemLabelGenerator("{1} {2} ({3} of {4})", numberFormat, yAxisSymbols));
                else
                    renderer.setItemLabelGenerator(
                            new CategoryItemLabelGenerator(dataLabelStyle, numberFormat, yAxisSymbols));
            }
        }

        // Add the renderer to the plot.
        // NOTE: this must be done before the setPaintStyle() call so the
        // DrawingSupplier object
        // will be set up properly for the generation of default colors.
        plot.setRenderer(num, renderer);

        // Set the paint style for this series (series 0)
        if (seriesData.getType().equals("bar") || seriesData.getType().equals("horizontalbar")
                || seriesData.getType().equals("area"))
            setPaintStyle(seriesData.getPaintStyle(), renderer, 0, height);

        num++;
    }

    // If gridLines was specified then we need to calculate the yAxisUnits
    if ((gridLines != -1) && (valueAxis instanceof NumberAxis)) {
        // Calculate the yAxisUnits we need to use to create the number of
        // gridLines
        yAxisUnits = calculateYAxisUnits(gridLines, minMax);

        // Set the yAxisUnits
        ((NumberAxis) valueAxis).setTickUnit(new NumberTickUnit(yAxisUnits));
    }

    return plot;
}