0001: /*
0002: * Copyright 2006-2007 Pentaho Corporation. All rights reserved.
0003: * This software was developed by Pentaho Corporation and is provided under the terms
0004: * of the Mozilla Public License, Version 1.1, or any later version. You may not use
0005: * this file except in compliance with the license. If you need a copy of the license,
0006: * please go to http://www.mozilla.org/MPL/MPL-1.1.txt.
0007: *
0008: * Software distributed under the Mozilla Public License is distributed on an "AS IS"
0009: * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. Please refer to
0010: * the license for the specific language governing your rights and limitations.
0011: *
0012: * Additional Contributor(s): Martin Schmid gridvision engineering GmbH
0013: */
0014: package org.pentaho.reportdesigner.crm.report.properties.editors;
0015:
0016: import com.jgoodies.forms.layout.CellConstraints;
0017: import com.jgoodies.forms.layout.FormLayout;
0018: import org.jetbrains.annotations.NonNls;
0019: import org.jetbrains.annotations.NotNull;
0020: import org.jfree.report.function.AbstractFunction;
0021: import org.jfree.report.function.Expression;
0022: import org.pentaho.plugin.jfreereport.reportcharts.AreaChartExpression;
0023: import org.pentaho.plugin.jfreereport.reportcharts.BarChartExpression;
0024: import org.pentaho.plugin.jfreereport.reportcharts.BarLineChartExpression;
0025: import org.pentaho.plugin.jfreereport.reportcharts.BubbleChartExpression;
0026: import org.pentaho.plugin.jfreereport.reportcharts.CategorySetCollectorFunction;
0027: import org.pentaho.plugin.jfreereport.reportcharts.ExtendedXYLineChartExpression;
0028: import org.pentaho.plugin.jfreereport.reportcharts.LineChartExpression;
0029: import org.pentaho.plugin.jfreereport.reportcharts.MultiPieChartExpression;
0030: import org.pentaho.plugin.jfreereport.reportcharts.PieChartExpression;
0031: import org.pentaho.plugin.jfreereport.reportcharts.PieSetCollectorFunction;
0032: import org.pentaho.plugin.jfreereport.reportcharts.RingChartExpression;
0033: import org.pentaho.plugin.jfreereport.reportcharts.ScatterPlotChartExpression;
0034: import org.pentaho.plugin.jfreereport.reportcharts.WaterfallChartExpressions;
0035: import org.pentaho.plugin.jfreereport.reportcharts.XYAreaChartExpression;
0036: import org.pentaho.plugin.jfreereport.reportcharts.XYBarChartExpression;
0037: import org.pentaho.plugin.jfreereport.reportcharts.XYLineChartExpression;
0038: import org.pentaho.plugin.jfreereport.reportcharts.XYSeriesCollectorFunction;
0039: import org.pentaho.plugin.jfreereport.reportcharts.XYZSeriesCollectorFunction;
0040: import org.pentaho.reportdesigner.crm.report.PropertyKeys;
0041: import org.pentaho.reportdesigner.crm.report.ReportDialog;
0042: import org.pentaho.reportdesigner.crm.report.ReportElementSelectionModel;
0043: import org.pentaho.reportdesigner.crm.report.model.ChartReportElement;
0044: import org.pentaho.reportdesigner.crm.report.model.ChartType;
0045: import org.pentaho.reportdesigner.crm.report.model.ReportFunctionElement;
0046: import org.pentaho.reportdesigner.crm.report.model.functions.ExpressionRegistry;
0047: import org.pentaho.reportdesigner.crm.report.properties.PropertyEditorPanel;
0048: import org.pentaho.reportdesigner.lib.client.components.CenterPanelDialog;
0049: import org.pentaho.reportdesigner.lib.client.i18n.TranslationManager;
0050: import org.pentaho.reportdesigner.lib.client.undo.Undo;
0051: import org.pentaho.reportdesigner.lib.client.util.UncaughtExcpetionsModel;
0052: import org.pentaho.reportdesigner.lib.client.util.WindowUtils;
0053:
0054: import javax.swing.*;
0055: import java.awt.*;
0056: import java.awt.event.ActionEvent;
0057: import java.awt.event.ActionListener;
0058: import java.beans.PropertyChangeEvent;
0059: import java.beans.PropertyChangeListener;
0060: import java.lang.reflect.Method;
0061: import java.util.logging.Level;
0062: import java.util.logging.Logger;
0063:
0064: /**
0065: * User: Martin
0066: * Date: 11.01.2006
0067: * Time: 11:02:54
0068: */
0069: public class ChartEditor {
0070: @NonNls
0071: @NotNull
0072: private static final Logger LOG = Logger
0073: .getLogger(ChartEditor.class.getName());
0074:
0075: private ChartEditor() {
0076: }
0077:
0078: public static void showChartEditor(@NotNull
0079: JComponent parent, @NotNull
0080: String title, @NotNull
0081: final ChartReportElement chartReportElement, @NotNull
0082: ReportDialog reportDialog) {
0083: //noinspection ConstantConditions
0084: if (parent == null) {
0085: throw new IllegalArgumentException(
0086: "parent must not be null");
0087: }
0088: //noinspection ConstantConditions
0089: if (title == null) {
0090: throw new IllegalArgumentException("title must not be null");
0091: }
0092: //noinspection ConstantConditions
0093: if (chartReportElement == null) {
0094: throw new IllegalArgumentException(
0095: "chartReportElement must not be null");
0096: }
0097: //noinspection ConstantConditions
0098: if (reportDialog == null) {
0099: throw new IllegalArgumentException(
0100: "reportDialog must not be null");
0101: }
0102:
0103: final CenterPanelDialog centerPanelDialog = CenterPanelDialog
0104: .createDialog(parent, title,
0105: CenterPanelDialog.ModalityType.DOCUMENT_MODAL);
0106:
0107: @NonNls
0108: final FormLayout formLayout = new FormLayout(
0109: "4dlu, pref, 10dlu, default, 4dlu, fill:default:grow, 4dlu",
0110: "4dlu, default, 4dlu, fill:default:grow, 4dlu");
0111: @NonNls
0112: CellConstraints cc = new CellConstraints();
0113: final JPanel centerPanel = new JPanel(formLayout);
0114:
0115: JPanel buttonPanel = new JPanel(new GridLayout(0, 1));
0116: ButtonGroup buttonGroup = new ButtonGroup();
0117:
0118: ReportElementSelectionModel reportElementSelectionModel = reportDialog
0119: .getReportElementModel();
0120: if (reportElementSelectionModel == null) {
0121: //noinspection ThrowableInstanceNeverThrown
0122: UncaughtExcpetionsModel
0123: .getInstance()
0124: .addException(
0125: new Throwable(
0126: "reportElementSelectionModel must not be null"));//NON-NLS
0127: return;
0128: }
0129:
0130: final PropertyEditorPanel propertyEditorPanelChart = new PropertyEditorPanel(
0131: reportDialog, reportElementSelectionModel);
0132: final PropertyEditorPanel propertyEditorPanelData1 = new PropertyEditorPanel(
0133: reportDialog, reportElementSelectionModel);
0134: final PropertyEditorPanel propertyEditorPanelData2 = new PropertyEditorPanel(
0135: reportDialog, reportElementSelectionModel);
0136:
0137: final JPanel editorPanel = new JPanel(
0138: new GridLayout(1, 0, 5, 0));
0139: editorPanel.add(new JScrollPane(propertyEditorPanelChart));
0140: editorPanel.add(new JScrollPane(propertyEditorPanelData1));
0141: final JScrollPane dataSource2ScrollPane = new JScrollPane(
0142: propertyEditorPanelData2);
0143:
0144: JToggleButton toggleButtonArea = new JToggleButton(
0145: TranslationManager.getInstance().getTranslation("R",
0146: "Chart.Area"));
0147: JToggleButton toggleButtonBar = new JToggleButton(
0148: TranslationManager.getInstance().getTranslation("R",
0149: "Chart.Bar"));
0150: JToggleButton toggleButtonLine = new JToggleButton(
0151: TranslationManager.getInstance().getTranslation("R",
0152: "Chart.Line"));
0153: JToggleButton toggleButtonPie = new JToggleButton(
0154: TranslationManager.getInstance().getTranslation("R",
0155: "Chart.Pie"));
0156: JToggleButton toggleButtonRing = new JToggleButton(
0157: TranslationManager.getInstance().getTranslation("R",
0158: "Chart.Ring"));
0159: JToggleButton toggleButtonMultiPie = new JToggleButton(
0160: TranslationManager.getInstance().getTranslation("R",
0161: "Chart.MultiPie"));
0162: JToggleButton toggleButtonWaterfall = new JToggleButton(
0163: TranslationManager.getInstance().getTranslation("R",
0164: "Chart.Waterfall"));
0165:
0166: JToggleButton toggleButtonBarLine = new JToggleButton(
0167: TranslationManager.getInstance().getTranslation("R",
0168: "Chart.BarLine"));
0169: JToggleButton toggleButtonBubble = new JToggleButton(
0170: TranslationManager.getInstance().getTranslation("R",
0171: "Chart.Bubble"));
0172: JToggleButton toggleButtonExtendedXYLine = new JToggleButton(
0173: TranslationManager.getInstance().getTranslation("R",
0174: "Chart.ExtendedXYLine"));
0175: JToggleButton toggleButtonScatterPlot = new JToggleButton(
0176: TranslationManager.getInstance().getTranslation("R",
0177: "Chart.Scatter"));
0178: JToggleButton toggleButtonXYArea = new JToggleButton(
0179: TranslationManager.getInstance().getTranslation("R",
0180: "Chart.XYArea"));
0181: JToggleButton toggleButtonXYBar = new JToggleButton(
0182: TranslationManager.getInstance().getTranslation("R",
0183: "Chart.XYBar"));
0184: JToggleButton toggleButtonXYLine = new JToggleButton(
0185: TranslationManager.getInstance().getTranslation("R",
0186: "Chart.XYLine"));
0187:
0188: buttonPanel.add(toggleButtonArea);
0189: buttonPanel.add(toggleButtonBar);
0190: buttonPanel.add(toggleButtonLine);
0191: buttonPanel.add(toggleButtonPie);
0192: buttonPanel.add(toggleButtonRing);
0193: buttonPanel.add(toggleButtonMultiPie);
0194: buttonPanel.add(toggleButtonWaterfall);
0195:
0196: buttonPanel.add(toggleButtonBarLine);
0197: buttonPanel.add(toggleButtonBubble);
0198: buttonPanel.add(toggleButtonScatterPlot);
0199: buttonPanel.add(toggleButtonXYArea);
0200: buttonPanel.add(toggleButtonXYBar);
0201: buttonPanel.add(toggleButtonXYLine);
0202: buttonPanel.add(toggleButtonExtendedXYLine);
0203:
0204: toggleButtonArea
0205: .setSelected(chartReportElement.getChartType() == ChartType.AREA);
0206: toggleButtonBar
0207: .setSelected(chartReportElement.getChartType() == ChartType.BAR);
0208: toggleButtonLine
0209: .setSelected(chartReportElement.getChartType() == ChartType.LINE);
0210: toggleButtonPie
0211: .setSelected(chartReportElement.getChartType() == ChartType.PIE);
0212: toggleButtonRing
0213: .setSelected(chartReportElement.getChartType() == ChartType.RING);
0214: toggleButtonMultiPie.setSelected(chartReportElement
0215: .getChartType() == ChartType.MULTI_PIE);
0216: toggleButtonWaterfall.setSelected(chartReportElement
0217: .getChartType() == ChartType.WATERFALL);
0218:
0219: toggleButtonBarLine.setSelected(chartReportElement
0220: .getChartType() == ChartType.BAR_LINE);
0221: toggleButtonBubble.setSelected(chartReportElement
0222: .getChartType() == ChartType.BUBBLE);
0223: toggleButtonExtendedXYLine.setSelected(chartReportElement
0224: .getChartType() == ChartType.EXTENDED_XY_LINE);
0225: toggleButtonScatterPlot.setSelected(chartReportElement
0226: .getChartType() == ChartType.SCATTER_PLOT);
0227: toggleButtonXYArea.setSelected(chartReportElement
0228: .getChartType() == ChartType.XY_AREA);
0229: toggleButtonXYBar
0230: .setSelected(chartReportElement.getChartType() == ChartType.XY_BAR);
0231: toggleButtonXYLine.setSelected(chartReportElement
0232: .getChartType() == ChartType.XY_LINE);
0233:
0234: if (chartReportElement.getChartType() == ChartType.BAR_LINE) {
0235: editorPanel.add(dataSource2ScrollPane);
0236: }
0237:
0238: final PropertyChangeListener propertyChangeListener = new PropertyChangeListener() {
0239: public void propertyChange(@NotNull
0240: PropertyChangeEvent evt) {
0241: try {
0242: Method declaredMethod = chartReportElement
0243: .getChartFunction().getClass().getMethod(
0244: "setDataSource", String.class);//NON-NLS
0245: declaredMethod.invoke(chartReportElement
0246: .getChartFunction(), evt.getNewValue());
0247: } catch (Exception ex) {
0248: if (LOG.isLoggable(Level.FINE))
0249: LOG.log(Level.FINE,
0250: "ChartEditor.propertyChange ", ex);
0251: }
0252: }
0253: };
0254:
0255: final PropertyChangeListener propertyChangeListener2 = new PropertyChangeListener() {
0256: public void propertyChange(@NotNull
0257: PropertyChangeEvent evt) {
0258: try {
0259: Method declaredMethod = chartReportElement
0260: .getChartFunction().getClass().getMethod(
0261: "setLinesDataSource", String.class);//NON-NLS
0262: declaredMethod.invoke(chartReportElement
0263: .getChartFunction(), evt.getNewValue());
0264: } catch (Exception ex) {
0265: if (LOG.isLoggable(Level.FINE))
0266: LOG.log(Level.FINE,
0267: "ChartEditor.propertyChange ", ex);
0268: }
0269: }
0270: };
0271:
0272: toggleButtonArea.addActionListener(new ActionListener() {
0273: public void actionPerformed(@NotNull
0274: ActionEvent e) {
0275: Undo undo = chartReportElement.getUndo();
0276: if (undo != null) {
0277: undo.startTransaction("charttype");//NON-NLS
0278:
0279: chartReportElement.getDataCollectorFunction()
0280: .removePropertyChangeListener(
0281: PropertyKeys.NAME,
0282: propertyChangeListener);
0283: chartReportElement.getDataCollectorFunction2()
0284: .removePropertyChangeListener(
0285: PropertyKeys.NAME,
0286: propertyChangeListener2);
0287: chartReportElement
0288: .setDataCollectorFunction(getDataFunction(
0289: chartReportElement.getChartType(),
0290: ChartType.AREA, chartReportElement
0291: .getDataCollectorFunction()));
0292: chartReportElement.getDataCollectorFunction()
0293: .addPropertyChangeListener(
0294: PropertyKeys.NAME,
0295: propertyChangeListener);
0296: chartReportElement.getDataCollectorFunction2()
0297: .addPropertyChangeListener(
0298: PropertyKeys.NAME,
0299: propertyChangeListener2);
0300:
0301: chartReportElement
0302: .setChartFunction(getChartFunction(
0303: chartReportElement,
0304: ExpressionRegistry
0305: .getInstance()
0306: .createWrapperInstance(
0307: new AreaChartExpression())));
0308:
0309: chartReportElement.setChartType(ChartType.AREA);
0310: undo.endTransaction();
0311:
0312: removeDataSource2Panel(editorPanel,
0313: dataSource2ScrollPane);
0314:
0315: propertyEditorPanelData1
0316: .setBeans(new Object[] { chartReportElement
0317: .getDataCollectorFunction() });
0318: propertyEditorPanelData2
0319: .setBeans(new Object[] { chartReportElement
0320: .getDataCollectorFunction2() });
0321: propertyEditorPanelChart
0322: .setBeans(new Object[] { chartReportElement
0323: .getChartFunction() });
0324: }
0325: }
0326: });
0327:
0328: toggleButtonBar.addActionListener(new ActionListener() {
0329: public void actionPerformed(@NotNull
0330: ActionEvent e) {
0331: Undo undo = chartReportElement.getUndo();
0332: if (undo != null) {
0333: undo.startTransaction("charttype");//NON-NLS
0334:
0335: chartReportElement.getDataCollectorFunction()
0336: .removePropertyChangeListener(
0337: PropertyKeys.NAME,
0338: propertyChangeListener);
0339: chartReportElement.getDataCollectorFunction2()
0340: .removePropertyChangeListener(
0341: PropertyKeys.NAME,
0342: propertyChangeListener2);
0343: chartReportElement
0344: .setDataCollectorFunction(getDataFunction(
0345: chartReportElement.getChartType(),
0346: ChartType.BAR, chartReportElement
0347: .getDataCollectorFunction()));
0348: chartReportElement.getDataCollectorFunction()
0349: .addPropertyChangeListener(
0350: PropertyKeys.NAME,
0351: propertyChangeListener);
0352: chartReportElement.getDataCollectorFunction2()
0353: .addPropertyChangeListener(
0354: PropertyKeys.NAME,
0355: propertyChangeListener2);
0356:
0357: chartReportElement
0358: .setChartFunction(getChartFunction(
0359: chartReportElement,
0360: ExpressionRegistry
0361: .getInstance()
0362: .createWrapperInstance(
0363: new BarChartExpression())));
0364: chartReportElement.setChartType(ChartType.BAR);
0365: undo.endTransaction();
0366:
0367: removeDataSource2Panel(editorPanel,
0368: dataSource2ScrollPane);
0369:
0370: propertyEditorPanelData1
0371: .setBeans(new Object[] { chartReportElement
0372: .getDataCollectorFunction() });
0373: propertyEditorPanelData2
0374: .setBeans(new Object[] { chartReportElement
0375: .getDataCollectorFunction2() });
0376: propertyEditorPanelChart
0377: .setBeans(new Object[] { chartReportElement
0378: .getChartFunction() });
0379: }
0380: }
0381: });
0382:
0383: toggleButtonLine.addActionListener(new ActionListener() {
0384: public void actionPerformed(@NotNull
0385: ActionEvent e) {
0386: Undo undo = chartReportElement.getUndo();
0387: if (undo != null) {
0388: undo.startTransaction("charttype");//NON-NLS
0389:
0390: chartReportElement.getDataCollectorFunction()
0391: .removePropertyChangeListener(
0392: PropertyKeys.NAME,
0393: propertyChangeListener);
0394: chartReportElement.getDataCollectorFunction2()
0395: .removePropertyChangeListener(
0396: PropertyKeys.NAME,
0397: propertyChangeListener2);
0398: chartReportElement
0399: .setDataCollectorFunction(getDataFunction(
0400: chartReportElement.getChartType(),
0401: ChartType.LINE, chartReportElement
0402: .getDataCollectorFunction()));
0403: chartReportElement.getDataCollectorFunction()
0404: .addPropertyChangeListener(
0405: PropertyKeys.NAME,
0406: propertyChangeListener);
0407: chartReportElement.getDataCollectorFunction2()
0408: .addPropertyChangeListener(
0409: PropertyKeys.NAME,
0410: propertyChangeListener2);
0411:
0412: chartReportElement
0413: .setChartFunction(getChartFunction(
0414: chartReportElement,
0415: ExpressionRegistry
0416: .getInstance()
0417: .createWrapperInstance(
0418: new LineChartExpression())));
0419: chartReportElement.setChartType(ChartType.LINE);
0420: undo.endTransaction();
0421:
0422: removeDataSource2Panel(editorPanel,
0423: dataSource2ScrollPane);
0424:
0425: propertyEditorPanelData1
0426: .setBeans(new Object[] { chartReportElement
0427: .getDataCollectorFunction() });
0428: propertyEditorPanelData2
0429: .setBeans(new Object[] { chartReportElement
0430: .getDataCollectorFunction2() });
0431: propertyEditorPanelChart
0432: .setBeans(new Object[] { chartReportElement
0433: .getChartFunction() });
0434: }
0435: }
0436: });
0437:
0438: toggleButtonPie.addActionListener(new ActionListener() {
0439: public void actionPerformed(@NotNull
0440: ActionEvent e) {
0441: Undo undo = chartReportElement.getUndo();
0442: if (undo != null) {
0443: undo.startTransaction("charttype");//NON-NLS
0444:
0445: chartReportElement.getDataCollectorFunction2()
0446: .removePropertyChangeListener(
0447: PropertyKeys.NAME,
0448: propertyChangeListener2);
0449: chartReportElement.getDataCollectorFunction()
0450: .removePropertyChangeListener(
0451: PropertyKeys.NAME,
0452: propertyChangeListener);
0453: chartReportElement
0454: .setDataCollectorFunction(getDataFunction(
0455: chartReportElement.getChartType(),
0456: ChartType.PIE, chartReportElement
0457: .getDataCollectorFunction()));
0458: chartReportElement.getDataCollectorFunction()
0459: .addPropertyChangeListener(
0460: PropertyKeys.NAME,
0461: propertyChangeListener);
0462: chartReportElement.getDataCollectorFunction2()
0463: .addPropertyChangeListener(
0464: PropertyKeys.NAME,
0465: propertyChangeListener2);
0466:
0467: chartReportElement
0468: .setChartFunction(getChartFunction(
0469: chartReportElement,
0470: ExpressionRegistry
0471: .getInstance()
0472: .createWrapperInstance(
0473: new PieChartExpression())));
0474: chartReportElement.setChartType(ChartType.PIE);
0475: undo.endTransaction();
0476:
0477: removeDataSource2Panel(editorPanel,
0478: dataSource2ScrollPane);
0479:
0480: propertyEditorPanelData1
0481: .setBeans(new Object[] { chartReportElement
0482: .getDataCollectorFunction() });
0483: propertyEditorPanelData2
0484: .setBeans(new Object[] { chartReportElement
0485: .getDataCollectorFunction2() });
0486: propertyEditorPanelChart
0487: .setBeans(new Object[] { chartReportElement
0488: .getChartFunction() });
0489: }
0490: }
0491: });
0492:
0493: toggleButtonRing.addActionListener(new ActionListener() {
0494: public void actionPerformed(@NotNull
0495: ActionEvent e) {
0496: Undo undo = chartReportElement.getUndo();
0497: if (undo != null) {
0498: undo.startTransaction("charttype");//NON-NLS
0499:
0500: chartReportElement.getDataCollectorFunction()
0501: .removePropertyChangeListener(
0502: PropertyKeys.NAME,
0503: propertyChangeListener);
0504: chartReportElement.getDataCollectorFunction2()
0505: .removePropertyChangeListener(
0506: PropertyKeys.NAME,
0507: propertyChangeListener2);
0508: chartReportElement
0509: .setDataCollectorFunction(getDataFunction(
0510: chartReportElement.getChartType(),
0511: ChartType.RING, chartReportElement
0512: .getDataCollectorFunction()));
0513: chartReportElement.getDataCollectorFunction()
0514: .addPropertyChangeListener(
0515: PropertyKeys.NAME,
0516: propertyChangeListener);
0517: chartReportElement.getDataCollectorFunction2()
0518: .addPropertyChangeListener(
0519: PropertyKeys.NAME,
0520: propertyChangeListener2);
0521:
0522: chartReportElement
0523: .setChartFunction(getChartFunction(
0524: chartReportElement,
0525: ExpressionRegistry
0526: .getInstance()
0527: .createWrapperInstance(
0528: new RingChartExpression())));
0529: chartReportElement.setChartType(ChartType.RING);
0530: undo.endTransaction();
0531:
0532: removeDataSource2Panel(editorPanel,
0533: dataSource2ScrollPane);
0534:
0535: propertyEditorPanelData1
0536: .setBeans(new Object[] { chartReportElement
0537: .getDataCollectorFunction() });
0538: propertyEditorPanelData2
0539: .setBeans(new Object[] { chartReportElement
0540: .getDataCollectorFunction2() });
0541: propertyEditorPanelChart
0542: .setBeans(new Object[] { chartReportElement
0543: .getChartFunction() });
0544: }
0545: }
0546: });
0547:
0548: toggleButtonMultiPie.addActionListener(new ActionListener() {
0549: public void actionPerformed(@NotNull
0550: ActionEvent e) {
0551: Undo undo = chartReportElement.getUndo();
0552: if (undo != null) {
0553: undo.startTransaction("charttype");//NON-NLS
0554:
0555: chartReportElement.getDataCollectorFunction2()
0556: .removePropertyChangeListener(
0557: PropertyKeys.NAME,
0558: propertyChangeListener2);
0559: chartReportElement.getDataCollectorFunction()
0560: .removePropertyChangeListener(
0561: PropertyKeys.NAME,
0562: propertyChangeListener);
0563: chartReportElement
0564: .setDataCollectorFunction(getDataFunction(
0565: chartReportElement.getChartType(),
0566: ChartType.MULTI_PIE,
0567: chartReportElement
0568: .getDataCollectorFunction()));
0569: chartReportElement.getDataCollectorFunction()
0570: .addPropertyChangeListener(
0571: PropertyKeys.NAME,
0572: propertyChangeListener);
0573: chartReportElement.getDataCollectorFunction2()
0574: .addPropertyChangeListener(
0575: PropertyKeys.NAME,
0576: propertyChangeListener2);
0577:
0578: chartReportElement
0579: .setChartFunction(getChartFunction(
0580: chartReportElement,
0581: ExpressionRegistry
0582: .getInstance()
0583: .createWrapperInstance(
0584: new MultiPieChartExpression())));
0585: chartReportElement
0586: .setChartType(ChartType.MULTI_PIE);
0587: undo.endTransaction();
0588:
0589: removeDataSource2Panel(editorPanel,
0590: dataSource2ScrollPane);
0591:
0592: propertyEditorPanelData1
0593: .setBeans(new Object[] { chartReportElement
0594: .getDataCollectorFunction() });
0595: propertyEditorPanelData2
0596: .setBeans(new Object[] { chartReportElement
0597: .getDataCollectorFunction2() });
0598: propertyEditorPanelChart
0599: .setBeans(new Object[] { chartReportElement
0600: .getChartFunction() });
0601: }
0602: }
0603: });
0604:
0605: toggleButtonWaterfall.addActionListener(new ActionListener() {
0606: public void actionPerformed(@NotNull
0607: ActionEvent e) {
0608: Undo undo = chartReportElement.getUndo();
0609: if (undo != null) {
0610: undo.startTransaction("charttype");//NON-NLS
0611:
0612: chartReportElement.getDataCollectorFunction2()
0613: .removePropertyChangeListener(
0614: PropertyKeys.NAME,
0615: propertyChangeListener2);
0616: chartReportElement.getDataCollectorFunction()
0617: .removePropertyChangeListener(
0618: PropertyKeys.NAME,
0619: propertyChangeListener);
0620: chartReportElement
0621: .setDataCollectorFunction(getDataFunction(
0622: chartReportElement.getChartType(),
0623: ChartType.WATERFALL,
0624: chartReportElement
0625: .getDataCollectorFunction()));
0626: chartReportElement.getDataCollectorFunction()
0627: .addPropertyChangeListener(
0628: PropertyKeys.NAME,
0629: propertyChangeListener);
0630: chartReportElement.getDataCollectorFunction2()
0631: .addPropertyChangeListener(
0632: PropertyKeys.NAME,
0633: propertyChangeListener2);
0634:
0635: chartReportElement
0636: .setChartFunction(getChartFunction(
0637: chartReportElement,
0638: ExpressionRegistry
0639: .getInstance()
0640: .createWrapperInstance(
0641: new WaterfallChartExpressions())));
0642: chartReportElement
0643: .setChartType(ChartType.WATERFALL);
0644: undo.endTransaction();
0645:
0646: removeDataSource2Panel(editorPanel,
0647: dataSource2ScrollPane);
0648:
0649: propertyEditorPanelData1
0650: .setBeans(new Object[] { chartReportElement
0651: .getDataCollectorFunction() });
0652: propertyEditorPanelData2
0653: .setBeans(new Object[] { chartReportElement
0654: .getDataCollectorFunction2() });
0655: propertyEditorPanelChart
0656: .setBeans(new Object[] { chartReportElement
0657: .getChartFunction() });
0658: }
0659: }
0660: });
0661:
0662: toggleButtonBarLine.addActionListener(new ActionListener() {
0663: public void actionPerformed(@NotNull
0664: ActionEvent e) {
0665: Undo undo = chartReportElement.getUndo();
0666: if (undo != null) {
0667: undo.startTransaction("charttype");//NON-NLS
0668:
0669: chartReportElement.getDataCollectorFunction2()
0670: .removePropertyChangeListener(
0671: PropertyKeys.NAME,
0672: propertyChangeListener2);
0673: chartReportElement.getDataCollectorFunction()
0674: .removePropertyChangeListener(
0675: PropertyKeys.NAME,
0676: propertyChangeListener);
0677: chartReportElement
0678: .setDataCollectorFunction(getDataFunction(
0679: chartReportElement.getChartType(),
0680: ChartType.BAR_LINE,
0681: chartReportElement
0682: .getDataCollectorFunction()));
0683: chartReportElement.getDataCollectorFunction()
0684: .addPropertyChangeListener(
0685: PropertyKeys.NAME,
0686: propertyChangeListener);
0687: chartReportElement.getDataCollectorFunction2()
0688: .addPropertyChangeListener(
0689: PropertyKeys.NAME,
0690: propertyChangeListener2);
0691:
0692: chartReportElement
0693: .setChartFunction(getChartFunction(
0694: chartReportElement,
0695: ExpressionRegistry
0696: .getInstance()
0697: .createWrapperInstance(
0698: new BarLineChartExpression())));
0699: chartReportElement.setChartType(ChartType.BAR_LINE);
0700: updateDataCollector2Name(chartReportElement
0701: .getChartFunction(), chartReportElement
0702: .getDataCollectorFunction2());
0703:
0704: undo.endTransaction();
0705:
0706: addDataSource2Panel(editorPanel,
0707: dataSource2ScrollPane);
0708:
0709: propertyEditorPanelData1
0710: .setBeans(new Object[] { chartReportElement
0711: .getDataCollectorFunction() });
0712: propertyEditorPanelData2
0713: .setBeans(new Object[] { chartReportElement
0714: .getDataCollectorFunction2() });
0715: propertyEditorPanelChart
0716: .setBeans(new Object[] { chartReportElement
0717: .getChartFunction() });
0718: }
0719: }
0720: });
0721:
0722: toggleButtonBubble.addActionListener(new ActionListener() {
0723: public void actionPerformed(@NotNull
0724: ActionEvent e) {
0725: Undo undo = chartReportElement.getUndo();
0726: if (undo != null) {
0727: undo.startTransaction("charttype");//NON-NLS
0728:
0729: chartReportElement.getDataCollectorFunction2()
0730: .removePropertyChangeListener(
0731: PropertyKeys.NAME,
0732: propertyChangeListener2);
0733: chartReportElement.getDataCollectorFunction()
0734: .removePropertyChangeListener(
0735: PropertyKeys.NAME,
0736: propertyChangeListener);
0737: chartReportElement
0738: .setDataCollectorFunction(getDataFunction(
0739: chartReportElement.getChartType(),
0740: ChartType.BUBBLE,
0741: chartReportElement
0742: .getDataCollectorFunction()));
0743: chartReportElement.getDataCollectorFunction()
0744: .addPropertyChangeListener(
0745: PropertyKeys.NAME,
0746: propertyChangeListener);
0747: chartReportElement.getDataCollectorFunction2()
0748: .addPropertyChangeListener(
0749: PropertyKeys.NAME,
0750: propertyChangeListener2);
0751:
0752: chartReportElement
0753: .setChartFunction(getChartFunction(
0754: chartReportElement,
0755: ExpressionRegistry
0756: .getInstance()
0757: .createWrapperInstance(
0758: new BubbleChartExpression())));
0759: chartReportElement.setChartType(ChartType.BUBBLE);
0760: undo.endTransaction();
0761:
0762: removeDataSource2Panel(editorPanel,
0763: dataSource2ScrollPane);
0764:
0765: propertyEditorPanelData1
0766: .setBeans(new Object[] { chartReportElement
0767: .getDataCollectorFunction() });
0768: propertyEditorPanelData2
0769: .setBeans(new Object[] { chartReportElement
0770: .getDataCollectorFunction2() });
0771: propertyEditorPanelChart
0772: .setBeans(new Object[] { chartReportElement
0773: .getChartFunction() });
0774: }
0775: }
0776: });
0777:
0778: toggleButtonExtendedXYLine
0779: .addActionListener(new ActionListener() {
0780: public void actionPerformed(@NotNull
0781: ActionEvent e) {
0782: Undo undo = chartReportElement.getUndo();
0783: if (undo != null) {
0784: undo.startTransaction("charttype");//NON-NLS
0785:
0786: chartReportElement
0787: .getDataCollectorFunction2()
0788: .removePropertyChangeListener(
0789: PropertyKeys.NAME,
0790: propertyChangeListener2);
0791: chartReportElement
0792: .getDataCollectorFunction()
0793: .removePropertyChangeListener(
0794: PropertyKeys.NAME,
0795: propertyChangeListener);
0796: chartReportElement
0797: .setDataCollectorFunction(getDataFunction(
0798: chartReportElement
0799: .getChartType(),
0800: ChartType.EXTENDED_XY_LINE,
0801: chartReportElement
0802: .getDataCollectorFunction()));
0803: chartReportElement
0804: .getDataCollectorFunction()
0805: .addPropertyChangeListener(
0806: PropertyKeys.NAME,
0807: propertyChangeListener);
0808: chartReportElement
0809: .getDataCollectorFunction2()
0810: .addPropertyChangeListener(
0811: PropertyKeys.NAME,
0812: propertyChangeListener2);
0813:
0814: chartReportElement
0815: .setChartFunction(getChartFunction(
0816: chartReportElement,
0817: ExpressionRegistry
0818: .getInstance()
0819: .createWrapperInstance(
0820: new ExtendedXYLineChartExpression())));
0821: chartReportElement
0822: .setChartType(ChartType.EXTENDED_XY_LINE);
0823: undo.endTransaction();
0824:
0825: removeDataSource2Panel(editorPanel,
0826: dataSource2ScrollPane);
0827:
0828: propertyEditorPanelData1
0829: .setBeans(new Object[] { chartReportElement
0830: .getDataCollectorFunction() });
0831: propertyEditorPanelData2
0832: .setBeans(new Object[] { chartReportElement
0833: .getDataCollectorFunction2() });
0834: propertyEditorPanelChart
0835: .setBeans(new Object[] { chartReportElement
0836: .getChartFunction() });
0837: }
0838: }
0839: });
0840:
0841: toggleButtonScatterPlot.addActionListener(new ActionListener() {
0842: public void actionPerformed(@NotNull
0843: ActionEvent e) {
0844: Undo undo = chartReportElement.getUndo();
0845: if (undo != null) {
0846: undo.startTransaction("charttype");//NON-NLS
0847:
0848: chartReportElement.getDataCollectorFunction2()
0849: .removePropertyChangeListener(
0850: PropertyKeys.NAME,
0851: propertyChangeListener2);
0852: chartReportElement.getDataCollectorFunction()
0853: .removePropertyChangeListener(
0854: PropertyKeys.NAME,
0855: propertyChangeListener);
0856: chartReportElement
0857: .setDataCollectorFunction(getDataFunction(
0858: chartReportElement.getChartType(),
0859: ChartType.SCATTER_PLOT,
0860: chartReportElement
0861: .getDataCollectorFunction()));
0862: chartReportElement.getDataCollectorFunction()
0863: .addPropertyChangeListener(
0864: PropertyKeys.NAME,
0865: propertyChangeListener);
0866: chartReportElement.getDataCollectorFunction2()
0867: .addPropertyChangeListener(
0868: PropertyKeys.NAME,
0869: propertyChangeListener2);
0870:
0871: chartReportElement
0872: .setChartFunction(getChartFunction(
0873: chartReportElement,
0874: ExpressionRegistry
0875: .getInstance()
0876: .createWrapperInstance(
0877: new ScatterPlotChartExpression())));
0878: chartReportElement
0879: .setChartType(ChartType.SCATTER_PLOT);
0880: undo.endTransaction();
0881:
0882: removeDataSource2Panel(editorPanel,
0883: dataSource2ScrollPane);
0884:
0885: propertyEditorPanelData1
0886: .setBeans(new Object[] { chartReportElement
0887: .getDataCollectorFunction() });
0888: propertyEditorPanelData2
0889: .setBeans(new Object[] { chartReportElement
0890: .getDataCollectorFunction2() });
0891: propertyEditorPanelChart
0892: .setBeans(new Object[] { chartReportElement
0893: .getChartFunction() });
0894: }
0895: }
0896: });
0897:
0898: toggleButtonXYArea.addActionListener(new ActionListener() {
0899: public void actionPerformed(@NotNull
0900: ActionEvent e) {
0901: Undo undo = chartReportElement.getUndo();
0902: if (undo != null) {
0903: undo.startTransaction("charttype");//NON-NLS
0904:
0905: chartReportElement.getDataCollectorFunction2()
0906: .removePropertyChangeListener(
0907: PropertyKeys.NAME,
0908: propertyChangeListener2);
0909: chartReportElement.getDataCollectorFunction()
0910: .removePropertyChangeListener(
0911: PropertyKeys.NAME,
0912: propertyChangeListener);
0913: chartReportElement
0914: .setDataCollectorFunction(getDataFunction(
0915: chartReportElement.getChartType(),
0916: ChartType.XY_AREA,
0917: chartReportElement
0918: .getDataCollectorFunction()));
0919: chartReportElement.getDataCollectorFunction()
0920: .addPropertyChangeListener(
0921: PropertyKeys.NAME,
0922: propertyChangeListener);
0923: chartReportElement.getDataCollectorFunction2()
0924: .addPropertyChangeListener(
0925: PropertyKeys.NAME,
0926: propertyChangeListener2);
0927:
0928: chartReportElement
0929: .setChartFunction(getChartFunction(
0930: chartReportElement,
0931: ExpressionRegistry
0932: .getInstance()
0933: .createWrapperInstance(
0934: new XYAreaChartExpression())));
0935: chartReportElement.setChartType(ChartType.XY_AREA);
0936: undo.endTransaction();
0937:
0938: removeDataSource2Panel(editorPanel,
0939: dataSource2ScrollPane);
0940:
0941: propertyEditorPanelData1
0942: .setBeans(new Object[] { chartReportElement
0943: .getDataCollectorFunction() });
0944: propertyEditorPanelData2
0945: .setBeans(new Object[] { chartReportElement
0946: .getDataCollectorFunction2() });
0947: propertyEditorPanelChart
0948: .setBeans(new Object[] { chartReportElement
0949: .getChartFunction() });
0950: }
0951: }
0952: });
0953:
0954: toggleButtonXYBar.addActionListener(new ActionListener() {
0955: public void actionPerformed(@NotNull
0956: ActionEvent e) {
0957: Undo undo = chartReportElement.getUndo();
0958: if (undo != null) {
0959: undo.startTransaction("charttype");//NON-NLS
0960:
0961: chartReportElement.getDataCollectorFunction2()
0962: .removePropertyChangeListener(
0963: PropertyKeys.NAME,
0964: propertyChangeListener2);
0965: chartReportElement.getDataCollectorFunction()
0966: .removePropertyChangeListener(
0967: PropertyKeys.NAME,
0968: propertyChangeListener);
0969: chartReportElement
0970: .setDataCollectorFunction(getDataFunction(
0971: chartReportElement.getChartType(),
0972: ChartType.XY_BAR,
0973: chartReportElement
0974: .getDataCollectorFunction()));
0975: chartReportElement.getDataCollectorFunction()
0976: .addPropertyChangeListener(
0977: PropertyKeys.NAME,
0978: propertyChangeListener);
0979: chartReportElement.getDataCollectorFunction2()
0980: .addPropertyChangeListener(
0981: PropertyKeys.NAME,
0982: propertyChangeListener2);
0983:
0984: chartReportElement
0985: .setChartFunction(getChartFunction(
0986: chartReportElement,
0987: ExpressionRegistry
0988: .getInstance()
0989: .createWrapperInstance(
0990: new XYBarChartExpression())));
0991: chartReportElement.setChartType(ChartType.XY_BAR);
0992: undo.endTransaction();
0993:
0994: removeDataSource2Panel(editorPanel,
0995: dataSource2ScrollPane);
0996:
0997: propertyEditorPanelData1
0998: .setBeans(new Object[] { chartReportElement
0999: .getDataCollectorFunction() });
1000: propertyEditorPanelData2
1001: .setBeans(new Object[] { chartReportElement
1002: .getDataCollectorFunction2() });
1003: propertyEditorPanelChart
1004: .setBeans(new Object[] { chartReportElement
1005: .getChartFunction() });
1006: }
1007: }
1008: });
1009:
1010: toggleButtonXYLine.addActionListener(new ActionListener() {
1011: public void actionPerformed(@NotNull
1012: ActionEvent e) {
1013: Undo undo = chartReportElement.getUndo();
1014: if (undo != null) {
1015: undo.startTransaction("charttype");//NON-NLS
1016:
1017: chartReportElement.getDataCollectorFunction2()
1018: .removePropertyChangeListener(
1019: PropertyKeys.NAME,
1020: propertyChangeListener2);
1021: chartReportElement.getDataCollectorFunction()
1022: .removePropertyChangeListener(
1023: PropertyKeys.NAME,
1024: propertyChangeListener);
1025: chartReportElement
1026: .setDataCollectorFunction(getDataFunction(
1027: chartReportElement.getChartType(),
1028: ChartType.XY_LINE,
1029: chartReportElement
1030: .getDataCollectorFunction()));
1031: chartReportElement.getDataCollectorFunction()
1032: .addPropertyChangeListener(
1033: PropertyKeys.NAME,
1034: propertyChangeListener);
1035: chartReportElement.getDataCollectorFunction2()
1036: .addPropertyChangeListener(
1037: PropertyKeys.NAME,
1038: propertyChangeListener2);
1039:
1040: chartReportElement
1041: .setChartFunction(getChartFunction(
1042: chartReportElement,
1043: ExpressionRegistry
1044: .getInstance()
1045: .createWrapperInstance(
1046: new XYLineChartExpression())));
1047: chartReportElement.setChartType(ChartType.XY_LINE);
1048: undo.endTransaction();
1049:
1050: removeDataSource2Panel(editorPanel,
1051: dataSource2ScrollPane);
1052:
1053: propertyEditorPanelData1
1054: .setBeans(new Object[] { chartReportElement
1055: .getDataCollectorFunction() });
1056: propertyEditorPanelData2
1057: .setBeans(new Object[] { chartReportElement
1058: .getDataCollectorFunction2() });
1059: propertyEditorPanelChart
1060: .setBeans(new Object[] { chartReportElement
1061: .getChartFunction() });
1062: }
1063: }
1064: });
1065:
1066: buttonGroup.add(toggleButtonArea);
1067: buttonGroup.add(toggleButtonBar);
1068: buttonGroup.add(toggleButtonLine);
1069: buttonGroup.add(toggleButtonPie);
1070: buttonGroup.add(toggleButtonRing);
1071: buttonGroup.add(toggleButtonMultiPie);
1072: buttonGroup.add(toggleButtonWaterfall);
1073:
1074: buttonGroup.add(toggleButtonBarLine);
1075: buttonGroup.add(toggleButtonBubble);
1076: buttonGroup.add(toggleButtonExtendedXYLine);
1077: buttonGroup.add(toggleButtonScatterPlot);
1078: buttonGroup.add(toggleButtonXYArea);
1079: buttonGroup.add(toggleButtonXYBar);
1080: buttonGroup.add(toggleButtonXYLine);
1081:
1082: centerPanel
1083: .add(buttonPanel, cc.xywh(2, 2, 1, 3, "center, top"));
1084:
1085: JLabel nameLabel = new JLabel(TranslationManager.getInstance()
1086: .getTranslation("R", "Property.name"));
1087: final JTextField nameTextField = new JTextField(
1088: chartReportElement.getName());
1089: centerPanel.add(nameLabel, cc.xy(4, 2));
1090: centerPanel.add(nameTextField, cc.xy(6, 2));
1091:
1092: propertyEditorPanelData1
1093: .setBeans(new Object[] { chartReportElement
1094: .getDataCollectorFunction() });
1095: propertyEditorPanelData2
1096: .setBeans(new Object[] { chartReportElement
1097: .getDataCollectorFunction2() });
1098: propertyEditorPanelChart
1099: .setBeans(new Object[] { chartReportElement
1100: .getChartFunction() });
1101:
1102: chartReportElement.getDataCollectorFunction()
1103: .addPropertyChangeListener(PropertyKeys.NAME,
1104: propertyChangeListener);
1105:
1106: centerPanel.add(editorPanel, cc.xyw(4, 4, 3));
1107:
1108: JButton okButton = new JButton(TranslationManager.getInstance()
1109: .getTranslation("R", "Button.apply"));
1110: okButton.addActionListener(new ActionListener() {
1111: public void actionPerformed(@NotNull
1112: ActionEvent e) {
1113: chartReportElement.setName(nameTextField.getText());
1114: centerPanelDialog.dispose();
1115: }
1116: });
1117:
1118: centerPanelDialog.setButtons(okButton, okButton, okButton);
1119:
1120: centerPanelDialog.setCenterPanel(centerPanel);
1121: centerPanelDialog.pack();
1122: centerPanelDialog.setSize(800, 600);
1123: WindowUtils.setLocationRelativeTo(centerPanelDialog, parent);
1124: centerPanelDialog.setVisible(true);
1125: }
1126:
1127: private static void updateDataCollector2Name(@NotNull
1128: ReportFunctionElement chartFunctionElement, @NotNull
1129: ReportFunctionElement dataCollectorFunction2) {
1130: try {
1131: Method setter = chartFunctionElement.getClass().getMethod(
1132: "setLinesDataSource", String.class);//NON-NLS
1133: Method getter = dataCollectorFunction2.getClass()
1134: .getMethod("getName");//NON-NLS
1135: setter.invoke(chartFunctionElement, getter
1136: .invoke(dataCollectorFunction2));
1137: } catch (Exception e) {
1138: if (LOG.isLoggable(Level.FINE))
1139: LOG.log(Level.FINE,
1140: "ChartEditor.updateDataCollector2Name ", e);
1141: }
1142: }
1143:
1144: private static void addDataSource2Panel(@NotNull
1145: JPanel editorPanel, @NotNull
1146: JScrollPane dataSource2ScrollPane) {
1147: editorPanel.add(dataSource2ScrollPane);
1148: editorPanel.revalidate();
1149: editorPanel.repaint();
1150: }
1151:
1152: private static void removeDataSource2Panel(@NotNull
1153: JPanel editorPanel, @NotNull
1154: JScrollPane dataSource2ScrollPane) {
1155: editorPanel.remove(dataSource2ScrollPane);
1156: editorPanel.revalidate();
1157: editorPanel.repaint();
1158: }
1159:
1160: @NotNull
1161: private static ReportFunctionElement getChartFunction(@NotNull
1162: ChartReportElement chartReportElement, @NotNull
1163: ReportFunctionElement wrapperInstance) {
1164: copyAsMuchAsPossible(chartReportElement.getChartFunction(),
1165: wrapperInstance);
1166: return wrapperInstance;
1167: }
1168:
1169: @NotNull
1170: private static ReportFunctionElement getDataFunction(@NotNull
1171: ChartType oldChartType, @NotNull
1172: ChartType newChartType, @NotNull
1173: ReportFunctionElement currentFunctionElement) {
1174: AbstractFunction collectorFunction = null;
1175: if (!oldChartType.isPieSet() && newChartType.isPieSet()) {
1176: collectorFunction = new PieSetCollectorFunction();
1177: }
1178: if (!oldChartType.isCategorySet()
1179: && newChartType.isCategorySet()) {
1180: collectorFunction = new CategorySetCollectorFunction();
1181: }
1182: if (!oldChartType.isXYSet() && newChartType.isXYSet()) {
1183: collectorFunction = new XYSeriesCollectorFunction();
1184: }
1185: if (!oldChartType.isXYZSet() && newChartType.isXYZSet()) {
1186: collectorFunction = new XYZSeriesCollectorFunction();
1187: }
1188:
1189: if (collectorFunction != null) {
1190: collectorFunction.setName(currentFunctionElement.getName());
1191: ReportFunctionElement element = ExpressionRegistry
1192: .getInstance().createWrapperInstance(
1193: collectorFunction);
1194: copyAsMuchAsPossible(currentFunctionElement, element);
1195: return element;
1196: }
1197: return currentFunctionElement;
1198: }
1199:
1200: private static void copyAsMuchAsPossible(@NotNull
1201: ReportFunctionElement reportElementSource, @NotNull
1202: ReportFunctionElement reportElementTarget) {
1203: try {
1204: Expression jFreeReportExpressionInstance = ExpressionRegistry
1205: .getInstance().createJFreeReportExpressionInstance(
1206: reportElementSource);
1207: ExpressionRegistry.getInstance().fillWrapper(
1208: reportElementTarget, jFreeReportExpressionInstance);
1209: } catch (Exception e) {
1210: if (LOG.isLoggable(Level.FINE))
1211: LOG.log(Level.FINE,
1212: "ChartEditor.copyAsMuchAsPossible ", e);
1213: }
1214: }
1215:
1216: }
|