--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/jdk.jconsole/share/classes/sun/tools/jconsole/Plotter.java Sun Aug 17 15:54:13 2014 +0100
@@ -0,0 +1,1100 @@
+/*
+ * Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.tools.jconsole;
+
+import java.awt.*;
+import java.awt.event.*;
+import java.beans.*;
+import java.io.*;
+import java.lang.reflect.Array;
+import java.util.*;
+
+import javax.accessibility.*;
+import javax.swing.*;
+import javax.swing.border.*;
+import javax.swing.filechooser.*;
+import javax.swing.filechooser.FileFilter;
+
+
+import com.sun.tools.jconsole.JConsoleContext;
+
+import static sun.tools.jconsole.Formatter.*;
+import static sun.tools.jconsole.ProxyClient.*;
+
+@SuppressWarnings("serial")
+public class Plotter extends JComponent
+ implements Accessible, ActionListener, PropertyChangeListener {
+
+ public static enum Unit {
+ NONE, BYTES, PERCENT
+ }
+
+ static final String[] rangeNames = {
+ Messages.ONE_MIN,
+ Messages.FIVE_MIN,
+ Messages.TEN_MIN,
+ Messages.THIRTY_MIN,
+ Messages.ONE_HOUR,
+ Messages.TWO_HOURS,
+ Messages.THREE_HOURS,
+ Messages.SIX_HOURS,
+ Messages.TWELVE_HOURS,
+ Messages.ONE_DAY,
+ Messages.SEVEN_DAYS,
+ Messages.ONE_MONTH,
+ Messages.THREE_MONTHS,
+ Messages.SIX_MONTHS,
+ Messages.ONE_YEAR,
+ Messages.ALL
+ };
+
+ static final int[] rangeValues = {
+ 1,
+ 5,
+ 10,
+ 30,
+ 1 * 60,
+ 2 * 60,
+ 3 * 60,
+ 6 * 60,
+ 12 * 60,
+ 1 * 24 * 60,
+ 7 * 24 * 60,
+ 1 * 31 * 24 * 60,
+ 3 * 31 * 24 * 60,
+ 6 * 31 * 24 * 60,
+ 366 * 24 * 60,
+ -1
+ };
+
+
+ final static long SECOND = 1000;
+ final static long MINUTE = 60 * SECOND;
+ final static long HOUR = 60 * MINUTE;
+ final static long DAY = 24 * HOUR;
+
+ final static Color bgColor = new Color(250, 250, 250);
+ final static Color defaultColor = Color.blue.darker();
+
+ final static int ARRAY_SIZE_INCREMENT = 4000;
+
+ private static Stroke dashedStroke;
+
+ private TimeStamps times = new TimeStamps();
+ private ArrayList<Sequence> seqs = new ArrayList<Sequence>();
+ private JPopupMenu popupMenu;
+ private JMenu timeRangeMenu;
+ private JRadioButtonMenuItem[] menuRBs;
+ private JMenuItem saveAsMI;
+ private JFileChooser saveFC;
+
+ private int viewRange = -1; // Minutes (value <= 0 means full range)
+ private Unit unit;
+ private int decimals;
+ private double decimalsMultiplier;
+ private Border border = null;
+ private Rectangle r = new Rectangle(1, 1, 1, 1);
+ private Font smallFont = null;
+
+ // Initial margins, may be recalculated as needed
+ private int topMargin = 10;
+ private int bottomMargin = 45;
+ private int leftMargin = 65;
+ private int rightMargin = 70;
+ private final boolean displayLegend;
+
+ public Plotter() {
+ this(Unit.NONE, 0);
+ }
+
+ public Plotter(Unit unit) {
+ this(unit, 0);
+ }
+
+ public Plotter(Unit unit, int decimals) {
+ this(unit,decimals,true);
+ }
+
+ // Note: If decimals > 0 then values must be decimally shifted left
+ // that many places, i.e. multiplied by Math.pow(10.0, decimals).
+ public Plotter(Unit unit, int decimals, boolean displayLegend) {
+ this.displayLegend = displayLegend;
+ setUnit(unit);
+ setDecimals(decimals);
+
+ enableEvents(AWTEvent.MOUSE_EVENT_MASK);
+
+ addMouseListener(new MouseAdapter() {
+ @Override
+ public void mousePressed(MouseEvent e) {
+ if (getParent() instanceof PlotterPanel) {
+ getParent().requestFocusInWindow();
+ }
+ }
+ });
+
+ }
+
+ public void setUnit(Unit unit) {
+ this.unit = unit;
+ }
+
+ public void setDecimals(int decimals) {
+ this.decimals = decimals;
+ this.decimalsMultiplier = Math.pow(10.0, decimals);
+ }
+
+ public void createSequence(String key, String name, Color color, boolean isPlotted) {
+ Sequence seq = getSequence(key);
+ if (seq == null) {
+ seq = new Sequence(key);
+ }
+ seq.name = name;
+ seq.color = (color != null) ? color : defaultColor;
+ seq.isPlotted = isPlotted;
+
+ seqs.add(seq);
+ }
+
+ public void setUseDashedTransitions(String key, boolean b) {
+ Sequence seq = getSequence(key);
+ if (seq != null) {
+ seq.transitionStroke = b ? getDashedStroke() : null;
+ }
+ }
+
+ public void setIsPlotted(String key, boolean isPlotted) {
+ Sequence seq = getSequence(key);
+ if (seq != null) {
+ seq.isPlotted = isPlotted;
+ }
+ }
+
+ // Note: If decimals > 0 then values must be decimally shifted left
+ // that many places, i.e. multiplied by Math.pow(10.0, decimals).
+ public synchronized void addValues(long time, long... values) {
+ assert (values.length == seqs.size());
+ times.add(time);
+ for (int i = 0; i < values.length; i++) {
+ seqs.get(i).add(values[i]);
+ }
+ repaint();
+ }
+
+ private Sequence getSequence(String key) {
+ for (Sequence seq : seqs) {
+ if (seq.key.equals(key)) {
+ return seq;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * @return the displayed time range in minutes, or -1 for all data
+ */
+ public int getViewRange() {
+ return viewRange;
+ }
+
+ /**
+ * @param minutes the displayed time range in minutes, or -1 to diaplay all data
+ */
+ public void setViewRange(int minutes) {
+ if (minutes != viewRange) {
+ int oldValue = viewRange;
+ viewRange = minutes;
+ /* Do not i18n this string */
+ firePropertyChange("viewRange", oldValue, viewRange);
+ if (popupMenu != null) {
+ for (int i = 0; i < menuRBs.length; i++) {
+ if (rangeValues[i] == viewRange) {
+ menuRBs[i].setSelected(true);
+ break;
+ }
+ }
+ }
+ repaint();
+ }
+ }
+
+ @Override
+ public JPopupMenu getComponentPopupMenu() {
+ if (popupMenu == null) {
+ popupMenu = new JPopupMenu(Messages.CHART_COLON);
+ timeRangeMenu = new JMenu(Messages.PLOTTER_TIME_RANGE_MENU);
+ timeRangeMenu.setMnemonic(Resources.getMnemonicInt(Messages.PLOTTER_TIME_RANGE_MENU));
+ popupMenu.add(timeRangeMenu);
+ menuRBs = new JRadioButtonMenuItem[rangeNames.length];
+ ButtonGroup rbGroup = new ButtonGroup();
+ for (int i = 0; i < rangeNames.length; i++) {
+ menuRBs[i] = new JRadioButtonMenuItem(rangeNames[i]);
+ rbGroup.add(menuRBs[i]);
+ menuRBs[i].addActionListener(this);
+ if (viewRange == rangeValues[i]) {
+ menuRBs[i].setSelected(true);
+ }
+ timeRangeMenu.add(menuRBs[i]);
+ }
+
+ popupMenu.addSeparator();
+
+ saveAsMI = new JMenuItem(Messages.PLOTTER_SAVE_AS_MENU_ITEM);
+ saveAsMI.setMnemonic(Resources.getMnemonicInt(Messages.PLOTTER_SAVE_AS_MENU_ITEM));
+ saveAsMI.addActionListener(this);
+ popupMenu.add(saveAsMI);
+ }
+ return popupMenu;
+ }
+
+ public void actionPerformed(ActionEvent ev) {
+ JComponent src = (JComponent)ev.getSource();
+ if (src == saveAsMI) {
+ saveAs();
+ } else {
+ int index = timeRangeMenu.getPopupMenu().getComponentIndex(src);
+ setViewRange(rangeValues[index]);
+ }
+ }
+
+ private void saveAs() {
+ if (saveFC == null) {
+ saveFC = new SaveDataFileChooser();
+ }
+ int ret = saveFC.showSaveDialog(this);
+ if (ret == JFileChooser.APPROVE_OPTION) {
+ saveDataToFile(saveFC.getSelectedFile());
+ }
+ }
+
+ private void saveDataToFile(File file) {
+ try {
+ PrintStream out = new PrintStream(new FileOutputStream(file));
+
+ // Print header line
+ out.print("Time");
+ for (Sequence seq : seqs) {
+ out.print(","+seq.name);
+ }
+ out.println();
+
+ // Print data lines
+ if (seqs.size() > 0 && seqs.get(0).size > 0) {
+ for (int i = 0; i < seqs.get(0).size; i++) {
+ double excelTime = toExcelTime(times.time(i));
+ out.print(String.format(Locale.ENGLISH, "%.6f", excelTime));
+ for (Sequence seq : seqs) {
+ out.print("," + getFormattedValue(seq.value(i), false));
+ }
+ out.println();
+ }
+ }
+
+ out.close();
+ JOptionPane.showMessageDialog(this,
+ Resources.format(Messages.FILE_CHOOSER_SAVED_FILE,
+ file.getAbsolutePath(),
+ file.length()));
+ } catch (IOException ex) {
+ String msg = ex.getLocalizedMessage();
+ String path = file.getAbsolutePath();
+ if (msg.startsWith(path)) {
+ msg = msg.substring(path.length()).trim();
+ }
+ JOptionPane.showMessageDialog(this,
+ Resources.format(Messages.FILE_CHOOSER_SAVE_FAILED_MESSAGE,
+ path,
+ msg),
+ Messages.FILE_CHOOSER_SAVE_FAILED_TITLE,
+ JOptionPane.ERROR_MESSAGE);
+ }
+ }
+
+ @Override
+ public void paintComponent(Graphics g) {
+ super.paintComponent(g);
+
+ int width = getWidth()-rightMargin-leftMargin-10;
+ int height = getHeight()-topMargin-bottomMargin;
+ if (width <= 0 || height <= 0) {
+ // not enough room to paint anything
+ return;
+ }
+
+ Color oldColor = g.getColor();
+ Font oldFont = g.getFont();
+ Color fg = getForeground();
+ Color bg = getBackground();
+ boolean bgIsLight = (bg.getRed() > 200 &&
+ bg.getGreen() > 200 &&
+ bg.getBlue() > 200);
+
+
+ ((Graphics2D)g).setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+ RenderingHints.VALUE_ANTIALIAS_ON);
+
+ if (smallFont == null) {
+ smallFont = oldFont.deriveFont(9.0F);
+ }
+
+ r.x = leftMargin - 5;
+ r.y = topMargin - 8;
+ r.width = getWidth()-leftMargin-rightMargin;
+ r.height = getHeight()-topMargin-bottomMargin+16;
+
+ if (border == null) {
+ // By setting colors here, we avoid recalculating them
+ // over and over.
+ border = new BevelBorder(BevelBorder.LOWERED,
+ getBackground().brighter().brighter(),
+ getBackground().brighter(),
+ getBackground().darker().darker(),
+ getBackground().darker());
+ }
+
+ border.paintBorder(this, g, r.x, r.y, r.width, r.height);
+
+ // Fill background color
+ g.setColor(bgColor);
+ g.fillRect(r.x+2, r.y+2, r.width-4, r.height-4);
+ g.setColor(oldColor);
+
+ long tMin = Long.MAX_VALUE;
+ long tMax = Long.MIN_VALUE;
+ long vMin = Long.MAX_VALUE;
+ long vMax = 1;
+
+ int w = getWidth()-rightMargin-leftMargin-10;
+ int h = getHeight()-topMargin-bottomMargin;
+
+ if (times.size > 1) {
+ tMin = Math.min(tMin, times.time(0));
+ tMax = Math.max(tMax, times.time(times.size-1));
+ }
+ long viewRangeMS;
+ if (viewRange > 0) {
+ viewRangeMS = viewRange * MINUTE;
+ } else {
+ // Display full time range, but no less than a minute
+ viewRangeMS = Math.max(tMax - tMin, 1 * MINUTE);
+ }
+
+ // Calculate min/max values
+ for (Sequence seq : seqs) {
+ if (seq.size > 0) {
+ for (int i = 0; i < seq.size; i++) {
+ if (seq.size == 1 || times.time(i) >= tMax - viewRangeMS) {
+ long val = seq.value(i);
+ if (val > Long.MIN_VALUE) {
+ vMax = Math.max(vMax, val);
+ vMin = Math.min(vMin, val);
+ }
+ }
+ }
+ } else {
+ vMin = 0L;
+ }
+ if (unit == Unit.BYTES || !seq.isPlotted) {
+ // We'll scale only to the first (main) value set.
+ // TODO: Use a separate property for this.
+ break;
+ }
+ }
+
+ // Normalize scale
+ vMax = normalizeMax(vMax);
+ if (vMin > 0) {
+ if (vMax / vMin > 4) {
+ vMin = 0;
+ } else {
+ vMin = normalizeMin(vMin);
+ }
+ }
+
+
+ g.setColor(fg);
+
+ // Axes
+ // Draw vertical axis
+ int x = leftMargin - 18;
+ int y = topMargin;
+ FontMetrics fm = g.getFontMetrics();
+
+ g.drawLine(x, y, x, y+h);
+
+ int n = 5;
+ if ((""+vMax).startsWith("2")) {
+ n = 4;
+ } else if ((""+vMax).startsWith("3")) {
+ n = 6;
+ } else if ((""+vMax).startsWith("4")) {
+ n = 4;
+ } else if ((""+vMax).startsWith("6")) {
+ n = 6;
+ } else if ((""+vMax).startsWith("7")) {
+ n = 7;
+ } else if ((""+vMax).startsWith("8")) {
+ n = 8;
+ } else if ((""+vMax).startsWith("9")) {
+ n = 3;
+ }
+
+ // Ticks
+ ArrayList<Long> tickValues = new ArrayList<Long>();
+ tickValues.add(vMin);
+ for (int i = 0; i < n; i++) {
+ long v = i * vMax / n;
+ if (v > vMin) {
+ tickValues.add(v);
+ }
+ }
+ tickValues.add(vMax);
+ n = tickValues.size();
+
+ String[] tickStrings = new String[n];
+ for (int i = 0; i < n; i++) {
+ long v = tickValues.get(i);
+ tickStrings[i] = getSizeString(v, vMax);
+ }
+
+ // Trim trailing decimal zeroes.
+ if (decimals > 0) {
+ boolean trimLast = true;
+ boolean removedDecimalPoint = false;
+ do {
+ for (String str : tickStrings) {
+ if (!(str.endsWith("0") || str.endsWith("."))) {
+ trimLast = false;
+ break;
+ }
+ }
+ if (trimLast) {
+ if (tickStrings[0].endsWith(".")) {
+ removedDecimalPoint = true;
+ }
+ for (int i = 0; i < n; i++) {
+ String str = tickStrings[i];
+ tickStrings[i] = str.substring(0, str.length()-1);
+ }
+ }
+ } while (trimLast && !removedDecimalPoint);
+ }
+
+ // Draw ticks
+ int lastY = Integer.MAX_VALUE;
+ for (int i = 0; i < n; i++) {
+ long v = tickValues.get(i);
+ y = topMargin+h-(int)(h * (v-vMin) / (vMax-vMin));
+ g.drawLine(x-2, y, x+2, y);
+ String s = tickStrings[i];
+ if (unit == Unit.PERCENT) {
+ s += "%";
+ }
+ int sx = x-6-fm.stringWidth(s);
+ if (y < lastY-13) {
+ if (checkLeftMargin(sx)) {
+ // Wait for next repaint
+ return;
+ }
+ g.drawString(s, sx, y+4);
+ }
+ // Draw horizontal grid line
+ g.setColor(Color.lightGray);
+ g.drawLine(r.x + 4, y, r.x + r.width - 4, y);
+ g.setColor(fg);
+ lastY = y;
+ }
+
+ // Draw horizontal axis
+ x = leftMargin;
+ y = topMargin + h + 15;
+ g.drawLine(x, y, x+w, y);
+
+ long t1 = tMax;
+ if (t1 <= 0L) {
+ // No data yet, so draw current time
+ t1 = System.currentTimeMillis();
+ }
+ long tz = timeDF.getTimeZone().getOffset(t1);
+ long tickInterval = calculateTickInterval(w, 40, viewRangeMS);
+ if (tickInterval > 3 * HOUR) {
+ tickInterval = calculateTickInterval(w, 80, viewRangeMS);
+ }
+ long t0 = tickInterval - (t1 - viewRangeMS + tz) % tickInterval;
+ while (t0 < viewRangeMS) {
+ x = leftMargin + (int)(w * t0 / viewRangeMS);
+ g.drawLine(x, y-2, x, y+2);
+
+ long t = t1 - viewRangeMS + t0;
+ String str = formatClockTime(t);
+ g.drawString(str, x, y+16);
+ //if (tickInterval > (1 * HOUR) && t % (1 * DAY) == 0) {
+ if ((t + tz) % (1 * DAY) == 0) {
+ str = formatDate(t);
+ g.drawString(str, x, y+27);
+ }
+ // Draw vertical grid line
+ g.setColor(Color.lightGray);
+ g.drawLine(x, topMargin, x, topMargin + h);
+ g.setColor(fg);
+ t0 += tickInterval;
+ }
+
+ // Plot values
+ int start = 0;
+ int nValues = 0;
+ int nLists = seqs.size();
+ if (nLists > 0) {
+ nValues = seqs.get(0).size;
+ }
+ if (nValues == 0) {
+ g.setColor(oldColor);
+ return;
+ } else {
+ Sequence seq = seqs.get(0);
+ // Find starting point
+ for (int p = 0; p < seq.size; p++) {
+ if (times.time(p) >= tMax - viewRangeMS) {
+ start = p;
+ break;
+ }
+ }
+ }
+
+ //Optimization: collapse plot of more than four values per pixel
+ int pointsPerPixel = (nValues - start) / w;
+ if (pointsPerPixel < 4) {
+ pointsPerPixel = 1;
+ }
+
+ // Draw graphs
+ // Loop backwards over sequences because the first needs to be painted on top
+ for (int i = nLists-1; i >= 0; i--) {
+ int x0 = leftMargin;
+ int y0 = topMargin + h + 1;
+
+ Sequence seq = seqs.get(i);
+ if (seq.isPlotted && seq.size > 0) {
+ // Paint twice, with white and with color
+ for (int pass = 0; pass < 2; pass++) {
+ g.setColor((pass == 0) ? Color.white : seq.color);
+ int x1 = -1;
+ long v1 = -1;
+ for (int p = start; p < nValues; p += pointsPerPixel) {
+ // Make sure we get the last value
+ if (pointsPerPixel > 1 && p >= nValues - pointsPerPixel) {
+ p = nValues - 1;
+ }
+ int x2 = (int)(w * (times.time(p)-(t1-viewRangeMS)) / viewRangeMS);
+ long v2 = seq.value(p);
+ if (v2 >= vMin && v2 <= vMax) {
+ int y2 = (int)(h * (v2 -vMin) / (vMax-vMin));
+ if (x1 >= 0 && v1 >= vMin && v1 <= vMax) {
+ int y1 = (int)(h * (v1-vMin) / (vMax-vMin));
+
+ if (y1 == y2) {
+ // fillrect is much faster
+ g.fillRect(x0+x1, y0-y1-pass, x2-x1, 1);
+ } else {
+ Graphics2D g2d = (Graphics2D)g;
+ Stroke oldStroke = null;
+ if (seq.transitionStroke != null) {
+ oldStroke = g2d.getStroke();
+ g2d.setStroke(seq.transitionStroke);
+ }
+ g.drawLine(x0+x1, y0-y1-pass, x0+x2, y0-y2-pass);
+ if (oldStroke != null) {
+ g2d.setStroke(oldStroke);
+ }
+ }
+ }
+ }
+ x1 = x2;
+ v1 = v2;
+ }
+ }
+
+ // Current value
+ long v = seq.value(seq.size - 1);
+ if (v >= vMin && v <= vMax) {
+ if (bgIsLight) {
+ g.setColor(seq.color);
+ } else {
+ g.setColor(fg);
+ }
+ x = r.x + r.width + 2;
+ y = topMargin+h-(int)(h * (v-vMin) / (vMax-vMin));
+ // a small triangle/arrow
+ g.fillPolygon(new int[] { x+2, x+6, x+6 },
+ new int[] { y, y+3, y-3 },
+ 3);
+ }
+ g.setColor(fg);
+ }
+ }
+
+ int[] valueStringSlots = new int[nLists];
+ for (int i = 0; i < nLists; i++) valueStringSlots[i] = -1;
+ for (int i = 0; i < nLists; i++) {
+ Sequence seq = seqs.get(i);
+ if (seq.isPlotted && seq.size > 0) {
+ // Draw current value
+
+ // TODO: collapse values if pointsPerPixel >= 4
+
+ long v = seq.value(seq.size - 1);
+ if (v >= vMin && v <= vMax) {
+ x = r.x + r.width + 2;
+ y = topMargin+h-(int)(h * (v-vMin) / (vMax-vMin));
+ int y2 = getValueStringSlot(valueStringSlots, y, 2*10, i);
+ g.setFont(smallFont);
+ if (bgIsLight) {
+ g.setColor(seq.color);
+ } else {
+ g.setColor(fg);
+ }
+ String curValue = getFormattedValue(v, true);
+ if (unit == Unit.PERCENT) {
+ curValue += "%";
+ }
+ int valWidth = fm.stringWidth(curValue);
+ String legend = (displayLegend?seq.name:"");
+ int legendWidth = fm.stringWidth(legend);
+ if (checkRightMargin(valWidth) || checkRightMargin(legendWidth)) {
+ // Wait for next repaint
+ return;
+ }
+ g.drawString(legend , x + 17, Math.min(topMargin+h, y2 + 3 - 10));
+ g.drawString(curValue, x + 17, Math.min(topMargin+h + 10, y2 + 3));
+
+ // Maybe draw a short line to value
+ if (y2 > y + 3) {
+ g.drawLine(x + 9, y + 2, x + 14, y2);
+ } else if (y2 < y - 3) {
+ g.drawLine(x + 9, y - 2, x + 14, y2);
+ }
+ }
+ g.setFont(oldFont);
+ g.setColor(fg);
+
+ }
+ }
+ g.setColor(oldColor);
+ }
+
+ private boolean checkLeftMargin(int x) {
+ // Make sure leftMargin has at least 2 pixels over
+ if (x < 2) {
+ leftMargin += (2 - x);
+ // Repaint from top (above any cell renderers)
+ SwingUtilities.getWindowAncestor(this).repaint();
+ return true;
+ }
+ return false;
+ }
+
+ private boolean checkRightMargin(int w) {
+ // Make sure rightMargin has at least 2 pixels over
+ if (w + 2 > rightMargin) {
+ rightMargin = (w + 2);
+ // Repaint from top (above any cell renderers)
+ SwingUtilities.getWindowAncestor(this).repaint();
+ return true;
+ }
+ return false;
+ }
+
+ private int getValueStringSlot(int[] slots, int y, int h, int i) {
+ for (int s = 0; s < slots.length; s++) {
+ if (slots[s] >= y && slots[s] < y + h) {
+ // collide below us
+ if (slots[s] > h) {
+ return getValueStringSlot(slots, slots[s]-h, h, i);
+ } else {
+ return getValueStringSlot(slots, slots[s]+h, h, i);
+ }
+ } else if (y >= h && slots[s] > y - h && slots[s] < y) {
+ // collide above us
+ return getValueStringSlot(slots, slots[s]+h, h, i);
+ }
+ }
+ slots[i] = y;
+ return y;
+ }
+
+ private long calculateTickInterval(int w, int hGap, long viewRangeMS) {
+ long tickInterval = viewRangeMS * hGap / w;
+ if (tickInterval < 1 * MINUTE) {
+ tickInterval = 1 * MINUTE;
+ } else if (tickInterval < 5 * MINUTE) {
+ tickInterval = 5 * MINUTE;
+ } else if (tickInterval < 10 * MINUTE) {
+ tickInterval = 10 * MINUTE;
+ } else if (tickInterval < 30 * MINUTE) {
+ tickInterval = 30 * MINUTE;
+ } else if (tickInterval < 1 * HOUR) {
+ tickInterval = 1 * HOUR;
+ } else if (tickInterval < 3 * HOUR) {
+ tickInterval = 3 * HOUR;
+ } else if (tickInterval < 6 * HOUR) {
+ tickInterval = 6 * HOUR;
+ } else if (tickInterval < 12 * HOUR) {
+ tickInterval = 12 * HOUR;
+ } else if (tickInterval < 1 * DAY) {
+ tickInterval = 1 * DAY;
+ } else {
+ tickInterval = normalizeMax(tickInterval / DAY) * DAY;
+ }
+ return tickInterval;
+ }
+
+ private long normalizeMin(long l) {
+ int exp = (int)Math.log10((double)l);
+ long multiple = (long)Math.pow(10.0, exp);
+ int i = (int)(l / multiple);
+ return i * multiple;
+ }
+
+ private long normalizeMax(long l) {
+ int exp = (int)Math.log10((double)l);
+ long multiple = (long)Math.pow(10.0, exp);
+ int i = (int)(l / multiple);
+ l = (i+1)*multiple;
+ return l;
+ }
+
+ private String getFormattedValue(long v, boolean groupDigits) {
+ String str;
+ String fmt = "%";
+ if (groupDigits) {
+ fmt += ",";
+ }
+ if (decimals > 0) {
+ fmt += "." + decimals + "f";
+ str = String.format(fmt, v / decimalsMultiplier);
+ } else {
+ fmt += "d";
+ str = String.format(fmt, v);
+ }
+ return str;
+ }
+
+ private String getSizeString(long v, long vMax) {
+ String s;
+
+ if (unit == Unit.BYTES && decimals == 0) {
+ s = formatBytes(v, vMax);
+ } else {
+ s = getFormattedValue(v, true);
+ }
+ return s;
+ }
+
+ private static synchronized Stroke getDashedStroke() {
+ if (dashedStroke == null) {
+ dashedStroke = new BasicStroke(1.0f,
+ BasicStroke.CAP_BUTT,
+ BasicStroke.JOIN_MITER,
+ 10.0f,
+ new float[] { 2.0f, 3.0f },
+ 0.0f);
+ }
+ return dashedStroke;
+ }
+
+ private static Object extendArray(Object a1) {
+ int n = Array.getLength(a1);
+ Object a2 =
+ Array.newInstance(a1.getClass().getComponentType(),
+ n + ARRAY_SIZE_INCREMENT);
+ System.arraycopy(a1, 0, a2, 0, n);
+ return a2;
+ }
+
+
+ private static class TimeStamps {
+ // Time stamps (long) are split into offsets (long) and a
+ // series of times from the offsets (int). A new offset is
+ // stored when the the time value doesn't fit in an int
+ // (approx every 24 days). An array of indices is used to
+ // define the starting point for each offset in the times
+ // array.
+ long[] offsets = new long[0];
+ int[] indices = new int[0];
+ int[] rtimes = new int[ARRAY_SIZE_INCREMENT];
+
+ // Number of stored timestamps
+ int size = 0;
+
+ /**
+ * Returns the time stamp for index i
+ */
+ public long time(int i) {
+ long offset = 0;
+ for (int j = indices.length - 1; j >= 0; j--) {
+ if (i >= indices[j]) {
+ offset = offsets[j];
+ break;
+ }
+ }
+ return offset + rtimes[i];
+ }
+
+ public void add(long time) {
+ // May need to store a new time offset
+ int n = offsets.length;
+ if (n == 0 || time - offsets[n - 1] > Integer.MAX_VALUE) {
+ // Grow offset and indices arrays and store new offset
+ offsets = Arrays.copyOf(offsets, n + 1);
+ offsets[n] = time;
+ indices = Arrays.copyOf(indices, n + 1);
+ indices[n] = size;
+ }
+
+ // May need to extend the array size
+ if (rtimes.length == size) {
+ rtimes = (int[])extendArray(rtimes);
+ }
+
+ // Store the time
+ rtimes[size] = (int)(time - offsets[offsets.length - 1]);
+ size++;
+ }
+ }
+
+ private static class Sequence {
+ String key;
+ String name;
+ Color color;
+ boolean isPlotted;
+ Stroke transitionStroke = null;
+
+ // Values are stored in an int[] if all values will fit,
+ // otherwise in a long[]. An int can represent up to 2 GB.
+ // Use a random start size, so all arrays won't need to
+ // be grown during the same update interval
+ Object values =
+ new byte[ARRAY_SIZE_INCREMENT + (int)(Math.random() * 100)];
+
+ // Number of stored values
+ int size = 0;
+
+ public Sequence(String key) {
+ this.key = key;
+ }
+
+ /**
+ * Returns the value at index i
+ */
+ public long value(int i) {
+ return Array.getLong(values, i);
+ }
+
+ public void add(long value) {
+ // May need to switch to a larger array type
+ if ((values instanceof byte[] ||
+ values instanceof short[] ||
+ values instanceof int[]) &&
+ value > Integer.MAX_VALUE) {
+ long[] la = new long[Array.getLength(values)];
+ for (int i = 0; i < size; i++) {
+ la[i] = Array.getLong(values, i);
+ }
+ values = la;
+ } else if ((values instanceof byte[] ||
+ values instanceof short[]) &&
+ value > Short.MAX_VALUE) {
+ int[] ia = new int[Array.getLength(values)];
+ for (int i = 0; i < size; i++) {
+ ia[i] = Array.getInt(values, i);
+ }
+ values = ia;
+ } else if (values instanceof byte[] &&
+ value > Byte.MAX_VALUE) {
+ short[] sa = new short[Array.getLength(values)];
+ for (int i = 0; i < size; i++) {
+ sa[i] = Array.getShort(values, i);
+ }
+ values = sa;
+ }
+
+ // May need to extend the array size
+ if (Array.getLength(values) == size) {
+ values = extendArray(values);
+ }
+
+ // Store the value
+ if (values instanceof long[]) {
+ ((long[])values)[size] = value;
+ } else if (values instanceof int[]) {
+ ((int[])values)[size] = (int)value;
+ } else if (values instanceof short[]) {
+ ((short[])values)[size] = (short)value;
+ } else {
+ ((byte[])values)[size] = (byte)value;
+ }
+ size++;
+ }
+ }
+
+ // Can be overridden by subclasses
+ long getValue() {
+ return 0;
+ }
+
+ long getLastTimeStamp() {
+ return times.time(times.size - 1);
+ }
+
+ long getLastValue(String key) {
+ Sequence seq = getSequence(key);
+ return (seq != null && seq.size > 0) ? seq.value(seq.size - 1) : 0L;
+ }
+
+
+ // Called on EDT
+ public void propertyChange(PropertyChangeEvent ev) {
+ String prop = ev.getPropertyName();
+
+ if (prop == JConsoleContext.CONNECTION_STATE_PROPERTY) {
+ ConnectionState newState = (ConnectionState)ev.getNewValue();
+
+ switch (newState) {
+ case DISCONNECTED:
+ synchronized(this) {
+ long time = System.currentTimeMillis();
+ times.add(time);
+ for (Sequence seq : seqs) {
+ seq.add(Long.MIN_VALUE);
+ }
+ }
+ break;
+ }
+ }
+ }
+
+ private static class SaveDataFileChooser extends JFileChooser {
+ private static final long serialVersionUID = -5182890922369369669L;
+ SaveDataFileChooser() {
+ setFileFilter(new FileNameExtensionFilter("CSV file", "csv"));
+ }
+
+ @Override
+ public void approveSelection() {
+ File file = getSelectedFile();
+ if (file != null) {
+ FileFilter filter = getFileFilter();
+ if (filter != null && filter instanceof FileNameExtensionFilter) {
+ String[] extensions =
+ ((FileNameExtensionFilter)filter).getExtensions();
+
+ boolean goodExt = false;
+ for (String ext : extensions) {
+ if (file.getName().toLowerCase().endsWith("." + ext.toLowerCase())) {
+ goodExt = true;
+ break;
+ }
+ }
+ if (!goodExt) {
+ file = new File(file.getParent(),
+ file.getName() + "." + extensions[0]);
+ }
+ }
+
+ if (file.exists()) {
+ String okStr = Messages.FILE_CHOOSER_FILE_EXISTS_OK_OPTION;
+ String cancelStr = Messages.FILE_CHOOSER_FILE_EXISTS_CANCEL_OPTION;
+ int ret =
+ JOptionPane.showOptionDialog(this,
+ Resources.format(Messages.FILE_CHOOSER_FILE_EXISTS_MESSAGE,
+ file.getName()),
+ Messages.FILE_CHOOSER_FILE_EXISTS_TITLE,
+ JOptionPane.OK_CANCEL_OPTION,
+ JOptionPane.WARNING_MESSAGE,
+ null,
+ new Object[] { okStr, cancelStr },
+ okStr);
+ if (ret != JOptionPane.OK_OPTION) {
+ return;
+ }
+ }
+ setSelectedFile(file);
+ }
+ super.approveSelection();
+ }
+ }
+
+ @Override
+ public AccessibleContext getAccessibleContext() {
+ if (accessibleContext == null) {
+ accessibleContext = new AccessiblePlotter();
+ }
+ return accessibleContext;
+ }
+
+ protected class AccessiblePlotter extends AccessibleJComponent {
+ private static final long serialVersionUID = -3847205410473510922L;
+ protected AccessiblePlotter() {
+ setAccessibleName(Messages.PLOTTER_ACCESSIBLE_NAME);
+ }
+
+ @Override
+ public String getAccessibleName() {
+ String name = super.getAccessibleName();
+
+ if (seqs.size() > 0 && seqs.get(0).size > 0) {
+ String keyValueList = "";
+ for (Sequence seq : seqs) {
+ if (seq.isPlotted) {
+ String value = "null";
+ if (seq.size > 0) {
+ if (unit == Unit.BYTES) {
+ value = Resources.format(Messages.SIZE_BYTES, seq.value(seq.size - 1));
+ } else {
+ value =
+ getFormattedValue(seq.value(seq.size - 1), false) +
+ ((unit == Unit.PERCENT) ? "%" : "");
+ }
+ }
+ // Assume format string ends with newline
+ keyValueList +=
+ Resources.format(Messages.PLOTTER_ACCESSIBLE_NAME_KEY_AND_VALUE,
+ seq.key, value);
+ }
+ }
+ name += "\n" + keyValueList + ".";
+ } else {
+ name += "\n" + Messages.PLOTTER_ACCESSIBLE_NAME_NO_DATA;
+ }
+ return name;
+ }
+
+ @Override
+ public AccessibleRole getAccessibleRole() {
+ return AccessibleRole.CANVAS;
+ }
+ }
+}