/**
  * Creates a sample chart.
  *
  * @param dataset a dataset.
  * @return The chart.
  */
 private static JFreeChart createChart(ValueDataset dataset) {
   MeterPlot plot = new MeterPlot(dataset);
   plot.addInterval(new MeterInterval("High", new Range(80.0, 100.0)));
   plot.setDialOutlinePaint(Color.white);
   JFreeChart chart = new JFreeChart("Meter Chart 2", JFreeChart.DEFAULT_TITLE_FONT, plot, false);
   return chart;
 }
 @Override
 public void propertyChanged(Property property) {
   if (property == min || property == max) {
     m_plotRange = new Range(min.getValue(), max.getValue());
     m_meter.setRange(m_plotRange);
   } else if (property == tickInterval) {
     m_meter.setTickSize(tickInterval.getValue());
   }
 }
Exemple #3
0
 /**
  * Returns an independent copy (clone) of the plot. The dataset is NOT cloned - both the original
  * and the clone will have a reference to the same dataset.
  *
  * @return A clone.
  * @throws CloneNotSupportedException if some component of the plot cannot be cloned.
  */
 public Object clone() throws CloneNotSupportedException {
   MeterPlot clone = (MeterPlot) super.clone();
   clone.tickLabelFormat = (NumberFormat) this.tickLabelFormat.clone();
   // the following relies on the fact that the intervals are immutable
   clone.intervals = new java.util.ArrayList(this.intervals);
   if (clone.dataset != null) {
     clone.dataset.addChangeListener(clone);
   }
   return clone;
 }
  @Override
  public void init() {
    setLayout(new BorderLayout());

    m_meter = new MeterPlot(data);
    m_plotRange = new Range(min.getValue(), max.getValue());
    m_meter.setRange(m_plotRange);
    // plot.addInterval(new MeterInterval("High", new Range(80.0, 100.0)));
    JFreeChart chart =
        new JFreeChart(getFieldName(), JFreeChart.DEFAULT_TITLE_FONT, m_meter, false);
    chartPanel = new ChartPanel(chart);
    chartPanel.setPreferredSize(new Dimension(250, 150));

    propertyChanged(tickInterval);

    add(chartPanel, BorderLayout.CENTER);
    revalidate();
    repaint();
  }
 private static JFreeChart createChart(ValueDataset paramValueDataset) {
   MeterPlot localMeterPlot = new MeterPlot(paramValueDataset);
   localMeterPlot.setRange(new Range(0.0D, 60.0D));
   localMeterPlot.addInterval(
       new MeterInterval(
           "Normal",
           new Range(0.0D, 35.0D),
           Color.lightGray,
           new BasicStroke(2.0F),
           new Color(0, 255, 0, 64)));
   localMeterPlot.addInterval(
       new MeterInterval(
           "Warning",
           new Range(35.0D, 50.0D),
           Color.lightGray,
           new BasicStroke(2.0F),
           new Color(255, 255, 0, 64)));
   localMeterPlot.addInterval(
       new MeterInterval(
           "Critical",
           new Range(50.0D, 60.0D),
           Color.lightGray,
           new BasicStroke(2.0F),
           new Color(255, 0, 0, 128)));
   localMeterPlot.setNeedlePaint(Color.darkGray);
   localMeterPlot.setDialBackgroundPaint(Color.white);
   localMeterPlot.setDialOutlinePaint(Color.gray);
   localMeterPlot.setDialShape(DialShape.CHORD);
   localMeterPlot.setMeterAngle(260);
   localMeterPlot.setTickLabelsVisible(true);
   localMeterPlot.setTickLabelFont(new Font("Dialog", 1, 10));
   localMeterPlot.setTickLabelPaint(Color.darkGray);
   localMeterPlot.setTickSize(5.0D);
   localMeterPlot.setTickPaint(Color.lightGray);
   localMeterPlot.setValuePaint(Color.black);
   localMeterPlot.setValueFont(new Font("Dialog", 1, 14));
   JFreeChart localJFreeChart =
       new JFreeChart("Meter Chart 1", JFreeChart.DEFAULT_TITLE_FONT, localMeterPlot, true);
   ChartUtilities.applyCurrentTheme(localJFreeChart);
   return localJFreeChart;
 }
  protected JFreeChart createMeterChart() throws JRException {
    // Start by creating the plot that will hold the meter
    MeterPlot chartPlot = new MeterPlot((ValueDataset) getDataset());
    JRMeterPlot jrPlot = (JRMeterPlot) getPlot();

    // Set the shape
    MeterShapeEnum shape =
        jrPlot.getShapeValue() == null ? MeterShapeEnum.DIAL : jrPlot.getShapeValue();

    switch (shape) {
      case CHORD:
        chartPlot.setDialShape(DialShape.CHORD);
        break;
      case PIE:
        chartPlot.setDialShape(DialShape.PIE);
        break;
      case CIRCLE:
        chartPlot.setDialShape(DialShape.CIRCLE);
        break;
      case DIAL:
      default:
        return createDialChart();
    }

    chartPlot.setDialOutlinePaint(Color.BLACK);
    int meterAngle =
        jrPlot.getMeterAngleInteger() == null ? 180 : jrPlot.getMeterAngleInteger().intValue();
    // Set the size of the meter
    chartPlot.setMeterAngle(meterAngle);

    // Set the spacing between ticks.  I hate the name "tickSize" since to me it
    // implies I am changing the size of the tick, not the spacing between them.
    double tickInterval =
        jrPlot.getTickIntervalDouble() == null
            ? 10.0
            : jrPlot.getTickIntervalDouble().doubleValue();
    chartPlot.setTickSize(tickInterval);

    JRFont tickLabelFont = jrPlot.getTickLabelFont();
    Integer defaultBaseFontSize =
        (Integer) getDefaultValue(defaultChartPropertiesMap, ChartThemesConstants.BASEFONT_SIZE);
    Font themeTickLabelFont =
        getFont(
            (JRFont)
                getDefaultValue(
                    defaultPlotPropertiesMap, ChartThemesConstants.PLOT_TICK_LABEL_FONT),
            tickLabelFont,
            defaultBaseFontSize);
    chartPlot.setTickLabelFont(themeTickLabelFont);

    Color tickColor = jrPlot.getTickColor() == null ? Color.BLACK : jrPlot.getTickColor();
    chartPlot.setTickPaint(tickColor);
    int dialUnitScale = 1;
    Range range = convertRange(jrPlot.getDataRange());
    if (range != null) {
      // Set the meter's range
      chartPlot.setRange(range);
      double bound = Math.max(Math.abs(range.getUpperBound()), Math.abs(range.getLowerBound()));
      dialUnitScale = ChartThemesUtilities.getScale(bound);
      if ((range.getLowerBound() == (int) range.getLowerBound()
              && range.getUpperBound() == (int) range.getUpperBound()
              && tickInterval == (int) tickInterval)
          || dialUnitScale > 1) {
        chartPlot.setTickLabelFormat(new DecimalFormat("#,##0"));
      } else if (dialUnitScale == 1) {
        chartPlot.setTickLabelFormat(new DecimalFormat("#,##0.0"));
      } else if (dialUnitScale <= 0) {
        chartPlot.setTickLabelFormat(new DecimalFormat("#,##0.00"));
      }
    }
    chartPlot.setTickLabelsVisible(true);

    // Set all the colors we support
    Paint backgroundPaint =
        jrPlot.getOwnBackcolor() == null
            ? ChartThemesConstants.TRANSPARENT_PAINT
            : jrPlot.getOwnBackcolor();
    chartPlot.setBackgroundPaint(backgroundPaint);

    GradientPaint gp =
        new GradientPaint(new Point(), Color.LIGHT_GRAY, new Point(), Color.BLACK, false);

    if (jrPlot.getMeterBackgroundColor() != null) {
      chartPlot.setDialBackgroundPaint(jrPlot.getMeterBackgroundColor());
    } else {
      chartPlot.setDialBackgroundPaint(gp);
    }
    // chartPlot.setForegroundAlpha(1f);
    Paint needlePaint =
        jrPlot.getNeedleColor() == null ? new Color(191, 48, 0) : jrPlot.getNeedleColor();
    chartPlot.setNeedlePaint(needlePaint);

    JRValueDisplay display = jrPlot.getValueDisplay();
    if (display != null) {
      Color valueColor = display.getColor() == null ? Color.BLACK : display.getColor();
      chartPlot.setValuePaint(valueColor);
      String pattern = display.getMask() != null ? display.getMask() : "#,##0.####";
      if (pattern != null) chartPlot.setTickLabelFormat(new DecimalFormat(pattern));
      JRFont displayFont = display.getFont();
      Font themeDisplayFont =
          getFont(
              (JRFont)
                  getDefaultValue(defaultPlotPropertiesMap, ChartThemesConstants.PLOT_DISPLAY_FONT),
              displayFont,
              defaultBaseFontSize);

      if (themeDisplayFont != null) {
        chartPlot.setValueFont(themeDisplayFont);
      }
    }
    String label =
        getChart().hasProperties()
            ? getChart().getPropertiesMap().getProperty(DefaultChartTheme.PROPERTY_DIAL_LABEL)
            : null;

    if (label != null) {
      if (dialUnitScale < 0)
        label =
            new MessageFormat(label)
                .format(new Object[] {String.valueOf(Math.pow(10, dialUnitScale))});
      else if (dialUnitScale < 3) label = new MessageFormat(label).format(new Object[] {"1"});
      else
        label =
            new MessageFormat(label)
                .format(new Object[] {String.valueOf((int) Math.pow(10, dialUnitScale - 2))});
    }

    // Set the units - this is just a string that will be shown next to the
    // value
    String units = jrPlot.getUnits() == null ? label : jrPlot.getUnits();
    if (units != null && units.length() > 0) chartPlot.setUnits(units);

    chartPlot.setTickPaint(Color.BLACK);

    // Now define all of the intervals, setting their range and color
    List intervals = jrPlot.getIntervals();
    if (intervals != null && intervals.size() > 0) {
      int size = Math.min(3, intervals.size());

      int colorStep = 0;
      if (size > 3) colorStep = 255 / (size - 3);

      for (int i = 0; i < size; i++) {
        JRMeterInterval interval = (JRMeterInterval) intervals.get(i);
        Color color =
            i < 3
                ? (Color) ChartThemesConstants.AEGEAN_INTERVAL_COLORS.get(i)
                : new Color(255 - colorStep * (i - 3), 0 + colorStep * (i - 3), 0);

        interval.setBackgroundColor(color);
        interval.setAlpha(new Double(1.0));
        chartPlot.addInterval(convertInterval(interval));
      }
    }

    // Actually create the chart around the plot
    JFreeChart jfreeChart =
        new JFreeChart(
            (String) evaluateExpression(getChart().getTitleExpression()),
            null,
            chartPlot,
            getChart().getShowLegend() == null ? false : getChart().getShowLegend().booleanValue());

    // Set all the generic options
    configureChart(jfreeChart, getPlot());

    return jfreeChart;
  }