Back to index...

	/*
	* Copyright (c) 2004, 2012, 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.inspector;


	import java.awt.Component;
	import java.awt.EventQueue;
	import java.awt.Dimension;
	import java.awt.event.MouseAdapter;
	import java.awt.event.MouseEvent;
	import java.io.IOException;

	import java.lang.reflect.Array;

	import java.util.EventObject;
	import java.util.HashMap;
	import java.util.WeakHashMap;

	import java.util.concurrent.ExecutionException;
	import java.util.logging.Level;
	import java.util.logging.Logger;
	import javax.management.JMException;
	import javax.management.MBeanInfo;
	import javax.management.MBeanAttributeInfo;
	import javax.management.AttributeList;
	import javax.management.Attribute;
	import javax.management.openmbean.CompositeData;
	import javax.management.openmbean.TabularData;

	import javax.swing.JComponent;
	import javax.swing.JOptionPane;
	import javax.swing.JTable;
	import javax.swing.JTextField;
	import javax.swing.SwingWorker;
	import javax.swing.event.ChangeEvent;
	import javax.swing.event.TableModelEvent;
	import javax.swing.event.TableModelListener;
	import javax.swing.table.DefaultTableCellRenderer;
	import javax.swing.table.DefaultTableModel;
	import javax.swing.table.TableCellEditor;
	import javax.swing.table.TableCellRenderer;
	import javax.swing.table.TableColumn;
	import javax.swing.table.TableColumnModel;
	import javax.swing.table.TableModel;

	import sun.tools.jconsole.MBeansTab;
	import sun.tools.jconsole.JConsole;
	import sun.tools.jconsole.Messages;
	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 {

	final Logger LOGGER =
	Logger.getLogger(XMBeanAttributes.class.getPackage().getName());

	private final static String[] columnNames =
	{Messages.NAME,
	Messages.VALUE};

	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 final TableModelListener attributesListener;
	private MBeansTab mbeansTab;
	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);
	attributesListener = new AttributesListener(this);
	getModel().addTableModelListener(attributesListener);
	getColumnModel().getColumn(NAME_COLUMN).setPreferredWidth(40);

	addMouseListener(mouseListener);
	getTableHeader().setReorderingAllowed(false);
	setColumnEditors();
	addKeyListener(new Utils.CopyKeyAdapter());
	}

	@Override
	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);
	}

	@Override
	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() {
	if (LOGGER.isLoggable(Level.FINER)) {
	LOGGER.finer("Cancel Editing Row: "+getEditingRow());
	}
	final TableCellEditor tableCellEditor = getCellEditor();
	if (tableCellEditor != null) {
	tableCellEditor.cancelCellEditing();
	}
	}

	public void stopCellEditing() {
	if (LOGGER.isLoggable(Level.FINER)) {
	LOGGER.finer("Stop Editing Row: "+getEditingRow());
	}
	final TableCellEditor tableCellEditor = getCellEditor();
	if (tableCellEditor != null) {
	tableCellEditor.stopCellEditing();
	}
	}

	@Override
	public final boolean editCellAt(final int row, final int column, EventObject e) {
	if (LOGGER.isLoggable(Level.FINER)) {
	LOGGER.finer("editCellAt(row="+row+", col="+column+
	", e="+e+")");
	}
	if (JConsole.isDebug()) {
	System.err.println("edit: "+getValueName(row)+"="+getValue(row));
	}
	boolean retVal = super.editCellAt(row, column, e);
	if (retVal) {
	final TableCellEditor tableCellEditor =
	getColumnModel().getColumn(column).getCellEditor();
	if (tableCellEditor == valueCellEditor) {
	((JComponent) tableCellEditor).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))) {
	if (JConsole.isDebug()) {
	System.err.println("validating [row="+row+", column="+column+
	"]: "+getValueName(row)+"="+value);
	}
	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(Messages.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) {
	final Object val = ((DefaultTableModel) getModel())
	.getValueAt(row, VALUE_COLUMN);
	return val;
	}

	//tool tip only for editable column
	@Override
	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 = Messages.DOUBLE_CLICK_TO_EXPAND_FORWARD_SLASH_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.
	*/
	@Override
	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;
	}

	// Call this in EDT
	public void loadAttributes(final XMBean mbean, final MBeanInfo mbeanInfo) {

	final SwingWorker<Runnable,Void> load =
	new SwingWorker<Runnable,Void>() {
	@Override
	protected Runnable doInBackground() throws Exception {
	return doLoadAttributes(mbean,mbeanInfo);
	}

	@Override
	protected void done() {
	try {
	final Runnable updateUI = get();
	if (updateUI != null) updateUI.run();
	} catch (RuntimeException x) {
	throw x;
	} catch (ExecutionException x) {
	if(JConsole.isDebug()) {
	System.err.println(
	"Exception raised while loading attributes: "
	+x.getCause());
	x.printStackTrace();
	}
	} catch (InterruptedException x) {
	if(JConsole.isDebug()) {
	System.err.println(
	"Interrupted while loading attributes: "+x);
	x.printStackTrace();
	}
	}
	}

	};
	mbeansTab.workerAdd(load);
	}

	// Don't call this in EDT, but execute returned Runnable inside
	// EDT - typically in the done() method of a SwingWorker
	// This method can return null.
	private Runnable doLoadAttributes(final XMBean mbean, MBeanInfo infoOrNull)
	throws JMException, IOException {
	// To avoid deadlock with events coming from the JMX side,
	// we retrieve all JMX stuff in a non synchronized block.

	if(mbean == null) return null;
	final MBeanInfo curMBeanInfo =
	(infoOrNull==null)?mbean.getMBeanInfo():infoOrNull;

	final MBeanAttributeInfo[] attrsInfo = curMBeanInfo.getAttributes();
	final HashMap<String, Object> attrs =
	new HashMap<String, Object>(attrsInfo.length);
	final HashMap<String, Object> unavailableAttrs =
	new HashMap<String, Object>(attrsInfo.length);
	final HashMap<String, Object> viewableAttrs =
	new HashMap<String, Object>(attrsInfo.length);
	AttributeList list = null;

	try {
	list = mbean.getAttributes(attrsInfo);
	}catch(Exception e) {
	if (JConsole.isDebug()) {
	System.err.println("Error calling getAttributes() on MBean \"" +
	mbean.getObjectName() + "\". JConsole will " +
	"try to get them individually calling " +
	"getAttribute() instead. Exception:");
	e.printStackTrace(System.err);
	}
	list = new AttributeList();
	//Can't load all attributes, do it one after each other.
	for(int i = 0; i < attrsInfo.length; i++) {
	String name = null;
	try {
	name = attrsInfo[i].getName();
	Object value =
	mbean.getMBeanServerConnection().
	getAttribute(mbean.getObjectName(), name);
	list.add(new Attribute(name, value));
	}catch(Exception ex) {
	if(attrsInfo[i].isReadable()) {
	unavailableAttrs.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)) {
	viewableAttrs.put(attribute.getName(),
	attribute.getValue());
	}
	else
	attrs.put(attribute.getName(),attribute.getValue());

	}
	// if not all attributes are accessible,
	// check them one after the other.
	if (att_length < attrsInfo.length) {
	for (int i=0;i<attrsInfo.length;i++) {
	MBeanAttributeInfo attributeInfo = attrsInfo[i];
	if (!attrs.containsKey(attributeInfo.getName()) &&
	!viewableAttrs.containsKey(attributeInfo.
	getName()) &&
	!unavailableAttrs.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.getMBeanServerConnection().getAttribute(
	mbean.getObjectName(), attributeInfo.getName());
	//What happens if now it is ok?
	// Be pragmatic, add it to readable...
	attrs.put(attributeInfo.getName(),
	v);
	}catch(Exception e) {
	//Put the exception that will be displayed
	// in tooltip
	unavailableAttrs.put(attributeInfo.getName(),
	Utils.getActualException(e).toString());
	}
	}
	}
	}
	}
	}
	catch(Exception e) {
	//sets all attributes unavailable except the writable ones
	for (int i=0;i<attrsInfo.length;i++) {
	MBeanAttributeInfo attributeInfo = attrsInfo[i];
	if (attributeInfo.isReadable()) {
	unavailableAttrs.put(attributeInfo.getName(),
	Utils.getActualException(e).
	toString());
	}
	}
	}
	//end of retrieval

	//one update at a time
	return new Runnable() {
	public void run() {
	synchronized (XMBeanAttributes.this) {
	XMBeanAttributes.this.mbean = mbean;
	XMBeanAttributes.this.mbeanInfo = curMBeanInfo;
	XMBeanAttributes.this.attributesInfo = attrsInfo;
	XMBeanAttributes.this.attributes = attrs;
	XMBeanAttributes.this.unavailableAttributes = unavailableAttrs;
	XMBeanAttributes.this.viewableAttributes = viewableAttrs;

	DefaultTableModel tableModel =
	(DefaultTableModel) getModel();

	// add attribute information
	emptyTable(tableModel);

	addTableData(tableModel,
	mbean,
	attrsInfo,
	attrs,
	unavailableAttrs,
	viewableAttrs);

	// 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);

	XDataViewer.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;
	}

	// This is called by XSheet when the "refresh" button is pressed.
	// In this case we will commit any pending attribute values by
	// calling 'stopCellEditing'.
	//
	public void refreshAttributes() {
	refreshAttributes(true);
	}

	// refreshAttributes(false) is called by tableChanged().
	// in this case we must not call stopCellEditing, because it's already
	// been called - e.g.
	// lostFocus/mousePressed -> stopCellEditing -> setValueAt -> tableChanged
	// -> refreshAttributes(false)
	//
	// Can be called in EDT - as long as the implementation of
	// mbeansTab.getCachedMBeanServerConnection() and mbsc.flush() doesn't
	// change
	//
	private void refreshAttributes(final boolean stopCellEditing) {
	SwingWorker<Void,Void> sw = new SwingWorker<Void,Void>() {

	@Override
	protected Void doInBackground() throws Exception {
	SnapshotMBeanServerConnection mbsc =
	mbeansTab.getSnapshotMBeanServerConnection();
	mbsc.flush();
	return null;
	}

	@Override
	protected void done() {
	try {
	get();
	if (stopCellEditing) stopCellEditing();
	loadAttributes(mbean, mbeanInfo);
	} catch (Exception x) {
	if (JConsole.isDebug()) {
	x.printStackTrace();
	}
	}
	}
	};
	mbeansTab.workerAdd(sw);
	}
	// We need to call stop editing here - otherwise edits are lost
	// when resizing the table.
	//
	@Override
	public void columnMarginChanged(ChangeEvent e) {
	if (isEditing()) stopCellEditing();
	super.columnMarginChanged(e);
	}

	// We need to call stop editing here - otherwise the edited value
	// is transferred to the wrong row...
	//
	@Override
	void sortRequested(int column) {
	if (isEditing()) stopCellEditing();
	super.sortRequested(column);
	}


	@Override
	public synchronized void emptyTable() {
	emptyTable((DefaultTableModel)getModel());
	}

	// Call this in synchronized block.
	private void emptyTable(DefaultTableModel model) {
	model.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());
	XDataViewer.registerForMouseEvent(comp, mouseListener);
	}
	} else {
	cell = new ZoomedCell(value);
	viewers.put(attribute, cell);
	}
	viewersCache.put(mbean, viewers);
	return cell;
	}
	}

	//will be called in a synchronized 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] = Messages.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 {

	@Override
	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
	@Override
	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() > 220) {
	comp.setPreferredSize(new Dimension((int) d.getWidth(), 220));
	}
	}
	@Override
	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;
	}

	@Override
	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;
	}

	// Call this in EDT
	public void tableChanged(final TableModelEvent e) {
	// only post changes to the draggable column
	if (isColumnEditable(e.getColumn())) {
	final TableModel model = (TableModel)e.getSource();
	Object tableValue = model.getValueAt(e.getFirstRow(),
	e.getColumn());

	if (LOGGER.isLoggable(Level.FINER)) {
	LOGGER.finer("tableChanged: firstRow="+e.getFirstRow()+
	", lastRow="+e.getLastRow()+", column="+e.getColumn()+
	", value="+tableValue);
	}
	// if it's a String, try construct new value
	// using the defined type.
	if (tableValue instanceof String) {
	try {
	tableValue =
	Utils.createObjectFromString(getClassName(e.getFirstRow()), // type
	(String)tableValue);// value
	} catch (Throwable ex) {
	popupAndLog(ex,"tableChanged",
	Messages.PROBLEM_SETTING_ATTRIBUTE);
	}
	}
	final String attributeName = getValueName(e.getFirstRow());
	final Attribute attribute =
	new Attribute(attributeName,tableValue);
	setAttribute(attribute, "tableChanged");
	}
	}

	// Call this in EDT
	private void setAttribute(final Attribute attribute, final String method) {
	final SwingWorker<Void,Void> setAttribute =
	new SwingWorker<Void,Void>() {
	@Override
	protected Void doInBackground() throws Exception {
	try {
	if (JConsole.isDebug()) {
	System.err.println("setAttribute("+
	attribute.getName()+
	"="+attribute.getValue()+")");
	}
	mbean.setAttribute(attribute);
	} catch (Throwable ex) {
	popupAndLog(ex,method,Messages.PROBLEM_SETTING_ATTRIBUTE);
	}
	return null;
	}
	@Override
	protected void done() {
	try {
	get();
	} catch (Exception x) {
	if (JConsole.isDebug())
	x.printStackTrace();
	}
	refreshAttributes(false);
	}

	};
	mbeansTab.workerAdd(setAttribute);
	}

	// Call this outside EDT
	private void popupAndLog(Throwable ex, String method, String title) {
	ex = Utils.getActualException(ex);
	if (JConsole.isDebug()) ex.printStackTrace();

	String message = (ex.getMessage() != null) ? ex.getMessage()
	: ex.toString();
	EventQueue.invokeLater(
	new ThreadDialog(component, message+"\n",
	title,
	JOptionPane.ERROR_MESSAGE));
	}
	}
	}

Back to index...