| /* |
| * Copyright (c) 2004, 2007, 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.io.*; |
| import java.lang.management.*; |
| import java.lang.reflect.*; |
| import java.util.*; |
| import java.util.concurrent.*; |
| |
| import javax.accessibility.*; |
| import javax.management.*; |
| import javax.management.openmbean.CompositeData; |
| import javax.swing.*; |
| import javax.swing.border.*; |
| |
| |
| import static sun.tools.jconsole.Formatter.*; |
| import static sun.tools.jconsole.Utilities.*; |
| |
| @SuppressWarnings("serial") |
| class MemoryTab extends Tab implements ActionListener, ItemListener { |
| JComboBox<Plotter> plotterChoice; |
| TimeComboBox timeComboBox; |
| JButton gcButton; |
| |
| PlotterPanel plotterPanel; |
| JPanel bottomPanel; |
| HTMLPane details; |
| PoolChart poolChart; |
| |
| ArrayList<Plotter> plotterList; |
| Plotter heapPlotter, nonHeapPlotter; |
| |
| private MemoryOverviewPanel overviewPanel; |
| |
| private static final String usedKey = "used"; |
| private static final String committedKey = "committed"; |
| private static final String maxKey = "max"; |
| private static final String thresholdKey = "threshold"; |
| private static final Color usedColor = Plotter.defaultColor; |
| private static final Color committedColor = null; |
| private static final Color maxColor = null; |
| private static final Color thresholdColor = Color.red; |
| |
| /* |
| Hierarchy of panels and layouts for this tab: |
| |
| MemoryTab (BorderLayout) |
| |
| North: topPanel (BorderLayout) |
| |
| Center: controlPanel (FlowLayout) |
| plotterChoice, timeComboBox |
| |
| East: topRightPanel (FlowLayout) |
| gcButton |
| |
| Center: plotterPanel |
| |
| Center: plotter |
| |
| South: bottomPanel (BorderLayout) |
| |
| Center: details |
| East: poolChart |
| */ |
| |
| |
| public static String getTabName() { |
| return Messages.MEMORY; |
| } |
| |
| public MemoryTab(VMPanel vmPanel) { |
| super(vmPanel, getTabName()); |
| |
| setLayout(new BorderLayout(0, 0)); |
| setBorder(new EmptyBorder(4, 4, 3, 4)); |
| |
| JPanel topPanel = new JPanel(new BorderLayout()); |
| plotterPanel = new PlotterPanel(null); |
| bottomPanel = new JPanel(new BorderLayout()); |
| |
| add(topPanel, BorderLayout.NORTH); |
| add(plotterPanel, BorderLayout.CENTER); |
| |
| JPanel controlPanel = new JPanel(new FlowLayout(FlowLayout.LEADING, 20, 5)); |
| topPanel.add(controlPanel, BorderLayout.CENTER); |
| |
| // Plotter choice |
| plotterChoice = new JComboBox<Plotter>(); |
| plotterChoice.addItemListener(this); |
| controlPanel.add(new LabeledComponent(Messages.CHART_COLON, |
| Resources.getMnemonicInt(Messages.CHART_COLON), |
| plotterChoice)); |
| |
| // Range control |
| timeComboBox = new TimeComboBox(); |
| controlPanel.add(new LabeledComponent(Messages.TIME_RANGE_COLON, |
| Resources.getMnemonicInt(Messages.TIME_RANGE_COLON), |
| timeComboBox)); |
| |
| gcButton = new JButton(Messages.PERFORM_GC); |
| gcButton.setMnemonic(Resources.getMnemonicInt(Messages.PERFORM_GC)); |
| gcButton.addActionListener(this); |
| gcButton.setToolTipText(Messages.PERFORM_GC_TOOLTIP); |
| JPanel topRightPanel = new JPanel(); |
| topRightPanel.setBorder(new EmptyBorder(0, 65-8, 0, 70)); |
| topRightPanel.add(gcButton); |
| topPanel.add(topRightPanel, BorderLayout.AFTER_LINE_ENDS); |
| |
| bottomPanel.setBorder(new CompoundBorder(new TitledBorder(Messages.DETAILS), |
| new EmptyBorder(10, 10, 10, 10))); |
| |
| details = new HTMLPane(); |
| setAccessibleName(details, Messages.DETAILS); |
| bottomPanel.add(new JScrollPane(details), BorderLayout.CENTER); |
| |
| poolChart = new PoolChart(); |
| bottomPanel.add(poolChart, BorderLayout.AFTER_LINE_ENDS); |
| } |
| |
| |
| private void createPlotters() throws IOException { |
| plotterList = new ArrayList<Plotter>(); |
| |
| ProxyClient proxyClient = vmPanel.getProxyClient(); |
| |
| heapPlotter = new Plotter(Plotter.Unit.BYTES) { |
| public String toString() { |
| return Messages.HEAP_MEMORY_USAGE; |
| } |
| }; |
| proxyClient.addWeakPropertyChangeListener(heapPlotter); |
| |
| nonHeapPlotter = new Plotter(Plotter.Unit.BYTES) { |
| public String toString() { |
| return Messages.NON_HEAP_MEMORY_USAGE; |
| } |
| }; |
| |
| setAccessibleName(heapPlotter, |
| Messages.MEMORY_TAB_HEAP_PLOTTER_ACCESSIBLE_NAME); |
| setAccessibleName(nonHeapPlotter, |
| Messages.MEMORY_TAB_NON_HEAP_PLOTTER_ACCESSIBLE_NAME); |
| |
| proxyClient.addWeakPropertyChangeListener(nonHeapPlotter); |
| |
| heapPlotter.createSequence(usedKey, Messages.USED, usedColor, true); |
| heapPlotter.createSequence(committedKey, Messages.COMMITTED, committedColor, false); |
| heapPlotter.createSequence(maxKey, Messages.MAX, maxColor, false); |
| |
| nonHeapPlotter.createSequence(usedKey, Messages.USED, usedColor, true); |
| nonHeapPlotter.createSequence(committedKey, Messages.COMMITTED, committedColor, false); |
| nonHeapPlotter.createSequence(maxKey, Messages.MAX, maxColor, false); |
| |
| plotterList.add(heapPlotter); |
| plotterList.add(nonHeapPlotter); |
| |
| // Now add memory pools |
| Map<ObjectName, MBeanInfo> mBeanMap = proxyClient.getMBeans("java.lang"); |
| Set<ObjectName> keys = mBeanMap.keySet(); |
| ObjectName[] objectNames = keys.toArray(new ObjectName[keys.size()]); |
| ArrayList<PoolPlotter> nonHeapPlotters = new ArrayList<PoolPlotter>(2); |
| for (ObjectName objectName : objectNames) { |
| String type = objectName.getKeyProperty("type"); |
| if (type.equals("MemoryPool")) { |
| String name = Resources.format(Messages.MEMORY_POOL_LABEL, |
| objectName.getKeyProperty("name")); |
| // Heap or non-heap? |
| boolean isHeap = false; |
| AttributeList al = |
| proxyClient.getAttributes(objectName, |
| new String[] { "Type" }); |
| if (al.size() > 0) { |
| isHeap = MemoryType.HEAP.name().equals(((Attribute)al.get(0)).getValue()); |
| } |
| PoolPlotter poolPlotter = new PoolPlotter(objectName, name, isHeap); |
| proxyClient.addWeakPropertyChangeListener(poolPlotter); |
| |
| poolPlotter.createSequence(usedKey, Messages.USED, usedColor, true); |
| poolPlotter.createSequence(committedKey, Messages.COMMITTED, committedColor, false); |
| poolPlotter.createSequence(maxKey, Messages.MAX, maxColor, false); |
| poolPlotter.createSequence(thresholdKey, Messages.THRESHOLD, thresholdColor, false); |
| poolPlotter.setUseDashedTransitions(thresholdKey, true); |
| |
| if (isHeap) { |
| plotterList.add(poolPlotter); |
| } else { |
| // Will be added to plotterList below |
| nonHeapPlotters.add(poolPlotter); |
| } |
| } |
| } |
| // Add non-heap plotters last |
| for (PoolPlotter poolPlotter : nonHeapPlotters) { |
| plotterList.add(poolPlotter); |
| } |
| } |
| |
| |
| public void itemStateChanged(ItemEvent ev) { |
| if (ev.getStateChange() == ItemEvent.SELECTED) { |
| Plotter plotter = (Plotter)plotterChoice.getSelectedItem(); |
| plotterPanel.setPlotter(plotter); |
| } |
| } |
| |
| public void gc() { |
| new Thread("MemoryPanel.gc") { |
| public void run() { |
| ProxyClient proxyClient = vmPanel.getProxyClient(); |
| try { |
| proxyClient.getMemoryMXBean().gc(); |
| } catch (UndeclaredThrowableException e) { |
| proxyClient.markAsDead(); |
| } catch (IOException e) { |
| // Ignore |
| } |
| } |
| }.start(); |
| } |
| |
| public SwingWorker<?, ?> newSwingWorker() { |
| return new SwingWorker<Boolean, Object>() { |
| private long[] used, committed, max, threshold; |
| private long timeStamp; |
| private String detailsStr; |
| private boolean initialRun = false; |
| |
| public Boolean doInBackground() { |
| ProxyClient proxyClient = vmPanel.getProxyClient(); |
| |
| if (plotterList == null) { |
| try { |
| createPlotters(); |
| } catch (UndeclaredThrowableException e) { |
| proxyClient.markAsDead(); |
| return false; |
| } catch (final IOException ex) { |
| return false; |
| } |
| initialRun = true; |
| } |
| |
| int n = plotterList.size(); |
| used = new long[n]; |
| committed = new long[n]; |
| max = new long[n]; |
| threshold = new long[n]; |
| timeStamp = System.currentTimeMillis(); |
| |
| for (int i = 0; i < n; i++) { |
| Plotter plotter = plotterList.get(i); |
| MemoryUsage mu = null; |
| used[i] = -1L; |
| threshold[i] = -1L; |
| |
| try { |
| if (plotter instanceof PoolPlotter) { |
| PoolPlotter poolPlotter = (PoolPlotter)plotter; |
| ObjectName objectName = poolPlotter.objectName; |
| AttributeList al = |
| proxyClient.getAttributes(objectName, |
| new String[] { "Usage", "UsageThreshold" }); |
| if (al.size() > 0) { |
| CompositeData cd = (CompositeData)((Attribute)al.get(0)).getValue(); |
| mu = MemoryUsage.from(cd); |
| |
| if (al.size() > 1) { |
| threshold[i] = (Long)((Attribute)al.get(1)).getValue(); |
| } |
| } |
| } else if (plotter == heapPlotter) { |
| mu = proxyClient.getMemoryMXBean().getHeapMemoryUsage(); |
| } else if (plotter == nonHeapPlotter) { |
| mu = proxyClient.getMemoryMXBean().getNonHeapMemoryUsage(); |
| } |
| } catch (UndeclaredThrowableException e) { |
| proxyClient.markAsDead(); |
| return false; |
| } catch (IOException ex) { |
| // Skip this plotter |
| } |
| |
| if (mu != null) { |
| used[i] = mu.getUsed(); |
| committed[i] = mu.getCommitted(); |
| max[i] = mu.getMax(); |
| } |
| } |
| detailsStr = formatDetails(); |
| |
| return true; |
| } |
| |
| protected void done() { |
| try { |
| if (!get()) { |
| return; |
| } |
| } catch (InterruptedException ex) { |
| return; |
| } catch (ExecutionException ex) { |
| if (JConsole.isDebug()) { |
| ex.printStackTrace(); |
| } |
| return; |
| } |
| |
| if (initialRun) { |
| // Add Memory Pools |
| for (Plotter p : plotterList) { |
| plotterChoice.addItem(p); |
| timeComboBox.addPlotter(p); |
| } |
| add(bottomPanel, BorderLayout.SOUTH); |
| } |
| |
| |
| int n = plotterList.size(); |
| int poolCount = 0; |
| |
| for (int i = 0; i < n; i++) { |
| Plotter plotter = plotterList.get(i); |
| if (used[i] >= 0L) { |
| if (plotter instanceof PoolPlotter) { |
| plotter.addValues(timeStamp, used[i], committed[i], max[i], threshold[i]); |
| if (threshold[i] > 0L) { |
| plotter.setIsPlotted(thresholdKey, true); |
| } |
| poolChart.setValue(poolCount++, (PoolPlotter)plotter, |
| used[i], threshold[i], max[i]); |
| } else { |
| plotter.addValues(timeStamp, used[i], committed[i], max[i]); |
| } |
| |
| if (plotter == heapPlotter && overviewPanel != null) { |
| overviewPanel.getPlotter().addValues(timeStamp, used[i]); |
| overviewPanel.updateMemoryInfo(used[i], committed[i], max[i]); |
| } |
| } |
| } |
| details.setText(detailsStr); |
| } |
| }; |
| } |
| |
| private String formatDetails() { |
| ProxyClient proxyClient = vmPanel.getProxyClient(); |
| if (proxyClient.isDead()) { |
| return ""; |
| } |
| |
| String text = "<table cellspacing=0 cellpadding=0>"; |
| |
| Plotter plotter = (Plotter)plotterChoice.getSelectedItem(); |
| if (plotter == null) { |
| return ""; |
| } |
| |
| //long time = plotter.getLastTimeStamp(); |
| long time = System.currentTimeMillis(); |
| String timeStamp = formatDateTime(time); |
| text += newRow(Messages.TIME, timeStamp); |
| |
| long used = plotter.getLastValue(usedKey); |
| long committed = plotter.getLastValue(committedKey); |
| long max = plotter.getLastValue(maxKey); |
| long threshold = plotter.getLastValue(thresholdKey); |
| |
| text += newRow(Messages.USED, formatKBytes(used)); |
| if (committed > 0L) { |
| text += newRow(Messages.COMMITTED, formatKBytes(committed)); |
| } |
| if (max > 0L) { |
| text += newRow(Messages.MAX, formatKBytes(max)); |
| } |
| if (threshold > 0L) { |
| text += newRow(Messages.USAGE_THRESHOLD, formatKBytes(threshold)); |
| } |
| |
| try { |
| Collection<GarbageCollectorMXBean> garbageCollectors = |
| proxyClient.getGarbageCollectorMXBeans(); |
| |
| boolean descPrinted = false; |
| for (GarbageCollectorMXBean garbageCollectorMBean : garbageCollectors) { |
| String gcName = garbageCollectorMBean.getName(); |
| long gcCount = garbageCollectorMBean.getCollectionCount(); |
| long gcTime = garbageCollectorMBean.getCollectionTime(); |
| String str = Resources.format(Messages.GC_TIME_DETAILS, justify(formatTime(gcTime), 14), |
| gcName, |
| String.format("%,d",gcCount)); |
| if (!descPrinted) { |
| text += newRow(Messages.GC_TIME, str); |
| descPrinted = true; |
| } else { |
| text += newRow(null, str); |
| } |
| } |
| } catch (IOException e) { |
| } |
| |
| return text; |
| } |
| |
| public void actionPerformed(ActionEvent ev) { |
| Object src = ev.getSource(); |
| if (src == gcButton) { |
| gc(); |
| } |
| } |
| |
| private class PoolPlotter extends Plotter { |
| ObjectName objectName; |
| String name; |
| boolean isHeap; |
| long value, threshold, max; |
| int barX; |
| |
| public PoolPlotter(ObjectName objectName, String name, boolean isHeap) { |
| super(Plotter.Unit.BYTES); |
| |
| this.objectName = objectName; |
| this.name = name; |
| this.isHeap = isHeap; |
| |
| setAccessibleName(this, |
| Resources.format(Messages.MEMORY_TAB_POOL_PLOTTER_ACCESSIBLE_NAME, |
| name)); |
| } |
| |
| |
| public String toString() { |
| return name; |
| } |
| } |
| |
| private class PoolChart extends BorderedComponent |
| implements Accessible, MouseListener { |
| final int height = 150; |
| final int leftMargin = 50; |
| final int rightMargin = 23; |
| final int bottomMargin = 35; |
| final int barWidth = 22; |
| final int barGap = 3; |
| final int groupGap = 8; |
| final int barHeight = height * 2 / 3; |
| |
| final Color greenBar = new Color(100, 255, 100); |
| final Color greenBarBackground = new Color(210, 255, 210); |
| final Color redBarBackground = new Color(255, 210, 210); |
| |
| Font smallFont = null; |
| |
| ArrayList<PoolPlotter> poolPlotters = new ArrayList<PoolPlotter>(5); |
| |
| int nHeapPools = 0; |
| int nNonHeapPools = 0; |
| Rectangle heapRect = new Rectangle(leftMargin, height - bottomMargin + 6, barWidth, 20); |
| Rectangle nonHeapRect = new Rectangle(leftMargin + groupGap, height - bottomMargin + 6, barWidth, 20); |
| |
| public PoolChart() { |
| super(null, null); |
| |
| setFocusable(true); |
| addMouseListener(this); |
| ToolTipManager.sharedInstance().registerComponent(this); |
| } |
| |
| public void setValue(int poolIndex, PoolPlotter poolPlotter, |
| long value, long threshold, long max) { |
| poolPlotter.value = value; |
| poolPlotter.threshold = threshold; |
| poolPlotter.max = max; |
| |
| if (poolIndex == poolPlotters.size()) { |
| poolPlotters.add(poolPlotter); |
| if (poolPlotter.isHeap) { |
| poolPlotter.barX = nHeapPools * (barWidth + barGap); |
| nHeapPools++; |
| heapRect.width = nHeapPools * barWidth + (nHeapPools - 1) * barGap; |
| nonHeapRect.x = leftMargin + heapRect.width + groupGap; |
| } else { |
| poolPlotter.barX = nonHeapRect.x - leftMargin + nNonHeapPools * (barWidth + barGap); |
| nNonHeapPools++; |
| nonHeapRect.width = nNonHeapPools * barWidth + (nNonHeapPools - 1) * barGap; |
| } |
| } else { |
| poolPlotters.set(poolIndex, poolPlotter); |
| } |
| repaint(); |
| } |
| |
| private void paintPoolBar(Graphics g, PoolPlotter poolPlotter) { |
| Rectangle barRect = getBarRect(poolPlotter); |
| g.setColor(Color.gray); |
| g.drawRect(barRect.x, barRect.y, barRect.width, barRect.height); |
| |
| long value = poolPlotter.value; |
| long max = poolPlotter.max; |
| if (max > 0L) { |
| g.translate(barRect.x, barRect.y); |
| |
| // Paint green background |
| g.setColor(greenBarBackground); |
| g.fillRect(1, 1, barRect.width - 1, barRect.height - 1); |
| |
| int greenHeight = (int)(value * barRect.height / max); |
| long threshold = poolPlotter.threshold; |
| if (threshold > 0L) { |
| int redHeight = (int)(threshold * barRect.height / max); |
| |
| // Paint red background |
| g.setColor(redBarBackground); |
| g.fillRect(1, 1, barRect.width - 1, barRect.height - redHeight); |
| |
| if (value > threshold) { |
| // Over threshold, paint red bar |
| g.setColor(thresholdColor); |
| g.fillRect(1, barRect.height - greenHeight, |
| barRect.width - 1, greenHeight - redHeight); |
| greenHeight = redHeight; |
| } |
| } |
| |
| // Paint green bar |
| g.setColor(greenBar); |
| g.fillRect(1, barRect.height - greenHeight, |
| barRect.width - 1, greenHeight); |
| |
| g.translate(-barRect.x, -barRect.y); |
| } |
| } |
| |
| public void paintComponent(Graphics g) { |
| super.paintComponent(g); |
| |
| if (poolPlotters.size() == 0) { |
| return; |
| } |
| |
| if (smallFont == null) { |
| smallFont = g.getFont().deriveFont(9.0F); |
| } |
| |
| // Paint background for chart area |
| g.setColor(getBackground()); |
| Rectangle r = g.getClipBounds(); |
| g.fillRect(r.x, r.y, r.width, r.height); |
| |
| g.setFont(smallFont); |
| FontMetrics fm = g.getFontMetrics(); |
| int fontDescent = fm.getDescent(); |
| |
| // Paint percentage axis |
| g.setColor(getForeground()); |
| for (int pc : new int[] { 0, 25, 50, 75, 100 }) { |
| String str = pc + "% --"; |
| g.drawString(str, |
| leftMargin - fm.stringWidth(str) - 4, |
| height - bottomMargin - (pc * barHeight / 100) + fontDescent + 1); |
| } |
| |
| for (PoolPlotter poolPlotter : poolPlotters) { |
| paintPoolBar(g, poolPlotter); |
| } |
| |
| g.setColor(Color.gray); |
| g.drawRect(heapRect.x, heapRect.y, heapRect.width, heapRect.height); |
| g.drawRect(nonHeapRect.x, nonHeapRect.y, nonHeapRect.width, nonHeapRect.height); |
| |
| Color heapColor = greenBar; |
| Color nonHeapColor = greenBar; |
| |
| |
| for (PoolPlotter poolPlotter : poolPlotters) { |
| if (poolPlotter.threshold > 0L && poolPlotter.value > poolPlotter.threshold) { |
| if (poolPlotter.isHeap) { |
| heapColor = thresholdColor; |
| } else { |
| nonHeapColor = thresholdColor; |
| } |
| } |
| } |
| g.setColor(heapColor); |
| g.fillRect(heapRect.x + 1, heapRect.y + 1, heapRect.width - 1, heapRect.height - 1); |
| g.setColor(nonHeapColor); |
| g.fillRect(nonHeapRect.x + 1, nonHeapRect.y + 1, nonHeapRect.width - 1, nonHeapRect.height - 1); |
| |
| String str = Messages.HEAP; |
| int stringWidth = fm.stringWidth(str); |
| int x = heapRect.x + (heapRect.width - stringWidth) / 2; |
| int y = heapRect.y + heapRect.height - 6; |
| g.setColor(Color.white); |
| g.drawString(str, x-1, y-1); |
| g.drawString(str, x+1, y-1); |
| g.drawString(str, x-1, y+1); |
| g.drawString(str, x+1, y+1); |
| g.setColor(Color.black); |
| g.drawString(str, x, y); |
| |
| str = Messages.NON_HEAP; |
| stringWidth = fm.stringWidth(str); |
| x = nonHeapRect.x + (nonHeapRect.width - stringWidth) / 2; |
| y = nonHeapRect.y + nonHeapRect.height - 6; |
| g.setColor(Color.white); |
| g.drawString(str, x-1, y-1); |
| g.drawString(str, x+1, y-1); |
| g.drawString(str, x-1, y+1); |
| g.drawString(str, x+1, y+1); |
| g.setColor(Color.black); |
| g.drawString(str, x, y); |
| |
| // Highlight current plotter |
| g.setColor(Color.blue); |
| r = null; |
| Plotter plotter = (Plotter)plotterChoice.getSelectedItem(); |
| if (plotter == heapPlotter) { |
| r = heapRect; |
| } else if (plotter == nonHeapPlotter) { |
| r = nonHeapRect; |
| } else if (plotter instanceof PoolPlotter) { |
| r = getBarRect((PoolPlotter)plotter); |
| } |
| if (r != null) { |
| g.drawRect(r.x - 1, r.y - 1, r.width + 2, r.height + 2); |
| } |
| } |
| |
| private Rectangle getBarRect(PoolPlotter poolPlotter) { |
| return new Rectangle(leftMargin + poolPlotter.barX, |
| height - bottomMargin - barHeight, |
| barWidth, barHeight); |
| } |
| |
| public Dimension getPreferredSize() { |
| return new Dimension(nonHeapRect.x + nonHeapRect.width + rightMargin, |
| height); |
| } |
| |
| public void mouseClicked(MouseEvent e) { |
| requestFocusInWindow(); |
| Plotter plotter = getPlotter(e); |
| |
| if (plotter != null && plotter != plotterChoice.getSelectedItem()) { |
| plotterChoice.setSelectedItem(plotter); |
| repaint(); |
| } |
| } |
| |
| public String getToolTipText(MouseEvent e) { |
| Plotter plotter = getPlotter(e); |
| |
| return (plotter != null) ? plotter.toString() : null; |
| } |
| |
| private Plotter getPlotter(MouseEvent e) { |
| Point p = e.getPoint(); |
| Plotter plotter = null; |
| |
| if (heapRect.contains(p)) { |
| plotter = heapPlotter; |
| } else if (nonHeapRect.contains(p)) { |
| plotter = nonHeapPlotter; |
| } else { |
| for (PoolPlotter poolPlotter : poolPlotters) { |
| if (getBarRect(poolPlotter).contains(p)) { |
| plotter = poolPlotter; |
| break; |
| } |
| } |
| } |
| return plotter; |
| } |
| |
| public void mousePressed(MouseEvent e) {} |
| public void mouseReleased(MouseEvent e) {} |
| public void mouseEntered(MouseEvent e) {} |
| public void mouseExited(MouseEvent e) {} |
| |
| |
| public AccessibleContext getAccessibleContext() { |
| if (accessibleContext == null) { |
| accessibleContext = new AccessiblePoolChart(); |
| } |
| return accessibleContext; |
| } |
| |
| protected class AccessiblePoolChart extends AccessibleJPanel { |
| public String getAccessibleName() { |
| String name = Messages.MEMORY_TAB_POOL_CHART_ACCESSIBLE_NAME; |
| |
| String keyValueList = ""; |
| for (PoolPlotter poolPlotter : poolPlotters) { |
| String value = (poolPlotter.value * 100 / poolPlotter.max) + "%"; |
| // Assume format string ends with newline |
| keyValueList += |
| Resources.format(Messages.PLOTTER_ACCESSIBLE_NAME_KEY_AND_VALUE, |
| poolPlotter.toString(), value); |
| if (poolPlotter.threshold > 0L) { |
| String threshold = |
| (poolPlotter.threshold * 100 / poolPlotter.max) + "%"; |
| if (poolPlotter.value > poolPlotter.threshold) { |
| keyValueList += |
| Resources.format(Messages.MEMORY_TAB_POOL_CHART_ABOVE_THRESHOLD, |
| threshold); |
| } else { |
| keyValueList += |
| Resources.format(Messages.MEMORY_TAB_POOL_CHART_BELOW_THRESHOLD, |
| threshold); |
| } |
| } |
| } |
| |
| return name + "\n" + keyValueList + "."; |
| } |
| } |
| } |
| |
| |
| OverviewPanel[] getOverviewPanels() { |
| if (overviewPanel == null) { |
| overviewPanel = new MemoryOverviewPanel(); |
| } |
| return new OverviewPanel[] { overviewPanel }; |
| } |
| |
| private static class MemoryOverviewPanel extends OverviewPanel { |
| MemoryOverviewPanel() { |
| super(Messages.HEAP_MEMORY_USAGE, usedKey, Messages.USED, Plotter.Unit.BYTES); |
| } |
| |
| private void updateMemoryInfo(long used, long committed, long max) { |
| getInfoLabel().setText(Resources.format(Messages.MEMORY_TAB_INFO_LABEL_FORMAT, |
| formatBytes(used, true), |
| formatBytes(committed, true), |
| formatBytes(max, true))); |
| } |
| } |
| } |
