/*
* Copyright 2004-2007 Sun Microsystems, Inc. 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. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package sun.tools.jconsole.inspector;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.*;
import javax.swing.tree.*;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.FlowLayout;
import java.awt.Component;
import java.awt.EventQueue;
import java.awt.event.*;
import java.awt.Insets;
import java.awt.Dimension;
import java.util.*;
import java.io.*;
import java.lang.reflect.Array;
import javax.management.*;
import javax.management.openmbean.CompositeData;
import javax.management.openmbean.TabularData;
import sun.tools.jconsole.Resources;
import sun.tools.jconsole.MBeansTab;
import sun.tools.jconsole.Plotter;
import sun.tools.jconsole.JConsole;
import sun.tools.jconsole.ProxyClient.SnapshotMBeanServerConnection;
/*IMPORTANT :
There is a deadlock issue there if we don't synchronize well loadAttributes,
refresh attributes and empty table methods since a UI thread can call
loadAttributes and at the same time a JMX notification can raise an
emptyTable. Since there are synchronization in the JMX world it's
COMPULSORY to not call the JMX world in synchronized blocks */
@SuppressWarnings("serial")
public class XMBeanAttributes extends XTable {
private final static String[] columnNames =
{Resources.getText("Name"),
Resources.getText("Value")};
private boolean editable = true;
private XMBean mbean;
private MBeanInfo mbeanInfo;
private MBeanAttributeInfo[] attributesInfo;
private HashMap<String, Object> attributes;
private HashMap<String, Object> unavailableAttributes;
private HashMap<String, Object> viewableAttributes;
private WeakHashMap<XMBean, HashMap<String, ZoomedCell>> viewersCache =
new WeakHashMap<XMBean, HashMap<String, ZoomedCell>>();
private TableModelListener attributesListener;
private MBeansTab mbeansTab;
private XTable table;
private TableCellEditor valueCellEditor = new ValueCellEditor();
private int rowMinHeight = -1;
private AttributesMouseListener mouseListener = new AttributesMouseListener();
private static TableCellEditor editor =
new Utils.ReadOnlyTableCellEditor(new JTextField());
public XMBeanAttributes(MBeansTab mbeansTab) {
super();
this.mbeansTab = mbeansTab;
((DefaultTableModel)getModel()).setColumnIdentifiers(columnNames);
getModel().addTableModelListener(attributesListener =
new AttributesListener(this));
getColumnModel().getColumn(NAME_COLUMN).setPreferredWidth(40);
addMouseListener(mouseListener);
getTableHeader().setReorderingAllowed(false);
setColumnEditors();
addKeyListener(new Utils.CopyKeyAdapter());
}
public synchronized Component prepareRenderer(TableCellRenderer renderer,
int row, int column) {
//In case we have a repaint thread that is in the process of
//repainting an obsolete table, just ignore the call.
//It can happen when MBean selection is switched at a very quick rate
if(row >= getRowCount())
return null;
else
return super.prepareRenderer(renderer, row, column);
}
void updateRowHeight(Object obj, int row) {
ZoomedCell cell = null;
if(obj instanceof ZoomedCell) {
cell = (ZoomedCell) obj;
if(cell.isInited())
setRowHeight(row, cell.getHeight());
else
if(rowMinHeight != - 1)
setRowHeight(row, rowMinHeight);
} else
if(rowMinHeight != - 1)
setRowHeight(row, rowMinHeight);
}
public synchronized TableCellRenderer getCellRenderer(int row,
int column) {
//In case we have a repaint thread that is in the process of
//repainting an obsolete table, just ignore the call.
//It can happen when MBean selection is switched at a very quick rate
if (row >= getRowCount()) {
return null;
} else {
if (column == VALUE_COLUMN) {
Object obj = getModel().getValueAt(row, column);
if (obj instanceof ZoomedCell) {
ZoomedCell cell = (ZoomedCell) obj;
if (cell.isInited()) {
DefaultTableCellRenderer renderer =
(DefaultTableCellRenderer) cell.getRenderer();
renderer.setToolTipText(getToolTip(row,column));
return renderer;
}
}
}
DefaultTableCellRenderer renderer = (DefaultTableCellRenderer)
super.getCellRenderer(row, column);
if (!isCellError(row, column)) {
if (!(isColumnEditable(column) && isWritable(row) &&
Utils.isEditableType(getClassName(row)))) {
renderer.setForeground(getDefaultColor());
}
}
return renderer;
}
}
private void setColumnEditors() {
TableColumnModel tcm = getColumnModel();
for (int i = 0; i < columnNames.length; i++) {
TableColumn tc = tcm.getColumn(i);
if (isColumnEditable(i)) {
tc.setCellEditor(valueCellEditor);
} else {
tc.setCellEditor(editor);
}
}
}
public void cancelCellEditing() {
TableCellEditor editor = getCellEditor();
if (editor != null) {
editor.cancelCellEditing();
}
}
public void stopCellEditing() {
TableCellEditor editor = getCellEditor();
if (editor != null) {
editor.stopCellEditing();
}
}
public final boolean editCellAt(int row, int column, EventObject e) {
boolean retVal = super.editCellAt(row, column, e);
if (retVal) {
TableCellEditor editor =
getColumnModel().getColumn(column).getCellEditor();
if (editor == valueCellEditor) {
((JComponent) editor).requestFocus();
}
}
return retVal;
}
@Override
public boolean isCellEditable(int row, int col) {
// All the cells in non-editable columns are editable
if (!isColumnEditable(col)) {
return true;
}
// Maximized zoomed cells are editable
Object obj = getModel().getValueAt(row, col);
if (obj instanceof ZoomedCell) {
ZoomedCell cell = (ZoomedCell) obj;
return cell.isMaximized();
}
return true;
}
@Override
public void setValueAt(Object value, int row, int column) {
if (!isCellError(row, column) && isColumnEditable(column) &&
isWritable(row) && Utils.isEditableType(getClassName(row))) {
super.setValueAt(value, row, column);
}
}
//Table methods
public boolean isTableEditable() {
return true;
}
public void setTableValue(Object value, int row) {
}
public boolean isColumnEditable(int column) {
if (column < getColumnCount()) {
return getColumnName(column).equals(Resources.getText("Value"));
}
else {
return false;
}
}
public String getClassName(int row) {
int index = convertRowToIndex(row);
if (index != -1) {
return attributesInfo[index].getType();
}
else {
return null;
}
}
public String getValueName(int row) {
int index = convertRowToIndex(row);
if (index != -1) {
return attributesInfo[index].getName();
}
else {
return null;
}
}
public Object getValue(int row) {
return ((DefaultTableModel) getModel()).getValueAt(row, VALUE_COLUMN);
}
//tool tip only for editable column
public String getToolTip(int row, int column) {
if (isCellError(row, column)) {
return (String) unavailableAttributes.get(getValueName(row));
}
if (isColumnEditable(column)) {
Object value = getValue(row);
String tip = null;
if (value != null) {
tip = value.toString();
if(isAttributeViewable(row, VALUE_COLUMN))
tip = Resources.getText("Double click to expand/collapse")+
". " + tip;
}
return tip;
}
if(column == NAME_COLUMN) {
int index = convertRowToIndex(row);
if (index != -1) {
return attributesInfo[index].getDescription();
}
}
return null;
}
public synchronized boolean isWritable(int row) {
int index = convertRowToIndex(row);
if (index != -1) {
return (attributesInfo[index].isWritable());
}
else {
return false;
}
}
/**
* Override JTable method in order to make any call to this method
* atomic with TableModel elements.
*/
public synchronized int getRowCount() {
return super.getRowCount();
}
public synchronized boolean isReadable(int row) {
int index = convertRowToIndex(row);
if (index != -1) {
return (attributesInfo[index].isReadable());
}
else {
return false;
}
}
public synchronized boolean isCellError(int row, int col) {
return (isColumnEditable(col) &&
(unavailableAttributes.containsKey(getValueName(row))));
}
public synchronized boolean isAttributeViewable(int row, int col) {
boolean isViewable = false;
if(col == VALUE_COLUMN) {
Object obj = getModel().getValueAt(row, col);
if(obj instanceof ZoomedCell)
isViewable = true;
}
return isViewable;
}
public void loadAttributes(final XMBean mbean, MBeanInfo mbeanInfo) {
// To avoid deadlock with events coming from the JMX side,
// we retrieve all JMX stuff in a non synchronized block.
if(mbean == null) return;
final MBeanAttributeInfo[] attributesInfo = mbeanInfo.getAttributes();
final HashMap<String, Object> attributes =
new HashMap<String, Object>(attributesInfo.length);
final HashMap<String, Object> unavailableAttributes =
new HashMap<String, Object>(attributesInfo.length);
final HashMap<String, Object> viewableAttributes =
new HashMap<String, Object>(attributesInfo.length);
AttributeList list = null;
try {
list = mbean.getAttributes(attributesInfo);
}catch(Exception e) {
list = new AttributeList();
//Can't load all attributes, do it one after each other.
for(int i = 0; i < attributesInfo.length; i++) {
String name = null;
try {
name = attributesInfo[i].getName();
Object value =
mbean.getAttribute(name);
list.add(new Attribute(name, value));
}catch(Exception ex) {
if(attributesInfo[i].isReadable()) {
unavailableAttributes.put(name,
Utils.getActualException(ex).
toString());
}
}
}
}
try {
int att_length = list.size();
for (int i=0;i<att_length;i++) {
Attribute attribute = (Attribute) list.get(i);
if(isViewable(attribute)) {
viewableAttributes.put(attribute.getName(),
attribute.getValue());
}
else
attributes.put(attribute.getName(),attribute.getValue());
}
// if not all attributes are accessible,
// check them one after the other.
if (att_length < attributesInfo.length) {
for (int i=0;i<attributesInfo.length;i++) {
MBeanAttributeInfo attributeInfo = attributesInfo[i];
if (!attributes.containsKey(attributeInfo.getName()) &&
!viewableAttributes.containsKey(attributeInfo.
getName()) &&
!unavailableAttributes.containsKey(attributeInfo.
getName())) {
if (attributeInfo.isReadable()) {
// getAttributes didn't help resolving the
// exception.
// We must call it again to understand what
// went wrong.
try {
Object v =
mbean.getAttribute(attributeInfo.
getName());
//What happens if now it is ok?
// Be pragmatic, add it to readable...
attributes.put(attributeInfo.getName(),
v);
}catch(Exception e) {
//Put the exception that will be displayed
// in tooltip
unavailableAttributes.put(attributeInfo.
getName(),
Utils.
getActualException(e)
.toString());
}
}
}
}
}
}
catch(Exception e) {
//sets all attributes unavailable except the writable ones
for (int i=0;i<attributesInfo.length;i++) {
MBeanAttributeInfo attributeInfo = attributesInfo[i];
if (attributeInfo.isReadable()) {
unavailableAttributes.put(attributeInfo.getName(),
Utils.getActualException(e).
toString());
}
}
}
//end of retrieval
//one update at a time
synchronized(this) {
this.mbean = mbean;
this.mbeanInfo = mbeanInfo;
this.attributesInfo = attributesInfo;
this.attributes = attributes;
this.unavailableAttributes = unavailableAttributes;
this.viewableAttributes = viewableAttributes;
EventQueue.invokeLater(new Runnable() {
public void run() {
DefaultTableModel tableModel =
(DefaultTableModel) getModel();
// don't listen to these events
tableModel.removeTableModelListener(attributesListener);
// add attribute information
emptyTable();
addTableData(tableModel,
mbean,
attributesInfo,
attributes,
unavailableAttributes,
viewableAttributes);
// update the model with the new data
tableModel.newDataAvailable(new TableModelEvent(tableModel));
// re-register for change events
tableModel.addTableModelListener(attributesListener);
}
});
}
}
void collapse(String attributeName, final Component c) {
final int row = getSelectedRow();
Object obj = getModel().getValueAt(row, VALUE_COLUMN);
if(obj instanceof ZoomedCell) {
cancelCellEditing();
ZoomedCell cell = (ZoomedCell) obj;
cell.reset();
setRowHeight(row,
cell.getHeight());
editCellAt(row,
VALUE_COLUMN);
invalidate();
repaint();
}
}
ZoomedCell updateZoomedCell(int row,
int col) {
Object obj = getModel().getValueAt(row, VALUE_COLUMN);
ZoomedCell cell = null;
if(obj instanceof ZoomedCell) {
cell = (ZoomedCell) obj;
if(!cell.isInited()) {
Object elem = cell.getValue();
String attributeName =
(String) getModel().getValueAt(row,
NAME_COLUMN);
Component comp = mbeansTab.getDataViewer().
createAttributeViewer(elem, mbean, attributeName, this);
if(comp != null){
if(rowMinHeight == -1)
rowMinHeight = getRowHeight(row);
cell.init(super.getCellRenderer(row, col),
comp,
rowMinHeight);
mbeansTab.getDataViewer().registerForMouseEvent(
comp, mouseListener);
} else
return cell;
}
cell.switchState();
setRowHeight(row,
cell.getHeight());
if(!cell.isMaximized()) {
cancelCellEditing();
//Back to simple editor.
editCellAt(row,
VALUE_COLUMN);
}
invalidate();
repaint();
}
return cell;
}
public void refreshAttributes() {
MBeanServerConnection mbsc = mbeansTab.getMBeanServerConnection();
if (mbsc instanceof SnapshotMBeanServerConnection) {
((SnapshotMBeanServerConnection) mbsc).flush();
}
stopCellEditing();
loadAttributes(mbean, mbeanInfo);
}
public void emptyTable() {
synchronized(this) {
((DefaultTableModel) getModel()).
removeTableModelListener(attributesListener);
super.emptyTable();
}
}
private boolean isViewable(Attribute attribute) {
Object data = attribute.getValue();
return XDataViewer.isViewableValue(data);
}
synchronized void removeAttributes() {
if (attributes != null) {
attributes.clear();
}
if (unavailableAttributes != null) {
unavailableAttributes.clear();
}
if (viewableAttributes != null) {
viewableAttributes.clear();
}
mbean = null;
}
private ZoomedCell getZoomedCell(XMBean mbean, String attribute, Object value) {
synchronized (viewersCache) {
HashMap<String, ZoomedCell> viewers;
if (viewersCache.containsKey(mbean)) {
viewers = viewersCache.get(mbean);
} else {
viewers = new HashMap<String, ZoomedCell>();
}
ZoomedCell cell;
if (viewers.containsKey(attribute)) {
cell = viewers.get(attribute);
cell.setValue(value);
if (cell.isMaximized() && cell.getType() != XDataViewer.NUMERIC) {
// Plotters are the only viewers with auto update capabilities.
// Other viewers need to be updated manually.
Component comp =
mbeansTab.getDataViewer().createAttributeViewer(
value, mbean, attribute, XMBeanAttributes.this);
cell.init(cell.getMinRenderer(), comp, cell.getMinHeight());
mbeansTab.getDataViewer().registerForMouseEvent(comp, mouseListener);
}
} else {
cell = new ZoomedCell(value);
viewers.put(attribute, cell);
}
viewersCache.put(mbean, viewers);
return cell;
}
}
//will be called in a synchronzed block
protected void addTableData(DefaultTableModel tableModel,
XMBean mbean,
MBeanAttributeInfo[] attributesInfo,
HashMap<String, Object> attributes,
HashMap<String, Object> unavailableAttributes,
HashMap<String, Object> viewableAttributes) {
Object rowData[] = new Object[2];
int col1Width = 0;
int col2Width = 0;
for (int i = 0; i < attributesInfo.length; i++) {
rowData[0] = (attributesInfo[i].getName());
if (unavailableAttributes.containsKey(rowData[0])) {
rowData[1] = Resources.getText("Unavailable");
} else if (viewableAttributes.containsKey(rowData[0])) {
rowData[1] = viewableAttributes.get(rowData[0]);
if (!attributesInfo[i].isWritable() ||
!Utils.isEditableType(attributesInfo[i].getType())) {
rowData[1] = getZoomedCell(mbean, (String) rowData[0], rowData[1]);
}
} else {
rowData[1] = attributes.get(rowData[0]);
}
tableModel.addRow(rowData);
//Update column width
//
String str = null;
if(rowData[0] != null) {
str = rowData[0].toString();
if(str.length() > col1Width)
col1Width = str.length();
}
if(rowData[1] != null) {
str = rowData[1].toString();
if(str.length() > col2Width)
col2Width = str.length();
}
}
updateColumnWidth(col1Width, col2Width);
}
private void updateColumnWidth(int col1Width, int col2Width) {
TableColumnModel colModel = getColumnModel();
//Get the column at index pColumn, and set its preferred width.
col1Width = col1Width * 7;
col2Width = col2Width * 7;
if(col1Width + col2Width <
(int) getPreferredScrollableViewportSize().getWidth())
col2Width = (int) getPreferredScrollableViewportSize().getWidth()
- col1Width;
colModel.getColumn(NAME_COLUMN).setPreferredWidth(50);
}
class AttributesMouseListener extends MouseAdapter {
public void mousePressed(MouseEvent e) {
if(e.getButton() == MouseEvent.BUTTON1) {
if(e.getClickCount() >= 2) {
int row = XMBeanAttributes.this.getSelectedRow();
int col = XMBeanAttributes.this.getSelectedColumn();
if(col != VALUE_COLUMN) return;
if(col == -1 || row == -1) return;
XMBeanAttributes.this.updateZoomedCell(row, col);
}
}
}
}
class ValueCellEditor extends XTextFieldEditor {
// implements javax.swing.table.TableCellEditor
public Component getTableCellEditorComponent(JTable table,
Object value,
boolean isSelected,
int row,
int column) {
Object val = value;
if(column == VALUE_COLUMN) {
Object obj = getModel().getValueAt(row,
column);
if(obj instanceof ZoomedCell) {
ZoomedCell cell = (ZoomedCell) obj;
if(cell.getRenderer() instanceof MaximizedCellRenderer) {
MaximizedCellRenderer zr =
(MaximizedCellRenderer) cell.getRenderer();
return zr.getComponent();
}
} else {
Component comp = super.getTableCellEditorComponent(
table, val, isSelected, row, column);
if (isCellError(row, column) ||
!isWritable(row) ||
!Utils.isEditableType(getClassName(row))) {
textField.setEditable(false);
}
return comp;
}
}
return super.getTableCellEditorComponent(table,
val,
isSelected,
row,
column);
}
@Override
public boolean stopCellEditing() {
int editingRow = getEditingRow();
int editingColumn = getEditingColumn();
if (editingColumn == VALUE_COLUMN) {
Object obj = getModel().getValueAt(editingRow, editingColumn);
if (obj instanceof ZoomedCell) {
ZoomedCell cell = (ZoomedCell) obj;
if (cell.isMaximized()) {
this.cancelCellEditing();
return true;
}
}
}
return super.stopCellEditing();
}
}
class MaximizedCellRenderer extends DefaultTableCellRenderer {
Component comp;
MaximizedCellRenderer(Component comp) {
this.comp = comp;
Dimension d = comp.getPreferredSize();
if (d.getHeight() > 200) {
comp.setPreferredSize(new Dimension((int) d.getWidth(), 200));
}
}
public Component getTableCellRendererComponent(JTable table,
Object value,
boolean isSelected,
boolean hasFocus,
int row,
int column) {
return comp;
}
public Component getComponent() {
return comp;
}
}
class ZoomedCell {
TableCellRenderer minRenderer;
MaximizedCellRenderer maxRenderer;
int minHeight;
boolean minimized = true;
boolean init = false;
int type;
Object value;
ZoomedCell(Object value) {
type = XDataViewer.getViewerType(value);
this.value = value;
}
boolean isInited() {
return init;
}
Object getValue() {
return value;
}
void setValue(Object value) {
this.value = value;
}
void init(TableCellRenderer minRenderer,
Component maxComponent,
int minHeight) {
this.minRenderer = minRenderer;
this.maxRenderer = new MaximizedCellRenderer(maxComponent);
this.minHeight = minHeight;
init = true;
}
int getType() {
return type;
}
void reset() {
init = false;
minimized = true;
}
void switchState() {
minimized = !minimized;
}
boolean isMaximized() {
return !minimized;
}
void minimize() {
minimized = true;
}
void maximize() {
minimized = false;
}
int getHeight() {
if(minimized) return minHeight;
else
return (int) maxRenderer.getComponent().
getPreferredSize().getHeight() ;
}
int getMinHeight() {
return minHeight;
}
public String toString() {
if(value == null) return null;
if(value.getClass().isArray()) {
String name =
Utils.getArrayClassName(value.getClass().getName());
int length = Array.getLength(value);
return name + "[" + length +"]";
}
if(value instanceof CompositeData ||
value instanceof TabularData)
return value.getClass().getName();
return value.toString();
}
TableCellRenderer getRenderer() {
if(minimized) return minRenderer;
else return maxRenderer;
}
TableCellRenderer getMinRenderer() {
return minRenderer;
}
}
class AttributesListener implements TableModelListener {
private Component component;
public AttributesListener(Component component) {
this.component = component;
}
public void tableChanged(final TableModelEvent e) {
final TableModel model = (TableModel)e.getSource();
// only post changes to the draggable column
if (isColumnEditable(e.getColumn())) {
mbeansTab.workerAdd(new Runnable() {
public void run() {
try {
Object tableValue =
model.getValueAt(e.getFirstRow(),
e.getColumn());
// if it's a String, try construct new value
// using the defined type.
if (tableValue instanceof String) {
tableValue =
Utils.createObjectFromString(getClassName(e.getFirstRow()), // type
(String)tableValue);// value
}
String attributeName =
getValueName(e.getFirstRow());
Attribute attribute =
new Attribute(attributeName,tableValue);
mbean.setAttribute(attribute);
}
catch (Throwable ex) {
if (JConsole.isDebug()) {
ex.printStackTrace();
}
ex = Utils.getActualException(ex);
String message = (ex.getMessage() != null) ? ex.getMessage() : ex.toString();
EventQueue.invokeLater(new ThreadDialog(component,
message+"\n",
Resources.getText("Problem setting attribute"),
JOptionPane.ERROR_MESSAGE));
}
refreshAttributes();
}
});
}
}
}
}