Example usage for org.jfree.chart.plot XYPlot setRenderer

List of usage examples for org.jfree.chart.plot XYPlot setRenderer

Introduction

In this page you can find the example usage for org.jfree.chart.plot XYPlot setRenderer.

Prototype

public void setRenderer(int index, XYItemRenderer renderer) 

Source Link

Document

Sets the renderer for the dataset with the specified index and sends a change event to all registered listeners.

Usage

From source file:netplot.GenericPlotPanel.java

void genericConfig(JFreeChart chart, XYPlot plot, int plotIndex) {
    if (!enableLegend) {
        chart.removeLegend();//from  www.  j  a v  a  2s  . co m
    }

    XYItemRenderer xyItemRenderer = plot.getRenderer();
    //May also be XYBarRenderer
    if (xyItemRenderer instanceof XYLineAndShapeRenderer) {
        XYToolTipGenerator xyToolTipGenerator = xyItemRenderer.getBaseToolTipGenerator();
        //If currently an XYLineAndShapeRenderer replace it so that we inc the colour for every plotIndex
        XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer(linesEnabled, shapesEnabled);
        //Ensure we don't loose the tool tips on the new renderer
        renderer.setBaseToolTipGenerator(xyToolTipGenerator);
        renderer.setBasePaint(getPlotColour(plotIndex));
        renderer.setSeriesStroke(0, new BasicStroke(lineWidth, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL),
                true);
        plot.setRenderer(plotIndex, renderer);
    }

    //If we have a new y axis then we need a new data set
    if (yAxisName != null && yAxisName.length() > 0) {
        if (logYAxis) {
            LogAxis yAxis = new LogAxis(yAxisName);
            yAxis.setAutoRange(false);
            yAxis.setNumberFormatOverride(new LogFormat(10, "10", true));
            yAxis.setRange(minScaleValue, maxScaleValue);
            yAxis.setLowerBound(minScaleValue);
            yAxis.setUpperBound(maxScaleValue);
            plot.setRangeAxis(yAxisIndex, yAxis);
            plot.setRangeAxisLocation(yAxisIndex, AxisLocation.BOTTOM_OR_LEFT);
        } else {
            NumberAxis axis = new NumberAxis(yAxisName);
            axis.setAutoRangeIncludesZero(zeroOnYScale);
            if (autoScaleEnabled) {
                axis.setAutoRange(true);
            } else {
                Range range = new Range(minScaleValue, maxScaleValue);
                axis.setRangeWithMargins(range, true, true);
            }
            if (yAxisTickCount > 0) {
                NumberTickUnit tick = new NumberTickUnit(yAxisTickCount);
                axis.setTickUnit(tick);
            }
            plot.setRangeAxis(yAxisIndex, axis);
            plot.setRangeAxisLocation(yAxisIndex, AxisLocation.BOTTOM_OR_LEFT);
        }
        yAxisIndex++;
    }
    plot.mapDatasetToRangeAxis(plotIndex, yAxisIndex - 1);
    ValueAxis a = plot.getDomainAxis();
    if (xAxisName.length() > 0) {
        a.setLabel(xAxisName);
    }
    //We can enable/disable zero on the axis if we have a NumberAxis
    if (a instanceof NumberAxis) {
        ((NumberAxis) a).setAutoRangeIncludesZero(zeroOnXScale);
    }
}

From source file:org.jfree.chart.demo.CompassFormatDemo.java

/**
 * Creates a sample chart.//from w w  w. j a  va  2s  .  co  m
 * 
 * @return a sample chart.
 */
private JFreeChart createChart() {
    final XYDataset direction = createDirectionDataset(600);
    final JFreeChart chart = ChartFactory.createTimeSeriesChart("Time", "Date", "Direction", direction, true,
            true, false);

    final XYPlot plot = chart.getXYPlot();
    plot.getDomainAxis().setLowerMargin(0.0);
    plot.getDomainAxis().setUpperMargin(0.0);

    // configure the range axis to display directions...
    final NumberAxis rangeAxis = (NumberAxis) plot.getRangeAxis();
    rangeAxis.setAutoRangeIncludesZero(false);
    final TickUnits units = new TickUnits();
    units.add(new NumberTickUnit(180.0, new CompassFormat()));
    units.add(new NumberTickUnit(90.0, new CompassFormat()));
    units.add(new NumberTickUnit(45.0, new CompassFormat()));
    units.add(new NumberTickUnit(22.5, new CompassFormat()));
    rangeAxis.setStandardTickUnits(units);

    // add the wind force with a secondary dataset/renderer/axis
    plot.setRangeAxis(rangeAxis);
    final XYItemRenderer renderer2 = new XYAreaRenderer();
    final ValueAxis axis2 = new NumberAxis("Force");
    axis2.setRange(0.0, 12.0);
    renderer2.setSeriesPaint(0, new Color(0, 0, 255, 128));
    plot.setDataset(1, createForceDataset(600));
    plot.setRenderer(1, renderer2);
    plot.setRangeAxis(1, axis2);
    plot.mapDatasetToRangeAxis(1, 1);

    return chart;
}

From source file:ca.nengo.plot.impl.DefaultPlotter.java

/**
 * @see ca.nengo.plot.Plotter#doPlot(java.util.List, java.util.List, java.lang.String)
 *///from  w  w  w.j av  a  2 s .c  o m
public void doPlot(List<TimeSeries> series, List<SpikePattern> patterns, String title) {
    JFreeChart chart = ChartFactory.createXYLineChart(title, "Time (s)", "", null, PlotOrientation.VERTICAL,
            true, false, false);
    XYPlot plot = (XYPlot) chart.getPlot();

    //we will change the legend to show one item per series/pattern (rather than dimension/neuron)
    LegendItemCollection revisedItems = new LegendItemCollection();
    int legendItemIndex = 0;

    int i = 0;
    for (; series != null && i < series.size(); i++) {
        plot.setDataset(i, getDataset(series.get(i)));
        XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer(true, false);
        renderer.setDrawSeriesLineAsPath(true);
        renderer.setPaint(getColor(i));
        plot.setRenderer(i, renderer);

        String seriesName = series.get(i).getName();
        if (seriesName == null)
            seriesName = "Time Series " + i;

        revisedItems.add(getCopy(plot.getLegendItems().get(legendItemIndex), seriesName));
        legendItemIndex += series.get(i).getDimension();
    }

    for (int j = 0; patterns != null && j < patterns.size(); j++) {
        int index = i + j;
        plot.setDataset(index, getDataset(patterns.get(j)));
        XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer(true, false);
        configSpikeRenderer(renderer);
        renderer.setPaint(getColor(j));
        plot.setRenderer(index, renderer);

        revisedItems.add(getCopy(plot.getLegendItems().get(legendItemIndex), "Spike Pattern " + j));
        legendItemIndex += patterns.get(j).getNumNeurons();
    }

    plot.setFixedLegendItems(revisedItems);
    showChart(chart, title);
}

From source file:com.hazelcast.monitor.server.MChartGenerator.java

@Override
protected void afterPlot(List<? super InstanceStatistics> list, JFreeChart chart, XYPlot plot) {
    NumberAxis sizeAxis = (NumberAxis) plot.getRangeAxis(0);
    Font labelFont = sizeAxis.getLabelFont();
    Paint labelPaint = sizeAxis.getLabelPaint();
    TimeSeries tm = new TimeSeries("memory");
    for (int i = 0; i < list.size(); i++) {
        double memory = 0;
        MapStatistics mapStatistics = (MapStatistics) list.get(i);
        for (MapStatistics.LocalMapStatistics localMapStatistics : mapStatistics.getListOfLocalStats()) {
            memory = memory + localMapStatistics.ownedEntryMemoryCost + localMapStatistics.backupEntryMemoryCost
                    + localMapStatistics.markedAsRemovedMemoryCost;
        }//from w w w.j  a v a 2  s.c  o  m
        double mem = new Double(memory / (double) (1024 * 1024));
        tm.addOrUpdate(new Second(((MapStatistics) list.get(i)).getCreatedDate()), mem);
    }
    NumberAxis memoryAxis = new NumberAxis("memory (MB)");
    memoryAxis.setAutoRange(true);
    memoryAxis.setAutoRangeIncludesZero(false);
    plot.setDataset(1, new TimeSeriesCollection(tm));
    plot.setRangeAxis(1, memoryAxis);
    plot.mapDatasetToRangeAxis(1, 1);
    plot.setRenderer(1, new StandardXYItemRenderer());
    plot.setDatasetRenderingOrder(DatasetRenderingOrder.FORWARD);
    increaseRange(memoryAxis);
    memoryAxis.setLabelFont(labelFont);
    memoryAxis.setLabelPaint(labelPaint);
}

From source file:se.six.jmeter.visualizer.statagg.StatAggVisualizer.java

private JFreeChart createChart() {
    setupDatasets();/* w  w w  .j a v a 2s.co m*/

    final JFreeChart chart = ChartFactory.createTimeSeriesChart(null, "Time", "ThroughPut", _dataSet1, true,
            true, false);
    final XYPlot plot = chart.getXYPlot();
    plot.setBackgroundPaint(Color.lightGray);
    plot.setDomainGridlinePaint(Color.white);
    plot.setRangeGridlinePaint(Color.white);
    plot.setAxisOffset(new RectangleInsets(5D, 5D, 5D, 5D));

    ValueAxis axis = plot.getDomainAxis();
    axis.setAutoRange(true);
    //axis.setFixedAutoRange(12 * 3600 * 1000);  // 12 Hours

    XYItemRenderer renderer1 = plot.getRenderer();
    renderer1.setSeriesPaint(0, Color.BLACK);

    final NumberAxis axis2 = new NumberAxis("Response Time");
    axis2.setAutoRangeIncludesZero(false);
    plot.setRangeAxis(1, axis2);
    plot.setDataset(1, _dataSet2);
    plot.mapDatasetToRangeAxis(1, 1);

    StandardXYItemRenderer renderer2 = new StandardXYItemRenderer();
    renderer2.setSeriesPaint(0, new Color(0, 153, 255));
    plot.setRenderer(1, renderer2);

    chart.setBackgroundPaint(Color.white);

    return chart;
}

From source file:msi.gama.outputs.layers.charts.ChartJFreeChartOutputHeatmap.java

@Override
protected void createNewSerie(final IScope scope, final String serieid) {

    final ChartDataSeries dataserie = chartdataset.getDataSeries(scope, serieid);
    final MatrixSeries serie = new MatrixSeries((String) dataserie.getSerieLegend(scope),
            Math.max(1, this.getChartdataset().getYSeriesValues().size()),
            Math.max(1, this.getChartdataset().getXSeriesValues().size()));
    final XYPlot plot = (XYPlot) this.chart.getPlot();

    final MatrixSeriesCollection firstdataset = (MatrixSeriesCollection) plot.getDataset();

    if (!IdPosition.containsKey(serieid)) {

        if (firstdataset.getSeriesCount() == 0) {
            firstdataset.addSeries(serie);
            plot.setDataset(0, firstdataset);

        } else {//from w w  w .  java2 s.  com

            final MatrixSeriesCollection newdataset = new MatrixSeriesCollection();
            newdataset.addSeries(serie);
            jfreedataset.add(newdataset);
            plot.setDataset(jfreedataset.size() - 1, newdataset);

        }
        plot.setRenderer(jfreedataset.size() - 1, (XYItemRenderer) getOrCreateRenderer(scope, serieid));
        IdPosition.put(serieid, jfreedataset.size() - 1);
        // DEBUG.LOG("new serie"+serieid+" at
        // "+IdPosition.get(serieid)+" fdsize "+plot.getSeriesCount()+" jfds
        // "+jfreedataset.size()+" datasc "+plot.getDatasetCount());
        // TODO Auto-generated method stub

    }
}

From source file:umontreal.iro.lecuyer.charts.ScatterChart.java

/**
 * Displays chart on the screen using Swing.
 *    This method creates an application containing a chart panel displaying
 *    the chart. The created frame is positioned on-screen, and displayed before
 *    it is returned. The <TT>width</TT> and the <TT>height</TT>
 *    of the chart are measured in pixels.
 * //  w w  w.  j  a  v  a 2 s .c o m
 * @param width frame width in pixels.
 * 
 *    @param height frame height in pixels.
 * 
 *    @return frame containing the chart.;
 * 
 */
public JFrame view(int width, int height) {
    JFrame myFrame;
    if (chart.getTitle() != null)
        myFrame = new JFrame("ScatterChart from SSJ: " + chart.getTitle().getText());
    else
        myFrame = new JFrame("ScatterChart from SSJ");
    XYPlot plot = chart.getXYPlot();

    /*    // The drawn points are somewhat big, of different shapes, unfilled
          XYLineAndShapeRenderer shape = new XYLineAndShapeRenderer(false, true);
          int nb = getSeriesCollection().getSeriesCollection().getSeriesCount();
          for (int i = 0 ; i < nb ; i++) {
             shape.setSeriesShapesFilled(i, false);
             plot.setRenderer(i, shape);
          }
    */
    // The drawn points are all square, filled
    XYDotRenderer shape = new XYDotRenderer();
    final int dotSize = 3;
    shape.setDotWidth(dotSize);
    shape.setDotHeight(dotSize);
    int nb = getSeriesCollection().getSeriesCollection().getSeriesCount();
    for (int i = 0; i < nb; i++)
        plot.setRenderer(i, shape);

    ChartPanel chartPanel = new ChartPanel(chart);
    chartPanel.setPreferredSize(new java.awt.Dimension(width, height));
    myFrame.setContentPane(chartPanel);
    myFrame.pack();
    myFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    myFrame.setLocationRelativeTo(null);
    myFrame.setVisible(true);
    return myFrame;
}

From source file:de.uka.aifb.com.systemDynamics.gui.ModelExecutionChartPanel.java

/**
 * Creates panel.//from ww w  . j a  va 2 s .c  om
 */
private void createPanel() {
    setLayout(new BorderLayout());

    // CENTER: chart
    ChartPanel chartPanel = new ChartPanel(createChart());
    // no context menu
    chartPanel.setPopupMenu(null);
    // not zoomable
    chartPanel.setMouseZoomable(false);
    add(chartPanel, BorderLayout.CENTER);

    // LINE_END: series table
    JPanel tablePanel = new JPanel(new GridBagLayout());
    String[] columnNames = { messages.getString("ModelExecutionChartPanel.Table.ColumnNames.ExtraAxis"),
            messages.getString("ModelExecutionChartPanel.Table.ColumnNames.LevelNode") };
    final MyTableModel tableModel = new MyTableModel(columnNames, xySeriesArray.length);
    for (int i = 0; i < xySeriesArray.length; i++) {
        tableModel.addEntry((String) xySeriesArray[i].getKey());
    }
    JTable table = new JTable(tableModel);
    table.setRowSelectionAllowed(false);
    JScrollPane tableScrollPane = new JScrollPane(table);
    int width = (int) Math.min(300, table.getPreferredSize().getWidth());
    int height = (int) Math.min(200, table.getPreferredSize().getHeight());
    tableScrollPane.getViewport().setPreferredSize(new Dimension(width, height));
    tableScrollPane.setMaximumSize(tableScrollPane.getViewport().getPreferredSize());
    axesButton = new JButton(messages.getString("ModelExecutionChartPanel.AxesButton.Text"));
    axesButton.setToolTipText(messages.getString("ModelExecutionChartPanel.AxesButton.ToolTipText"));
    axesButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            // create XYSeriesCollections (and renderer)
            XYSeriesCollection standardData = new XYSeriesCollection();
            XYLineAndShapeRenderer standardRenderer = new XYLineAndShapeRenderer(true, false);
            LinkedList<XYSeriesCollection> extraDataList = new LinkedList<XYSeriesCollection>();
            LinkedList<XYLineAndShapeRenderer> extraRendererList = new LinkedList<XYLineAndShapeRenderer>();
            for (int i = 0; i < tableModel.getRowCount(); i++) {
                if (tableModel.getValueAt(i, 0).equals(Boolean.FALSE)) {
                    standardData.addSeries(xySeriesArray[i]);
                    standardRenderer.setSeriesPaint(standardData.getSeriesCount() - 1,
                            DefaultDrawingSupplier.DEFAULT_PAINT_SEQUENCE[i
                                    % DefaultDrawingSupplier.DEFAULT_PAINT_SEQUENCE.length]);
                } else {
                    // extra axis
                    XYSeriesCollection extraData = new XYSeriesCollection();
                    extraData.addSeries(xySeriesArray[i]);
                    extraDataList.add(extraData);
                    XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer(true, false);
                    extraRendererList.add(renderer);
                    renderer.setSeriesPaint(0, DefaultDrawingSupplier.DEFAULT_PAINT_SEQUENCE[i
                            % DefaultDrawingSupplier.DEFAULT_PAINT_SEQUENCE.length]);
                }
            }
            LinkedList<XYSeriesCollection> dataList = new LinkedList<XYSeriesCollection>();
            LinkedList<XYLineAndShapeRenderer> rendererList = new LinkedList<XYLineAndShapeRenderer>();
            if (!standardData.getSeries().isEmpty()) {
                dataList.add(standardData);
                rendererList.add(standardRenderer);
            }
            for (XYSeriesCollection data : extraDataList) {
                dataList.add(data);
            }
            for (XYLineAndShapeRenderer renderer : extraRendererList) {
                rendererList.add(renderer);
            }

            // creates axes
            LinkedList<NumberAxis> axesList = new LinkedList<NumberAxis>();
            if (!standardData.getSeries().isEmpty()) {
                NumberAxis axis = new NumberAxis(messages.getString("ModelExecutionChartPanel.Value"));
                axis.setNumberFormatOverride(NumberFormat.getInstance(locale));
                axesList.add(axis);
            }
            for (XYSeriesCollection data : extraDataList) {
                NumberAxis axis = new NumberAxis((String) data.getSeries(0).getKey());
                axis.setNumberFormatOverride(NumberFormat.getInstance(locale));
                axesList.add(axis);
            }

            // store data and axes in plot
            XYPlot plot = chart.getXYPlot();
            plot.clearRangeAxes();
            plot.setRangeAxes(axesList.toArray(new NumberAxis[0]));
            for (int i = 0; i < plot.getDatasetCount(); i++) {
                plot.setDataset(i, null);
            }
            int datasetIndex = 0;
            Iterator<XYSeriesCollection> datasetIterator = dataList.iterator();
            Iterator<XYLineAndShapeRenderer> rendererIterator = rendererList.iterator();
            while (datasetIterator.hasNext()) {
                plot.setDataset(datasetIndex, datasetIterator.next());
                plot.setRenderer(datasetIndex, rendererIterator.next());
                datasetIndex++;
            }
            for (int i = 0; i < plot.getDatasetCount(); i++) {
                plot.mapDatasetToRangeAxis(i, i);
            }
        }
    });
    GridBagConstraints c = new GridBagConstraints();
    c.anchor = GridBagConstraints.CENTER;
    c.gridx = 0;
    c.gridy = 0;
    c.insets = new Insets(0, 0, 10, 0);
    tablePanel.add(tableScrollPane, c);
    c.gridx = 0;
    c.gridy = 1;
    tablePanel.add(axesButton, c);
    add(tablePanel, BorderLayout.LINE_END);

    // PAGE_END: number of rounds and execution button
    JPanel commandPanel = new JPanel();
    commandPanel.add(new JLabel(messages.getString("ModelExecutionChartPanel.NumberRounds")));
    final JTextField numberRoundsField = new JTextField("1", 5);
    numberRoundsField.addFocusListener(this);
    commandPanel.add(numberRoundsField);
    executionButton = new JButton(messages.getString("ModelExecutionChartPanel.ExecutionButton.Text"));
    executionButton.setToolTipText(messages.getString("ModelExecutionChartPanel.ExecutionButton.ToolTipText"));
    executionButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            int numberRounds = 0;
            boolean correctNumber = false;
            try {
                numberRounds = integerNumberFormatter.parse(numberRoundsField.getText()).intValue();
            } catch (ParseException parseExcep) {
                // do nothing
            }

            if (numberRounds >= 1) {
                correctNumber = true;
            }

            if (correctNumber) {
                ModelExecutionThread executionThread = new ModelExecutionThread(numberRounds);
                executionThread.start();
            } else {
                JOptionPane.showMessageDialog(null,
                        messages.getString("ModelExecutionChartPanel.Error.Message"),
                        messages.getString("ModelExecutionChartPanel.Error.Title"), JOptionPane.ERROR_MESSAGE);
            }
        }
    });
    commandPanel.add(executionButton);
    add(commandPanel, BorderLayout.PAGE_END);
}

From source file:org.jfree.chart.demo.MultipleAxisDemo1.java

/**
 * Creates the demo chart.//  w w  w.  j  a  v a 2  s. c  o  m
 * 
 * @return The chart.
 */
private JFreeChart createChart() {

    final XYDataset dataset1 = createDataset("Series 1", 100.0, new Minute(), 200);

    final JFreeChart chart = ChartFactory.createTimeSeriesChart("Multiple Axis Demo 1", "Time of Day",
            "Primary Range Axis", dataset1, true, true, false);

    chart.setBackgroundPaint(Color.white);
    chart.addSubtitle(new TextTitle("Four datasets and four range axes."));
    final XYPlot plot = chart.getXYPlot();
    plot.setOrientation(PlotOrientation.VERTICAL);
    plot.setBackgroundPaint(Color.lightGray);
    plot.setDomainGridlinePaint(Color.white);
    plot.setRangeGridlinePaint(Color.white);

    //        plot.setAxisOffset(new Spacer(Spacer.ABSOLUTE, 5.0, 5.0, 5.0, 5.0));

    final StandardXYItemRenderer renderer = (StandardXYItemRenderer) plot.getRenderer();
    renderer.setPaint(Color.black);

    // AXIS 2
    final NumberAxis axis2 = new NumberAxis("Range Axis 2");
    axis2.setAutoRangeIncludesZero(false);
    axis2.setLabelPaint(Color.red);
    axis2.setTickLabelPaint(Color.red);
    plot.setRangeAxis(1, axis2);
    plot.setRangeAxisLocation(1, AxisLocation.BOTTOM_OR_LEFT);

    final XYDataset dataset2 = createDataset("Series 2", 1000.0, new Minute(), 170);
    plot.setDataset(1, dataset2);
    plot.mapDatasetToRangeAxis(1, 1);
    XYItemRenderer renderer2 = new StandardXYItemRenderer();
    renderer2.setSeriesPaint(0, Color.red);
    plot.setRenderer(1, renderer2);

    // AXIS 3
    final NumberAxis axis3 = new NumberAxis("Range Axis 3");
    axis3.setLabelPaint(Color.blue);
    axis3.setTickLabelPaint(Color.blue);
    plot.setRangeAxis(2, axis3);

    final XYDataset dataset3 = createDataset("Series 3", 10000.0, new Minute(), 170);
    plot.setDataset(2, dataset3);
    plot.mapDatasetToRangeAxis(2, 2);
    XYItemRenderer renderer3 = new StandardXYItemRenderer();
    renderer3.setSeriesPaint(0, Color.blue);
    plot.setRenderer(2, renderer3);

    // AXIS 4        
    final NumberAxis axis4 = new NumberAxis("Range Axis 4");
    axis4.setLabelPaint(Color.green);
    axis4.setTickLabelPaint(Color.green);
    plot.setRangeAxis(3, axis4);

    final XYDataset dataset4 = createDataset("Series 4", 25.0, new Minute(), 200);
    plot.setDataset(3, dataset4);
    plot.mapDatasetToRangeAxis(3, 3);

    XYItemRenderer renderer4 = new StandardXYItemRenderer();
    renderer4.setSeriesPaint(0, Color.green);
    plot.setRenderer(3, renderer4);

    return chart;
}

From source file:com.jaspersoft.studio.jasper.ChartConverter.java

/**
 * /*from w w w.j  a  va 2s .c  o  m*/
 */
private Renderable getRenderer(ReportConverter reportConverter, JRChart chart) {
    JasperReportsConfiguration jContext = (JasperReportsConfiguration) reportConverter
            .getJasperReportsContext();
    String renderType = null;
    Rectangle2D rectangle = null;
    ClassLoader oldLoader = Thread.currentThread().getContextClassLoader();
    try {
        Thread.currentThread().setContextClassLoader(jContext.getClassLoader());
        if (dataset != null && jfreeChart != null)
            dataset.removeChangeListener(jfreeChart.getPlot());

        renderType = chart.getRenderType();// FIXMETHEME try reuse this sequence
        if (renderType == null) {
            renderType = JRPropertiesUtil.getInstance(jContext).getProperty(reportConverter.getReport(),
                    JRChart.PROPERTY_CHART_RENDER_TYPE);
        }

        String themeName = chart.getTheme();
        if (themeName == null) {
            themeName = JRPropertiesUtil.getInstance(jContext).getProperty(reportConverter.getReport(),
                    JRChart.PROPERTY_CHART_THEME);
        }
        ChartTheme theme = ChartUtil.getInstance(jContext).getTheme(themeName);
        if (theme instanceof SimpleChartTheme) {
            SimpleChartTheme sct = (SimpleChartTheme) theme;
            sct.getChartSettings()
                    .setBackgroundImage(getCachedImageProvider(sct.getChartSettings().getBackgroundImage()));
            sct.getPlotSettings()
                    .setBackgroundImage(getCachedImageProvider(sct.getPlotSettings().getBackgroundImage()));
        }
        ChartContext chartContext = null;
        // Object cc = jContext.getMap().get(chart);
        // if (cc != null && cc instanceof ChartContext)
        // chartContext = (ChartContext) cc;
        // else {
        chartContext = new ConvertChartContext(chart, jContext);
        try {
            jfreeChart = theme.createChart(chartContext);
            dataset = chartContext.getDataset();
            if (jfreeChart == null && chart.getChartType() == JRChart.CHART_TYPE_MULTI_AXIS) {
                List<JRChartAxis> axis = ((JRDesignMultiAxisPlot) chart.getPlot()).getAxes();
                Plot mainPlot = null;
                int axisNumber = 0;
                for (JRChartAxis ax : axis) {
                    JRChart chartAxis = ((JRDesignChartAxis) ax).getChart();
                    if (jfreeChart == null) {
                        jfreeChart = getJFreeChart(reportConverter, chartAxis);
                        mainPlot = jfreeChart.getPlot();
                        if (mainPlot instanceof CategoryPlot)
                            ((CategoryPlot) mainPlot).setRangeAxisLocation(0, getChartAxisLocation(ax));
                        else if (mainPlot instanceof XYPlot)
                            ((XYPlot) mainPlot).setRangeAxisLocation(0, getChartAxisLocation(ax));
                    } else {
                        axisNumber++;
                        JFreeChart axisChart = getJFreeChart(reportConverter, chartAxis);
                        if (mainPlot instanceof CategoryPlot) {
                            CategoryPlot mainCatPlot = (CategoryPlot) mainPlot;
                            if (!(axisChart.getPlot() instanceof CategoryPlot))
                                continue;

                            // Get the axis and add it to the multi axis chart plot
                            CategoryPlot axisPlot = (CategoryPlot) axisChart.getPlot();
                            mainCatPlot.setRangeAxis(axisNumber, axisPlot.getRangeAxis());
                            mainCatPlot.setRangeAxisLocation(axisNumber, getChartAxisLocation(ax));

                            // Add the data set and map it to the recently added axis
                            mainCatPlot.setDataset(axisNumber, axisPlot.getDataset());
                            mainCatPlot.mapDatasetToRangeAxis(axisNumber, axisNumber);

                            // Set the renderer to use to draw the dataset.
                            mainCatPlot.setRenderer(axisNumber, axisPlot.getRenderer());

                            // Handle any color series for this chart
                            configureAxisSeriesColors(axisPlot.getRenderer(), chartAxis.getPlot());
                        } else if (mainPlot instanceof XYPlot) {
                            XYPlot mainXyPlot = (XYPlot) mainPlot;
                            if (!(axisChart.getPlot() instanceof XYPlot))
                                continue;

                            // Get the axis and add it to the multi axis chart plot
                            XYPlot axisPlot = (XYPlot) axisChart.getPlot();
                            mainXyPlot.setRangeAxis(axisNumber, axisPlot.getRangeAxis());
                            mainXyPlot.setRangeAxisLocation(axisNumber, getChartAxisLocation(ax));

                            // Add the data set and map it to the recently added axis
                            mainXyPlot.setDataset(axisNumber, axisPlot.getDataset());
                            mainXyPlot.mapDatasetToRangeAxis(axisNumber, axisNumber);

                            // Set the renderer to use to draw the dataset.
                            mainXyPlot.setRenderer(axisNumber, axisPlot.getRenderer());

                            // Handle any color series for this chart
                            configureAxisSeriesColors(axisPlot.getRenderer(), chartAxis.getPlot());
                        }
                    }
                }
            }
        } catch (JRException e) {
            throw new JRRuntimeException(e);
        }

        rectangle = new Rectangle2D.Double(0, 0, chart.getWidth(), chart.getHeight());
    } finally {
        Thread.currentThread().setContextClassLoader(oldLoader);
    }
    return ChartUtil.getInstance(jContext).getChartRenderableFactory(renderType).getRenderable(jContext,
            jfreeChart, null, rectangle);
}