Mercurial > hg > graal-compiler
view agent/src/share/classes/sun/jvm/hotspot/ui/treetable/JTreeTable.java @ 904:ef671fb22f73
6868051: (SA) FreeChunk support for compressed oops is broken
Reviewed-by: kvn, dcubed
author | never |
---|---|
date | Thu, 06 Aug 2009 12:24:41 -0700 |
parents | d1605aabd0a1 |
children | c18cbe5936b8 |
line wrap: on
line source
/* * Copyright 2001-2008 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. * * 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.jvm.hotspot.ui.treetable; import java.awt.*; import javax.swing.*; import javax.swing.border.*; import javax.swing.event.*; import javax.swing.tree.*; import javax.swing.table.*; import java.awt.event.*; import java.util.EventObject; /** * This example shows how to create a simple JTreeTable component, * by using a JTree as a renderer (and editor) for the cells in a * particular column in the JTable. * * * @author Philip Milne * @author Scott Violet */ public class JTreeTable extends JTable { /** A subclass of JTree. */ protected TreeTableCellRenderer tree; ////////////////////////// // Convenience routines // ////////////////////////// private boolean treeEditable = true; private boolean showsIcons = true; public boolean getTreeEditable() { return treeEditable; } public void setTreeEditable(boolean editable) { treeEditable = editable; } public boolean getShowsIcons() { return showsIcons; } public void setShowsIcons(boolean show) { showsIcons = show; } public void setRootVisible(boolean visible) { tree.setRootVisible(visible); } public boolean getShowsRootHandles() { return tree.getShowsRootHandles(); } public void setShowsRootHandles(boolean newValue) { tree.setShowsRootHandles(newValue); } public JTreeTable(TreeTableModel treeTableModel) { super(); // Create the tree. It will be used as a renderer and editor. tree = new TreeTableCellRenderer(treeTableModel); // Install a tableModel representing the visible rows in the tree. super.setModel(new TreeTableModelAdapter(treeTableModel, tree)); // Force the JTable and JTree to share their row selection models. ListToTreeSelectionModelWrapper selectionWrapper = new ListToTreeSelectionModelWrapper(); tree.setSelectionModel(selectionWrapper); setSelectionModel(selectionWrapper.getListSelectionModel()); // Install the tree editor renderer and editor. setDefaultRenderer(TreeTableModel.class, tree); setDefaultEditor(TreeTableModel.class, new TreeTableCellEditor()); // No grid. setShowGrid(false); // No intercell spacing setIntercellSpacing(new Dimension(0, 0)); // And update the height of the trees row to match that of // the table. if (tree.getRowHeight() < 1) { // Metal looks better like this. setRowHeight(20); } } /** * Overridden to message super and forward the method to the tree. * Since the tree is not actually in the component hieachy it will * never receive this unless we forward it in this manner. */ public void updateUI() { super.updateUI(); if(tree != null) { tree.updateUI(); // Do this so that the editor is referencing the current renderer // from the tree. The renderer can potentially change each time // laf changes. setDefaultEditor(TreeTableModel.class, new TreeTableCellEditor()); } // Use the tree's default foreground and background colors in the // table. LookAndFeel.installColorsAndFont(this, "Tree.background", "Tree.foreground", "Tree.font"); } /** * Workaround for BasicTableUI anomaly. Make sure the UI never tries to * resize the editor. The UI currently uses different techniques to * paint the renderers and editors and overriding setBounds() below * is not the right thing to do for an editor. Returning -1 for the * editing row in this case, ensures the editor is never painted. */ public int getEditingRow() { return (getColumnClass(editingColumn) == TreeTableModel.class) ? -1 : editingRow; } /** * Returns the actual row that is editing as <code>getEditingRow</code> * will always return -1. */ private int realEditingRow() { return editingRow; } /** * This is overriden to invoke supers implementation, and then, * if the receiver is editing a Tree column, the editors bounds is * reset. The reason we have to do this is because JTable doesn't * think the table is being edited, as <code>getEditingRow</code> returns * -1, and therefore doesn't automaticly resize the editor for us. */ public void sizeColumnsToFit(int resizingColumn) { super.sizeColumnsToFit(resizingColumn); if (getEditingColumn() != -1 && getColumnClass(editingColumn) == TreeTableModel.class) { Rectangle cellRect = getCellRect(realEditingRow(), getEditingColumn(), false); Component component = getEditorComponent(); component.setBounds(cellRect); component.validate(); } } /** * Overridden to pass the new rowHeight to the tree. */ public void setRowHeight(int rowHeight) { super.setRowHeight(rowHeight); if (tree != null && tree.getRowHeight() != rowHeight) { tree.setRowHeight(getRowHeight()); } } /** * Returns the tree that is being shared between the model. */ public JTree getTree() { return tree; } /** * Overriden to invoke repaint for the particular location if * the column contains the tree. This is done as the tree editor does * not fill the bounds of the cell, we need the renderer to paint * the tree in the background, and then draw the editor over it. */ public boolean editCellAt(int row, int column, EventObject e){ boolean retValue = super.editCellAt(row, column, e); if (retValue && getColumnClass(column) == TreeTableModel.class) { repaint(getCellRect(row, column, false)); } return retValue; } /** A DefaultTreeCellRenderer which can optionally skip drawing all icons. */ class JTreeTableCellRenderer extends DefaultTreeCellRenderer { public Icon getClosedIcon() { return (showsIcons ? super.getClosedIcon() : null); } public Icon getDefaultClosedIcon() { return (showsIcons ? super.getDefaultClosedIcon() : null); } public Icon getDefaultLeafIcon() { return (showsIcons ? super.getDefaultLeafIcon() : null); } public Icon getDefaultOpenIcon() { return (showsIcons ? super.getDefaultOpenIcon() : null); } public Icon getLeafIcon() { return (showsIcons ? super.getLeafIcon() : null); } public Icon getOpenIcon() { return (showsIcons ? super.getOpenIcon() : null); } } /** * A TreeCellRenderer that displays a JTree. */ public class TreeTableCellRenderer extends JTree implements TableCellRenderer { /** Last table/tree row asked to renderer. */ protected int visibleRow; /** Border to draw around the tree, if this is non-null, it will * be painted. */ protected Border highlightBorder; public TreeTableCellRenderer(TreeModel model) { super(model); setCellRenderer(new JTreeTableCellRenderer()); } /** * updateUI is overridden to set the colors of the Tree's renderer * to match that of the table. */ public void updateUI() { super.updateUI(); // Make the tree's cell renderer use the table's cell selection // colors. TreeCellRenderer tcr = getCellRenderer(); if (tcr instanceof DefaultTreeCellRenderer) { DefaultTreeCellRenderer dtcr = ((DefaultTreeCellRenderer)tcr); // For 1.1 uncomment this, 1.2 has a bug that will cause an // exception to be thrown if the border selection color is // null. // dtcr.setBorderSelectionColor(null); dtcr.setTextSelectionColor(UIManager.getColor ("Table.selectionForeground")); dtcr.setBackgroundSelectionColor(UIManager.getColor ("Table.selectionBackground")); } } /** * Sets the row height of the tree, and forwards the row height to * the table. */ public void setRowHeight(int rowHeight) { if (rowHeight > 0) { super.setRowHeight(rowHeight); if (JTreeTable.this != null && JTreeTable.this.getRowHeight() != rowHeight) { JTreeTable.this.setRowHeight(getRowHeight()); } } } /** * This is overridden to set the height to match that of the JTable. */ public void setBounds(int x, int y, int w, int h) { super.setBounds(x, 0, w, JTreeTable.this.getHeight()); } /** * Sublcassed to translate the graphics such that the last visible * row will be drawn at 0,0. */ public void paint(Graphics g) { g.translate(0, -visibleRow * getRowHeight()); super.paint(g); // Draw the Table border if we have focus. if (highlightBorder != null) { highlightBorder.paintBorder(this, g, 0, visibleRow * getRowHeight(), getWidth(), getRowHeight()); } } /** * TreeCellRenderer method. Overridden to update the visible row. */ public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) { Color background; Color foreground; if(isSelected) { background = table.getSelectionBackground(); foreground = table.getSelectionForeground(); } else { background = table.getBackground(); foreground = table.getForeground(); } highlightBorder = null; if (realEditingRow() == row && getEditingColumn() == column) { background = UIManager.getColor("Table.focusCellBackground"); foreground = UIManager.getColor("Table.focusCellForeground"); } else if (hasFocus) { highlightBorder = UIManager.getBorder ("Table.focusCellHighlightBorder"); if (isCellEditable(row, column)) { background = UIManager.getColor ("Table.focusCellBackground"); foreground = UIManager.getColor ("Table.focusCellForeground"); } } visibleRow = row; setBackground(background); TreeCellRenderer tcr = getCellRenderer(); if (tcr instanceof DefaultTreeCellRenderer) { DefaultTreeCellRenderer dtcr = ((DefaultTreeCellRenderer)tcr); if (isSelected) { dtcr.setTextSelectionColor(foreground); dtcr.setBackgroundSelectionColor(background); } else { dtcr.setTextNonSelectionColor(foreground); dtcr.setBackgroundNonSelectionColor(background); } } return this; } } /** * An editor that can be used to edit the tree column. This extends * DefaultCellEditor and uses a JTextField (actually, TreeTableTextField) * to perform the actual editing. * <p>To support editing of the tree column we can not make the tree * editable. The reason this doesn't work is that you can not use * the same component for editing and renderering. The table may have * the need to paint cells, while a cell is being edited. If the same * component were used for the rendering and editing the component would * be moved around, and the contents would change. When editing, this * is undesirable, the contents of the text field must stay the same, * including the caret blinking, and selections persisting. For this * reason the editing is done via a TableCellEditor. * <p>Another interesting thing to be aware of is how tree positions * its render and editor. The render/editor is responsible for drawing the * icon indicating the type of node (leaf, branch...). The tree is * responsible for drawing any other indicators, perhaps an additional * +/- sign, or lines connecting the various nodes. So, the renderer * is positioned based on depth. On the other hand, table always makes * its editor fill the contents of the cell. To get the allusion * that the table cell editor is part of the tree, we don't want the * table cell editor to fill the cell bounds. We want it to be placed * in the same manner as tree places it editor, and have table message * the tree to paint any decorations the tree wants. Then, we would * only have to worry about the editing part. The approach taken * here is to determine where tree would place the editor, and to override * the <code>reshape</code> method in the JTextField component to * nudge the textfield to the location tree would place it. Since * JTreeTable will paint the tree behind the editor everything should * just work. So, that is what we are doing here. Determining of * the icon position will only work if the TreeCellRenderer is * an instance of DefaultTreeCellRenderer. If you need custom * TreeCellRenderers, that don't descend from DefaultTreeCellRenderer, * and you want to support editing in JTreeTable, you will have * to do something similiar. */ public class TreeTableCellEditor extends DefaultCellEditor { public TreeTableCellEditor() { super(new TreeTableTextField()); } /** * Overriden to determine an offset that tree would place the * editor at. The offset is determined from the * <code>getRowBounds</code> JTree method, and additionaly * from the icon DefaultTreeCellRenderer will use. * <p>The offset is then set on the TreeTableTextField component * created in the constructor, and returned. */ public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int r, int c) { Component component = super.getTableCellEditorComponent (table, value, isSelected, r, c); JTree t = getTree(); boolean rv = t.isRootVisible(); int offsetRow = rv ? r : r - 1; Rectangle bounds = t.getRowBounds(offsetRow); int offset = bounds.x; TreeCellRenderer tcr = t.getCellRenderer(); if (tcr instanceof DefaultTreeCellRenderer) { Object node = t.getPathForRow(offsetRow). getLastPathComponent(); Icon icon; if (t.getModel().isLeaf(node)) icon = ((DefaultTreeCellRenderer)tcr).getLeafIcon(); else if (tree.isExpanded(offsetRow)) icon = ((DefaultTreeCellRenderer)tcr).getOpenIcon(); else icon = ((DefaultTreeCellRenderer)tcr).getClosedIcon(); if (icon != null) { offset += ((DefaultTreeCellRenderer)tcr).getIconTextGap() + icon.getIconWidth(); } } ((TreeTableTextField)getComponent()).offset = offset; return component; } /** * This is overriden to forward the event to the tree. This will * return true if the click count >= 3, or the event is null. */ public boolean isCellEditable(EventObject e) { if (e instanceof MouseEvent) { MouseEvent me = (MouseEvent)e; // If the modifiers are not 0 (or the left mouse button), // tree may try and toggle the selection, and table // will then try and toggle, resulting in the // selection remaining the same. To avoid this, we // only dispatch when the modifiers are 0 (or the left mouse // button). if (me.getModifiers() == 0 || me.getModifiers() == InputEvent.BUTTON1_MASK) { for (int counter = getColumnCount() - 1; counter >= 0; counter--) { if (getColumnClass(counter) == TreeTableModel.class) { MouseEvent newME = new MouseEvent (JTreeTable.this.tree, me.getID(), me.getWhen(), me.getModifiers(), me.getX() - getCellRect(0, counter, true).x, me.getY(), me.getClickCount(), me.isPopupTrigger()); JTreeTable.this.tree.dispatchEvent(newME); break; } } } if (me.getClickCount() >= 3) { return treeEditable; } return false; } if (e == null) { return treeEditable; } return false; } } /** * Component used by TreeTableCellEditor. The only thing this does * is to override the <code>reshape</code> method, and to ALWAYS * make the x location be <code>offset</code>. */ static class TreeTableTextField extends JTextField { public int offset; public void setBounds(int x, int y, int w, int h) { int newX = Math.max(x, offset); super.setBounds(newX, y, w - (newX - x), h); } } /** * ListToTreeSelectionModelWrapper extends DefaultTreeSelectionModel * to listen for changes in the ListSelectionModel it maintains. Once * a change in the ListSelectionModel happens, the paths are updated * in the DefaultTreeSelectionModel. */ class ListToTreeSelectionModelWrapper extends DefaultTreeSelectionModel { /** Set to true when we are updating the ListSelectionModel. */ protected boolean updatingListSelectionModel; public ListToTreeSelectionModelWrapper() { super(); getListSelectionModel().addListSelectionListener (createListSelectionListener()); } /** * Returns the list selection model. ListToTreeSelectionModelWrapper * listens for changes to this model and updates the selected paths * accordingly. */ ListSelectionModel getListSelectionModel() { return listSelectionModel; } /** * This is overridden to set <code>updatingListSelectionModel</code> * and message super. This is the only place DefaultTreeSelectionModel * alters the ListSelectionModel. */ public void resetRowSelection() { if(!updatingListSelectionModel) { updatingListSelectionModel = true; try { super.resetRowSelection(); } finally { updatingListSelectionModel = false; } } // Notice how we don't message super if // updatingListSelectionModel is true. If // updatingListSelectionModel is true, it implies the // ListSelectionModel has already been updated and the // paths are the only thing that needs to be updated. } /** * Creates and returns an instance of ListSelectionHandler. */ protected ListSelectionListener createListSelectionListener() { return new ListSelectionHandler(); } /** * If <code>updatingListSelectionModel</code> is false, this will * reset the selected paths from the selected rows in the list * selection model. */ protected void updateSelectedPathsFromSelectedRows() { if(!updatingListSelectionModel) { updatingListSelectionModel = true; try { // This is way expensive, ListSelectionModel needs an // enumerator for iterating. int min = listSelectionModel.getMinSelectionIndex(); int max = listSelectionModel.getMaxSelectionIndex(); clearSelection(); if(min != -1 && max != -1) { for(int counter = min; counter <= max; counter++) { if(listSelectionModel.isSelectedIndex(counter)) { TreePath selPath = tree.getPathForRow (counter); if(selPath != null) { addSelectionPath(selPath); } } } } } finally { updatingListSelectionModel = false; } } } /** * Class responsible for calling updateSelectedPathsFromSelectedRows * when the selection of the list changse. */ class ListSelectionHandler implements ListSelectionListener { public void valueChanged(ListSelectionEvent e) { updateSelectedPathsFromSelectedRows(); } } } }