--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/demo/share/jfc/J2Ddemo/java2d/MemoryMonitor.java Mon May 14 08:58:32 2018 -0700
@@ -0,0 +1,367 @@
+/*
+ *
+ * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of Oracle nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package java2d;
+
+
+import static java.awt.Color.BLACK;
+import static java.awt.Color.GREEN;
+import static java.awt.Color.YELLOW;
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.awt.event.WindowListener;
+import java.awt.geom.Line2D;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.BufferedImage;
+import java.util.Date;
+import javax.swing.JCheckBox;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JTextField;
+import javax.swing.border.EtchedBorder;
+import javax.swing.border.TitledBorder;
+
+
+/**
+ * Tracks Memory allocated & used, displayed in graph form.
+ */
+@SuppressWarnings("serial")
+public class MemoryMonitor extends JPanel {
+
+ private final JCheckBox dateStampCB = new JCheckBox("Output Date Stamp");
+ public Surface surf;
+ JPanel controls;
+ boolean doControls;
+ JTextField tf;
+
+ public MemoryMonitor() {
+ setLayout(new BorderLayout());
+ setBorder(new TitledBorder(new EtchedBorder(), "Memory Monitor"));
+ add(surf = new Surface());
+ controls = new JPanel();
+ controls.setPreferredSize(new Dimension(135, 80));
+ Font font = new Font(Font.SERIF, Font.PLAIN, 10);
+ JLabel label = new JLabel("Sample Rate");
+ label.setFont(font);
+ label.setForeground(BLACK);
+ controls.add(label);
+ tf = new JTextField("1000");
+ tf.setPreferredSize(new Dimension(45, 20));
+ controls.add(tf);
+ controls.add(label = new JLabel("ms"));
+ label.setFont(font);
+ label.setForeground(BLACK);
+ controls.add(dateStampCB);
+ dateStampCB.setFont(font);
+ addMouseListener(new MouseAdapter() {
+
+ @Override
+ public void mouseClicked(MouseEvent e) {
+ removeAll();
+ if ((doControls = !doControls)) {
+ surf.stop();
+ add(controls);
+ } else {
+ try {
+ surf.sleepAmount = Long.parseLong(tf.getText().trim());
+ } catch (Exception ex) {
+ }
+ surf.start();
+ add(surf);
+ }
+ revalidate();
+ repaint();
+ }
+ });
+ }
+
+
+ public class Surface extends JPanel implements Runnable {
+
+ public Thread thread;
+ public long sleepAmount = 1000;
+ private int w, h;
+ private BufferedImage bimg;
+ private Graphics2D big;
+ private Font font = new Font(Font.SERIF, Font.PLAIN, 11);
+ private Runtime r = Runtime.getRuntime();
+ private int columnInc;
+ private int pts[];
+ private int ptNum;
+ private int ascent, descent;
+ private Rectangle graphOutlineRect = new Rectangle();
+ private Rectangle2D mfRect = new Rectangle2D.Float();
+ private Rectangle2D muRect = new Rectangle2D.Float();
+ private Line2D graphLine = new Line2D.Float();
+ private Color graphColor = new Color(46, 139, 87);
+ private Color mfColor = new Color(0, 100, 0);
+ private String usedStr;
+
+ public Surface() {
+ setBackground(BLACK);
+ addMouseListener(new MouseAdapter() {
+
+ @Override
+ public void mouseClicked(MouseEvent e) {
+ if (thread == null) {
+ start();
+ } else {
+ stop();
+ }
+ }
+ });
+ }
+
+ @Override
+ public Dimension getMinimumSize() {
+ return getPreferredSize();
+ }
+
+ @Override
+ public Dimension getMaximumSize() {
+ return getPreferredSize();
+ }
+
+ @Override
+ public Dimension getPreferredSize() {
+ return new Dimension(135, 80);
+ }
+
+ @Override
+ public void paint(Graphics g) {
+
+ if (big == null) {
+ return;
+ }
+
+ big.setBackground(getBackground());
+ big.clearRect(0, 0, w, h);
+
+ float freeMemory = r.freeMemory();
+ float totalMemory = r.totalMemory();
+
+ // .. Draw allocated and used strings ..
+ big.setColor(GREEN);
+ big.drawString(String.valueOf((int) totalMemory / 1024)
+ + "K allocated", 4.0f, ascent + 0.5f);
+ usedStr = String.valueOf(((int) (totalMemory - freeMemory)) / 1024)
+ + "K used";
+ big.drawString(usedStr, 4, h - descent);
+
+ // Calculate remaining size
+ float ssH = ascent + descent;
+ float remainingHeight = (h - (ssH * 2) - 0.5f);
+ float blockHeight = remainingHeight / 10;
+ float blockWidth = 20.0f;
+
+ // .. Memory Free ..
+ big.setColor(mfColor);
+ int MemUsage = (int) ((freeMemory / totalMemory) * 10);
+ int i = 0;
+ for (; i < MemUsage; i++) {
+ mfRect.setRect(5, ssH + i * blockHeight,
+ blockWidth, blockHeight - 1);
+ big.fill(mfRect);
+ }
+
+ // .. Memory Used ..
+ big.setColor(GREEN);
+ for (; i < 10; i++) {
+ muRect.setRect(5, ssH + i * blockHeight,
+ blockWidth, blockHeight - 1);
+ big.fill(muRect);
+ }
+
+ // .. Draw History Graph ..
+ big.setColor(graphColor);
+ int graphX = 30;
+ int graphY = (int) ssH;
+ int graphW = w - graphX - 5;
+ int graphH = (int) remainingHeight;
+ graphOutlineRect.setRect(graphX, graphY, graphW, graphH);
+ big.draw(graphOutlineRect);
+
+ int graphRow = graphH / 10;
+
+ // .. Draw row ..
+ for (int j = graphY; j <= graphH + graphY; j += graphRow) {
+ graphLine.setLine(graphX, j, graphX + graphW, j);
+ big.draw(graphLine);
+ }
+
+ // .. Draw animated column movement ..
+ int graphColumn = graphW / 15;
+
+ if (columnInc == 0) {
+ columnInc = graphColumn;
+ }
+
+ for (int j = graphX + columnInc; j < graphW + graphX; j +=
+ graphColumn) {
+ graphLine.setLine(j, graphY, j, graphY + graphH);
+ big.draw(graphLine);
+ }
+
+ --columnInc;
+
+ if (pts == null) {
+ pts = new int[graphW];
+ ptNum = 0;
+ } else if (pts.length != graphW) {
+ int tmp[] = null;
+ if (ptNum < graphW) {
+ tmp = new int[ptNum];
+ System.arraycopy(pts, 0, tmp, 0, tmp.length);
+ } else {
+ tmp = new int[graphW];
+ System.arraycopy(pts, pts.length - tmp.length, tmp, 0,
+ tmp.length);
+ ptNum = tmp.length - 2;
+ }
+ pts = new int[graphW];
+ System.arraycopy(tmp, 0, pts, 0, tmp.length);
+ } else {
+ big.setColor(YELLOW);
+ pts[ptNum] =
+ (int) (graphY + graphH * (freeMemory / totalMemory));
+ for (int j = graphX + graphW - ptNum, k = 0; k < ptNum; k++, j++) {
+ if (k != 0) {
+ if (pts[k] != pts[k - 1]) {
+ big.drawLine(j - 1, pts[k - 1], j, pts[k]);
+ } else {
+ big.fillRect(j, pts[k], 1, 1);
+ }
+ }
+ }
+ if (ptNum + 2 == pts.length) {
+ // throw out oldest point
+ for (int j = 1; j < ptNum; j++) {
+ pts[j - 1] = pts[j];
+ }
+ --ptNum;
+ } else {
+ ptNum++;
+ }
+ }
+ g.drawImage(bimg, 0, 0, this);
+ }
+
+ public void start() {
+ thread = new Thread(this);
+ thread.setPriority(Thread.MIN_PRIORITY);
+ thread.setName("MemoryMonitor");
+ thread.start();
+ }
+
+ public synchronized void stop() {
+ thread = null;
+ notify();
+ }
+
+ @Override
+ @SuppressWarnings("SleepWhileHoldingLock")
+ public void run() {
+
+ Thread me = Thread.currentThread();
+
+ while (thread == me && !isShowing() || getSize().width == 0) {
+ try {
+ Thread.sleep(500);
+ } catch (InterruptedException e) {
+ return;
+ }
+ }
+
+ while (thread == me && isShowing()) {
+ Dimension d = getSize();
+ if (d.width != w || d.height != h) {
+ w = d.width;
+ h = d.height;
+ bimg = (BufferedImage) createImage(w, h);
+ big = bimg.createGraphics();
+ big.setFont(font);
+ FontMetrics fm = big.getFontMetrics(font);
+ ascent = fm.getAscent();
+ descent = fm.getDescent();
+ }
+ repaint();
+ try {
+ Thread.sleep(sleepAmount);
+ } catch (InterruptedException e) {
+ break;
+ }
+ if (dateStampCB.isSelected()) {
+ System.out.println(new Date().toString() + " " + usedStr);
+ }
+ }
+ thread = null;
+ }
+ }
+
+ public static void main(String s[]) {
+ final MemoryMonitor demo = new MemoryMonitor();
+ WindowListener l = new WindowAdapter() {
+
+ @Override
+ public void windowClosing(WindowEvent e) {
+ System.exit(0);
+ }
+
+ @Override
+ public void windowDeiconified(WindowEvent e) {
+ demo.surf.start();
+ }
+
+ @Override
+ public void windowIconified(WindowEvent e) {
+ demo.surf.stop();
+ }
+ };
+ JFrame f = new JFrame("J2D Demo - MemoryMonitor");
+ f.addWindowListener(l);
+ f.getContentPane().add("Center", demo);
+ f.pack();
+ f.setSize(new Dimension(200, 200));
+ f.setVisible(true);
+ demo.surf.start();
+ }
+}