1. /*

  2.  * @(#)SynthTreeUI.java	1.20 04/01/13

  3.  *

  4.  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. package com.sun.java.swing.plaf.gtk;

  8. 

  9. import javax.swing.*;

  10. import javax.swing.event.*;

  11. import java.awt.*;

  12. import java.awt.event.*;

  13. import java.awt.datatransfer.*;

  14. import java.awt.dnd.*;

  15. import java.beans.*;

  16. import java.io.*;

  17. import java.util.*;

  18. import javax.swing.plaf.ActionMapUIResource;

  19. import javax.swing.plaf.ComponentUI;

  20. import javax.swing.plaf.UIResource;

  21. import javax.swing.plaf.TreeUI;

  22. import javax.swing.tree.*;

  23. import javax.swing.text.Position;

  24. 

  25. /**

  26.  * SynthTreeUI provides space for a control icon and the renderer

  27.  * portion of a node. The leading edge of the renderer is calculated

  28.  * by <code>Tree.indent</code> * depth - 1 + <code>Tree.controlSize</code>.

  29.  * The icon is centered at leading renderer edge -

  30.  * <code>Tree.trailingControlOffset</code>. The horizontal separators,

  31.  * if drawn, are drawn from the leading edge of the renderer -

  32.  * <code>Tree.trailingControlOffset</code> to the leading edge of

  33.  * renderer - <code>Tree.trailingLegBufferOffset</code>.

  34.  * <p>

  35.  *

  36.  * @version 1.20, 01/13/04 (based on BasicTreeUI v 1.155)

  37.  * @author Scott Violet

  38.  */

  39. class SynthTreeUI extends TreeUI implements PropertyChangeListener, SynthUI,

  40.            LazyActionMap.Loader {

  41. 

  42.     private static final TreeDragGestureRecognizer defaultDragRecognizer

  43.         = new TreeDragGestureRecognizer();

  44. 

  45.     private static DropTargetListener defaultDropTargetListener = null;

  46.     

  47.     private static final TransferHandler defaultTransferHandler

  48.         = new TreeTransferHandler();

  49. 

  50.     /**

  51.      * Icon to use for nodes that are collapsed.

  52.      */

  53.     private Icon collapsedIcon;

  54. 

  55.     /**

  56.      * Icon to use when a node is expanded.

  57.      */

  58.     private Icon expandedIcon;

  59. 

  60.     /**

  61.      * The Tree!

  62.      */

  63.     private JTree tree;

  64. 

  65.     /**

  66.      * Used during drawing to track which nodes have had their separators

  67.      * drawn.

  68.      */

  69.     private Map drawingCache;

  70. 

  71.     /**

  72.      * Offset, from trailing margin, to center of control icon.

  73.      */

  74.     private int trailingControlOffset;

  75. 

  76.     /**

  77.      * Total size to allow to expand/collapse icon. This includes the

  78.      * leading padding.

  79.      */

  80.     private int controlSize;

  81.  

  82.     /**

  83.      * Pixels to indent children, this is not necessarily controlSize.

  84.      */

  85.     private int indent;

  86. 

  87.    /**

  88.      * Amount of space to leave between node and horizontal separators as

  89.      * measured from trailing margin.

  90.      */

  91.     private int trailingLegBufferOffset;

  92. 

  93.     /**

  94.      * Indicates if the horizontal legs should be drawn.

  95.      */

  96.     private boolean drawHorizontalLegs;

  97. 

  98.     /**

  99.      * Indicates if the vertical legs should be drawn.

  100.      */

  101.     private boolean drawVerticalLegs;

  102. 

  103.     /**

  104.      * Whether or not the focus border should be drawn around the renderer.

  105.      */

  106.     private boolean drawsFocusBorder;

  107. 

  108.     /**

  109.      * The offset the root should be rendered at. This isn't a pixel

  110.      * value, rather an integer that will be offset by the getIndent.

  111.      * The value depends upon if the root is visible, and if the root handles

  112.      * are visible.

  113.      */

  114.     private int rootOffset;

  115. 

  116.     /**

  117.      * If true, when TreeSelectionListener.valueChanged is invoked it will

  118.      * NOT invoke stopCellEditing. This is used when the selection is changed

  119.      * as a result of editing so that the editing session isn't canceled

  120.      * immediately.

  121.      */

  122.     private boolean stopEditingWhenSelectionChanges;

  123. 

  124.     /**

  125.      * Used to paint the TreeCellRenderer.

  126.      */

  127.     private CellRendererPane  rendererPane;

  128. 

  129.     /**

  130.      * Preferred size, calculated from the AbstractLayoutCache.

  131.      */

  132.     private Dimension preferredSize;

  133. 

  134.     /**

  135.      * Is the preferredSize valid?

  136.      */

  137.     protected boolean validCachedPreferredSize;

  138. 

  139.     /**

  140.      * Object responsible for handling sizing and expanded issues.

  141.      */

  142.     private AbstractLayoutCache  treeState;

  143. 

  144.     /**

  145.      * True if doing optimizations for a largeModel. This is used

  146.      * to determine the type of AbstractLayoutCache to create.

  147.      */

  148.     private boolean largeModel;

  149. 

  150.     /**

  151.      * Reponsible for telling the TreeState the size needed for a node.

  152.      */

  153.     private AbstractLayoutCache.NodeDimensions     nodeDimensions;

  154. 

  155.     /**

  156.      * Used during editing to hold editing related state.

  157.      */

  158.     private EditingState editingState;

  159. 

  160.     /**

  161.      * Indicates the orientation. This is cached as used quite extensively

  162.      * while painting.

  163.      */

  164.     private boolean leftToRight;

  165. 

  166.     /**

  167.      * Row corresponding to the lead path.

  168.      */

  169.     private int leadRow;

  170. 

  171.     // Cached listeners

  172.     private MouseListener mouseListener;

  173.     private FocusListener focusListener;

  174.     private KeyListener keyListener;

  175.     /**

  176.      * Used for large models, listens for moved/resized events and

  177.      * updates the validCachedPreferredSize bit accordingly.

  178.      */

  179.     private ComponentListener componentListener;

  180.     private CellEditorListener cellEditorListener;

  181.     private TreeSelectionListener treeSelectionListener;

  182.     private TreeModelListener treeModelListener;

  183.     private TreeExpansionListener treeExpansionListener;

  184. 

  185.     private SynthStyle style;

  186.     private SynthStyle cellStyle;

  187. 

  188. 

  189.     public static ComponentUI createUI(JComponent x) {

  190. 	return new SynthTreeUI();

  191.     }

  192. 

  193.     /**

  194.      * Ensures that the rows identified by beginRow through endRow are

  195.      * visible.

  196.      */

  197.     private static void ensureRowsAreVisible(JTree tree, int beginRow,

  198.                                              int endRow) {

  199. 	if (beginRow >= 0 && endRow < tree.getRowCount()) {

  200.             // PENDING: needs to be updated.

  201.             SynthTreeUI ui = (SynthTreeUI)tree.getUI();

  202.             SynthContext context = ui.getContext(tree);

  203.             boolean scrollVert = context.getStyle().getBoolean(context,

  204.                               "Tree.scrollsHorizontallyAndVertically", false);

  205.             context.dispose();

  206. 

  207. 	    if (beginRow == endRow) {

  208. 		Rectangle scrollBounds = tree.getPathBounds(

  209.                                 tree.getPathForRow(beginRow));

  210. 

  211. 		if (scrollBounds != null) {

  212.                     if (!scrollVert) {

  213.                         scrollBounds.x = tree.getVisibleRect().x;

  214.                         scrollBounds.width = 1;

  215.                     }

  216. 		    tree.scrollRectToVisible(scrollBounds);

  217. 		}

  218. 	    }

  219. 	    else {

  220. 		Rectangle beginRect = tree.getPathBounds(tree.getPathForRow

  221.                                                            (beginRow));

  222. 		Rectangle visRect = tree.getVisibleRect();

  223. 		Rectangle testRect = beginRect;

  224. 		int beginY = beginRect.y;

  225. 		int maxY = beginY + visRect.height;

  226. 

  227. 		for (int counter = beginRow + 1; counter <= endRow; counter++){

  228. 		    testRect = tree.getPathBounds(tree.getPathForRow(counter));

  229. 		    if ((testRect.y + testRect.height) > maxY) {

  230. 			counter = endRow;

  231.                     }

  232. 		}

  233. 		tree.scrollRectToVisible(new Rectangle(visRect.x, beginY, 1,

  234. 						  testRect.y + testRect.height-

  235. 						  beginY));

  236. 	    }

  237. 	}

  238.     }

  239. 

  240. 

  241.     //

  242.     // ComponentUI methods

  243.     //

  244. 

  245.     /**

  246.      * Returns the preferred size needed to properly renderer the tree.

  247.      */

  248.     public Dimension getPreferredSize(JComponent c) {

  249. 	if (!validCachedPreferredSize) {

  250. 	    updateCachedPreferredSize();

  251.         }

  252.         return new Dimension(preferredSize);

  253.     }

  254. 

  255.     /**

  256.       * Returns the minimum size for this component.  Which will be

  257.       * the min preferred size or 0, 0.

  258.       */

  259.     public Dimension getMinimumSize(JComponent c) {

  260. 	return new Dimension(0, 0);

  261.     }

  262. 

  263.     /**

  264.       * Returns the maximum size for this component, which will be the

  265.       * preferred size if the instance is currently in a JTree, or 0, 0.

  266.       */

  267.     public Dimension getMaximumSize(JComponent c) {

  268.         return getPreferredSize(tree);

  269.     }

  270. 

  271.     //

  272.     // TreeUI methods

  273.     //

  274. 

  275.     /**

  276.       * Returns the Rectangle enclosing the label portion that the

  277.       * last item in path will be drawn into.  Will return null if

  278.       * any component in path is currently valid.

  279.       */

  280.     public Rectangle getPathBounds(JTree tree, TreePath path) {

  281. 	if (tree != null && treeState != null) {

  282. 	    Rectangle        bounds = treeState.getBounds(path, null);

  283. 

  284.             adjustCellBounds(tree, bounds, null);

  285. 	    return bounds;

  286. 	}

  287. 	return null;

  288.     }

  289. 

  290.     /**

  291.       * Returns the path for passed in row.  If row is not visible

  292.       * null is returned.

  293.       */

  294.     public TreePath getPathForRow(JTree tree, int row) {

  295. 	return (treeState != null) ? treeState.getPathForRow(row) : null;

  296.     }

  297. 

  298.     /**

  299.       * Returns the row that the last item identified in path is visible

  300.       * at.  Will return -1 if any of the elements in path are not

  301.       * currently visible.

  302.       */

  303.     public int getRowForPath(JTree tree, TreePath path) {

  304. 	return (treeState != null) ? treeState.getRowForPath(path) : -1;

  305.     }

  306. 

  307.     /**

  308.       * Returns the number of rows that are being displayed.

  309.       */

  310.     public int getRowCount(JTree tree) {

  311. 	return (treeState != null) ? treeState.getRowCount() : 0;

  312.     }

  313. 

  314.     /**

  315.       * Returns the path to the node that is closest to x,y.  If

  316.       * there is nothing currently visible this will return null, otherwise

  317.       * it'll always return a valid path.  If you need to test if the

  318.       * returned object is exactly at x, y you should get the bounds for

  319.       * the returned path and test x, y against that.

  320.       */

  321.     public TreePath getClosestPathForLocation(JTree tree, int x, int y) {

  322. 	if (tree != null && treeState != null) {

  323. 	    Insets          i = tree.getInsets();

  324. 

  325.             if (leftToRight) {

  326.                 x -= i.left;

  327.             }

  328.             else {

  329.                 x = tree.getWidth() - x - i.right;

  330.             }

  331. 	    return treeState.getPathClosestTo(x, y - i.top);

  332. 	}

  333. 	return null;

  334.     }

  335. 

  336.     /**

  337.       * Returns true if the tree is being edited.  The item that is being

  338.       * edited can be returned by getEditingPath().

  339.       */

  340.     public boolean isEditing(JTree tree) {

  341. 	return (editingState != null);

  342.     }

  343. 

  344.     /**

  345.       * Stops the current editing session.  This has no effect if the

  346.       * tree isn't being edited.  Returns true if the editor allows the

  347.       * editing session to stop.

  348.       */

  349.     public boolean stopEditing(JTree tree) {

  350. 	if (editingState != null && tree.getCellEditor().stopCellEditing()) {

  351. 	    completeEditing(false, false, true);

  352. 	    return true;

  353. 	}

  354. 	return false;

  355.     }

  356. 

  357.     /**

  358.       * Cancels the current editing session.

  359.       */

  360.     public void cancelEditing(JTree tree) {

  361. 	if (editingState != null) {

  362. 	    completeEditing(false, true, false);

  363. 	}

  364.     }

  365. 

  366.     /**

  367.       * Selects the last item in path and tries to edit it.  Editing will

  368.       * fail if the CellEditor won't allow it for the selected item.

  369.       */

  370.     public void startEditingAtPath(JTree tree, TreePath path) {

  371. 	tree.scrollPathToVisible(path);

  372. 	if (path != null && tree.isVisible(path)) {

  373. 	    startEditing(path, null);

  374.         }

  375.     }

  376. 

  377.     /**

  378.      * Returns the path to the element that is being edited.

  379.      */

  380.     public TreePath getEditingPath(JTree tree) {

  381. 	return (editingState != null) ? editingState.path : null;

  382.     }

  383. 

  384.     //

  385.     // Install methods

  386.     //

  387. 

  388.     public SynthTreeUI() {

  389.         preferredSize = new Dimension();

  390.     }

  391. 

  392.     public void installUI(JComponent c) {

  393.         if (c == null) {

  394. 	    throw new NullPointerException(

  395.                           "null component passed to SynthTreeUI.installUI()");

  396.         }

  397. 

  398. 	tree = (JTree)c;

  399. 

  400. 	drawingCache = new HashMap(7);

  401. 	leftToRight = tree.getComponentOrientation().isLeftToRight();

  402.         stopEditingWhenSelectionChanges = true;

  403.         validCachedPreferredSize = false;

  404. 

  405. 	installDefaults();

  406. 	installKeyboardActions();

  407. 	installComponents();

  408. 	installListeners();

  409.     }

  410. 

  411.     protected void installDefaults() {

  412.         // Installs the renderer, and potentially the editor

  413.         updateRenderer();

  414. 

  415.         fetchStyle(tree);

  416. 

  417.         // This has to be here so that createLayoutCache doesn't get an NPE

  418.         // when the renderer calls into the NodeDimensions.

  419. 	rendererPane = createCellRendererPane();

  420.         tree.add(rendererPane);

  421. 

  422. 	treeState = createLayoutCache();

  423. 	configureLayoutCache();

  424. 

  425.         TransferHandler th = tree.getTransferHandler();

  426.         if (th == null || th instanceof UIResource) {

  427.             tree.setTransferHandler(defaultTransferHandler);

  428.         }

  429.         DropTarget dropTarget = tree.getDropTarget();

  430.         if (dropTarget instanceof UIResource) {

  431.             if (defaultDropTargetListener == null) {

  432.                 defaultDropTargetListener = new TreeDropTargetListener();

  433.             }

  434.             try {

  435.                 dropTarget.addDropTargetListener(defaultDropTargetListener);

  436.             } catch (TooManyListenersException tmle) {

  437.                 // should not happen... swing drop target is multicast

  438.             }

  439.         }

  440.     }

  441. 

  442.     private void fetchStyle(JTree tree) {

  443.         SynthContext context = getContext(tree, ENABLED);

  444.         SynthStyle oldStyle = style;

  445. 

  446.         style = SynthLookAndFeel.updateStyle(context, this);

  447.         if (style != oldStyle) {

  448.             drawHorizontalLegs = style.getBoolean(

  449.                           context, "Tree.drawHorizontalLegs",true);

  450.             drawVerticalLegs = style.getBoolean(

  451.                         context, "Tree.drawVerticalLegs", true);

  452. 

  453.             tree.setRowHeight(style.getInt(context, "Tree.rowHeight", -1));

  454. 

  455.             tree.setScrollsOnExpand(style.getBoolean(

  456.                                      context, "Tree.scrollsOnExpand", true));

  457. 

  458.             largeModel = (tree.isLargeModel() && tree.getRowHeight() > 0);

  459. 

  460.             expandedIcon = style.getIcon(context, "Tree.expandedIcon");

  461.             collapsedIcon = style.getIcon(context, "Tree.collapsedIcon");

  462. 

  463.             trailingLegBufferOffset = style.getInt(

  464.                       context, "Tree.trailingLegBufferOffset", 0);

  465.             trailingControlOffset = style.getInt(

  466.                         context, "Tree.trailingControlOffset", 0);

  467.             controlSize = style.getInt(context, "Tree.controlSize", 0);

  468.             indent = style.getInt(context, "Tree.indent", 0);

  469.             updateRootOffset();

  470. 

  471.             drawsFocusBorder = style.getBoolean(

  472.                       context, "Tree.drawsFocusBorder", true);

  473.         }

  474.         context.dispose();

  475. 

  476.         context = getContext(tree, Region.TREE_CELL, ENABLED);

  477.         cellStyle = SynthLookAndFeel.updateStyle(context, this);

  478.         context.dispose();

  479.     }

  480. 

  481.     protected void installListeners() {

  482.         tree.addPropertyChangeListener(this);

  483. 

  484. 	tree.addMouseListener(defaultDragRecognizer);

  485. 	tree.addMouseMotionListener(defaultDragRecognizer);

  486. 

  487.         if ((mouseListener = createMouseListener()) != null) {

  488. 	    tree.addMouseListener(mouseListener);

  489. 	    if (mouseListener instanceof MouseMotionListener) {

  490. 		tree.addMouseMotionListener(

  491.                              (MouseMotionListener)mouseListener);

  492. 	    }

  493. 	}

  494.         if ((focusListener = createFocusListener()) != null) {

  495. 	    tree.addFocusListener(focusListener);

  496. 	}

  497.         if ((keyListener = createKeyListener()) != null) {

  498. 	    tree.addKeyListener(keyListener);

  499. 	}

  500. 	if ((treeExpansionListener = createTreeExpansionListener()) != null) {

  501. 	    tree.addTreeExpansionListener(treeExpansionListener);

  502. 	}

  503.         // TreeModel can be null

  504.         TreeModel model = tree.getModel();

  505. 	if ((treeModelListener = createTreeModelListener()) != null &&

  506. 	                         model != null) {

  507. 	    model.addTreeModelListener(treeModelListener);

  508. 	}

  509.         TreeSelectionModel treeSelectionModel = tree.getSelectionModel();

  510. 	if ((treeSelectionListener = createTreeSelectionListener()) != null) {

  511. 	    treeSelectionModel.addTreeSelectionListener(treeSelectionListener);

  512. 	}

  513. 

  514.         TreeCellEditor editor = tree.getCellEditor();

  515. 

  516.         if (editor != null) {

  517.             cellEditorListener = createCellEditorListener();

  518. 

  519.             if (cellEditorListener != null) {

  520.                 editor.addCellEditorListener(cellEditorListener);

  521.             }

  522.         }

  523.     }

  524. 

  525.     protected void installKeyboardActions() {

  526. 	InputMap km = getInputMap(JComponent.

  527. 				  WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

  528. 

  529. 	SwingUtilities.replaceUIInputMap(tree, JComponent.

  530. 					 WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,

  531. 					 km);

  532. 	km = getInputMap(JComponent.WHEN_FOCUSED);

  533. 	SwingUtilities.replaceUIInputMap(tree, JComponent.WHEN_FOCUSED, km);

  534. 

  535.         LazyActionMap.installLazyActionMap(tree, this);

  536.     }

  537. 

  538.     InputMap getInputMap(int condition) {

  539.         SynthContext context = getContext(tree, ENABLED);

  540.         SynthStyle style = context.getStyle();

  541.         InputMap map = null;

  542. 

  543. 	if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {

  544. 	    map = (InputMap)style.get(context, "Tree.ancestorInputMap");

  545. 	}

  546. 	else if (condition == JComponent.WHEN_FOCUSED) {

  547. 	    map = (InputMap)style.get(context, "Tree.focusInputMap");

  548. 

  549. 	    InputMap rtlKeyMap;

  550. 

  551. 	    if (!leftToRight && ((rtlKeyMap = (InputMap)style.get(context,

  552.                                  "Tree.focusInputMap.RightToLeft")) != null)) {

  553. 		rtlKeyMap.setParent(map);

  554.                 map = rtlKeyMap;

  555. 	    }

  556. 	}

  557.         context.dispose();

  558. 	return map;

  559.     }

  560. 

  561.     public void loadActionMap(JComponent c, ActionMap map) {

  562. 	map.put("selectPrevious", new IncrementAction("selectPrevious", -1,

  563. 							  false, true));

  564. 	map.put("selectPreviousChangeLead", new IncrementAction

  565. 		("selectPreviousLead", -1, false, false));

  566. 	map.put("selectPreviousExtendSelection", new IncrementAction

  567. 		("selectPreviousExtendSelection", -1, true, true));

  568. 

  569. 	map.put("selectNext", new IncrementAction

  570. 		("selectNext", 1, false, true));

  571. 	map.put("selectNextChangeLead", new IncrementAction

  572. 		("selectNextLead", 1, false, false));

  573. 	map.put("selectNextExtendSelection", new IncrementAction

  574. 		("selectNextExtendSelection", 1, true, true));

  575. 

  576. 	map.put("selectChild", new TraverseAction

  577. 		("selectChild", 1, true));

  578. 	map.put("selectChildChangeLead", new TraverseAction

  579. 		("selectChildLead", 1, false));

  580. 

  581. 	map.put("selectParent", new TraverseAction

  582. 		("selectParent", -1, true));

  583. 	map.put("selectParentChangeLead", new TraverseAction

  584. 		("selectParentLead", -1, false));	

  585. 

  586. 	map.put("scrollUpChangeSelection", new ScrollAndSelectAction

  587. 		("scrollUpChangeSelection", SwingConstants.NORTH,false, true));

  588. 	map.put("scrollUpChangeLead", new ScrollAndSelectAction

  589. 		("scrollUpChangeLead", SwingConstants.NORTH, false, false));

  590. 	map.put("scrollUpExtendSelection", new ScrollAndSelectAction

  591. 		("scrollUpExtendSelection", SwingConstants.NORTH, true, true));

  592. 

  593. 	map.put("scrollDownChangeSelection", new ScrollAndSelectAction

  594. 		("scrollDownChangeSelection", SwingConstants.SOUTH, false,

  595.                  true));

  596. 	map.put("scrollDownExtendSelection", new ScrollAndSelectAction

  597. 		("scrollDownExtendSelection", SwingConstants.SOUTH, true,

  598.                  true));

  599. 	map.put("scrollDownChangeLead", new ScrollAndSelectAction

  600. 		("scrollDownChangeLead", SwingConstants.SOUTH, false, false));

  601. 

  602. 	map.put("selectFirst", new HomeAction

  603. 		("selectFirst", -1, false, true));

  604. 	map.put("selectFirstChangeLead", new HomeAction

  605. 		("selectFirst", -1, false, false));

  606. 	map.put("selectFirstExtendSelection",new HomeAction

  607. 		("selectFirstExtendSelection", -1, true, true));

  608. 

  609. 	map.put("selectLast", new HomeAction

  610. 		("selectLast", 1, false, true));

  611. 	map.put("selectLastChangeLead", new HomeAction

  612. 		("selectLast", 1, false, false));

  613. 	map.put("selectLastExtendSelection", new HomeAction

  614. 		("selectLastExtendSelection", 1, true, true));

  615. 

  616. 	map.put("toggle", new ToggleAction("toggle"));

  617. 

  618. 	map.put("cancel", new CancelEditingAction("cancel"));

  619. 

  620. 	map.put("startEditing", new EditAction("startEditing"));

  621. 

  622. 	map.put("selectAll", new SelectAllAction("selectAll", true));

  623. 

  624. 	map.put("clearSelection", new SelectAllAction

  625. 		("clearSelection", false));

  626. 

  627. 	map.put("toggleSelectionPreserveAnchor",

  628. 		new AddSelectionAction("toggleSelectionPreserveAnchor",

  629. 					   false));

  630. 	map.put("toggleSelection",

  631. 		new AddSelectionAction("toggleSelection", true));

  632. 

  633. 	map.put("extendSelection", new ExtendSelectionAction

  634. 		("extendSelection"));

  635. 

  636. 	map.put("scrollLeft", new ScrollAction

  637. 		("scrollLeft", SwingConstants.HORIZONTAL, -10));

  638. 	map.put("scrollLeftExtendSelection", new ScrollAndSelectAction

  639. 		("scrollLeftExtendSelection", SwingConstants.WEST,true, true));

  640. 	map.put("scrollRight", new ScrollAction

  641. 		("scrollRight", SwingConstants.HORIZONTAL, 10));

  642. 	map.put("scrollRightExtendSelection", new ScrollAndSelectAction

  643. 		("scrollRightExtendSelection", SwingConstants.EAST,true,true));

  644. 

  645. 	map.put("scrollRightChangeLead", new ScrollAndSelectAction

  646. 		("scrollRightChangeLead", SwingConstants.EAST, false, false));

  647. 	map.put("scrollLeftChangeLead", new ScrollAndSelectAction

  648. 		("scrollLeftChangeLead", SwingConstants.WEST, false, false));

  649.         

  650.         map.put("expand", new TreeExpandAction());

  651.         map.put("collapse", new TreeCollapseAction());

  652.         map.put("moveSelectionToParent", new TreeMoveSelectionToParentAction());

  653. 

  654.         map.put(TransferHandler.getCutAction().getValue(Action.NAME),

  655.                 TransferHandler.getCutAction());

  656.         map.put(TransferHandler.getCopyAction().getValue(Action.NAME),

  657.                 TransferHandler.getCopyAction());

  658.         map.put(TransferHandler.getPasteAction().getValue(Action.NAME),

  659.                 TransferHandler.getPasteAction());

  660.     }

  661. 

  662.     /**

  663.      * Intalls the subcomponents of the tree, which is the renderer pane.

  664.      */

  665.     protected void installComponents() {

  666.     }

  667. 

  668.     public SynthContext getContext(JComponent c) {

  669.         return getContext(c, getComponentState(c));

  670.     }

  671. 

  672.     private SynthContext getContext(JComponent c, int state) {

  673.         return SynthContext.getContext(SynthContext.class, c,

  674.                     SynthLookAndFeel.getRegion(c), style, state);

  675.     }

  676. 

  677.     private Region getRegion(JTree c) {

  678.         return SynthLookAndFeel.getRegion(c);

  679.     }

  680. 

  681.     private int getComponentState(JComponent c) {

  682.         return SynthLookAndFeel.getComponentState(c);

  683.     }

  684. 

  685.     private SynthContext getContext(JComponent c, Region region) {

  686.         return getContext(c, region, getComponentState(c, region));

  687.     }

  688. 

  689.     private SynthContext getContext(JComponent c, Region region, int state) {

  690.         return SynthContext.getContext(SynthContext.class, c,

  691.                                        region, cellStyle, state);

  692.     }

  693. 

  694.     private int getComponentState(JComponent c, Region region) {

  695.         // Always treat the cell as selected, will be adjusted appropriately

  696.         // when painted.

  697.         return ENABLED | SELECTED;

  698.     }

  699. 

  700.     //

  701.     // Create methods.

  702.     //

  703. 

  704.     /**

  705.      * Adjusts the bounds, as returned from the TreeState to the insets

  706.      * and orientation of the Tree.

  707.      */

  708.     private void adjustCellBounds(JTree tree, Rectangle bounds, Insets i){

  709.         if (bounds != null) {

  710.             if (i == null) {

  711.                 i = tree.getInsets();

  712.             }

  713.             bounds.y += i.top;

  714.             if (leftToRight) {

  715.                 bounds.x += i.left;

  716.             }

  717.             else {

  718.                 bounds.x = tree.getWidth() - i.right - bounds.x - bounds.width;

  719.             }

  720.         }

  721.     }

  722. 

  723.     /**

  724.      * Creates an instance of NodeDimensions that is able to determine

  725.      * the size of a given node in the tree.

  726.      */

  727.     protected AbstractLayoutCache.NodeDimensions createNodeDimensions() {

  728. 	return new NodeDimensionsHandler();

  729.     }

  730. 

  731.     /**

  732.      * Creates the listener responsible for updating the selection based on

  733.      * mouse events.

  734.      */

  735.     protected MouseListener createMouseListener() {

  736.         return new MouseHandler();

  737.     }

  738. 

  739.     /**

  740.      * Creates a listener that is responsible for updating the display

  741.      * when focus is lost/gained.

  742.      */

  743.     protected FocusListener createFocusListener() {

  744.         return new FocusHandler();

  745.     }

  746. 

  747.     /**

  748.      * Creates the listener reponsible for getting key events from

  749.      * the tree.

  750.      */

  751.     protected KeyListener createKeyListener() {

  752.         return new KeyHandler();

  753.     }

  754. 

  755.     /**

  756.      * Creates the listener that updates the display based on selection change

  757.      * methods.

  758.      */

  759.     protected TreeSelectionListener createTreeSelectionListener() {

  760. 	return new TreeSelectionHandler();

  761.     }

  762. 

  763.     /**

  764.      * Creates a listener to handle events from the current editor.

  765.      */

  766.     protected CellEditorListener createCellEditorListener() {

  767. 	return new CellEditorHandler();

  768.     }

  769. 

  770.     /**

  771.      * Creates and returns a new ComponentHandler. This is used for

  772.      * the large model to mark the validCachedPreferredSize as invalid

  773.      * when the component moves.

  774.      */

  775.     protected ComponentListener createComponentListener() {

  776. 	return new ComponentHandler();

  777.     }

  778. 

  779.     /**

  780.      * Creates and returns the object responsible for updating the treestate

  781.      * when nodes expanded state changes.

  782.      */

  783.     protected TreeExpansionListener createTreeExpansionListener() {

  784. 	return new TreeExpansionHandler();

  785.     }

  786. 

  787.     /**

  788.      * Creates the object responsible for managing what is expanded, as

  789.      * well as the size of nodes.

  790.      */

  791.     protected AbstractLayoutCache createLayoutCache() {

  792. 	if (largeModel && tree.getRowHeight() > 0) {

  793. 	    return new FixedHeightLayoutCache();

  794. 	}

  795.         return new VariableHeightLayoutCache();

  796.     }

  797. 

  798.     /**

  799.      * Returns the renderer pane that renderer components are placed in.

  800.      */

  801.     protected CellRendererPane createCellRendererPane() {

  802.         return new CellRendererPane();

  803.     }

  804. 

  805.     /**

  806.       * Creates a default cell editor.

  807.       */

  808.     protected TreeCellEditor createCellEditor() {

  809.         TreeCellRenderer renderer = tree.getCellRenderer();

  810.         DefaultTreeCellEditor editor;

  811. 

  812. 	if(renderer != null && (renderer instanceof DefaultTreeCellRenderer)) {

  813. 	    editor = new SynthTreeCellEditor(tree, (DefaultTreeCellRenderer)

  814.                                              renderer);

  815. 	}

  816.         else {

  817.             editor = new SynthTreeCellEditor(tree, null);

  818.         }

  819.         SynthContext context = getContext(tree, ENABLED);

  820.         context.setComponentState(ENABLED | SELECTED);

  821.         context.dispose();

  822.         return editor;

  823.     }

  824. 

  825.     /**

  826.       * Returns the default cell renderer that is used to do the

  827.       * stamping of each node.

  828.       */

  829.     protected TreeCellRenderer createCellRenderer() {

  830.         return new SynthTreeCellRenderer();

  831.     }

  832. 

  833.     /**

  834.      * Returns a listener that can update the tree when the model changes.

  835.      */

  836.     protected TreeModelListener createTreeModelListener() {

  837. 	return new TreeModelHandler();

  838.     }

  839. 

  840.     //

  841.     // Uninstall methods

  842.     //

  843. 

  844.     public void uninstallUI(JComponent c) {

  845. 	completeEditing();

  846. 

  847. 	uninstallListeners();

  848. 	uninstallComponents();

  849. 	uninstallKeyboardActions();

  850. 	uninstallDefaults();

  851.     }

  852. 

  853.     protected void uninstallDefaults() {

  854.         SynthContext context = getContext(tree, ENABLED);

  855. 

  856.         style.uninstallDefaults(context);

  857.         context.dispose();

  858.         style = null;

  859. 

  860.         context = getContext(tree, Region.TREE_CELL, ENABLED);

  861.         cellStyle.uninstallDefaults(context);

  862.         context.dispose();

  863.         cellStyle = null;

  864. 

  865. 

  866. 	if (tree.getTransferHandler() instanceof UIResource) {

  867. 	    tree.setTransferHandler(null);

  868. 	}

  869.         if (tree.getCellRenderer() instanceof UIResource) {

  870. 	    tree.setCellRenderer(null);

  871. 	}

  872.         if (tree.getCellEditor() instanceof UIResource) {

  873. 	    tree.setCellEditor(null);

  874. 	}

  875.         tree = null;

  876.     }

  877. 

  878.     protected void uninstallListeners() {

  879. 	if (componentListener != null) {

  880. 	    tree.removeComponentListener(componentListener);

  881. 	}

  882.         tree.removePropertyChangeListener(this);

  883. 

  884. 	tree.removeMouseListener(defaultDragRecognizer);

  885. 	tree.removeMouseMotionListener(defaultDragRecognizer);

  886. 

  887.         if (mouseListener != null) {

  888. 	    tree.removeMouseListener(mouseListener);

  889. 	    if (mouseListener instanceof MouseMotionListener) {

  890. 		tree.removeMouseMotionListener((MouseMotionListener)

  891.                                                mouseListener);

  892. 	    }

  893. 	}

  894.         if (focusListener != null) {

  895. 	    tree.removeFocusListener(focusListener);

  896. 	}

  897.         if (keyListener != null) {

  898. 	    tree.removeKeyListener(keyListener);

  899. 	}

  900. 	if (treeExpansionListener != null) {

  901. 	    tree.removeTreeExpansionListener(treeExpansionListener);

  902. 	}

  903.         TreeModel treeModel = tree.getModel();

  904. 

  905. 	if (treeModel != null && treeModelListener != null) {

  906. 	    treeModel.removeTreeModelListener(treeModelListener);

  907. 	}

  908.         TreeSelectionModel selectionModel = tree.getSelectionModel();

  909. 	if (treeSelectionListener != null) {

  910. 	    tree.getSelectionModel().removeTreeSelectionListener

  911. 		               (treeSelectionListener);

  912. 	}

  913. 

  914.         TreeCellEditor editor = tree.getCellEditor();

  915.         if (editor != null && cellEditorListener != null) {

  916.             editor.removeCellEditorListener(cellEditorListener);

  917.         }

  918.     }

  919. 

  920.     protected void uninstallKeyboardActions() {

  921. 	SwingUtilities.replaceUIActionMap(tree, null);

  922. 	SwingUtilities.replaceUIInputMap(tree, JComponent.

  923. 					 WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,

  924. 					 null);

  925. 	SwingUtilities.replaceUIInputMap(tree, JComponent.WHEN_FOCUSED, null);

  926.     }

  927. 

  928.     /**

  929.      * Uninstalls the renderer pane.

  930.      */

  931.     protected void uninstallComponents() {

  932. 	if (rendererPane != null) {

  933. 	    tree.remove(rendererPane);

  934. 	}

  935.     }

  936. 

  937.     //

  938.     // Painting routines.

  939.     //

  940. 

  941.     public void update(Graphics g, JComponent c) {

  942.         SynthContext context = getContext(c);

  943. 

  944.         SynthLookAndFeel.update(context, g);

  945.         paint(context, g);

  946.         context.dispose();

  947.     }

  948. 

  949.     public void paint(Graphics g, JComponent c) {

  950.         SynthContext context = getContext(c);

  951. 

  952.         paint(context, g);

  953.         context.dispose();

  954.     }

  955. 

  956.     protected void paint(SynthContext context, Graphics g) {

  957. 	Rectangle paintBounds = g.getClipBounds();

  958. 	Insets insets = tree.getInsets();

  959. 	TreePath initialPath = getClosestPathForLocation(tree, 0,

  960.                                                          paintBounds.y);

  961. 	Enumeration paintingEnumerator = treeState.getVisiblePathsFrom

  962. 	                                      (initialPath);

  963. 	int row = treeState.getRowForPath(initialPath);

  964. 	int endY = paintBounds.y + paintBounds.height;

  965.         TreeModel treeModel = tree.getModel();

  966.         SynthContext cellContext = getContext(tree, Region.TREE_CELL);

  967. 

  968. 	drawingCache.clear();

  969. 

  970. 	if (paintingEnumerator != null) {

  971.             // First pass, draw the rows

  972. 

  973. 	    boolean done = false;

  974. 	    boolean isExpanded;

  975. 	    boolean hasBeenExpanded;

  976. 	    boolean isLeaf;

  977. 	    Rectangle boundsBuffer = new Rectangle();

  978.             Rectangle rowBounds = new Rectangle(0, 0, tree.getWidth(),0);

  979. 	    Rectangle bounds;

  980. 	    TreePath path;

  981.             TreeCellRenderer renderer = tree.getCellRenderer();

  982.             DefaultTreeCellRenderer dtcr = (renderer instanceof

  983.                        DefaultTreeCellRenderer) ? (DefaultTreeCellRenderer)

  984.                        renderer : null;

  985. 

  986.             configureRenderer(cellContext);

  987. 	    while (!done && paintingEnumerator.hasMoreElements()) {

  988. 		path = (TreePath)paintingEnumerator.nextElement();

  989. 		if (path != null) {

  990. 		    isLeaf = treeModel.isLeaf(path.getLastPathComponent());

  991. 		    if (isLeaf) {

  992. 			isExpanded = hasBeenExpanded = false;

  993.                     }

  994. 		    else {

  995. 			isExpanded = treeState.getExpandedState(path);

  996. 			hasBeenExpanded = tree.hasBeenExpanded(path);

  997. 		    }

  998. 		    bounds = treeState.getBounds(path, boundsBuffer);

  999.                     adjustCellBounds(tree, bounds, insets);

  1000.                     rowBounds.y = bounds.y;

  1001.                     rowBounds.height = bounds.height;

  1002. 		    paintRow(renderer, dtcr, context, cellContext, g,

  1003.                              paintBounds, insets, bounds, rowBounds, path,

  1004.                              row, isExpanded, hasBeenExpanded, isLeaf);

  1005. 		    if ((bounds.y + bounds.height) >= endY) {

  1006. 			done = true;

  1007.                     }

  1008. 		}

  1009. 		else {

  1010. 		    done = true;

  1011. 		}

  1012. 		row++;

  1013. 	    }

  1014. 

  1015. 

  1016. 	    // Draw the connecting lines and controls.

  1017. 	    // Find each parent and have them draw a line to their last child

  1018.             boolean rootVisible = tree.isRootVisible();

  1019.             TreePath parentPath = initialPath;

  1020. 	    parentPath = parentPath.getParentPath();

  1021. 	    while (parentPath != null) {

  1022.                 paintVerticalPartOfLeg(context, g, paintBounds,

  1023.                                        insets, parentPath);

  1024. 		drawingCache.put(parentPath, Boolean.TRUE);

  1025. 		parentPath = parentPath.getParentPath();

  1026. 	    }

  1027. 	    done = false;

  1028.             paintingEnumerator = treeState.getVisiblePathsFrom(initialPath);

  1029. 	    while (!done && paintingEnumerator.hasMoreElements()) {

  1030. 		path = (TreePath)paintingEnumerator.nextElement();

  1031. 		if (path != null) {

  1032. 		    isLeaf = treeModel.isLeaf(path.getLastPathComponent());

  1033. 		    if (isLeaf) {

  1034. 			isExpanded = hasBeenExpanded = false;

  1035.                     }

  1036. 		    else {

  1037. 			isExpanded = treeState.getExpandedState(path);

  1038. 			hasBeenExpanded = tree.hasBeenExpanded(path);

  1039. 		    }

  1040. 		    bounds = treeState.getBounds(path, boundsBuffer);

  1041.                     adjustCellBounds(tree, bounds, insets);

  1042. 		    // See if the vertical line to the parent has been drawn.

  1043. 		    parentPath = path.getParentPath();

  1044. 		    if (parentPath != null) {

  1045. 			if (drawingCache.get(parentPath) == null) {

  1046.                             paintVerticalPartOfLeg(context, g,

  1047.                                                    paintBounds, insets,

  1048.                                                    parentPath);

  1049. 			    drawingCache.put(parentPath, Boolean.TRUE);

  1050. 			}

  1051. 			paintHorizontalPartOfLeg(context, g,

  1052.                                                  paintBounds, insets, bounds,

  1053.                                                  path, row, isExpanded,

  1054. 						 hasBeenExpanded, isLeaf);

  1055. 		    }

  1056. 		    else if (rootVisible && row == 0) {

  1057. 			paintHorizontalPartOfLeg(context, g,

  1058.                                                  paintBounds, insets, bounds,

  1059.                                                  path, row, isExpanded,

  1060. 						 hasBeenExpanded, isLeaf);

  1061. 		    }

  1062. 		    if (shouldPaintExpandControl(path, row, isExpanded,

  1063.                                                  hasBeenExpanded, isLeaf)) {

  1064. 			paintExpandControl(context, g, paintBounds,

  1065.                                            insets, bounds, path, row,

  1066.                                            isExpanded, hasBeenExpanded,isLeaf);

  1067. 		    }

  1068. 		    if ((bounds.y + bounds.height) >= endY) {

  1069. 			done = true;

  1070.                     }

  1071. 		}

  1072. 		else {

  1073. 		    done = true;

  1074. 		}

  1075. 		row++;

  1076. 	    }

  1077. 	}

  1078.         cellContext.dispose();

  1079. 	// Empty out the renderer pane, allowing renderers to be gc'ed.

  1080. 	rendererPane.removeAll();

  1081.     }

  1082. 

  1083.     private void configureRenderer(SynthContext context) {

  1084.         TreeCellRenderer renderer = tree.getCellRenderer();

  1085. 

  1086.         if (renderer instanceof DefaultTreeCellRenderer) {

  1087.             DefaultTreeCellRenderer r = (DefaultTreeCellRenderer)renderer;

  1088.             SynthStyle style = context.getStyle();

  1089. 

  1090.             context.setComponentState(ENABLED | SELECTED);

  1091.             Color color = r.getTextSelectionColor();

  1092.             if (color == null || (color instanceof UIResource)) {

  1093.                 r.setTextSelectionColor(style.getColor(

  1094.                                      context, ColorType.TEXT_FOREGROUND));

  1095.             }

  1096.             color = r.getBackgroundSelectionColor();

  1097.             if (color == null || (color instanceof UIResource)) {

  1098.                 r.setBackgroundSelectionColor(style.getColor(

  1099.                                         context, ColorType.TEXT_BACKGROUND));

  1100.             }

  1101. 

  1102.             context.setComponentState(ENABLED);

  1103.             color = r.getTextNonSelectionColor();

  1104.             if (color == null || color instanceof UIResource) {

  1105.                 r.setTextNonSelectionColor(style.getColor(

  1106.                                         context, ColorType.TEXT_FOREGROUND));

  1107.             }

  1108.             color = r.getBackgroundNonSelectionColor();

  1109.             if (color instanceof UIResource) {

  1110.                 r.setBackgroundNonSelectionColor(style.getColor(

  1111.                                   context, ColorType.TEXT_BACKGROUND));

  1112.             }

  1113.         }

  1114.     }

  1115. 

  1116.     /**

  1117.      * Paints the horizontal part of the leg. The receiver should

  1118.      * NOT modify <code>clipBounds</code>, or <code>insets</code>.<p>

  1119.      * NOTE: <code>parentRow</code> can be -1 if the root is not visible.

  1120.      */

  1121.     protected void paintHorizontalPartOfLeg(SynthContext context, Graphics g,

  1122.                                           Rectangle clipBounds, Insets insets,

  1123.                                           Rectangle bounds, TreePath path,

  1124.                                           int row, boolean isExpanded,

  1125.                                           boolean hasBeenExpanded,

  1126.                                           boolean isLeaf) {

  1127.         if (!drawHorizontalLegs) {

  1128.             return;

  1129.         }

  1130.         int depth = path.getPathCount() - 1;

  1131. 	if ((depth == 0 || (depth == 1 && !tree.isRootVisible())) &&

  1132.             !tree.getShowsRootHandles()) {

  1133. 	    return;

  1134.         }

  1135. 

  1136. 	int clipLeft = clipBounds.x;

  1137. 	int clipRight = clipBounds.x + (clipBounds.width - 1);

  1138. 	int clipBottom = clipBounds.y + (clipBounds.height - 1);

  1139. 	int y = bounds.y + bounds.height / 2;

  1140.         int x0;

  1141.         int x1;

  1142. 

  1143.         if (leftToRight) {

  1144.             x0 = bounds.x - getIndent() - getTrailingControlOffset();

  1145.             x1 = bounds.x - trailingLegBufferOffset;

  1146.         }

  1147.         else {

  1148.             x0 = bounds.x + bounds.width + trailingLegBufferOffset;

  1149.             x1 = bounds.x + bounds.width + getIndent() +

  1150.                             getTrailingControlOffset();

  1151.         }

  1152.         if (y >= clipBounds.y && y <= clipBottom && x1 >= clipLeft &&

  1153. 	                                            x0 <= clipRight ) {

  1154.             x0 = Math.max(x0, clipLeft);

  1155.             x1 = Math.min(x1, clipRight);

  1156. 

  1157.             if (x0 < x1) {

  1158.                 SynthGraphics engine = context.getStyle().

  1159.                                                getSynthGraphics(context);

  1160. 

  1161.                 g.setColor(context.getStyle().getColor(context,

  1162.                                                        ColorType.FOREGROUND));

  1163.                 engine.drawLine(context, "Tree.horizontalLine", g, x0, y,

  1164.                                 x1, y);

  1165. 	    }

  1166. 	}

  1167.     }

  1168. 

  1169.     /**

  1170.      * Paints the vertical part of the leg. The receiver should

  1171.      * NOT modify <code>clipBounds</code>, <code>insets</code>.<p>

  1172.      */

  1173.     protected void paintVerticalPartOfLeg(SynthContext context, Graphics g,

  1174.                                           Rectangle clipBounds, Insets insets,

  1175.                                           TreePath path) {

  1176.         if (!drawVerticalLegs) {

  1177.             return;

  1178.         }

  1179.         int depth = path.getPathCount() - 1;

  1180. 	if (depth == 0 && !tree.getShowsRootHandles() &&

  1181.                           !tree.isRootVisible()) {

  1182. 	    return;

  1183.         }

  1184. 	int lineX;

  1185.         int offset = getRowX(-1, depth) - getTrailingControlOffset();

  1186. 	if (leftToRight) {

  1187. 	    lineX = offset + insets.left;

  1188. 	}

  1189. 	else {

  1190. 	    lineX = tree.getWidth() - offset - insets.right;

  1191. 	}

  1192. 	int clipLeft = clipBounds.x;

  1193. 	int clipRight = clipBounds.x + (clipBounds.width - 1);

  1194. 

  1195. 	if (lineX >= clipLeft && lineX <= clipRight) {

  1196. 	    int clipTop = clipBounds.y;

  1197. 	    int clipBottom = clipBounds.y + clipBounds.height;

  1198. 	    Rectangle parentBounds = getPathBounds(tree, path);

  1199. 	    Rectangle lastChildBounds = getPathBounds(tree,

  1200. 						     getLastChildPath(path));

  1201. 	    int       top;

  1202. 

  1203. 	    if (parentBounds == null) {

  1204. 		top = Math.max(insets.top, clipTop);

  1205. 	    }

  1206. 	    else {

  1207. 		top = Math.max(parentBounds.y + parentBounds.height, clipTop);

  1208.             }

  1209. 	    if (depth == 0 && !tree.isRootVisible()) {

  1210. 		TreeModel     model = tree.getModel();

  1211.                 Object        root = model.getRoot();

  1212. 

  1213.                 if (model.getChildCount(root) > 0) {

  1214.                     parentBounds = getPathBounds(tree, path.

  1215. 				  pathByAddingChild(model.getChild(root, 0)));

  1216.                     if (parentBounds != null) {

  1217.                         top = Math.max(insets.top, parentBounds.y +

  1218.                                        parentBounds.height / 2);

  1219.                     }

  1220. 		}

  1221. 	    }

  1222. 

  1223. 	    int bottom = Math.min(lastChildBounds.y +

  1224. 				  (lastChildBounds.height / 2), clipBottom);

  1225. 

  1226.             if (top < bottom) {

  1227.                 SynthGraphics engine = context.getStyle().

  1228.                                                getSynthGraphics(context);

  1229. 

  1230.                 g.setColor(context.getStyle().getColor(context,

  1231.                                                        ColorType.FOREGROUND));

  1232.                 engine.drawLine(context, "Tree.verticalLine", g, lineX, top,

  1233.                                 lineX, bottom);

  1234.             }

  1235. 	}

  1236.     }

  1237. 

  1238.     /**

  1239.      * Paints the expand (toggle) part of a row. The receiver should

  1240.      * NOT modify <code>clipBounds</code>, or <code>insets</code>.

  1241.      */

  1242.     protected void paintExpandControl(SynthContext context, Graphics g,

  1243.                                     Rectangle clipBounds, Insets insets,

  1244.                                     Rectangle bounds, TreePath path,

  1245.                                     int row, boolean isExpanded,

  1246.                                     boolean hasBeenExpanded,

  1247.                                     boolean isLeaf) {

  1248. 	Object       value = path.getLastPathComponent();

  1249. 

  1250. 	// Draw icons if not a leaf and either hasn't been loaded,

  1251. 	// or the model child count is > 0.

  1252. 	if (!isLeaf && (!hasBeenExpanded ||

  1253. 			tree.getModel().getChildCount(value) > 0)) {

  1254. 	    int middleXOfKnob;

  1255. 

  1256. 	    if (leftToRight) {

  1257. 	        middleXOfKnob = bounds.x - getTrailingControlOffset() + 1;

  1258. 	    }

  1259. 	    else {

  1260. 	        middleXOfKnob = bounds.x + bounds.width +

  1261.                                          getTrailingControlOffset() - 1;

  1262. 	    }

  1263. 	    int middleYOfKnob = bounds.y + (bounds.height / 2);

  1264. 

  1265. 	    if (isExpanded) {

  1266. 		Icon expandedIcon = getExpandedIcon();

  1267. 

  1268. 		if (expandedIcon != null) {

  1269.                     paintIconCenteredAt(context, tree, g, expandedIcon,

  1270.                                         middleXOfKnob, middleYOfKnob);

  1271.                 }

  1272. 	    }

  1273. 	    else {

  1274. 		Icon collapsedIcon = getCollapsedIcon();

  1275. 

  1276. 		if (collapsedIcon != null) {

  1277.                     paintIconCenteredAt(context, tree, g, collapsedIcon,

  1278.                                         middleXOfKnob, middleYOfKnob);

  1279.                 }

  1280. 	    }

  1281. 	}

  1282.     }

  1283. 

  1284.     /**

  1285.      * Paints the renderer part of a row. The receiver should

  1286.      * NOT modify <code>clipBounds</code>, or <code>insets</code>.

  1287.      */

  1288.     protected void paintRow(TreeCellRenderer renderer,

  1289.                DefaultTreeCellRenderer dtcr, SynthContext treeContext,

  1290.                SynthContext cellContext, Graphics g, Rectangle clipBounds,

  1291.                Insets insets, Rectangle bounds, Rectangle rowBounds,

  1292.                TreePath path, int row, boolean isExpanded,

  1293.                boolean hasBeenExpanded, boolean isLeaf) {

  1294. 	// Don't paint the renderer if editing this row.

  1295.         boolean selected = tree.isRowSelected(row);

  1296. 

  1297.         if (selected) {

  1298.             cellContext.setComponentState(ENABLED | SELECTED);

  1299.         }

  1300.         else {

  1301.             cellContext.setComponentState(ENABLED);

  1302.         }

  1303.         if (dtcr != null && (dtcr.getBorderSelectionColor() instanceof

  1304.                              UIResource)) {

  1305.             dtcr.setBorderSelectionColor(style.getColor(

  1306.                                              cellContext, ColorType.FOCUS));

  1307.         }

  1308.         SynthLookAndFeel.updateSubregion(cellContext, g, rowBounds);

  1309. 	if (getEditingRow() == row) {

  1310. 	    return;

  1311.         }

  1312. 

  1313. 	int leadIndex;

  1314. 

  1315. 	if (tree.hasFocus()) {

  1316. 	    leadIndex = getLeadSelectionRow();

  1317. 	}

  1318. 	else {

  1319. 	    leadIndex = -1;

  1320.         }

  1321. 

  1322. 	Component component = renderer.getTreeCellRendererComponent(

  1323.                          tree, path.getLastPathComponent(),

  1324.                          selected, isExpanded, isLeaf, row,

  1325.                          (leadIndex == row));

  1326. 	

  1327. 	rendererPane.paintComponent(g, component, tree, bounds.x, bounds.y,

  1328. 				    bounds.width, bounds.height, true);	

  1329.     }

  1330. 

  1331.     /**

  1332.      * Returns true if the expand (toggle) control should be drawn for

  1333.      * the specified row.

  1334.      */

  1335.     private boolean shouldPaintExpandControl(TreePath path, int row,

  1336.                                              boolean isExpanded,

  1337.                                              boolean hasBeenExpanded,

  1338.                                              boolean isLeaf) {

  1339. 	if (isLeaf) {

  1340. 	    return false;

  1341.         }

  1342. 

  1343. 	int              depth = path.getPathCount() - 1;

  1344. 

  1345. 	if ((depth == 0 || (depth == 1 && !tree.isRootVisible())) &&

  1346.                            !tree.getShowsRootHandles()) {

  1347. 	    return false;

  1348.         }

  1349. 	return true;

  1350.     }

  1351. 

  1352.     //

  1353.     // Generic painting methods

  1354.     //

  1355. 

  1356.     /**

  1357.      * Paints the Icon centered at the specified location.

  1358.      */

  1359.     private void paintIconCenteredAt(SynthContext context, Component c,

  1360.                                      Graphics graphics, Icon icon,

  1361.                                      int x, int y) {

  1362.         int w = SynthIcon.getIconWidth(icon, context);

  1363.         int h = SynthIcon.getIconHeight(icon, context);

  1364. 	SynthIcon.paintIcon(icon, context, graphics, x - w2, y - h2, w, h);

  1365.     }

  1366. 

  1367.     //

  1368.     // Various local methods

  1369.     //

  1370. 

  1371.     /**

  1372.      * Resets the selection model. The appropriate listener are installed

  1373.      * on the model.

  1374.      */

  1375.     private void selectionModelChanged(TreeSelectionModel oldModel,

  1376.                                     TreeSelectionModel newModel) {

  1377. 	completeEditing();

  1378.         if (newModel != null) {

  1379.             if (treeSelectionListener != null) {

  1380.                 newModel.removeTreeSelectionListener

  1381. 		               (treeSelectionListener);

  1382.             }

  1383.         }

  1384. 	if (newModel != null) {

  1385. 	    if (treeSelectionListener != null) {

  1386. 		newModel.addTreeSelectionListener

  1387. 		                   (treeSelectionListener);

  1388.             }

  1389. 	    if (treeState != null) {

  1390. 		treeState.setSelectionModel(newModel);

  1391.             }

  1392. 	}

  1393. 	else if (treeState != null) {

  1394. 	    treeState.setSelectionModel(null);

  1395.         }

  1396. 	if (tree != null) {

  1397. 	    tree.repaint();

  1398.         }

  1399.     }

  1400. 

  1401.     public void propertyChange(PropertyChangeEvent event) {

  1402.         if (event.getSource() == tree) {

  1403.             String              changeName = event.getPropertyName();

  1404. 

  1405.             if (SynthLookAndFeel.shouldUpdateStyle(event)) {

  1406.                 fetchStyle((JTree)event.getSource());

  1407.             }

  1408.             if (JTree.LEAD_SELECTION_PATH_PROPERTY.equals(changeName)) {

  1409.                 updateLeadRow();

  1410.                 repaintPath((TreePath)event.getOldValue());

  1411.                 repaintPath((TreePath)event.getNewValue());

  1412.             }

  1413.             else if (JTree.ANCHOR_SELECTION_PATH_PROPERTY.equals(changeName)) {

  1414.                 repaintPath((TreePath)event.getOldValue());

  1415.                 repaintPath((TreePath)event.getNewValue());

  1416.             }

  1417.             else if (JTree.CELL_RENDERER_PROPERTY.equals(changeName)) {

  1418.                 completeEditing();

  1419.                 updateRenderer();

  1420.                 invalidateStateAndSize();

  1421.             }

  1422.             else if (JTree.TREE_MODEL_PROPERTY.equals(changeName)) {

  1423.                 TreeModel oldModel = (TreeModel)event.getOldValue();

  1424. 

  1425.                 completeEditing();

  1426.                 if (oldModel != null && treeModelListener != null) {

  1427.                     oldModel.removeTreeModelListener(treeModelListener);

  1428.                 }

  1429.                 TreeModel newModel = (TreeModel)event.getNewValue();

  1430.                 if (newModel != null && treeModelListener != null) {

  1431.                     newModel.addTreeModelListener(treeModelListener);

  1432.                 }

  1433.                 if (treeState != null) {

  1434.                     treeState.setModel(newModel);

  1435.                     updateLayoutCacheExpandedNodes();

  1436.                     invalidateSize();

  1437.                 }

  1438.             }

  1439.             else if (JTree.ROOT_VISIBLE_PROPERTY.equals(changeName)) {

  1440.                 completeEditing();

  1441.                 updateRootOffset();

  1442.                 if (treeState != null) {

  1443.                     treeState.setRootVisible(((Boolean)event.getNewValue()).

  1444.                                              booleanValue());

  1445.                     invalidateStateAndSize();

  1446.                 }

  1447.             }

  1448.             else if (JTree.SHOWS_ROOT_HANDLES_PROPERTY.equals(changeName)) {

  1449.                 completeEditing();

  1450.                 updateRootOffset();

  1451.                 invalidateStateAndSize();

  1452.             }

  1453.             else if (JTree.ROW_HEIGHT_PROPERTY.equals(changeName)) {

  1454.                 completeEditing();

  1455.                 if (treeState != null) {

  1456.                     updateLargeModel();

  1457.                     treeState.setRowHeight(tree.getRowHeight());

  1458.                     invalidateSize();

  1459.                 }

  1460.             }

  1461.             else if (JTree.CELL_EDITOR_PROPERTY.equals(changeName)) {

  1462.                 completeEditing();

  1463.                 TreeCellEditor oldEditor = (TreeCellEditor)event.getOldValue();

  1464. 

  1465.                 if (oldEditor != null && cellEditorListener != null) {

  1466.                     oldEditor.removeCellEditorListener(cellEditorListener);

  1467.                 }

  1468. 

  1469.                 TreeCellEditor newEditor = (TreeCellEditor)event.getNewValue();

  1470.                 if (newEditor != null) {

  1471.                     if (cellEditorListener == null) {

  1472.                         cellEditorListener = createCellEditorListener();

  1473.                     }

  1474.                     if (cellEditorListener != null) {

  1475.                         newEditor.addCellEditorListener(cellEditorListener);

  1476.                     }

  1477.                 }

  1478.             }

  1479.             else if (JTree.EDITABLE_PROPERTY.equals(changeName)) {

  1480.                 completeEditing();

  1481. 

  1482.                 TreeCellEditor editor = tree.getCellEditor();

  1483. 

  1484.                 if (tree.isEditable()) {

  1485.                     if (editor == null) {

  1486.                         editor = createCellEditor();

  1487.                         if (editor != null) {

  1488.                             tree.setCellEditor(editor);

  1489.                         }

  1490.                     }

  1491.                     else {

  1492.                         if (cellEditorListener == null) {

  1493.                             cellEditorListener = createCellEditorListener();

  1494.                         }

  1495.                         if (cellEditorListener != null) {

  1496.                             editor.addCellEditorListener(cellEditorListener);

  1497.                         }

  1498.                     }

  1499.                 }

  1500.                 else if (editor instanceof UIResource) {

  1501.                     tree.setCellEditor(null);

  1502.                 }

  1503.             }

  1504.             else if (JTree.LARGE_MODEL_PROPERTY.equals(changeName)) {

  1505.                 updateLargeModel();

  1506.             }

  1507.             else if(JTree.SELECTION_MODEL_PROPERTY.equals(changeName)) {

  1508.                 selectionModelChanged((TreeSelectionModel)event.

  1509.                                       getOldValue(), tree.getSelectionModel());

  1510.             }

  1511.             else if("font".equals(changeName)) {

  1512.                 completeEditing();

  1513.                 invalidateStateAndSize();

  1514.             }

  1515.             else if ("componentOrientation".equals(changeName)) {

  1516.                 leftToRight = tree.getComponentOrientation().isLeftToRight();

  1517.                 invalidateStateAndSize();

  1518. 

  1519.                 InputMap km = getInputMap(JComponent.WHEN_FOCUSED);

  1520.                 SwingUtilities.replaceUIInputMap(tree,

  1521. 						JComponent.WHEN_FOCUSED, km);

  1522.             } else if ("transferHandler".equals(changeName)) {

  1523.                 DropTarget dropTarget = tree.getDropTarget();

  1524.                 if (dropTarget instanceof UIResource) {

  1525.                     if (defaultDropTargetListener == null) {

  1526.                         defaultDropTargetListener = new TreeDropTargetListener();

  1527.                     }

  1528.                     try {

  1529.                         dropTarget.addDropTargetListener(defaultDropTargetListener);

  1530.                     } catch (TooManyListenersException tmle) {

  1531.                         // should not happen... swing drop target is multicast

  1532.                     }

  1533.                 }

  1534.             }

  1535. 	}

  1536.     }

  1537. 

  1538. 

  1539.     private int getTrailingControlOffset() {

  1540. 	return trailingControlOffset;

  1541.     }

  1542. 

  1543.     private int getIndent() {

  1544.         return indent;

  1545.     }

  1546. 

  1547.     /**

  1548.      * Returns the icon to draw when the node is expanded.

  1549.      */

  1550.     private Icon getExpandedIcon() {

  1551. 	return expandedIcon;

  1552.     }

  1553. 

  1554.     /**

  1555.      * Returns the Icon to draw when the node is collapsed.

  1556.      */

  1557.     private Icon getCollapsedIcon() {

  1558. 	return collapsedIcon;

  1559.     }

  1560. 

  1561.     /**

  1562.      * Updates the necessary state in response to the large model, or rowHeight

  1563.      * property changing.

  1564.      */

  1565.     private void updateLargeModel() {

  1566.         boolean largeModel = tree.isLargeModel();

  1567. 

  1568. 	if (tree.getRowHeight() < 1) {

  1569. 	    largeModel = false;

  1570.         }

  1571. 	if (this.largeModel != largeModel) {

  1572. 	    completeEditing();

  1573. 	    this.largeModel = largeModel;

  1574. 	    treeState = createLayoutCache();

  1575. 	    configureLayoutCache();

  1576. 	    invalidateSize();

  1577. 	}

  1578.     }

  1579. 

  1580.     /**

  1581.      * Returns true if operating in large model mode.

  1582.      */

  1583.     private boolean isLargeModel() {

  1584. 	return largeModel;

  1585.     }

  1586. 

  1587.     /**

  1588.      * Returns the amount to indent the given row. NOTE: This does not

  1589.      * include insets, nor should it!

  1590.      */

  1591.     private int getRowX(int row, int depth) {

  1592.         return getIndent() * (depth + rootOffset - 1) + controlSize;

  1593.     }

  1594. 

  1595. 

  1596.     /**

  1597.      * Makes all the nodes that are expanded in JTree expanded in LayoutCache.

  1598.      * This invokes updateExpandedDescendants with the root path.

  1599.      */

  1600.     private void updateLayoutCacheExpandedNodes() {

  1601.         TreeModel treeModel = tree.getModel();

  1602. 

  1603. 	if (treeModel != null && treeModel.getRoot() != null) {

  1604. 	    updateExpandedDescendants(new TreePath(treeModel.getRoot()));

  1605.         }

  1606.     }

  1607. 

  1608.     /**

  1609.      * Updates the expanded state of all the descendants of <code>path</code>

  1610.      * by getting the expanded descendants from the tree and forwarding

  1611.      * to the tree state.

  1612.      */

  1613.     private void updateExpandedDescendants(TreePath path) {

  1614. 	completeEditing();

  1615.         treeState.setExpandedState(path, true);

  1616. 

  1617.         Enumeration   descendants = tree.getExpandedDescendants(path);

  1618. 

  1619.         if (descendants != null) {

  1620.             while (descendants.hasMoreElements()) {

  1621.                 path = (TreePath)descendants.nextElement();

  1622.                 treeState.setExpandedState(path, true);

  1623.             }

  1624.         }

  1625.         updateLeadRow();

  1626.         invalidateSize();

  1627.     }

  1628. 

  1629.     /**

  1630.      * Returns a path to the last child of <code>parent</code>.

  1631.      */

  1632.     private TreePath getLastChildPath(TreePath parent) {

  1633.         TreeModel treeModel = tree.getModel();

  1634. 

  1635. 	if (treeModel != null) {

  1636. 	    int         childCount = treeModel.getChildCount

  1637. 		                         (parent.getLastPathComponent());

  1638. 	    

  1639. 	    if(childCount > 0) {

  1640. 		return parent.pathByAddingChild(treeModel.getChild

  1641. 			   (parent.getLastPathComponent(), childCount - 1));

  1642.             }

  1643. 	}

  1644. 	return null;

  1645.     }

  1646. 

  1647.     /**

  1648.      * Updates the offset for the root. This should be invoked as the

  1649.      * properties the rootOffset depends upon change, eg root visibility,

  1650.      * showing root handles...

  1651.      */

  1652.     private void updateRootOffset() {

  1653. 	if (tree.isRootVisible()) {

  1654. 	    if (tree.getShowsRootHandles()) {

  1655. 		rootOffset = 1;

  1656.             }

  1657. 	    else {

  1658. 		rootOffset = 0;

  1659.             }

  1660. 	}

  1661. 	else if (!tree.getShowsRootHandles()) {

  1662. 	    rootOffset = -1;

  1663.         }

  1664. 	else {

  1665. 	    rootOffset = 0;

  1666.         }

  1667.     }

  1668. 

  1669.     /**

  1670.      * If the JTree's renderer is null, this will install a default one.

  1671.      * Additionaly if we have installed an editor, we're reinstall it.

  1672.       */

  1673.     private void updateRenderer() {

  1674.         TreeCellRenderer      newCellRenderer = tree.getCellRenderer();

  1675. 

  1676.         if (newCellRenderer == null) {

  1677.             tree.setCellRenderer(createCellRenderer());

  1678.         }

  1679.         if (tree.isEditable() && (tree.getCellEditor() instanceof

  1680.                                   UIResource)) {

  1681.             // We do this as the editor gets state from the renderer,

  1682.             // so that any time one changes we need to update the other.

  1683.             tree.setCellEditor(createCellEditor());

  1684.         }

  1685.     }

  1686. 

  1687.     /**

  1688.      * Configures the AbstractLayoutCache based on the tree we're

  1689.      * providing the look and feel for.

  1690.      */

  1691.     private void configureLayoutCache() {

  1692.         if (nodeDimensions == null) {

  1693.             nodeDimensions = createNodeDimensions();

  1694.         }

  1695.         treeState.setNodeDimensions(nodeDimensions);

  1696.         treeState.setRootVisible(tree.isRootVisible());

  1697.         treeState.setRowHeight(tree.getRowHeight());

  1698.         treeState.setSelectionModel(tree.getSelectionModel());

  1699.         // Only do this if necessary, may loss state if call with

  1700.         // same model as it currently has.

  1701.         if (treeState.getModel() != tree.getModel()) {

  1702.             treeState.setModel(tree.getModel());

  1703.         }

  1704.         updateLayoutCacheExpandedNodes();

  1705.         // Create a listener to update preferred size when bounds

  1706.         // changes, if necessary.

  1707.         if (largeModel) {

  1708.             if (componentListener == null) {

  1709.                 componentListener = createComponentListener();

  1710.                 if (componentListener != null) {

  1711.                     tree.addComponentListener(componentListener);

  1712.                 }

  1713.             }

  1714.         }

  1715. 	else if(componentListener != null) {

  1716. 	    tree.removeComponentListener(componentListener);

  1717. 	    componentListener = null;

  1718. 	}

  1719.     }

  1720. 

  1721.     /**

  1722.      * Invalides the size of the AbstractLayoutCache and marks the tree as

  1723.      * needing to redisplay.

  1724.      */

  1725.     private void invalidateStateAndSize() {

  1726.         treeState.invalidateSizes();

  1727. 	invalidateSize();

  1728.     }

  1729. 

  1730.     /**

  1731.      * Marks the cached size as being invalid, and messages the

  1732.      * tree with <code>treeDidChange</code>.

  1733.      */

  1734.     private void invalidateSize() {

  1735. 	validCachedPreferredSize = false;

  1736. 	tree.treeDidChange();

  1737.     }

  1738. 

  1739.     /**

  1740.      * Recalculates the preferred size needed to display the tree.

  1741.      */

  1742.     private void updateCachedPreferredSize() {

  1743.         Insets               i = tree.getInsets();

  1744. 

  1745.         if (largeModel) {

  1746.             Rectangle            visRect = tree.getVisibleRect();

  1747. 

  1748.             visRect.x -= i.left;

  1749.             visRect.y -= i.top;

  1750.             preferredSize.width = treeState.getPreferredWidth(visRect);

  1751.         }

  1752.         else if (leftToRight) {

  1753.             preferredSize.width = treeState.getPreferredWidth(null);

  1754.         }

  1755.         preferredSize.height = treeState.getPreferredHeight();

  1756.         preferredSize.width += i.left + i.right;

  1757.         preferredSize.height += i.top + i.bottom;

  1758. 	validCachedPreferredSize = true;

  1759.     }

  1760. 

  1761.     // 

  1762.     // Editing related methods

  1763.     //

  1764. 

  1765.     /**

  1766.      * Returns the row being edited, -1 if not editing.

  1767.      */

  1768.     private int getEditingRow() {

  1769.         return (editingState != null) ? editingState.row : -1;

  1770.     }

  1771. 

  1772.     /**

  1773.      * Returns the Component responsible for editing, or null if not

  1774.      * editing.

  1775.      */

  1776.     private Component getEditingComponent() {

  1777.         return (editingState != null) ? editingState.component : null;

  1778.     }

  1779. 

  1780.     /**

  1781.      * Messaged to stop the editing session. If the tree the receiver

  1782.      * is providing the look and feel for returns true from

  1783.      * <code>getInvokesStopCellEditing</code>, stopCellEditing will be

  1784.      * invoked on the current editor, otherwise cancelCellEditing will be

  1785.      * invoked

  1786.      */

  1787.     private void completeEditing() {

  1788. 	if (tree.getInvokesStopCellEditing() && getEditingComponent() != null){

  1789. 	    tree.getCellEditor().stopCellEditing();

  1790. 	}

  1791. 	// Invoke cancelCellEditing, this will do nothing if stopCellEditing

  1792.         // was successful.

  1793. 	completeEditing(false, true, false);

  1794.     }

  1795. 

  1796.     /**

  1797.       * Stops the editing session.  If messageStop is true the editor

  1798.       * is messaged with stopEditing, if messageCancel is true the

  1799.       * editor is messaged with cancelEditing. If messageTree is true

  1800.       * the treeModel is messaged with valueForPathChanged.

  1801.       */

  1802.     private void completeEditing(boolean messageStop,

  1803.                                  boolean messageCancel,

  1804.                                  boolean messageTree) {

  1805. 	if (editingState != null) {

  1806.             EditingState oldState = editingState;

  1807. 	    Object newValue = editingState.editor.getCellEditorValue();

  1808. 	    Rectangle editingBounds = tree.getPathBounds(oldState.path);

  1809. 	    boolean requestFocus = (tree != null && (tree.hasFocus() ||

  1810.                SwingUtilities.findFocusOwner(editingState.component) != null));

  1811. 

  1812.             editingState = null;

  1813. 	    if (messageStop) {

  1814. 		oldState.editor.stopCellEditing();

  1815.             }

  1816. 	    else if (messageCancel) {

  1817. 		oldState.editor.cancelCellEditing();

  1818.             }

  1819. 	    tree.remove(oldState.component);

  1820. 	    if (oldState.editorHasDifferentSize) {

  1821. 		treeState.invalidatePathBounds(oldState.path);

  1822. 		invalidateSize();

  1823. 	    }

  1824. 	    else {

  1825. 		editingBounds.x = 0;

  1826. 		editingBounds.width = tree.getSize().width;

  1827. 		tree.repaint(editingBounds);

  1828. 	    }

  1829. 	    if (requestFocus) {

  1830. 		tree.requestFocus();

  1831.             }

  1832. 	    if (messageTree) {

  1833. 		tree.getModel().valueForPathChanged(oldState.path, newValue);

  1834.             }

  1835. 	}

  1836.     }

  1837. 

  1838.     /**

  1839.       * Will start editing for node if there is a cellEditor and

  1840.       * shouldSelectCell returns true.<p>

  1841.       * This assumes that path is valid and visible.

  1842.       */

  1843.     private boolean startEditing(TreePath path, MouseEvent event) {

  1844.         if (tree.isEditing() && tree.getInvokesStopCellEditing() &&

  1845.                                !tree.stopEditing()) {

  1846.             return false;

  1847.         }

  1848. 	completeEditing();

  1849.         TreeCellEditor cellEditor = tree.getCellEditor();

  1850. 	if (cellEditor != null && tree.isPathEditable(path)) {

  1851. 	    int           row = getRowForPath(tree, path);

  1852. 

  1853. 	    if (cellEditor.isCellEditable(event)) {

  1854.                 EditingState state = new EditingState();

  1855. 

  1856.                 editingState = state;

  1857.                 state.component = cellEditor.getTreeCellEditorComponent

  1858. 		      (tree, path.getLastPathComponent(),

  1859. 		       tree.isPathSelected(path), tree.isExpanded(path),

  1860. 		       tree.getModel().isLeaf(path.getLastPathComponent()),

  1861.                        row);

  1862.                 state.editor = cellEditor;

  1863. 

  1864. 		Rectangle           nodeBounds = getPathBounds(tree, path);

  1865. 

  1866. 		state.row = row;

  1867. 

  1868. 		Dimension editorSize = state.component.getPreferredSize();

  1869. 

  1870. 		// Only allow odd heights if explicitly set.

  1871. 		if (editorSize.height != nodeBounds.height &&

  1872.                                          tree.getRowHeight() > 0) {

  1873. 		    editorSize.height = tree.getRowHeight();

  1874.                 }

  1875. 

  1876. 		if (editorSize.width != nodeBounds.width ||

  1877. 		               editorSize.height != nodeBounds.height) {

  1878. 		    // Editor wants different width or height, invalidate 

  1879. 		    // treeState and relayout.

  1880. 		    state.editorHasDifferentSize = true;

  1881. 		    treeState.invalidatePathBounds(path);

  1882. 		    invalidateSize();

  1883. 		}

  1884. 		else {

  1885. 		    state.editorHasDifferentSize = false;

  1886.                 }

  1887. 		tree.add(state.component);

  1888. 		state.component.setBounds(nodeBounds.x, nodeBounds.y,

  1889. 					   editorSize.width,

  1890. 					   editorSize.height);

  1891. 		state.path = path;

  1892. 		state.component.validate();

  1893. 

  1894. 		Rectangle              visRect = tree.getVisibleRect();

  1895. 

  1896.                 tree.repaint(nodeBounds.x, nodeBounds.y, visRect.width +

  1897.                              visRect.x - nodeBounds.x, editorSize.height);

  1898. 		if (cellEditor.shouldSelectCell(event)) {

  1899.                     stopEditingWhenSelectionChanges = false;

  1900.                     tree.setSelectionRow(row);

  1901.                     stopEditingWhenSelectionChanges = true;

  1902. 		}

  1903. 		SynthLookAndFeel.compositeRequestFocus(state.component);

  1904. 		return true;

  1905. 	    }

  1906. 	}

  1907. 	return false;

  1908.     }

  1909. 

  1910.     //

  1911.     // Following are primarily for handling mouse events.

  1912.     //

  1913. 

  1914.     /**

  1915.      * If the <code>mouseX</code> and <code>mouseY</code> are in the

  1916.      * expand/collapse region of the <code>row</code>, this will toggle

  1917.      * the row.

  1918.      */

  1919.     protected void expandPathIfNecessary(SynthContext context,

  1920.                                          TreePath path, int mouseX,

  1921.                                          int mouseY) {

  1922.         if (isLocationInExpandControl(context, path, mouseX, mouseY)) {

  1923.             handleExpandControlClick(path, mouseX, mouseY);

  1924. 	}

  1925.     }

  1926. 

  1927.     /**

  1928.      * Returns true if <code>mouseX</code> and <code>mouseY</code> fall

  1929.      * in the area of row that is used to expand/collapse the node and

  1930.      * the node at <code>row</code> does not represent a leaf.

  1931.      */

  1932.     protected boolean isLocationInExpandControl(SynthContext context,

  1933.                                   TreePath path, int mouseX, int mouseY) {

  1934.         TreeModel treeModel = tree.getModel();

  1935. 

  1936. 	if (path != null && !treeModel.isLeaf(path.getLastPathComponent())){

  1937. 	    int                     boxWidth;

  1938. 

  1939. 	    if (getExpandedIcon() != null) {

  1940. 		boxWidth = SynthIcon.getIconWidth(getExpandedIcon(), context);

  1941.             }

  1942. 	    else {

  1943. 		boxWidth = 8;

  1944.             }

  1945. 

  1946. 	    Insets i = tree.getInsets();

  1947.             int boxX = getRowX(tree.getRowForPath(path),

  1948.                                path.getPathCount() - 1) -

  1949.                           getTrailingControlOffset() - boxWidth / 2;

  1950. 

  1951.             if (leftToRight) {

  1952.                 boxX += i.left;

  1953.             }

  1954.             else {

  1955.                 boxX = tree.getWidth() - getRowX(

  1956.                        tree.getRowForPath(path), path.getPathCount() - 1) +

  1957.                        getTrailingControlOffset() - boxWidth / 2;

  1958.             }

  1959. 	    return mouseX >= boxX && (mouseX <= boxX + boxWidth);

  1960. 	}

  1961. 	return false;

  1962.     }

  1963. 

  1964.     /**

  1965.      * Messaged when the user clicks the particular row, this invokes

  1966.      * toggleExpandState.

  1967.      */

  1968.     protected void handleExpandControlClick(TreePath path, int mouseX,

  1969. 					    int mouseY) {

  1970. 	toggleExpandState(path);

  1971.     }

  1972. 

  1973.     /**

  1974.      * Expands path if it is not expanded, or collapses row if it is expanded.

  1975.      * If expanding a path and JTree scrolls on expand, ensureRowsAreVisible

  1976.      * is invoked to scroll as many of the children to visible as possible

  1977.      * (tries to scroll to last visible descendant of path).

  1978.      */

  1979.     private void toggleExpandState(TreePath path) {

  1980. 	if (!tree.isExpanded(path)) {

  1981. 	    int       row = tree.getRowForPath(path);

  1982. 

  1983. 	    tree.expandPath(path);

  1984. 	    invalidateSize();

  1985. 	    if (row != -1) {

  1986. 		if(tree.getScrollsOnExpand()) {

  1987. 		    ensureRowsAreVisible(tree, row, row + treeState.

  1988. 					 getVisibleChildCount(path));

  1989.                 }

  1990. 		else {

  1991. 		    ensureRowsAreVisible(tree, row, row);

  1992.                 }

  1993. 	    }

  1994. 	}

  1995. 	else {

  1996. 	    tree.collapsePath(path);

  1997. 	    invalidateSize();

  1998. 	}

  1999.     }

  2000. 

  2001.     /**

  2002.      * Returning true signifies a mouse event on the node should toggle

  2003.      * the selection of only the row under mouse.

  2004.      */

  2005.     protected boolean isToggleSelectionEvent(MouseEvent event) {

  2006. 	return (SynthLookAndFeel.isPrimaryMouseButton(event) &&

  2007. 		event.isControlDown());

  2008.     }

  2009. 

  2010.     /**

  2011.      * Returning true signifies a mouse event on the node should select

  2012.      * from the anchor point.

  2013.      */

  2014.     protected boolean isMultiSelectEvent(MouseEvent event) {

  2015. 	return (SynthLookAndFeel.isPrimaryMouseButton(event) &&

  2016. 		event.isShiftDown());

  2017.     }

  2018. 

  2019.     /**

  2020.      * Returning true indicates the row under the mouse should be toggled

  2021.      * based on the event. This is invoked after checkForClickInExpandControl,

  2022.      * implying the location is not in the expand (toggle) control

  2023.      */

  2024.     protected boolean isToggleEvent(MouseEvent event) {

  2025. 	if (!SynthLookAndFeel.isPrimaryMouseButton(event)) {

  2026. 	    return false;

  2027. 	}

  2028. 	int           clickCount = tree.getToggleClickCount();

  2029. 

  2030. 	if (clickCount <= 0) {

  2031. 	    return false;

  2032. 	}

  2033. 	return (event.getClickCount() == clickCount);

  2034.     }

  2035. 

  2036.     /**

  2037.      * Messaged to update the selection based on a MouseEvent over a

  2038.      * particular row. If the event is a toggle selection event, the

  2039.      * row is either selected, or deselected. If the event identifies

  2040.      * a multi selection event, the selection is updated from the

  2041.      * anchor point. Otherwise the row is selected, and if the event

  2042.      * specified a toggle event the row is expanded/collapsed.

  2043.      */

  2044.     protected void selectPathForEvent(TreePath path, MouseEvent event) {

  2045. 	// Should this event toggle the selection of this row?

  2046. 	/* Control toggles just this node. */

  2047. 	if (isToggleSelectionEvent(event)) {

  2048. 	    if (tree.isPathSelected(path)) {

  2049. 		tree.removeSelectionPath(path);

  2050.             }

  2051. 	    else {

  2052. 		tree.addSelectionPath(path);

  2053.             }

  2054. 	    tree.setAnchorSelectionPath(path);

  2055. 	    tree.setLeadSelectionPath(path);

  2056. 	}

  2057. 	/* Adjust from the anchor point. */

  2058. 	else if (isMultiSelectEvent(event)) {

  2059. 	    TreePath anchor = tree.getAnchorSelectionPath();

  2060. 	    int anchorRow = (anchor == null) ? -1 : tree.getRowForPath(anchor);

  2061. 

  2062. 	    if (anchorRow == -1 || tree.getSelectionModel().

  2063.                       getSelectionMode() == TreeSelectionModel.

  2064.                       SINGLE_TREE_SELECTION) {

  2065. 		tree.setSelectionPath(path);

  2066. 	    }

  2067. 	    else {

  2068. 		int row = getRowForPath(tree, path);

  2069. 		TreePath lastAnchorPath = anchor;

  2070. 

  2071. 		if (row < anchorRow) {

  2072. 		    tree.setSelectionInterval(row, anchorRow);

  2073.                 }

  2074. 		else {

  2075. 		    tree.setSelectionInterval(anchorRow, row);

  2076.                 }

  2077. 		tree.setAnchorSelectionPath(lastAnchorPath);

  2078. 		tree.setLeadSelectionPath(path);

  2079. 	    }

  2080. 	}

  2081. 	/* Otherwise set the selection to just this interval. */

  2082. 	else if(SynthLookAndFeel.isPrimaryMouseButton(event)) {

  2083. 	    tree.setSelectionPath(path);

  2084. 	    if(isToggleEvent(event)) {

  2085. 		toggleExpandState(path);

  2086. 	    }

  2087. 	}

  2088.     }

  2089. 

  2090.     /**

  2091.      * Updates the lead row.

  2092.      */

  2093.     private void updateLeadRow() {

  2094. 	leadRow = tree.getLeadSelectionRow();

  2095.     }

  2096. 

  2097.     /**

  2098.      * Returns the lead selection row. This is cached as painting makes

  2099.      * extensive use of this.

  2100.      */

  2101.     private int getLeadSelectionRow() {

  2102. 	return leadRow;

  2103.     }

  2104. 

  2105.     /**

  2106.      * Invokes <code>repaint</code> on the JTree for the passed in TreePath,

  2107.      * <code>path</code>.

  2108.      */

  2109.     private void repaintPath(TreePath path) {

  2110. 	if (path != null) {

  2111. 	    Rectangle bounds = tree.getPathBounds(path);

  2112. 	    if (bounds != null) {

  2113. 		tree.repaint(bounds.x, bounds.y, bounds.width, bounds.height);

  2114. 	    }

  2115. 	}

  2116.     }

  2117. 

  2118.     /**

  2119.      * Updates the TreeState in response to nodes expanding/collapsing.

  2120.      */

  2121.     private static class TreeExpansionHandler implements

  2122.                              TreeExpansionListener {

  2123. 	/**

  2124. 	 * Called whenever an item in the tree has been expanded.

  2125. 	 */

  2126. 	public void treeExpanded(TreeExpansionEvent event) {

  2127.             JTree tree = (JTree)event.getSource();

  2128.             // PENDING: needs to be updated.

  2129.             SynthTreeUI ui = (SynthTreeUI)tree.getUI();

  2130.             TreePath      path = event.getPath();

  2131. 

  2132.             ui.updateExpandedDescendants(path);

  2133. 	}

  2134. 

  2135. 	/**

  2136. 	 * Called whenever an item in the tree has been collapsed.

  2137. 	 */

  2138. 	public void treeCollapsed(TreeExpansionEvent event) {

  2139.             JTree tree = (JTree)event.getSource();

  2140.             SynthTreeUI ui = (SynthTreeUI)tree.getUI();

  2141.             TreePath path = event.getPath();

  2142. 

  2143.             ui.completeEditing();

  2144.             if (path != null && tree.isVisible(path)) {

  2145.                 ui.treeState.setExpandedState(path, false);

  2146.                 ui.updateLeadRow();

  2147.                 ui.invalidateSize();

  2148. 	    }

  2149. 	}

  2150.     }

  2151. 

  2152. 

  2153.     /**

  2154.      * Updates the preferred size when scrolling (if necessary). This class

  2155.      * is used when FixedHeightLayoutCache is used by SynthTreeUI. Because

  2156.      * FixedHeightLayoutCache only returns the preferred width of the visible

  2157.      * paths, you need to revalidate on every move otherwise certain regions

  2158.      * may not be visible. This class does this.

  2159.      */

  2160.     private static class ComponentHandler extends ComponentAdapter implements

  2161.                  ActionListener {

  2162. 	/**

  2163.          * Timer used when inside a scrollpane and the scrollbar is

  2164. 	 * adjusting.

  2165.          */

  2166. 	private javax.swing.Timer timer;

  2167. 	/**

  2168.          * ScrollBar that is being adjusted.

  2169.          */

  2170. 	private JScrollBar scrollBar;

  2171. 

  2172.         /**

  2173.          * Last SynthTreeUI that we were in.

  2174.          */

  2175.         private SynthTreeUI ui;

  2176. 

  2177. 

  2178. 	public void componentMoved(ComponentEvent e) {

  2179.             JTree tree = (JTree)e.getSource();

  2180.             // PENDING: change me

  2181.             SynthTreeUI ui = (SynthTreeUI)tree.getUI();

  2182. 

  2183.             if (this.ui != ui) {

  2184.                 adjust();

  2185.             }

  2186. 	    if (timer == null) {

  2187. 		JScrollPane scrollPane = (JScrollPane)SwingUtilities.

  2188.                                   getAncestorOfClass(JScrollPane.class, tree);

  2189. 

  2190. 		if (scrollPane == null) {

  2191. 		    ui.invalidateSize();

  2192.                 }

  2193. 		else {

  2194. 		    JScrollBar scrollBar = scrollPane.getVerticalScrollBar();

  2195. 

  2196. 		    if (scrollBar == null || !scrollBar.getValueIsAdjusting()){

  2197. 			// Try the horizontal scrollbar.

  2198. 			if((scrollBar = scrollPane.getHorizontalScrollBar())

  2199.                                  != null && scrollBar.getValueIsAdjusting()) {

  2200.                             queue(ui, scrollBar);

  2201.                         }

  2202. 			else {

  2203. 			    ui.invalidateSize();

  2204.                         }

  2205. 		    }

  2206. 		    else {

  2207.                         queue(ui, scrollBar);

  2208.                     }

  2209. 		}

  2210. 	    }

  2211. 	}

  2212. 

  2213. 	/**

  2214. 	 * Creates, if necessary, and starts a Timer to check if need to

  2215. 	 * resize the bounds.

  2216. 	 */

  2217. 	private void queue(SynthTreeUI ui, JScrollBar bar) {

  2218. 	    if (timer == null) {

  2219. 		timer = new javax.swing.Timer(200, this);

  2220. 		timer.setRepeats(true);

  2221. 	    }

  2222. 	    timer.start();

  2223.             this.ui = ui;

  2224.             this.scrollBar = bar;

  2225. 	}

  2226. 

  2227. 	/**

  2228. 	 * Public as a result of Timer. If the scrollBar is null, or

  2229. 	 * not adjusting, this stops the timer and updates the sizing.

  2230. 	 */

  2231. 	public void actionPerformed(ActionEvent ae) {

  2232. 	    if (!scrollBar.getValueIsAdjusting()) {

  2233.                 adjust();

  2234.             }

  2235.         }

  2236. 

  2237.         /**

  2238.          * Stops the timer and schedules a repaint/revalidate on the tree.

  2239.          */

  2240.         private void adjust() {

  2241.             if (timer != null) {

  2242.                 timer.stop();

  2243.             }

  2244.             ui.invalidateSize();

  2245.             timer = null;

  2246.             scrollBar = null;

  2247.             ui = null;

  2248. 	}

  2249.     }

  2250. 

  2251.     private class TreeExpandAction extends AbstractAction {

  2252.         public void actionPerformed(ActionEvent e) {

  2253.             int selRow = getLeadSelectionRow();

  2254.             tree.expandRow(selRow); 

  2255.         }

  2256.     }

  2257. 

  2258.     private class TreeCollapseAction extends AbstractAction {

  2259.         public void actionPerformed(ActionEvent e) {

  2260.             int selRow = getLeadSelectionRow(); 

  2261.             tree.collapseRow(selRow);  

  2262.         }

  2263.     }

  2264. 

  2265.     private class TreeMoveSelectionToParentAction extends AbstractAction {

  2266.         public void actionPerformed(ActionEvent e) {

  2267.             int selRow = getLeadSelectionRow();

  2268.             TreePath path = getPathForRow(tree, selRow);

  2269.             if (path != null && path.getPathCount() > 1) {

  2270.                 int  newIndex = getRowForPath(tree, path.getParentPath());

  2271.                 if (newIndex != -1) { 

  2272.                     tree.setSelectionInterval(newIndex, newIndex);

  2273.                     ensureRowsAreVisible(tree, newIndex, newIndex);

  2274.                 }

  2275.             } 

  2276.         }

  2277.     }

  2278. 

  2279.     /**

  2280.      * Forwards all TreeModel events to the TreeState.

  2281.      */

  2282.     private class TreeModelHandler implements TreeModelListener {

  2283. 	public void treeNodesChanged(TreeModelEvent e) {

  2284. 	    if (treeState != null && e != null) {

  2285. 		treeState.treeNodesChanged(e);

  2286. 

  2287. 		TreePath       pPath = e.getTreePath().getParentPath();

  2288. 

  2289. 		if (pPath == null || treeState.isExpanded(pPath)) {

  2290. 		    invalidateSize();

  2291.                 }

  2292. 	    }

  2293. 	}

  2294. 

  2295. 	public void treeNodesInserted(TreeModelEvent e) {

  2296. 	    if (treeState != null && e != null) {

  2297. 		treeState.treeNodesInserted(e);

  2298. 

  2299. 		updateLeadRow();

  2300. 

  2301. 		TreePath       path = e.getTreePath();

  2302. 

  2303. 		if (treeState.isExpanded(path)) {

  2304. 		    invalidateSize();

  2305. 		}

  2306. 		else {

  2307. 		    // PENDING(sky): Need a method in TreeModelEvent

  2308. 		    // that can return the count, getChildIndices allocs

  2309. 		    // a new array!

  2310. 		    int[] indices = e.getChildIndices();

  2311. 		    int childCount = tree.getModel().getChildCount

  2312. 			                    (path.getLastPathComponent());

  2313. 

  2314. 		    if (indices != null && (childCount - indices.length) == 0){

  2315. 			invalidateSize();

  2316.                     }

  2317. 		}

  2318. 	    }

  2319. 	}

  2320. 

  2321. 	public void treeNodesRemoved(TreeModelEvent e) {

  2322. 	    if (treeState != null && e != null) {

  2323. 		treeState.treeNodesRemoved(e);

  2324. 

  2325. 		updateLeadRow();

  2326. 

  2327. 		TreePath       path = e.getTreePath();

  2328. 

  2329. 		if (treeState.isExpanded(path) || tree.getModel().

  2330.                             getChildCount(path.getLastPathComponent()) == 0) {

  2331. 		    invalidateSize();

  2332.                 }

  2333. 	    }

  2334. 	}

  2335. 

  2336. 	public void treeStructureChanged(TreeModelEvent e) {

  2337. 	    if (treeState != null && e != null) {

  2338. 		treeState.treeStructureChanged(e);

  2339. 

  2340. 		updateLeadRow();

  2341. 

  2342. 		TreePath       pPath = e.getTreePath();

  2343. 

  2344.                 if (pPath != null) {

  2345.                     pPath = pPath.getParentPath();

  2346.                 }

  2347.                 if(pPath == null || treeState.isExpanded(pPath)) {

  2348.                     invalidateSize();

  2349.                 }

  2350. 	    }

  2351. 	}

  2352.     }

  2353. 

  2354. 

  2355.     /**

  2356.      * Listens for changes in the selection model and updates the display

  2357.      * accordingly.

  2358.      */

  2359.     private class TreeSelectionHandler implements TreeSelectionListener {

  2360. 	/**

  2361. 	 * Messaged when the selection changes in the tree we're displaying

  2362. 	 * for.  Stops editing, messages super and displays the changed paths.

  2363. 	 */

  2364. 	public void valueChanged(TreeSelectionEvent event) {

  2365. 	    // Stop editing

  2366.             if (stopEditingWhenSelectionChanges) {

  2367.                 completeEditing();

  2368.             }

  2369. 

  2370. 	    // Make sure all the paths are visible, if necessary.

  2371.             TreeSelectionModel model = tree.getSelectionModel();

  2372.             TreeModel treeModel = tree.getModel();

  2373. 

  2374. 	    if (tree.getExpandsSelectedPaths()) {

  2375. 		TreePath[]           paths = model.getSelectionPaths();

  2376. 

  2377. 		if (paths != null) {

  2378. 		    for(int counter = paths.length - 1; counter >= 0;

  2379. 			    counter--) {

  2380.                         TreePath path = paths[counter].getParentPath();

  2381.                         boolean expand = true;

  2382. 

  2383.                         while (path != null) {

  2384.                             // Indicates this path isn't valid anymore,

  2385.                             // we shouldn't attempt to expand it then.

  2386.                             if (treeModel != null && treeModel.isLeaf(

  2387.                                              path.getLastPathComponent())){

  2388.                                 expand = false;

  2389.                                 path = null;

  2390.                             }

  2391.                             else {

  2392.                                 path = path.getParentPath();

  2393.                             }

  2394.                         }

  2395.                         if (expand) {

  2396.                             tree.makeVisible(paths[counter]);

  2397.                         }

  2398. 		    }

  2399. 		}

  2400. 	    }

  2401. 

  2402. 	    TreePath oldLead = tree.getLeadSelectionPath();

  2403. 	    TreePath lead = tree.getSelectionModel().getLeadSelectionPath();

  2404. 

  2405. 	    tree.setAnchorSelectionPath(lead);

  2406. 	    tree.setLeadSelectionPath(lead);

  2407. 

  2408. 	    TreePath[]       changedPaths = event.getPaths();

  2409. 	    Rectangle        nodeBounds;

  2410. 	    Rectangle        visRect = tree.getVisibleRect();

  2411. 	    boolean          paintPaths = true;

  2412. 	    int              nWidth = tree.getWidth();

  2413. 

  2414. 	    if (changedPaths != null) {

  2415. 		int              counter, maxCounter = changedPaths.length;

  2416. 

  2417. 		if (maxCounter > 4) {

  2418. 		    tree.repaint();

  2419. 		    paintPaths = false;

  2420. 		}

  2421. 		else {

  2422. 		    for (counter = 0; counter < maxCounter; counter++) {

  2423. 			nodeBounds = getPathBounds(tree,

  2424. 						   changedPaths[counter]);

  2425. 			if (nodeBounds != null && visRect.

  2426.                                           intersects(nodeBounds)) {

  2427. 			    tree.repaint(0, nodeBounds.y, nWidth,

  2428. 					 nodeBounds.height);

  2429.                         }

  2430. 		    }

  2431. 		}

  2432. 	    }

  2433. 	    if (paintPaths) {

  2434. 		nodeBounds = getPathBounds(tree, oldLead);

  2435. 		if (nodeBounds != null && visRect.intersects(nodeBounds)) {

  2436. 		    tree.repaint(0, nodeBounds.y, nWidth, nodeBounds.height);

  2437.                 }

  2438. 		nodeBounds = getPathBounds(tree, lead);

  2439. 		if(nodeBounds != null && visRect.intersects(nodeBounds)) {

  2440. 		    tree.repaint(0, nodeBounds.y, nWidth, nodeBounds.height);

  2441.                 }

  2442. 	    }

  2443.         }

  2444.     }

  2445. 

  2446. 

  2447.     /**

  2448.      * Listener responsible for getting cell editing events and updating

  2449.      * the tree accordingly.

  2450.      */

  2451.     class CellEditorHandler implements CellEditorListener {

  2452. 	/** Messaged when editing has stopped in the tree. */

  2453. 	public void editingStopped(ChangeEvent e) {

  2454. 	    completeEditing(false, false, true);

  2455. 	}

  2456. 

  2457. 	/** Messaged when editing has been canceled in the tree. */

  2458. 	public void editingCanceled(ChangeEvent e) {

  2459. 	    completeEditing(false, false, false);

  2460. 	}

  2461.     }

  2462. 

  2463. 

  2464.     /**

  2465.      * This class is used to handle selecting nodes based on a typed

  2466.      * sequence.

  2467.      */

  2468.     private static class KeyHandler extends KeyAdapter {

  2469. 	public void keyTyped(KeyEvent e) {

  2470.             JTree tree = (JTree)e.getSource();

  2471. 

  2472.             if (e.isAltDown() || e.isControlDown() || e.isMetaDown()) {

  2473.                 return;

  2474.             }

  2475. 

  2476. 	    // handle first letter navigation

  2477. 	    if(tree != null && tree.getRowCount() > 0 && tree.hasFocus() &&

  2478.                                tree.isEnabled()) {

  2479. 		boolean startingFromSelection = true;

  2480. 		String prefix = Character.toString(e.getKeyChar());

  2481. 		int startingRow = tree.getMinSelectionRow() + 1;

  2482. 

  2483. 		if (startingRow >= tree.getRowCount()) {

  2484. 		    startingFromSelection = false;

  2485. 		    startingRow = 0;

  2486. 		}

  2487. 		TreePath path = tree.getNextMatch(prefix, startingRow,

  2488. 						  Position.Bias.Forward);

  2489. 		if (path != null) {

  2490.                     tree.setSelectionPath(path);

  2491. 		}

  2492.                 else if (startingFromSelection) {

  2493. 		    path = tree.getNextMatch(prefix, 0,

  2494. 					     Position.Bias.Forward);

  2495. 		    if (path != null) {

  2496. 			tree.setSelectionPath(path);

  2497. 		    }

  2498. 		}

  2499. 	    }

  2500. 	}

  2501.     }

  2502. 

  2503. 

  2504.     /**

  2505.      * Repaints the lead selection row when focus is lost/gained.

  2506.      */

  2507.     private static class FocusHandler implements FocusListener {

  2508. 	/**

  2509. 	 * Invoked when focus is activated on the tree we're in, redraws the

  2510. 	 * lead row.

  2511. 	 */

  2512. 	public void focusGained(FocusEvent e) {

  2513.             paintLead((JTree)e.getSource());

  2514. 	}

  2515. 

  2516. 	/**

  2517. 	 * Invoked when focus is activated on the tree we're in, redraws the

  2518. 	 * lead row.

  2519. 	 */

  2520. 	public void focusLost(FocusEvent e) {

  2521.             paintLead((JTree)e.getSource());

  2522. 	}

  2523. 

  2524.         /**

  2525.          * Pains the lead selection of the tree.

  2526.          */

  2527.         private void paintLead(JTree tree) {

  2528.             Rectangle                 bounds;

  2529. 

  2530.             bounds = tree.getPathBounds(tree.getLeadSelectionPath());

  2531.             if (bounds != null) {

  2532.                 tree.repaint(bounds);

  2533. 	    }

  2534.         }

  2535.     }

  2536. 

  2537. 

  2538.     /**

  2539.      * Class responsible for getting size of node

  2540.      */

  2541.     // This returns locations that don't include any Insets.

  2542.     private class NodeDimensionsHandler extends

  2543. 	         AbstractLayoutCache.NodeDimensions {

  2544. 	/**

  2545. 	 * Responsible for getting the size of a particular node. Returned

  2546.          * location does not include insets, that is handled by SynthTreeUI.

  2547. 	 */

  2548. 	public Rectangle getNodeDimensions(Object value, int row,

  2549. 					   int depth, boolean expanded,

  2550. 					   Rectangle size) {

  2551. 	    // Return size of editing component, if editing and asking

  2552. 	    // for editing row.

  2553.             Component c = getEditingComponent();

  2554.             int editingRow = getEditingRow();

  2555. 

  2556. 	    if (c != null && editingRow == row) {

  2557. 		Dimension        prefSize = c.getPreferredSize();

  2558. 		int              rh = tree.getRowHeight();

  2559. 

  2560. 		if (rh > 0 && rh != prefSize.height) {

  2561. 		    prefSize.height = rh;

  2562.                 }

  2563. 		if (size != null) {

  2564. 		    size.x = getRowX(row, depth);

  2565. 		    size.width = prefSize.width;

  2566. 		    size.height = prefSize.height;

  2567. 		}

  2568. 		else {

  2569. 		    size = new Rectangle(getRowX(row, depth), 0,

  2570. 					 prefSize.width, prefSize.height);

  2571. 		}

  2572. 		return size;

  2573. 	    }

  2574. 	    // Not editing, use renderer.

  2575.             TreeCellRenderer renderer = tree.getCellRenderer();

  2576. 

  2577. 	    if (renderer != null) {

  2578. 		c = renderer.getTreeCellRendererComponent

  2579. 		             (tree, value, tree.isRowSelected(row),

  2580.                               expanded, tree.getModel().isLeaf(value), row,

  2581.                               false);

  2582.                 rendererPane.add(c);

  2583.                 c.validate();

  2584. 		Dimension        prefSize = c.getPreferredSize();

  2585. 

  2586. 		if (size != null) {

  2587. 		    size.x = getRowX(row, depth);

  2588. 		    size.width = prefSize.width;

  2589. 		    size.height = prefSize.height;

  2590. 		}

  2591. 		else {

  2592. 		    size = new Rectangle(getRowX(row, depth), 0,

  2593. 					 prefSize.width, prefSize.height);

  2594. 		}

  2595. 		return size;

  2596. 	    }

  2597. 	    return null;

  2598. 	}

  2599.     }

  2600. 

  2601. 

  2602.     /**

  2603.      * TreeMouseListener is responsible for updating the selection

  2604.      * based on mouse events, it will also redispatch events to the editing

  2605.      * component.

  2606.      */

  2607.     private static class MouseHandler extends MouseAdapter implements

  2608.                               MouseMotionListener {

  2609.         /**

  2610.          * Indicates if in the process of doing a drag and drop session.

  2611.          * This affects how the selection will be changed.

  2612.          */

  2613.         private boolean inDND;

  2614.         /**

  2615.          * Destination Component that events are dispatched to.

  2616.          */

  2617.         private Component destination;

  2618. 

  2619. 	/**

  2620. 	 * Invoked when a mouse button has been pressed on a component.

  2621. 	 */

  2622. 	public void mousePressed(MouseEvent e) {

  2623. 	    if (!e.isConsumed()) {

  2624. 		handleSelection(e);

  2625.                 redispatchEventIfNecessary(e);

  2626.                 inDND = false;

  2627. 	    }

  2628.             else {

  2629.                 inDND = true;

  2630. 	    }

  2631. 	}

  2632. 

  2633.         /**

  2634.          * Updates the selection as necessary based on the MoueEvent.

  2635.          */

  2636.         private void handleSelection(MouseEvent e) {

  2637.             JTree tree = (JTree)e.getSource();

  2638.             // PENDING: Change to new getUI method

  2639.             SynthTreeUI ui = (SynthTreeUI)tree.getUI();

  2640. 

  2641. 	    if (tree != null && tree.isEnabled()) {

  2642.                 if (tree.isEditing() && tree.getInvokesStopCellEditing() &&

  2643.                                         !tree.stopEditing()) {

  2644.                     return;

  2645.                 }

  2646. 

  2647.                 if (tree.isRequestFocusEnabled()) {

  2648. 		    tree.requestFocus();

  2649.                 }

  2650. 		TreePath     path = tree.getClosestPathForLocation(e.getX(),

  2651.                                                                    e.getY());

  2652. 

  2653. 		if (path != null) {

  2654. 		    Rectangle bounds = tree.getPathBounds(path);

  2655. 

  2656. 		    if (e.getY() > (bounds.y + bounds.height)) {

  2657. 			return;

  2658. 		    }

  2659. 

  2660. 		    if (SynthLookAndFeel.isPrimaryMouseButton(e)) {

  2661.                         SynthContext context = ui.getContext(tree);

  2662. 			ui.expandPathIfNecessary(context, path, e.getX(),

  2663.                                                  e.getY());

  2664.                         context.dispose();

  2665.                     }

  2666. 		    

  2667. 		    int x = e.getX();

  2668. 		    if (x > bounds.x && x <= (bounds.x + bounds.width) && 

  2669. 			    !ui.startEditing(path, e)) {

  2670.                         ui.selectPathForEvent(path, e);

  2671. 		    }

  2672. 		}

  2673. 	    }

  2674.             cacheDestination(ui.getEditingComponent(), e.getX(), e.getY());

  2675. 	}

  2676. 

  2677.         public void mouseDragged(MouseEvent e) {

  2678.             redispatchEventIfNecessary(e);

  2679.         }

  2680. 

  2681.         /**

  2682. 	 * Invoked when the mouse button has been moved on a component

  2683. 	 * (with no buttons no down).

  2684. 	 */

  2685.         public void mouseMoved(MouseEvent e) {

  2686. 	}

  2687. 

  2688.         public void mouseReleased(MouseEvent e) {

  2689. 	    if (!e.isConsumed() && inDND) {

  2690. 		handleSelection(e);

  2691.                 redispatchEventIfNecessary(e);

  2692. 	    }

  2693.         }

  2694. 

  2695.         /**

  2696.          * Caches the component used to redirect events to.

  2697.          */

  2698.         private void cacheDestination(Component editingComponent, int x,

  2699.                                       int y) {

  2700.             if (editingComponent != null) {

  2701.                 destination = SwingUtilities.getDeepestComponentAt(

  2702.                                              editingComponent, x, y);

  2703.             }

  2704.             else {

  2705.                 destination = null;

  2706.             }

  2707.         }

  2708. 

  2709.         /**

  2710.          * Dispatches the MouseEvent to the current destination.

  2711.          */

  2712.         private void redispatchEventIfNecessary(MouseEvent e) {

  2713.             if (destination != null) {

  2714.                 JTree tree = (JTree)e.getSource();

  2715. 

  2716.                 destination.dispatchEvent(SwingUtilities.convertMouseEvent

  2717. 					  (tree, e, destination));

  2718.             }

  2719.         }

  2720.     }

  2721. 

  2722. 

  2723.     // 

  2724.     // Actions used for keyboard navigation

  2725.     //

  2726. 

  2727.     private abstract static class GenericTreeAction extends AbstractAction {

  2728. 	/**

  2729.          * Specifies the direction to adjust the selection by, intepretation of

  2730.          * this is left to subclasses.

  2731.          */

  2732. 	protected int         direction;

  2733. 	/**

  2734.          * True indicates should set selection from anchor path.

  2735.          */

  2736. 	protected boolean       addToSelection;

  2737.         /**

  2738.          * True indicates the selection should be reset.

  2739.          */

  2740. 	protected boolean       changeSelection;

  2741. 

  2742.         GenericTreeAction(String name) {

  2743.             super(name);

  2744.         }

  2745. 

  2746.         GenericTreeAction(String name, int direction, boolean addToSelection,

  2747.                           boolean changeSelection) {

  2748.             super(name);

  2749.             this.direction = direction;

  2750.             this.addToSelection = addToSelection;

  2751.             this.changeSelection = changeSelection;

  2752.         }

  2753. 

  2754. 	public void actionPerformed(ActionEvent e) {

  2755.             JTree tree = (JTree)e.getSource();

  2756. 	    int rowCount = tree.getRowCount();

  2757. 

  2758.             if (rowCount > 0) {

  2759.                 actionPerformed(e, tree, rowCount);

  2760.             }

  2761.         }

  2762. 

  2763.         protected abstract void actionPerformed(ActionEvent e, JTree tree,

  2764.                                                 int rowCount);

  2765. 

  2766.         protected void adjustSelection(JTree tree, TreePath path) {

  2767.             if (addToSelection) {

  2768.                 extendSelection(tree, path);

  2769.             }

  2770.             else if(changeSelection) {

  2771.                 tree.setSelectionPath(path);

  2772.             }

  2773.             else {

  2774.                 tree.setLeadSelectionPath(path);

  2775.             }

  2776.         }

  2777. 

  2778.         /**

  2779.          * Extends the selection from the anchor to make <code>newLead</code>

  2780.          * the lead of the selection. This does not scroll.

  2781.          */

  2782.         private void extendSelection(JTree tree, TreePath newLead) {

  2783.             TreePath aPath = tree.getAnchorSelectionPath();

  2784.             int aRow = (aPath == null) ? -1 : tree.getRowForPath(aPath);

  2785.             int newIndex = tree.getRowForPath(newLead);

  2786. 

  2787.             if(aRow == -1) {

  2788.                 tree.setSelectionRow(newIndex);

  2789.             }

  2790.             else {

  2791.                 if (aRow < newIndex) {

  2792.                     tree.setSelectionInterval(aRow, newIndex);

  2793.                 }

  2794.                 else {

  2795.                     tree.setSelectionInterval(newIndex, aRow);

  2796.                 }

  2797.                 tree.setAnchorSelectionPath(aPath);

  2798.                 tree.setLeadSelectionPath(newLead);

  2799.             }

  2800.         }

  2801.     }

  2802. 

  2803.     /**

  2804.      * <code>TraverseAction</code> is the action used for left/right keys.

  2805.      * Will toggle the expandedness of a node, as well as potentially

  2806.      * incrementing the selection.

  2807.      */

  2808.     private static class TraverseAction extends GenericTreeAction {

  2809.         TraverseAction(String name, int direction, boolean changeSelection) {

  2810.             super(name, direction, false, changeSelection);

  2811. 	}

  2812. 

  2813. 	protected void actionPerformed(ActionEvent e, JTree tree,

  2814.                                        int rowCount) {

  2815.             int minSelIndex = tree.getLeadSelectionRow();

  2816.             int newIndex;

  2817.             TreeModel model = tree.getModel();

  2818. 

  2819.             if (minSelIndex == -1) {

  2820.                 newIndex = 0;

  2821.             }

  2822.             else {

  2823.                 // PENDING: needs to be updated.

  2824.                 SynthTreeUI ui = (SynthTreeUI)tree.getUI();

  2825.                 TreePath path = tree.getPathForRow(minSelIndex);

  2826. 

  2827.                 // Try and expand the node, otherwise go to next

  2828.                 // node.

  2829.                 if (direction == 1) {

  2830.                     if (!model.isLeaf(path.getLastPathComponent()) &&

  2831.                                !tree.isExpanded(minSelIndex)) {

  2832.                         ui.toggleExpandState(path);

  2833.                         newIndex = -1;

  2834.                     }

  2835.                     else {

  2836.                         newIndex = Math.min(minSelIndex + 1, rowCount - 1);

  2837.                     }

  2838.                 }

  2839.                 // Try to collapse node.

  2840.                 else {

  2841.                     if (!model.isLeaf(path.getLastPathComponent()) &&

  2842.                                tree.isExpanded(minSelIndex)) {

  2843.                         ui.toggleExpandState(tree.getPathForRow(minSelIndex));

  2844.                         newIndex = -1;

  2845.                     }

  2846.                     else {

  2847.                         path = tree.getPathForRow(minSelIndex);

  2848.                         if (path != null && path.getPathCount() > 1) {

  2849.                             newIndex = tree.getRowForPath(

  2850.                                             path.getParentPath());

  2851.                         }

  2852.                         else {

  2853.                             newIndex = -1;

  2854.                         }

  2855.                     }

  2856.                 }

  2857.             }

  2858.             if (newIndex != -1) {

  2859.                 if (changeSelection) {

  2860.                     tree.setSelectionInterval(newIndex, newIndex);

  2861.                 }

  2862.                 else {

  2863.                     tree.setLeadSelectionPath(tree.getPathForRow(newIndex));

  2864.                 }

  2865.                 ensureRowsAreVisible(tree, newIndex, newIndex);

  2866. 	    }

  2867. 	}

  2868.     }

  2869. 

  2870. 

  2871.     /**

  2872.      * ScrollAction handles scrolling left/right/up/down and changing

  2873.      * the selection.

  2874.      */

  2875.     private static class ScrollAndSelectAction extends GenericTreeAction {

  2876. 	private ScrollAndSelectAction(String name, int direction,

  2877.                                       boolean

  2878.                                       addToSelection, boolean changeSelection){

  2879.             super(name, direction, addToSelection, changeSelection);

  2880. 	}

  2881. 

  2882. 	protected void actionPerformed(ActionEvent e, JTree tree,

  2883.                                        int rowCount) {

  2884.             Dimension maxSize = tree.getSize();

  2885.             TreePath lead = tree.getLeadSelectionPath();

  2886.             TreePath newPath = null;

  2887.             Rectangle visRect = tree.getVisibleRect();

  2888.             Rectangle newRect;

  2889. 

  2890.             switch(direction) {

  2891.             case SwingConstants.NORTH:

  2892.                 // up.

  2893.                 newPath = tree.getClosestPathForLocation(visRect.x, visRect.y);

  2894.                 if (newPath.equals(lead)) {

  2895.                     visRect.y = Math.max(0, visRect.y - visRect.height);

  2896.                     newPath = tree.getClosestPathForLocation(visRect.x,

  2897.                                                              visRect.y);

  2898.                 }

  2899.                 newRect = tree.getPathBounds(newPath);

  2900.                 visRect.y = newRect.y;

  2901.                 break;

  2902.             case SwingConstants.SOUTH:

  2903.                 // down

  2904.                 visRect.y = Math.min(maxSize.height, visRect.y +

  2905.                                      visRect.height - 1);

  2906.                 newPath = tree.getClosestPathForLocation(visRect.x, visRect.y);

  2907.                 if (newPath.equals(lead)) {

  2908.                     visRect.y = Math.min(maxSize.height, visRect.y +

  2909.                                          visRect.height - 1);

  2910.                     newPath = tree.getClosestPathForLocation(visRect.x,

  2911.                                                              visRect.y);

  2912.                 }

  2913.                 newRect = tree.getPathBounds(newPath);

  2914.                 visRect.y = newRect.y - (visRect.height - newRect.height);

  2915.                 break;

  2916.             case SwingConstants.WEST:

  2917.                 newPath = tree.getClosestPathForLocation(visRect.x, visRect.y);

  2918.                 visRect.x = Math.max(0, visRect.x - visRect.width);

  2919.                 break;

  2920.             case SwingConstants.EAST:

  2921.                 visRect.x = Math.min(Math.max(0, tree.getWidth() -

  2922. 				   visRect.width), visRect.x + visRect.width);

  2923.                 newPath = tree.getClosestPathForLocation(visRect.x,

  2924. 						 visRect.y + visRect.height);

  2925.                 break;

  2926.             }

  2927.             adjustSelection(tree, newPath);

  2928.             tree.scrollRectToVisible(visRect);

  2929. 	}

  2930.     }

  2931. 

  2932. 

  2933.     /**

  2934.      * Moves the selection up/down.

  2935.      */

  2936.     private static class IncrementAction extends GenericTreeAction  {

  2937.         IncrementAction(String name, int direction, boolean addToSelection,

  2938.                             boolean changeSelection) {

  2939.             super(name);

  2940. 	    this.direction = direction;

  2941. 	    this.addToSelection = addToSelection;

  2942. 	    this.changeSelection = changeSelection;

  2943. 	}

  2944. 

  2945. 	protected void actionPerformed(ActionEvent e, JTree tree,

  2946.                                        int rowCount) {

  2947.             int selIndex = tree.getLeadSelectionRow();

  2948.             int newIndex;

  2949.             TreeSelectionModel selectionModel = tree.getSelectionModel();

  2950. 

  2951.             if (selIndex == -1) {

  2952.                 if (direction == 1) {

  2953.                     newIndex = 0;

  2954.                 }

  2955.                 else {

  2956.                     newIndex = rowCount - 1;

  2957.                 }

  2958.             }

  2959.             else {

  2960.                 //  Aparently people don't like wrapping;(

  2961.                 newIndex = Math.min(rowCount - 1, Math.max

  2962.                                     (0, (selIndex + direction)));

  2963.             }

  2964.             adjustSelection(tree, tree.getPathForRow(newIndex));

  2965.             ensureRowsAreVisible(tree, newIndex, newIndex);

  2966. 	}

  2967.     }

  2968. 

  2969. 

  2970.     /**

  2971.       * HomeAction is used to handle end/home actions.

  2972.       * Scrolls either the first or last cell to be visible based on

  2973.       * direction.

  2974.       */

  2975.     private static class HomeAction extends GenericTreeAction {

  2976.         HomeAction(String name, int direction, boolean addToSelection,

  2977.                    boolean changeSelection) {

  2978.             super(name, direction, addToSelection, changeSelection);

  2979. 	}

  2980. 

  2981. 	protected void actionPerformed(ActionEvent e, JTree tree,

  2982.                                        int rowCount) {

  2983.             if (direction == -1) {

  2984.                 ensureRowsAreVisible(tree, 0, 0);

  2985.                 if (addToSelection) {

  2986.                     TreePath aPath = tree.getAnchorSelectionPath();

  2987.                     int aRow = (aPath == null) ? -1 :tree.getRowForPath(aPath);

  2988. 

  2989.                     if (aRow == -1) {

  2990.                         tree.setSelectionInterval(0, 0);

  2991.                     }

  2992.                     else {

  2993.                         tree.setSelectionInterval(0, aRow);

  2994.                         tree.setAnchorSelectionPath(aPath);

  2995.                         tree.setLeadSelectionPath(tree.getPathForRow(0));

  2996.                     }

  2997.                 }

  2998.                 else if (changeSelection) {

  2999.                     tree.setSelectionInterval(0, 0);

  3000.                 }

  3001.                 else {

  3002.                     tree.setLeadSelectionPath(tree.getPathForRow(0));

  3003.                 }

  3004.             }

  3005.             else {

  3006.                 ensureRowsAreVisible(tree, rowCount - 1, rowCount - 1);

  3007.                 if (addToSelection) {

  3008.                     TreePath        aPath = tree.getAnchorSelectionPath();

  3009.                     int             aRow = (aPath == null) ? -1 :

  3010. 			                   tree.getRowForPath(aPath);

  3011. 

  3012.                     if (aRow == -1) {

  3013.                         tree.setSelectionInterval(rowCount - 1, rowCount -1);

  3014.                     }

  3015.                     else {

  3016.                         tree.setSelectionInterval(aRow, rowCount - 1);

  3017.                         tree.setAnchorSelectionPath(aPath);

  3018.                         tree.setLeadSelectionPath(tree.getPathForRow(

  3019.                                              rowCount -1));

  3020.                     }

  3021.                 }

  3022.                 else if (changeSelection) {

  3023.                     tree.setSelectionInterval(rowCount - 1, rowCount - 1);

  3024.                 }

  3025.                 else {

  3026.                     tree.setLeadSelectionPath(tree.getPathForRow(

  3027.                                          rowCount - 1));

  3028.                 }

  3029.             }

  3030.         }

  3031.     }

  3032. 

  3033. 

  3034.     /**

  3035.      * Toggles the expanded state of the first row.

  3036.       */

  3037.     private static class ToggleAction extends GenericTreeAction {

  3038. 	ToggleAction(String name) {

  3039.             super(name);

  3040. 	}

  3041. 

  3042. 	protected void actionPerformed(ActionEvent e, JTree tree,

  3043.                                        int rowCount) {

  3044.             int            selRow = tree.getLeadSelectionRow();

  3045. 

  3046.             if (selRow != -1) {

  3047.                 TreePath path = tree.getPathForRow(selRow);

  3048. 

  3049.                 if (!tree.getModel().isLeaf(path.getLastPathComponent())) {

  3050. 		    TreePath aPath = tree.getAnchorSelectionPath();

  3051. 		    TreePath lPath = tree.getLeadSelectionPath();

  3052. 

  3053.                     // PENDING:

  3054. 		    ((SynthTreeUI)tree.getUI()).toggleExpandState(path);

  3055. 		    tree.setAnchorSelectionPath(aPath);

  3056. 		    tree.setLeadSelectionPath(lPath);

  3057. 		}

  3058. 	    }

  3059. 	}

  3060.     }

  3061. 

  3062. 

  3063.     /**

  3064.      * Scrolls the component it is created with a specified amount.

  3065.      */

  3066.     private static class ScrollAction extends AbstractAction {

  3067.         /**

  3068.          * Direction to scroll.

  3069.          */

  3070. 	private int direction;

  3071.         /**

  3072.          * Amount to scroll.

  3073.          */

  3074. 	private int amount;

  3075. 

  3076. 	public ScrollAction(String name, int direction, int amount) {

  3077.             super(name);

  3078. 	    this.direction = direction;

  3079. 	    this.amount = amount;

  3080. 	}

  3081. 

  3082. 	public void actionPerformed(ActionEvent e) {

  3083.             JComponent component = (JComponent)e.getSource();

  3084. 	    Rectangle visRect = component.getVisibleRect();

  3085. 	    Dimension size = component.getSize();

  3086. 

  3087. 	    if (direction == SwingConstants.HORIZONTAL) {

  3088. 		visRect.x += amount;

  3089. 		visRect.x = Math.max(0, visRect.x);

  3090. 		visRect.x = Math.min(Math.max(0, size.width - visRect.width),

  3091. 				     visRect.x);

  3092. 	    }

  3093. 	    else {

  3094. 		visRect.y += amount;

  3095. 		visRect.y = Math.max(0, visRect.y);

  3096. 		visRect.y = Math.min(Math.max(0, size.width - visRect.height),

  3097. 				     visRect.y);

  3098. 	    }

  3099. 	    component.scrollRectToVisible(visRect);

  3100. 	}

  3101. 	

  3102.     }

  3103. 

  3104.  

  3105.     /**

  3106.      * ActionListener that invokes cancelEditing when action performed.

  3107.      */

  3108.     // PENDING: Make this static when isEnabled can be changed.

  3109.     private class CancelEditingAction extends AbstractAction {

  3110. 	public CancelEditingAction(String name) {

  3111.             super(name);

  3112. 	}

  3113. 

  3114. 	public void actionPerformed(ActionEvent e) {

  3115. 	    if (tree != null) {

  3116. 		tree.cancelEditing();

  3117. 	    }

  3118. 	}

  3119. 

  3120.         // PENDING: Need an isEnabled that takes a Component

  3121. 	public boolean isEnabled() { return (tree != null &&

  3122. 					     tree.isEnabled() &&

  3123.                                              isEditing(tree)); }

  3124.     }

  3125. 

  3126. 

  3127.     /**

  3128.      * ActionListener invoked to start editing on the leadPath.

  3129.      */

  3130.     private static class EditAction extends GenericTreeAction {

  3131. 	public EditAction(String name) {

  3132.             super(name);

  3133. 	}

  3134. 

  3135. 	protected void actionPerformed(ActionEvent ae, JTree tree,

  3136.                                        int rowCount) {

  3137.             TreePath path = tree.getLeadSelectionPath();

  3138. 

  3139.             if (path != null) {

  3140.                 tree.startEditingAtPath(path);

  3141. 	    }

  3142. 	}

  3143.     }

  3144. 

  3145. 

  3146.     /**

  3147.      * Action to select everything in tree.

  3148.      */

  3149.     private static class SelectAllAction extends GenericTreeAction {

  3150.         /**

  3151.          * If true, everything is selected, if false, the selection is cleared.

  3152.          */

  3153. 	private boolean       selectAll;

  3154. 

  3155. 	public SelectAllAction(String name, boolean selectAll) {

  3156.             super(name);

  3157. 	    this.selectAll = selectAll;

  3158. 	}

  3159. 

  3160. 	protected void actionPerformed(ActionEvent ae, JTree tree,

  3161.                                        int rowCount) {

  3162.             if (selectAll) {

  3163.                 TreePath lastPath = tree.getLeadSelectionPath();

  3164.                 TreePath aPath = tree.getAnchorSelectionPath();

  3165. 

  3166.                 if (lastPath != null && !tree.isVisible(lastPath)) {

  3167.                     lastPath = null;

  3168.                 }

  3169.                 tree.setSelectionInterval(0, rowCount - 1);

  3170.                 if (lastPath != null) {

  3171.                     tree.setLeadSelectionPath(lastPath);

  3172.                 }

  3173.                 if (aPath != null && tree.isVisible(aPath)) {

  3174.                     tree.setAnchorSelectionPath(aPath);

  3175.                 }

  3176.                 else if (lastPath != null) {

  3177.                     tree.setAnchorSelectionPath(lastPath);

  3178.                 }

  3179.             }

  3180.             else {

  3181.                 TreePath lastPath = tree.getLeadSelectionPath();

  3182.                 TreePath aPath = tree.getAnchorSelectionPath();

  3183. 

  3184.                 tree.clearSelection();

  3185.                 tree.setAnchorSelectionPath(aPath);

  3186.                 tree.setLeadSelectionPath(lastPath);

  3187.             }

  3188.         }

  3189.     }

  3190. 

  3191. 

  3192.     /**

  3193.      * Toggles the selection of the lead selected row.

  3194.      */

  3195.     private static class AddSelectionAction extends GenericTreeAction {

  3196. 	private boolean       changeAnchor;

  3197. 

  3198.         AddSelectionAction(String name, boolean changeAnchor) {

  3199.             super(name);

  3200. 	    this.changeAnchor = changeAnchor;

  3201. 	}

  3202. 

  3203. 	protected void actionPerformed(ActionEvent ae, JTree tree,

  3204.                                        int rowCount) {

  3205.             int lead = tree.getLeadSelectionRow();

  3206.             TreePath aPath = tree.getAnchorSelectionPath();

  3207.             TreePath lPath = tree.getLeadSelectionPath();

  3208. 

  3209.             if (lead == -1) {

  3210.                 lead = 0;

  3211.             }

  3212.             if (!changeAnchor) {

  3213.                 if (tree.isRowSelected(lead)) {

  3214.                     tree.removeSelectionRow(lead);

  3215.                     tree.setLeadSelectionPath(lPath);

  3216.                 }

  3217.                 else {

  3218.                     tree.addSelectionRow(lead);

  3219.                 }

  3220.                 tree.setAnchorSelectionPath(aPath);

  3221.             }

  3222.             else {

  3223.                 tree.setSelectionRow(lead);

  3224.             }

  3225.         }

  3226.     }

  3227. 

  3228. 

  3229.     /**

  3230.      * Extends the selection from the anchor to the lead.

  3231.      */

  3232.     private static class ExtendSelectionAction extends GenericTreeAction {

  3233.         ExtendSelectionAction(String name) {

  3234.             super(name);

  3235. 	}

  3236. 

  3237. 	protected void actionPerformed(ActionEvent ae, JTree tree,

  3238.                                        int rowCount) {

  3239.             int lead = tree.getLeadSelectionRow();

  3240. 

  3241.             if (lead != -1) {

  3242.                 TreePath leadP = tree.getLeadSelectionPath();

  3243.                 TreePath aPath = tree.getAnchorSelectionPath();

  3244.                 int aRow = tree.getRowForPath(aPath);

  3245. 

  3246.                 if (aRow == -1) {

  3247.                     aRow = 0;

  3248.                 }

  3249.                 tree.setSelectionInterval(aRow, lead);

  3250.                 tree.setLeadSelectionPath(leadP);

  3251.                 tree.setAnchorSelectionPath(aPath);

  3252. 	    }

  3253. 	}

  3254.     }

  3255. 

  3256. 

  3257.     private static class SynthTreeCellEditor extends DefaultTreeCellEditor {

  3258.         public SynthTreeCellEditor(JTree tree,

  3259.                                    DefaultTreeCellRenderer renderer) {

  3260.             super(tree, renderer);

  3261.             setBorderSelectionColor(null);

  3262.         }

  3263. 

  3264.         protected TreeCellEditor createTreeCellEditor() {

  3265.             // PENDING: should custom border be allowed from style?

  3266.             JTextField tf = new JTextField();

  3267.             tf.setName("Tree.cellEditor");

  3268.             // PENDING: rethink this

  3269.             ((SynthTextUI)tf.getUI()).forceFetchStyle(tf);

  3270. 

  3271.             DefaultCellEditor editor = new DefaultCellEditor(tf);

  3272. 

  3273.             // One click to edit.

  3274.             editor.setClickCountToStart(1);

  3275.             return editor;

  3276.         }

  3277.     }

  3278. 

  3279.     /**

  3280.      * Used to track the editing state.

  3281.      */

  3282.     private static class EditingState {

  3283.         /**

  3284.          * Component doing the editing.

  3285.          */

  3286.         public Component component;

  3287. 

  3288.         /**

  3289.          * Path being edited.

  3290.          */

  3291.         public TreePath path;

  3292. 

  3293.         /**

  3294.          *   Row that is being edited.

  3295.          */

  3296.         public int row;

  3297. 

  3298.         /**

  3299.          * Indicates if the editor has a different size than the renderer.

  3300.          */

  3301.         public boolean editorHasDifferentSize;

  3302. 

  3303.         /**

  3304.          * The editor.

  3305.          */

  3306.         public CellEditor editor;

  3307.     }

  3308. 

  3309. 

  3310.     private class SynthTreeCellRenderer extends DefaultTreeCellRenderer

  3311.                                implements UIResource {

  3312.         SynthTreeCellRenderer() {

  3313.             setName("Tree.cellRenderer");

  3314.             // PENDING: rethink this, we shouldn't have to force this.

  3315.             ((SynthLabelUI)getUI()).forceFetchStyle(this);

  3316.         }

  3317.         public void paint(Graphics g) {

  3318.             paintComponent(g);

  3319.             if (hasFocus) {

  3320.                 SynthContext context = getContext(tree, Region.TREE_CELL);

  3321. 

  3322.                 if (context.getStyle() == null) {

  3323.                     assert false: "SynthTreeCellRenderer is being used " +

  3324.                         "outside of UI that created it";

  3325.                     return;

  3326.                 }

  3327.                 SynthPainter painter = (SynthPainter)context.getStyle().

  3328.                                            get(context, "focus");

  3329.                 if (painter != null) {

  3330.                     int imageOffset = 0;

  3331.                     Icon currentI = getIcon();

  3332. 

  3333.                     if(currentI != null && getText() != null) {

  3334.                         imageOffset = currentI.getIconWidth() +

  3335.                                           Math.max(0, getIconTextGap() - 1);

  3336.                     }

  3337.                     if (selected) {

  3338.                         context.setComponentState(ENABLED | SELECTED);

  3339.                     }

  3340.                     else {

  3341.                         context.setComponentState(ENABLED);

  3342.                     }

  3343.                     if(getComponentOrientation().isLeftToRight()) {

  3344.                         painter.paint(context, "focus", g, imageOffset, 0,

  3345.                                       getWidth() - imageOffset, getHeight());

  3346.                     }

  3347.                     else {

  3348.                         painter.paint(context, "focus", g, 0, 0, getWidth() -

  3349.                                       imageOffset, getHeight());

  3350.                     }

  3351.                 }

  3352.                 context.dispose();

  3353.             }

  3354.         }

  3355.     }

  3356. 

  3357.     /**

  3358.      * Drag gesture recognizer for JTree components

  3359.      */

  3360.     static class TreeDragGestureRecognizer extends SynthDragGestureRecognizer {

  3361. 

  3362.         /**

  3363.          * Determines if the following are true:

  3364.          * <ul>

  3365.          * <li>the press event is located over a selection

  3366.          * <li>the dragEnabled property is true

  3367.          * <li>A TranferHandler is installed

  3368.          * </ul>

  3369.          * <p>

  3370.          * This is implemented to check for a TransferHandler.

  3371.          * Subclasses should perform the remaining conditions.

  3372.          */

  3373.         protected boolean isDragPossible(MouseEvent e) {

  3374.             if (super.isDragPossible(e)) {

  3375.                 JTree tree = (JTree) this.getComponent(e);

  3376.                 if (tree.getDragEnabled()) {

  3377.                     TreeUI ui = tree.getUI();

  3378.                     TreePath path = ui.getClosestPathForLocation(tree, e.getX(),

  3379.                                                                  e.getY());

  3380.                     if ((path != null) && tree.isPathSelected(path)) {

  3381.                         return true;

  3382.                     }

  3383.                 }

  3384.             }

  3385.             return false;

  3386.         }

  3387.     }

  3388. 

  3389.     /**

  3390.      * A DropTargetListener to extend the default Swing handling of drop operations

  3391.      * by moving the tree selection to the nearest location to the mouse pointer.

  3392.      * Also adds autoscroll capability.

  3393.      */

  3394.     static class TreeDropTargetListener extends SynthDropTargetListener {

  3395. 

  3396.         /**

  3397.          * called to save the state of a component in case it needs to

  3398.          * be restored because a drop is not performed.

  3399.          */

  3400.         protected void saveComponentState(JComponent comp) {

  3401.             JTree tree = (JTree) comp;

  3402.             selectedIndices = tree.getSelectionRows();

  3403.         }

  3404. 

  3405.         /**

  3406.          * called to restore the state of a component 

  3407.          * because a drop was not performed.

  3408.          */

  3409.         protected void restoreComponentState(JComponent comp) {

  3410.             JTree tree = (JTree) comp;

  3411.             tree.setSelectionRows(selectedIndices);

  3412.         }

  3413. 

  3414.         /**

  3415.          * called to set the insertion location to match the current

  3416.          * mouse pointer coordinates.

  3417.          */

  3418.         protected void updateInsertionLocation(JComponent comp, Point p) {

  3419.             JTree tree = (JTree) comp;

  3420.             TreeUI ui = tree.getUI();

  3421.             TreePath path = ui.getClosestPathForLocation(tree, p.x, p.y);

  3422.             if (path != null) {

  3423.                 tree.setSelectionPath(path);

  3424.             }

  3425.         }

  3426. 

  3427.         private int[] selectedIndices;

  3428.     }

  3429. 

  3430.     static class TreeTransferHandler extends TransferHandler implements UIResource, Comparator {

  3431.         

  3432.         private JTree tree;

  3433. 

  3434.         /**

  3435.          * Create a Transferable to use as the source for a data transfer.

  3436.          *

  3437.          * @param c  The component holding the data to be transfered.  This

  3438.          *  argument is provided to enable sharing of TransferHandlers by

  3439.          *  multiple components.

  3440.          * @return  The representation of the data to be transfered. 

  3441.          *  

  3442.          */

  3443.         protected Transferable createTransferable(JComponent c) {

  3444.             if (c instanceof JTree) {

  3445.                 tree = (JTree) c;

  3446.                 TreePath[] paths = tree.getSelectionPaths();

  3447.                 

  3448.                 if (paths == null || paths.length == 0) {

  3449.                     return null;

  3450.                 }

  3451.                 

  3452.                 StringBuffer plainBuf = new StringBuffer();

  3453.                 StringBuffer htmlBuf = new StringBuffer();

  3454.                 

  3455.                 htmlBuf.append("<html>\n<body>\n<ul>\n");

  3456.                 

  3457.                 TreeModel model = tree.getModel();

  3458.                 TreePath lastPath = null;

  3459.                 TreePath[] displayPaths = getDisplayOrderPaths(paths);

  3460. 

  3461.                 for (int i = 0; i < displayPaths.length; i++) {

  3462.                     TreePath path = displayPaths[i];

  3463.                     

  3464.                     Object node = path.getLastPathComponent();

  3465.                     boolean leaf = model.isLeaf(node);

  3466.                     String label = getDisplayString(path, true, leaf);

  3467.                     

  3468.                     plainBuf.append(label + "\n");

  3469.                     htmlBuf.append("  <li>" + label + "\n");

  3470.                 }

  3471.                 

  3472.                 // remove the last newline

  3473.                 plainBuf.deleteCharAt(plainBuf.length() - 1);

  3474.                 htmlBuf.append("</ul>\n</body>\n</html>");

  3475.                 

  3476.                 tree = null;

  3477.                 

  3478.                 return new SynthTransferable(plainBuf.toString(), htmlBuf.toString());

  3479.             }

  3480. 

  3481.             return null;

  3482.         }

  3483.         

  3484.         public int compare(Object o1, Object o2) {

  3485.             int row1 = tree.getRowForPath((TreePath)o1);

  3486.             int row2 = tree.getRowForPath((TreePath)o2);

  3487.             return row1 - row2;

  3488.         }

  3489. 

  3490.         String getDisplayString(TreePath path, boolean selected, boolean leaf) {

  3491.             int row = tree.getRowForPath(path);

  3492.             boolean hasFocus = tree.getLeadSelectionRow() == row;

  3493.             Object node = path.getLastPathComponent();

  3494.             return tree.convertValueToText(node, selected, tree.isExpanded(row), 

  3495.                                            leaf, row, hasFocus);

  3496.         }

  3497.         

  3498.         /**

  3499.          * Selection paths are in selection order.  The conversion to

  3500.          * HTML requires display order.  This method resorts the paths

  3501.          * to be in the display order.

  3502.          */

  3503.         TreePath[] getDisplayOrderPaths(TreePath[] paths) {

  3504.             // sort the paths to display order rather than selection order

  3505.             ArrayList selOrder = new ArrayList();

  3506.             for (int i = 0; i < paths.length; i++) {

  3507.                 selOrder.add(paths[i]);

  3508.             }

  3509.             Collections.sort(selOrder, this);

  3510.             int n = selOrder.size();

  3511.             TreePath[] displayPaths = new TreePath[n];

  3512.             for (int i = 0; i < n; i++) {

  3513.                 displayPaths[i] = (TreePath) selOrder.get(i);

  3514.             }

  3515.             return displayPaths;

  3516.         }

  3517. 

  3518.         public int getSourceActions(JComponent c) {

  3519.             return COPY;

  3520.         }

  3521. 

  3522.     }

  3523. 

  3524. } // End of class BasicTreeUI