getRowBounds JTree method, and additionally
* from the icon DefaultTreeCellRenderer will use.
* 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);
determineOffset(value, isSelected, r);
((TreeTableTextField)getComponent()).offset = offset;
return component;
}
/**
* This is overridden to forward the event to the tree and start editor timer.
*/
public boolean isCellEditable(EventObject e) {
if (lastRow != -1) {
org.openide.nodes.Node n = Visualizer.findNode (tree.getPathForRow(lastRow).getLastPathComponent());
if (n == null || !n.canRename ()) {
//return false;
canEdit = false;
}
}
if (canEdit && e != null && ( e.getSource() instanceof Timer ))
return true;
if (canEdit && shouldStartEditingTimer(e)) {
startEditingTimer();
} else if (shouldStopEditingTimer(e)) {
timer.stop();
}
if (e instanceof MouseEvent) {
MouseEvent me = (MouseEvent)e;
int column = getTreeColumnIndex();
if ( MouseUtils.isLeftMouseButton(me) && me.getClickCount() == 2 ) {
TreePath path = tree.getPathForRow(TreeTable.this.rowAtPoint(me.getPoint()));
Rectangle r = tree.getPathBounds(path);
if ( me.getX() < r.x - positionX || me.getX() > r.x - positionX + r.width ) {
me.translatePoint( r.x - me.getX(), 0 );
}
}
MouseEvent newME = new MouseEvent
(TreeTable.this.tree, me.getID(),
me.getWhen(), me.getModifiers(),
me.getX() - getCellRect(0, column, true).x + positionX,
me.getY(), me.getClickCount(),
me.isPopupTrigger());
TreeTable.this.tree.dispatchEvent(newME);
}
return false;
}
/* Stop timer when selection has been changed.
*/
public void valueChanged(TreeSelectionEvent e) {
if (timer != null) {
timer.stop();
}
}
/* Timer performer.
*/
public void actionPerformed(java.awt.event.ActionEvent e) {
if (lastRow != -1) {
editCellAt(lastRow, getTreeColumnIndex(), new EventObject( timer ));
}
}
/* Start editing timer only on certain conditions.
*/
private boolean shouldStartEditingTimer(EventObject event) {
if ((event instanceof MouseEvent) &&
SwingUtilities.isLeftMouseButton((MouseEvent)event)) {
MouseEvent me = (MouseEvent)event;
return (me.getID() == me.MOUSE_PRESSED &&
me.getClickCount() == 1 &&
inHitRegion(me));
}
return false;
}
/* Stop editing timer only on certain conditions.
*/
private boolean shouldStopEditingTimer(EventObject event) {
if (timer == null)
return false;
if (event instanceof MouseEvent) {
MouseEvent me = (MouseEvent)event;
return (!SwingUtilities.isLeftMouseButton(me) ||
me.getClickCount() > 1);
}
return false;
}
/**
* Starts the editing timer.
*/
private void startEditingTimer() {
if(timer == null) {
timer = new Timer(1200, this);
timer.setRepeats(false);
}
timer.start();
}
/* Does a click go into node's label?
*/
private boolean inHitRegion(MouseEvent me) {
determineOffset(me);
if (me.getX() <= offset) {
return false;
}
return true;
}
/* Determines offset of node's label from left edge of the table.
*/
private void determineOffset(MouseEvent me) {
int row = TreeTable.this.rowAtPoint(me.getPoint());
if (row == -1) {
offset = 0;
return;
}
determineOffset(tree.getPathForRow(row).getLastPathComponent(),
TreeTable.this.isRowSelected(row), row);
}
/* Determines offset of node's label from left edge of the table.
*/
private void determineOffset(Object value, boolean isSelected, int row) {
JTree t = getTree();
boolean rv = t.isRootVisible();
int offsetRow = row;
if ( !rv && row > 0 )
offsetRow--;
Rectangle bounds = t.getRowBounds(offsetRow);
offset = bounds.x;
TreeCellRenderer tcr = t.getCellRenderer();
Object node = t.getPathForRow(offsetRow).getLastPathComponent();
Component comp = tcr.getTreeCellRendererComponent(
t, node, isSelected, t.isExpanded(offsetRow),
t.getModel().isLeaf(node), offsetRow, false);
if (comp instanceof JLabel) {
Icon icon = ((JLabel)comp).getIcon();
if (icon != null) {
offset += ((JLabel)comp).getIconTextGap() + icon.getIconWidth();
}
}
offset -= positionX;
}
/* Revalidates text field upon change of x position of renderer
*/
private void revalidateTextField() {
int row = TreeTable.this.editingRow;
if (row == -1) {
offset = 0;
return;
}
determineOffset(tree.getPathForRow(row).getLastPathComponent(),
TreeTable.this.isRowSelected(row), row);
((TreeTableTextField)super.getComponent()).offset = offset;
getComponent().setBounds(TreeTable.this.getCellRect(row, getTreeColumnIndex(), false));
}
// Focus listener
/* Cancel editing when text field loses focus
*/
public void focusLost (java.awt.event.FocusEvent evt) {
/* to allow Escape functionality
if (!stopCellEditing())
cancelCellEditing();
*/
}
/* Select a text in text field when it gets focus.
*/
public void focusGained (java.awt.event.FocusEvent evt) {
((TreeTableTextField)super.getComponent()).selectAll();
}
// Cell editor listener - copied from TreeViewCellEditor
/** Implements CellEditorListener interface method. */
public void editingStopped(ChangeEvent e) {
TreePath lastP = tree.getPathForRow(lastRow);
if (lastP != null) {
Node n = Visualizer.findNode (lastP.getLastPathComponent());
if (n != null && n.canRename ()) {
String newStr = (String) getCellEditorValue();
try {
// bugfix #21589 don't update name if there is not any change
if (!n.getName ().equals (newStr)) {
n.setName (newStr);
}
}
catch (IllegalArgumentException exc) {
boolean needToAnnotate = true;
ErrorManager em = ErrorManager.getDefault ();
ErrorManager.Annotation[] ann = em.findAnnotations(exc);
// determine if "new annotation" of this exception is needed
if (ann!=null && ann.length>0) {
for (int i=0; ireshape method, and to ALWAYS
* make the x location be offset.
*/
static class TreeTableTextField extends JTextField {
public int offset;
public void reshape(int x, int y, int w, int h) {
int newX = Math.max(x, offset);
super.reshape(newX, y, w - (newX - x), h);
}
public void addNotify() {
super.addNotify();
//requestFocus(); //no longer necessary, STPolicy will do it - Tim
}
}
/**
* 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 updatingListSelectionModel
* 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 updatingListSelectionModel 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();
this.clearSelection ();
java.util.Vector v = new java.util.Vector();
if(min != -1 && max != -1) {
for(int counter = min; counter <= max; counter++) {
if(listSelectionModel.isSelectedIndex(counter)) {
TreePath selPath = tree.getPathForRow
(counter);
if(selPath != null) {
v.add( selPath );
// addSelectionPath(selPath);
}
}
}
if( v.size() > 0 ) {
addSelectionPaths( (TreePath[])v.toArray( new TreePath[v.size()]) );
}
}
}
finally {
updatingListSelectionModel = false;
}
}
}
/**
* Class responsible for calling updateSelectedPathsFromSelectedRows
* when the selection of the list changes.
*/
class ListSelectionHandler implements ListSelectionListener {
public void valueChanged(ListSelectionEvent e) {
updateSelectedPathsFromSelectedRows();
}
}
}
/* This is overriden to handle mouse events especially. E.g. do not change selection
* when it was clicked on tree's expand/collapse toggles.
*/
class TreeTableUI extends BasicTableUI {
/**
* Creates the mouse listener for the JTable.
*/
protected MouseInputListener createMouseInputListener() {
return new TreeTableMouseInputHandler();
}
public class TreeTableMouseInputHandler extends MouseInputHandler {
// Component recieving mouse events during editing. May not be editorComponent.
private Component dispatchComponent;
// The Table's mouse listener methods.
public void mouseClicked(MouseEvent e) {
processMouseEvent(e);
}
public void mousePressed(MouseEvent e) {
processMouseEvent(e);
}
public void mouseReleased(MouseEvent e) {
if (shouldIgnore(e)) {
return;
}
repostEvent(e);
dispatchComponent = null;
setValueIsAdjusting(false);
if (!TreeTable.this.isEditing())
processMouseEvent(e);
}
public void mouseDragged(MouseEvent e) {
return;
}
private void setDispatchComponent(MouseEvent e) {
Component editorComponent = table.getEditorComponent();
Point p = e.getPoint();
Point p2 = SwingUtilities.convertPoint(table, p, editorComponent);
dispatchComponent = SwingUtilities.getDeepestComponentAt(editorComponent,
p2.x, p2.y);
}
private boolean repostEvent(MouseEvent e) {
if (dispatchComponent == null) {
return false;
}
MouseEvent e2 = SwingUtilities.convertMouseEvent(table, e, dispatchComponent);
dispatchComponent.dispatchEvent(e2);
return true;
}
private void setValueIsAdjusting(boolean flag) {
table.getSelectionModel().setValueIsAdjusting(flag);
table.getColumnModel().getSelectionModel().setValueIsAdjusting(flag);
}
private boolean shouldIgnore(MouseEvent e) {
return !table.isEnabled() ||
( e.getButton() == MouseEvent.BUTTON3 &&
e.getClickCount() == 1 &&
! e.isPopupTrigger() ) ;
}
private boolean isTreeColumn(int column) {
return TreeTable.this.getColumnClass(column) == TreeTableModelAdapter.class;
}
/** Forwards mouse events to a renderer (tree).
*/
private void processMouseEvent(MouseEvent e) {
if (shouldIgnore(e)) {
return;
}
Point p = e.getPoint();
int row = table.rowAtPoint(p);
int column = table.columnAtPoint(p);
// The autoscroller can generate drag events outside the Table's range.
if ((column == -1) || (row == -1)) {
return;
}
// for automatic jemmy testing purposes
if ( getEditingColumn() == column && getEditingRow() == row ) {
return;
}
boolean changeSelection = true;
if (isTreeColumn(column)) {
TreePath path = tree.getPathForRow(TreeTable.this.rowAtPoint(e.getPoint()));
Rectangle r = tree.getPathBounds(path);
if (e.getX() >= r.x - positionX && e.getX() <= r.x - positionX + r.width) {
changeSelection = false;
}
}
if ( table.getSelectionModel().isSelectedIndex( row ) &&
e.isPopupTrigger() )
return;
if (table.editCellAt(row, column, e)) {
setDispatchComponent(e);
repostEvent(e);
}
else {
table.requestFocus();
}
CellEditor editor = table.getCellEditor();
if (changeSelection && (editor == null || editor.shouldSelectCell(e))) {
setValueIsAdjusting(true);
table.changeSelection(row, column, e.isControlDown(), e.isShiftDown());
}
}
}
}
/* When selected column is tree column then call tree's action otherwise call table's.
*/
class TreeTableAction extends AbstractAction {
Action treeAction;
Action tableAction;
TreeTableAction(Action treeAction, Action tableAction) {
this.treeAction = treeAction;
this.tableAction = tableAction;
}
public void actionPerformed(ActionEvent e) {
if (TreeTable.this.getSelectedColumn() == getTreeColumnIndex()) {
//Issue 40075, on JDK 1.5, BasicTreeUI remarkably expects
//that action events performed on trees actually come from
//trees
e.setSource(getTree());
treeAction.actionPerformed(e);
}
}
}
/** Focus transfer policy that retains focus after closing an editor.
* Copied wholesale from org.openide.explorer.propertysheet.SheetTable */
private class STPolicy extends ContainerOrderFocusTraversalPolicy {
public Component getComponentAfter(Container focusCycleRoot,
Component aComponent) {
if (inRemoveRequest) {
return TreeTable.this;
} else {
Component result = super.getComponentAfter(focusCycleRoot, aComponent);
return result;
}
}
public Component getComponentBefore(Container focusCycleRoot,
Component aComponent) {
if (inRemoveRequest) {
return TreeTable.this;
} else {
return super.getComponentBefore(focusCycleRoot, aComponent);
}
}
public Component getFirstComponent(Container focusCycleRoot) {
if (!inRemoveRequest && isEditing()) {
return editorComp;
} else {
return TreeTable.this;
}
}
public Component getDefaultComponent(Container focusCycleRoot) {
if (inRemoveRequest && isEditing() && editorComp.isShowing()) {
return editorComp;
} else {
return TreeTable.this;
}
}
protected boolean accept(Component aComponent) {
//Do not allow focus to go to a child of the editor we're using if
//we are in the process of removing the editor
if (isEditing() && inEditRequest) {
return isKnownComponent (aComponent);
}
return super.accept(aComponent) && aComponent.isShowing();
}
}
/** Enables tab keys to navigate between rows but also exit the table
* to the next focusable component in either direction */
private final class NavigationAction extends AbstractAction {
private boolean direction;
public NavigationAction(boolean direction) {
this.direction = direction;
}
public void actionPerformed(ActionEvent e) {
if (isEditing()) {
removeEditor();
}
int targetRow;
int targetColumn;
if (direction) {
if (getSelectedColumn() == getColumnCount()-1) {
targetColumn=0;
targetRow = getSelectedRow()+1;
} else {
targetColumn = getSelectedColumn()+1;
targetRow = getSelectedRow();
}
} else {
if (getSelectedColumn() == 0) {
targetColumn = getColumnCount()-1;
targetRow = getSelectedRow()-1;
} else {
targetRow = getSelectedRow();
targetColumn = getSelectedColumn() -1;
}
}
//if we're off the end, try to find a sibling component to pass
//focus to
if (targetRow >= getRowCount() || targetRow < 0) {
//This code is a bit ugly, but works
Container ancestor = getFocusCycleRootAncestor();
//Find the next component in our parent's focus cycle
Component sibling = direction ?
ancestor.getFocusTraversalPolicy().getComponentAfter(ancestor,
TreeTable.this.getParent()) :
ancestor.getFocusTraversalPolicy().getComponentBefore(ancestor,
TreeTable.this);
//Often LayoutFocusTranferPolicy will return ourselves if we're
//the last. First try to find a parent focus cycle root that
//will be a little more polite
if (sibling == TreeTable.this) {
Container grandcestor = ancestor.getFocusCycleRootAncestor();
if (grandcestor != null) {
sibling = direction ? grandcestor.getFocusTraversalPolicy().getComponentAfter(grandcestor, ancestor) :
grandcestor.getFocusTraversalPolicy().getComponentBefore(grandcestor, ancestor);
ancestor = grandcestor;
}
}
//Okay, we still ended up with ourselves, or there is only one focus
//cycle root ancestor. Try to find the first component according to
//the policy
if (sibling == TreeTable.this) {
if (ancestor.getFocusTraversalPolicy().getFirstComponent(ancestor) != null) {
sibling = ancestor.getFocusTraversalPolicy().getFirstComponent(ancestor);
}
}
//If we're *still* getting ourselves, find the default button and punt
if (sibling == TreeTable.this) {
JRootPane rp = getRootPane();
JButton jb = rp.getDefaultButton();
if (jb != null) {
sibling = jb;
}
}
//See if it's us, or something we know about, and if so, just
//loop around to the top or bottom row - there's noplace
//interesting for focus to go to
if (sibling != null) {
if (sibling == TreeTable.this) {
//set the selection if there's nothing else to do
changeSelection(direction ? 0 : getRowCount()-1,
direction ? 0 : getColumnCount()-1,false,false);
} else {
//Request focus on the sibling
sibling.requestFocus();
}
return;
}
}
changeSelection (targetRow, targetColumn, false, false);
}
}
/** Used to explicitly invoke editing from the keyboard */
private class EditAction extends AbstractAction {
public void actionPerformed(ActionEvent e) {
int row = getSelectedRow();
int col = getSelectedColumn();
if (col == 0) {
col = 1;
}
editCellAt(row, col, null);
}
public boolean isEnabled() {
return getSelectedRow() != -1 && getSelectedColumn() != -1 && !isEditing();
}
}
/** Either cancels an edit, or closes the enclosing dialog if present */
private class CancelEditAction extends AbstractAction {
public void actionPerformed(ActionEvent e) {
if (isEditing() || editorComp != null) {
removeEditor();
return;
} else {
Component c = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
InputMap imp = getRootPane().getInputMap(WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
ActionMap am = getRootPane().getActionMap();
KeyStroke escape = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0, false);
Object key = imp.get(escape);
if (key == null) {
//Default for NbDialog
key = "Cancel";
}
if (key != null) {
Action a = am.get(key);
if (a != null) {
String commandKey = (String)a.getValue(Action.ACTION_COMMAND_KEY);
if (commandKey == null) {
commandKey = key.toString();
}
a.actionPerformed(new ActionEvent(this,
ActionEvent.ACTION_PERFORMED, commandKey)); //NOI18N
}
}
}
}
public boolean isEnabled() {
// return isEditing();
return true;
}
}
private class EnterAction extends AbstractAction {
public void actionPerformed(ActionEvent e) {
JRootPane jrp = getRootPane();
if (jrp != null) {
JButton b = getRootPane().getDefaultButton();
if (b != null && b.isEnabled()) {
b.doClick();
}
}
}
public boolean isEnabled() {
return !isEditing() && !inRemoveRequest;
}
}
private class CTRLTabAction extends AbstractAction {
public void actionPerformed(ActionEvent e) {
setFocusCycleRoot(false);
try {
Container con = TreeTable.this.getFocusCycleRootAncestor();
if (con != null) {
Component target = TreeTable.this;
if (getParent() instanceof JViewport) {
target = getParent().getParent();
if (target == con) {
target = TreeTable.this;
}
}
EventObject eo = EventQueue.getCurrentEvent();
boolean backward = false;
if (eo instanceof KeyEvent) {
backward =
(((KeyEvent) eo).getModifiers()
& KeyEvent.SHIFT_MASK)
!= 0 && (((KeyEvent) eo).getModifiersEx() &
KeyEvent.SHIFT_DOWN_MASK) != 0;
}
Component to = backward ?
con.getFocusTraversalPolicy().getComponentAfter(
con, TreeTable.this)
: con.getFocusTraversalPolicy().getComponentAfter(
con, TreeTable.this);
if (to == TreeTable.this) {
to = backward ?
con.getFocusTraversalPolicy().getFirstComponent(con) :
con.getFocusTraversalPolicy().getLastComponent(con);
}
to.requestFocus();
}
} finally {
setFocusCycleRoot(true);
}
}
}
}