public class MultipleAxisTrend extends JPanel implements MouseListener
{
private int x = 0; // x repräsentiert die einzelnen Seiten
private boolean addAxis = false;
private int yAxisLocation = 0;
private static int index = 0;
private static final int PAGECNT = 10;
private static final int TRENDLINIEN_ANZAHL = 40;
private static HashMap<String, Integer>[] trendMap = new HashMap[TRENDLINIEN_ANZAHL];
private static HashMap<String, Integer>[] unitMap = new HashMap[TRENDLINIEN_ANZAHL];
private static HashMap<String, Integer>[] unitAxisMap = new HashMap[TRENDLINIEN_ANZAHL];
private static HashMap<String, Integer>[] axisPosMap = new HashMap[TRENDLINIEN_ANZAHL];
private static int[] trendCnt = new int[PAGECNT];
private static String[] trendtitel = new String[PAGECNT];
private static String[] xachsetitel = new String[PAGECNT];
private static String[] yachsetitel = new String[PAGECNT];
private JFreeChart[] chart = new JFreeChart[PAGECNT];
private ChartPanel[] chartPanel = new ChartPanel[PAGECNT];
public static XYPlot[] plot = new XYPlot[PAGECNT];
private static NumberAxis[][] axis = new NumberAxis[PAGECNT][TRENDLINIEN_ANZAHL];
private XYItemRenderer[] renderer = new XYItemRenderer[PAGECNT];
private XYStepRenderer[] stepRenderer = new XYStepRenderer[PAGECNT];
private static TimeSeries[][] series = new TimeSeries[PAGECNT][TRENDLINIEN_ANZAHL]; //10 Seiten mit je 40 Variablen
private static CombinedDomainXYPlot[] cplot = new CombinedDomainXYPlot[PAGECNT];
private static StandardXYToolTipGenerator toolTip = new StandardXYToolTipGenerator();
private TimeSeriesCollection dataset;
private DateTime dateTime = new DateTime();
public static JMenuItem[][] mi = new JMenuItem[PAGECNT][10];
private boolean schaltSignal = false;
private String dBName;
private SearchDBName searchDBName = new SearchDBName();
private static DateAxis[] axis1 = new DateAxis[10];
private static Date startXAchse, endXAchse;
public MultipleAxisTrend(String trendtitel, String xachsetitel, String yachsetitel, int x)
{
this.x = x;
trendMap[x] = new HashMap();
unitMap[x] = new HashMap();
unitAxisMap[x] = new HashMap();
axisPosMap[x] = new HashMap();
axis1[x] = new DateAxis();
MultipleAxisTrend.trendtitel[x] = trendtitel;
MultipleAxisTrend.xachsetitel[x] = xachsetitel;
MultipleAxisTrend.yachsetitel[x] = yachsetitel;
chart[x] = createChart(x);
chartPanel[x] = new ChartPanel(chart[x]);
chartPanel[x].getPopupMenu().addSeparator();
chartPanel[x].getPopupMenu().setBorderPainted(false);
chartPanel[x].setPreferredSize(new java.awt.Dimension(600, 270));
chartPanel[x].setDomainZoomable(true);
chartPanel[x].setRangeZoomable(true);
chartPanel[x].addMouseListener(this);
mi[x][0] = (JMenuItem)chartPanel[x].getPopupMenu().getComponent(0);
mi[x][1] = (JMenuItem)chartPanel[x].getPopupMenu().getComponent(2);
mi[x][2] = (JMenuItem)chartPanel[x].getPopupMenu().getComponent(4);
mi[x][3] = (JMenuItem)((JMenu)chartPanel[x].getPopupMenu().getComponent(9)).getMenuComponent(0);
}
public ChartPanel getChartPanel()
{
return this.chartPanel[x];
}
private static JFreeChart createChart(int x)
{
JFreeChart chart = ChartFactory.createTimeSeriesChart(MultipleAxisTrend.trendtitel[x], MultipleAxisTrend.xachsetitel[x] + " ", MultipleAxisTrend.yachsetitel[x] + " ", null, false, true, false);
chart.setBackgroundPaint(Color.white);
plot[x] = (XYPlot) chart.getPlot();
axis1[x] = (DateAxis)plot[x].getDomainAxis();
plot[x].setOrientation(PlotOrientation.VERTICAL);
plot[x].setBackgroundPaint(Color.WHITE);
plot[x].setDomainGridlinePaint(Color.white);
plot[x].setRangeGridlinePaint(Color.white);
plot[x].setAxisOffset(new RectangleInsets(5.0, 5.0, 5.0, 5.0));
plot[x].getRangeAxis().setFixedDimension(15.0);
plot[x].setDomainGridlinePaint(Color.GRAY);
plot[x].setRangeGridlinePaint(Color.GRAY);
plot[x].setDomainCrosshairVisible(true);
plot[x].setRangeCrosshairVisible(true);
DateAxis axis = (DateAxis) plot[x].getDomainAxis();
return chart;
}
public void updatePanel(HashMap<String, Float> dBWerte, String nameLinie, int xSeite, String einheit, Color lineColor, int zeitRaum)
{
try {
if (zeitRaum != 6)
{
if (unitMap[xSeite].containsKey(einheit)) // Wieviele Linien benutzen die einzelnen Einheiten-Achsen
{
unitMap[xSeite].put(einheit, new Integer(unitMap[xSeite].get(einheit)+1));
addAxis = false; // wenn die Einheit schon vorhanden ist, dann auf dem Plot keine neue y- Achse zeichnen
}
else
{
unitMap[xSeite].put(einheit, new Integer(1));
if (axisPosMap[xSeite].containsKey(einheit))
addAxis = false;
else
addAxis = true; // neue y- Achse zeichnen
}
if (axisPosMap[xSeite].containsKey(einheit) == false)
{
axisPosMap[xSeite].put(einheit, trendCnt[xSeite]);
}
}
else
{
addAxis = false;
}
if (trendMap[xSeite].containsKey(nameLinie) == false) // wenn die Linie in der Map noch nicht vorhanden ist // wenn eine neue Linie hinzugefügt wird
{
trendMap[xSeite].put(nameLinie, trendCnt[xSeite]);
createPlot(dBWerte, einheit, xSeite, nameLinie, trendCnt[xSeite], lineColor, addAxis, zeitRaum);
trendCnt[xSeite]++;
}
else
{
index = trendMap[xSeite].get(nameLinie); //trend[xSeite] ist die Position, wo die Serie gespeichert wird
createPlot(dBWerte, einheit, xSeite, nameLinie, index, lineColor, addAxis, zeitRaum);
}
}
catch (Exception ex)
{
System.out.println("Fehler Klasse MultipleAxisTrend, Methode updatePanel: " + ex);
}
}
public void createPlot(HashMap<String,Float> dBWerte, String einheit, int xSeite, String nameLinie, int trendCnt, final Color lineColor, boolean addAxis, int zeitRaum)
{
try {
dBName = searchDBName.getDBName(nameLinie, xSeite);
for (int i = 0; i < Control.states.size(); i++)
{
if (Control.states.elementAt(i).getTypeElement().equals("TrendVariable") && Control.states.elementAt(i).getElementName().equals(dBName))
{
schaltSignal = Control.states.elementAt(i).getSchaltSignal();
break;
}
}
if (addAxis == true)
{
axis[xSeite][trendCnt] = new NumberAxis(einheit, trendCnt, xSeite);
axis[xSeite][trendCnt].setAutoRangeIncludesZero(false);
axis[xSeite][trendCnt].setAutoRange(true);
plot[xSeite].setRangeAxis(trendCnt, axis[xSeite][trendCnt]); // für jede TrendSeite einen plot[], also fuer 2 Seiten -> plot[0] und plot[1]
plot[xSeite].mapDatasetToRangeAxis(trendCnt, axisPosMap[xSeite].get(einheit)); // mapDatasetToRangeAxis(int indexLine, int axisIndex);
}
else if (addAxis == false)
{
axis[xSeite][axisPosMap[xSeite].get(einheit)].setVisible(true);
plot[xSeite].mapDatasetToRangeAxis(trendCnt, axisPosMap[xSeite].get(einheit));
}
XYDataset dataset = createDataset(nameLinie, new Second(), dBWerte, trendCnt, xSeite);
plot[xSeite].setDataset(trendCnt, dataset);
toolTip = new StandardXYToolTipGenerator(StandardXYToolTipGenerator.DEFAULT_TOOL_TIP_FORMAT, new SimpleDateFormat("d-MMM-yyyy HH:mm:ss.SSSS"), new DecimalFormat("0.00"));
if (schaltSignal == false) // Linie Punkt zu Punkt zeichnen
{
renderer[trendCnt] = new StandardXYItemRenderer();
renderer[trendCnt].setSeriesPaint(0, lineColor); // setSeriesPaint(int series, Paint paint);
//renderer[trendCnt].setBaseItemLabelsVisible(true);
plot[xSeite].setRenderer(trendCnt, renderer[trendCnt]);
plot[xSeite].getDomainAxis().setAutoRange(true);
renderer[trendCnt].setBaseToolTipGenerator(toolTip);
}
else if (schaltSignal == true) // Linie in binärer Form zeichnen
{
stepRenderer[trendCnt] = new XYStepRenderer();
stepRenderer[trendCnt].setSeriesPaint(0, lineColor); // setSeriesPaint(int series, Paint paint);
stepRenderer[trendCnt].setBaseItemLabelsVisible(true);
plot[xSeite].setRenderer(trendCnt, stepRenderer[trendCnt]);
stepRenderer[trendCnt].setBaseToolTipGenerator(toolTip);
}
if (zeitRaum == 6)
{
axis1[xSeite].setRange(startXAchse, endXAchse);
}
else
axis1[xSeite].setAutoRange(true);
}
catch (Exception ex)
{
System.out.println("Fehler Klasse MultipleAxisTrend, Methode createPlot: " + ex);
}
}
private XYDataset createDataset(final String name, RegularTimePeriod start, final HashMap<String, Float> dBWerte, final int trendCnt, final int xSeite) // erstellt das dataset
{
series[xSeite][trendCnt] = new TimeSeries(name, start.getClass());
for (Map.Entry<String, Float> e : dBWerte.entrySet())
{
dateTime.setDateTime(e.getKey());
try {
series[xSeite][trendCnt].add(new Second(dateTime.getSecond(), dateTime.getMinute(), dateTime.getHour(), dateTime.getDay(), dateTime.getMonth(), dateTime.getYear()), e.getValue());
}
catch (Exception ex) {//System.out.println("Fehler Klasse MultipleAxisTrend, Methode createDataset: " + ex); // hier tritt eine Exception auf, wenn 2 Werte mit den gleichen Zeiten hinzugefügt werden sollen
}
}
dataset = new TimeSeriesCollection();
dataset.addSeries(series[xSeite][trendCnt]);
return dataset;
}
public void deleteCurve(String nameLinie, int xSeite, int isCheckCnt) // Löschen der Linie
{
try {
String einheit = "";
series[xSeite][trendMap[xSeite].get(nameLinie)].clear(); // die Linie, welche Abgewählt wurde, löschen
for (int i = 0; i < Control.states.size(); i++)
{
if (Control.states.elementAt(i).getTypeElement().equals("TrendSeite") && Integer.parseInt(Control.states.elementAt(i).getElementName()) == xSeite && Control.states.elementAt(i).getText().equals(nameLinie))
{
dBName = Control.states.elementAt(i).getBezeichner();
break;
}
}
for (int i = 0; i < Control.states.size(); i++)
{
if (Control.states.elementAt(i).getElementName().equals(dBName) && Control.states.elementAt(i).getTypeElement().equals("TrendVariable"))
{
einheit = Control.states.elementAt(i).getEinheit();
break;
}
}
if (unitMap[xSeite].get(einheit) == 1) // wenn nur mehr eine Linie mit bezug auf eine Achse da ist, dann die Achse unsichtbar machen
{
try {
axis[xSeite][axisPosMap[xSeite].get(einheit)].setVisible(false);
}
catch (Exception e)
{
System.out.println("Fehler in der Methode deleteCurve: " + e);
}
unitMap[xSeite].remove(einheit);
}
else
{
unitMap[xSeite].put(einheit, new Integer(unitMap[xSeite].get(einheit)-1));
}
if (isCheckCnt == 0) // wenn keine Linie mehr angewählt ist, dann alles auf null setzen
{
unitMap[xSeite].clear();
axisPosMap[xSeite].clear();
trendMap[xSeite].clear();
unitAxisMap[xSeite].clear();
trendCnt[xSeite] = 0;
index = 0;
addAxis = false;
}
}
catch (Exception ex)
{
System.out.println("Fehler in der Klasse MultipleAxisTrend beim Löschen: " + ex);
}
}
public void setXAxisTimes(Date startXAchse, Date endXAchse)
{
this.startXAchse = startXAchse;
this.endXAchse = endXAchse;
}
}