1. /*

  2.  * @(#)BasicTreeUI.java	1.107 01/11/29

  3.  *

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

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

  6.  */

  7. 

  8. package javax.swing.plaf.basic;

  9. 

  10. import javax.swing.*;

  11. import javax.swing.event.*;

  12. import javax.swing.text.DefaultTextUI;

  13. import java.awt.*;

  14. import java.awt.event.*;

  15. import java.beans.*;

  16. import java.io.*;

  17. import java.util.*;

  18. import javax.swing.plaf.ComponentUI;

  19. import javax.swing.plaf.UIResource;

  20. import javax.swing.plaf.TreeUI;

  21. import javax.swing.tree.*;

  22. 

  23. /**

  24.  * The basic L&F for a hierarchical data structure.

  25.  * <p>

  26.  *

  27.  * @version 1.107 11/29/01

  28.  * @author Scott Violet

  29.  */

  30. 

  31. public class BasicTreeUI extends TreeUI

  32. {

  33.     static private final Insets EMPTY_INSETS = new Insets(0, 0, 0, 0);

  34. 

  35.     transient protected Icon        collapsedIcon;

  36.     transient protected Icon        expandedIcon;

  37. 

  38.     /** Color used to draw hash marks.  If null no hash marks will be

  39.       * drawn. */

  40.     private Color hashColor;

  41. 

  42.     /** Distance between left margin and where verical dashes will be

  43.       * drawn. */

  44.     protected int               leftChildIndent;

  45.     /** Distance to add to leftChildIndent to determine where cell

  46.       * contents will be drawn. */

  47.     protected int               rightChildIndent;

  48.     /** Total distance that will be indented.  The sum of leftChildIndent

  49.       * and rightChildIndent. */

  50.     protected int               totalChildIndent;

  51. 

  52.     /** Minimum preferred size. */

  53.     protected Dimension         preferredMinSize;

  54. 

  55.     /** Index of the row that was last selected. */

  56.     protected int               lastSelectedRow;

  57. 

  58.     /** Component that we're going to be drawing into. */

  59.     protected JTree             tree;

  60. 

  61.     /** Renderer that is being used to do the actual cell drawing. */

  62.     transient protected TreeCellRenderer   currentCellRenderer;

  63. 

  64.     /** Set to true if the renderer that is currently in the tree was

  65.      * created by this instance. */

  66.     protected boolean           createdRenderer;

  67. 

  68.     /** Editor for the tree. */

  69.     transient protected TreeCellEditor     cellEditor;

  70. 

  71.     /** Set to true if editor that is currently in the tree was

  72.      * created by this instance. */

  73.     protected boolean           createdCellEditor;

  74. 

  75.     /** Set to false when editing and shouldSelectCell() returns true meaning

  76.       * the node should be selected before editing, used in completeEditing. */

  77.     protected boolean           stopEditingInCompleteEditing;

  78. 

  79.     /** Used to paint the TreeCellRenderer. */

  80.     protected CellRendererPane  rendererPane;

  81. 

  82.     /** Size needed to completely display all the nodes. */

  83.     protected Dimension         preferredSize;

  84. 

  85.     /** Is the preferredSize valid? */

  86.     protected boolean           validCachedPreferredSize;

  87. 

  88.     /** Object responsible for handling sizing and expanded issues. */

  89.     protected AbstractLayoutCache  treeState;

  90. 

  91. 

  92.     /** Used for minimizing the drawing of vertical lines. */

  93.     protected Hashtable         drawingCache;

  94. 

  95.     /** True if doing optimizations for a largeModel. Subclasses that

  96.      * don't support this may wish to override createLayoutCache to not

  97.      * return a FixedHeightLayoutCache instance. */

  98.     protected boolean           largeModel;

  99. 

  100.     /** Reponsible for telling the TreeState the size needed for a node. */

  101.     protected AbstractLayoutCache.NodeDimensions     nodeDimensions;

  102. 

  103.     /** Used to determine what to display. */

  104.     protected TreeModel         treeModel;

  105. 

  106.     /** Model maintaing the selection. */

  107.     protected TreeSelectionModel treeSelectionModel;

  108. 

  109.     /** How much the depth should be offset to properly calculate

  110.      * x locations. This is based on whether or not the root is visible,

  111.      * and if the root handles are visible. */

  112.     protected int               depthOffset;

  113. 

  114.     // Following 4 ivars are only valid when editing.

  115. 

  116.     /** When editing, this will be the Component that is doing the actual

  117.       * editing. */

  118.     protected Component         editingComponent;

  119. 

  120.     /** Path that is being edited. */

  121.     protected TreePath          editingPath;

  122. 

  123.     /** Row that is being edited. Should only be referenced if

  124.      * editingComponent is not null. */

  125.     protected int               editingRow;

  126. 

  127.     /** Set to true if the editor has a different size than the renderer. */

  128.     protected boolean           editorHasDifferentSize;

  129. 

  130.     /** Updated when selection changes. This really needs to be in JTree, and

  131.      * public at some point. */

  132.     private TreePath            anchorPath;

  133.     /** Path of last selected item. */

  134.     private TreePath            leadPath;

  135.     /** Row correspondin to lead path. */

  136.     private int                 leadRow;

  137.     /** If true, the selection will be changed with the focus, otherwise

  138.      * both the selection and focus will change at the same time. This comes

  139.      * from the property Tree.changeSelectionWithFocus. */

  140.     private boolean             changeSelectionWithFocus;

  141.     /** KeyStrokes registered actions under. */

  142.     private Vector              keyActions;

  143. 

  144. 

  145.     // Cached listeners

  146.     private PropertyChangeListener propertyChangeListener;

  147.     private PropertyChangeListener selectionModelPropertyChangeListener;

  148.     private MouseListener mouseListener;

  149.     private FocusListener focusListener;

  150.     private KeyListener keyListener;

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

  152.      * updates the validCachedPreferredSize bit accordingly. */

  153.     private ComponentListener   componentListener;

  154.     /** Listens for CellEditor events. */

  155.     private CellEditorListener  cellEditorListener;

  156.     /** Updates the display when the selection changes. */

  157.     private TreeSelectionListener treeSelectionListener;

  158.     /** Is responsible for updating the display based on model events. */

  159.     private TreeModelListener treeModelListener;

  160.     /** Updates the treestate as the nodes expand. */

  161.     private TreeExpansionListener treeExpansionListener;

  162. 

  163.     public static ComponentUI createUI(JComponent x) {

  164. 	return new BasicTreeUI();

  165.     }

  166. 

  167.     public BasicTreeUI() {

  168. 	super();

  169.     }

  170. 

  171.     protected Color getHashColor() {

  172.         return hashColor;

  173.     }

  174. 

  175.     protected void setHashColor(Color color) {

  176.         hashColor = color;

  177.     }

  178. 

  179.     public void setLeftChildIndent(int newAmount) {

  180. 	leftChildIndent = newAmount;

  181. 	totalChildIndent = leftChildIndent + rightChildIndent;

  182. 	if(treeState != null)

  183. 	    treeState.invalidateSizes();

  184. 	updateSize();

  185.     }

  186. 

  187.     public int getLeftChildIndent() {

  188. 	return leftChildIndent;

  189.     }

  190. 

  191.     public void setRightChildIndent(int newAmount) {

  192. 	rightChildIndent = newAmount;

  193. 	totalChildIndent = leftChildIndent + rightChildIndent;

  194. 	if(treeState != null)

  195. 	    treeState.invalidateSizes();

  196. 	updateSize();

  197.     }

  198. 

  199.     public int getRightChildIndent() {

  200. 	return rightChildIndent;

  201.     }

  202. 

  203.     public void setExpandedIcon(Icon newG) {

  204. 	expandedIcon = newG;

  205.     }

  206. 

  207.     public Icon getExpandedIcon() {

  208. 	return expandedIcon;

  209.     }

  210. 

  211.     public void setCollapsedIcon(Icon newG) {

  212. 	collapsedIcon = newG;

  213.     }

  214. 

  215.     public Icon getCollapsedIcon() {

  216. 	return collapsedIcon;

  217.     }

  218. 

  219.     //

  220.     // Methods for configuring the behavior of the tree. None of them

  221.     // push the value to the JTree instance. You should really only

  222.     // call these methods on the JTree.

  223.     //

  224. 

  225.     /**

  226.      * Updates the componentListener, if necessary.

  227.      */

  228.     protected void setLargeModel(boolean largeModel) {

  229. 	if(getRowHeight() < 1)

  230. 	    largeModel = false;

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

  232. 	    completeEditing();

  233. 	    this.largeModel = largeModel;

  234. 	    treeState = createLayoutCache();

  235. 	    configureLayoutCache();

  236. 	    updateLayoutCacheExpandedNodes();

  237. 	    updateSize();

  238. 	}

  239.     }

  240. 

  241.     protected boolean isLargeModel() {

  242. 	return largeModel;

  243.     }

  244. 

  245.     /**

  246.      * Sets the row height, this is forwarded to the treeState.

  247.      */

  248.     protected void setRowHeight(int rowHeight) {

  249. 	completeEditing();

  250. 	if(treeState != null) {

  251. 	    setLargeModel(tree.isLargeModel());

  252. 	    treeState.setRowHeight(rowHeight);

  253. 	    updateSize();

  254. 	}

  255.     }

  256. 

  257.     protected int getRowHeight() {

  258. 	return (tree == null) ? -1 : tree.getRowHeight();

  259.     }

  260. 

  261.     /**

  262.      * Sets the TreeCellRenderer to <code>tcr</code>. This invokes

  263.      * <code>updateRenderer</code>.

  264.      */

  265.     protected void setCellRenderer(TreeCellRenderer tcr) {

  266. 	completeEditing();

  267. 	updateRenderer();

  268. 	if(treeState != null) {

  269. 	    treeState.invalidateSizes();

  270. 	    updateSize();

  271. 	}

  272.     }

  273. 

  274.     /**

  275.      * Return currentCellRenderer, which will either be the trees

  276.      * renderer, or defaultCellRenderer, which ever wasn't null.

  277.      */

  278.     protected TreeCellRenderer getCellRenderer() {

  279. 	return currentCellRenderer;

  280.     }

  281. 

  282.     /**

  283.      * Sets the TreeModel.

  284.      */

  285.     protected void setModel(TreeModel model) {

  286. 	completeEditing();

  287. 	if(treeModel != null && treeModelListener != null)

  288. 	    treeModel.removeTreeModelListener(treeModelListener);

  289. 	treeModel = model;

  290. 	if(treeModel != null) {

  291. 	    if(treeModelListener != null)

  292. 		treeModel.addTreeModelListener(treeModelListener);

  293. 	}

  294. 	if(treeState != null) {

  295. 	    treeState.setModel(model);

  296. 	    updateLayoutCacheExpandedNodes();

  297. 	    updateSize();

  298. 	}

  299.     }

  300. 

  301.     protected TreeModel getModel() {

  302. 	return treeModel;

  303.     }

  304. 

  305.     /**

  306.      * Sets the root to being visible.

  307.      */

  308.     protected void setRootVisible(boolean newValue) {

  309. 	completeEditing();

  310. 	updateDepthOffset();

  311. 	if(treeState != null) {

  312. 	    treeState.setRootVisible(newValue);

  313. 	    treeState.invalidateSizes();

  314. 	    updateSize();

  315. 	}

  316.     }

  317. 

  318.     protected boolean isRootVisible() {

  319. 	return (tree != null) ? tree.isRootVisible() : false;

  320.     }

  321. 

  322.     /**

  323.      * Determines whether the node handles are to be displayed.

  324.      */

  325.     protected void setShowsRootHandles(boolean newValue) {

  326. 	completeEditing();

  327. 	updateDepthOffset();

  328. 	if(treeState != null) {

  329. 	    treeState.invalidateSizes();

  330. 	    updateSize();

  331. 	}

  332.     }

  333. 

  334.     protected boolean getShowsRootHandles() {

  335. 	return (tree != null) ? tree.getShowsRootHandles() : false;

  336.     }

  337. 

  338.     /**

  339.      * Sets the cell editor.

  340.      */

  341.     protected void setCellEditor(TreeCellEditor editor) {

  342. 	updateCellEditor();

  343.     }

  344. 

  345.     protected TreeCellEditor getCellEditor() {

  346. 	return (tree != null) ? tree.getCellEditor() : null;

  347.     }

  348. 

  349.     /**

  350.      * Configures the receiver to allow, or not allow, editing.

  351.      */

  352.     protected void setEditable(boolean newValue) {

  353. 	updateCellEditor();

  354.     }

  355. 

  356.     protected boolean isEditable() {

  357. 	return (tree != null) ? tree.isEditable() : false;

  358.     }

  359. 

  360.     /**

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

  362.      * on the model.

  363.      */

  364.     protected void setSelectionModel(TreeSelectionModel newLSM) {

  365. 	completeEditing();

  366. 	if(selectionModelPropertyChangeListener != null &&

  367. 	   treeSelectionModel != null)

  368. 	    treeSelectionModel.removePropertyChangeListener

  369. 		              (selectionModelPropertyChangeListener);

  370. 	if(treeSelectionListener != null && treeSelectionModel != null)

  371. 	    treeSelectionModel.removeTreeSelectionListener

  372. 		               (treeSelectionListener);

  373. 	treeSelectionModel = newLSM;

  374. 	if(treeSelectionModel != null) {

  375. 	    if(selectionModelPropertyChangeListener != null)

  376. 		treeSelectionModel.addPropertyChangeListener

  377. 		              (selectionModelPropertyChangeListener);

  378. 	    if(treeSelectionListener != null)

  379. 		treeSelectionModel.addTreeSelectionListener

  380. 		                   (treeSelectionListener);

  381. 	    if(treeState != null)

  382. 		treeState.setSelectionModel(treeSelectionModel);

  383. 	}

  384. 	else if(treeState != null)

  385. 	    treeState.setSelectionModel(null);

  386. 	if(tree != null)

  387. 	    tree.repaint();

  388.     }

  389. 

  390.     protected TreeSelectionModel getSelectionModel() {

  391. 	return treeSelectionModel;

  392.     }

  393. 

  394.     //

  395.     // TreeUI methods

  396.     //

  397. 

  398.     /**

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

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

  401.       * any component in path is currently valid.

  402.       */

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

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

  405. 	    Insets           i = tree.getInsets();

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

  407. 

  408. 	    if(bounds != null && i != null) {

  409. 		bounds.x += i.left;

  410. 		bounds.y += i.top;

  411. 	    }

  412. 	    return bounds;

  413. 	}

  414. 	return null;

  415.     }

  416. 

  417.     /**

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

  419.       * null is returned.

  420.       */

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

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

  423.     }

  424. 

  425.     /**

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

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

  428.       * currently visible.

  429.       */

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

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

  432.     }

  433. 

  434.     /**

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

  436.       */

  437.     public int getRowCount(JTree tree) {

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

  439.     }

  440. 

  441.     /**

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

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

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

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

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

  447.       */

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

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

  450. 	    Insets          i = tree.getInsets();

  451. 

  452. 	    if(i == null)

  453. 		i = EMPTY_INSETS;

  454. 

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

  456. 	}

  457. 	return null;

  458.     }

  459. 

  460.     /**

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

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

  463.       */

  464.     public boolean isEditing(JTree tree) {

  465. 	return (editingComponent != null);

  466.     }

  467. 

  468.     /**

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

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

  471.       * editing session to stop.

  472.       */

  473.     public boolean stopEditing(JTree tree) {

  474. 	if(editingComponent != null && cellEditor.stopCellEditing()) {

  475. 	    completeEditing(false, false, true);

  476. 	    return true;

  477. 	}

  478. 	return false;

  479.     }

  480. 

  481.     /**

  482.       * Cancels the current editing session.

  483.       */

  484.     public void cancelEditing(JTree tree) {

  485. 	if(editingComponent != null) {

  486. 	    completeEditing(false, true, false);

  487. 	}

  488.     }

  489. 

  490.     /**

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

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

  493.       */

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

  495. 	tree.scrollPathToVisible(path);

  496. 	if(path != null && tree.isVisible(path))

  497. 	    startEditing(path, null);

  498.     }

  499. 

  500.     /**

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

  502.      */

  503.     public TreePath getEditingPath(JTree tree) {

  504. 	return editingPath;

  505.     }

  506. 

  507.     //

  508.     // Install methods

  509.     //

  510. 

  511.     public void installUI(JComponent c) {

  512.         if ( c == null ) {

  513. 	    throw new NullPointerException( "null component passed to BasicTreeUI.installUI()" );

  514.         }

  515. 

  516. 	tree = (JTree)c;

  517. 

  518. 	prepareForUIInstall();

  519. 

  520. 	// Boilerplate install block

  521. 	installDefaults();

  522. 	installListeners();

  523. 	installKeyboardActions();

  524. 	installComponents();

  525. 

  526. 	completeUIInstall();

  527.     }

  528. 

  529.     /**

  530.      * Invoked after the <code>tree</code> instance variable has been

  531.      * set, but before any defaults/listeners have been installed.

  532.      */

  533.     protected void prepareForUIInstall() {

  534. 	drawingCache = new Hashtable(7);

  535. 

  536. 	// Data member initializations

  537. 	stopEditingInCompleteEditing = true;

  538. 	lastSelectedRow = -1;

  539. 	leadPath = anchorPath = null;

  540. 	leadRow = -1;

  541. 	preferredSize = new Dimension();

  542. 	tree.setRowHeight(UIManager.getInt("Tree.rowHeight"));

  543. 

  544. 	Object     b = UIManager.get("Tree.scrollsOnExpand");

  545. 

  546. 	if(b != null)

  547. 	    tree.setScrollsOnExpand(((Boolean)b).booleanValue());

  548. 

  549. 	largeModel = tree.isLargeModel();

  550. 	if(getRowHeight() <= 0)

  551. 	    largeModel = false;

  552. 	setModel(tree.getModel());

  553.     }

  554. 

  555.     /**

  556.      * Invoked from installUI after all the defaults/listeners have been

  557.      * installed.

  558.      */

  559.     protected void completeUIInstall() {

  560. 	// Custom install code

  561. 

  562. 	this.setShowsRootHandles(tree.getShowsRootHandles());

  563. 

  564. 	updateRenderer();

  565. 

  566. 	updateDepthOffset();

  567. 

  568. 	setSelectionModel(tree.getSelectionModel());

  569. 

  570. 	// Create, if necessary, the TreeState instance.

  571. 	treeState = createLayoutCache();

  572. 	configureLayoutCache();

  573. 

  574. 	updateSize();

  575.     }

  576. 

  577.     protected void installDefaults() {

  578. 	if(tree.getBackground() == null ||

  579. 	   tree.getBackground() instanceof UIResource) {

  580. 	    tree.setBackground(UIManager.getColor("Tree.background"));

  581. 	} 

  582. 	if(getHashColor() == null || getHashColor() instanceof UIResource) {

  583. 	    setHashColor(UIManager.getColor("Tree.hash"));

  584. 	}

  585. 	if (tree.getFont() == null || tree.getFont() instanceof UIResource)

  586. 	    tree.setFont( UIManager.getFont("Tree.font") );

  587. 

  588. 	setExpandedIcon( (Icon)UIManager.get( "Tree.expandedIcon" ) );

  589. 	setCollapsedIcon( (Icon)UIManager.get( "Tree.collapsedIcon" ) );

  590. 

  591. 	setLeftChildIndent(((Integer)UIManager.get("Tree.leftChildIndent")).

  592. 			   intValue());

  593. 	setRightChildIndent(((Integer)UIManager.get("Tree.rightChildIndent")).

  594. 			   intValue());

  595. 	changeSelectionWithFocus = ((Boolean)UIManager.get

  596. 			     ("Tree.changeSelectionWithFocus")).booleanValue();

  597.     }

  598. 

  599.     protected void installListeners() {

  600.         if ( (propertyChangeListener = createPropertyChangeListener())

  601. 	     != null ) {

  602. 	    tree.addPropertyChangeListener(propertyChangeListener);

  603. 	}

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

  605. 	    tree.addMouseListener(mouseListener);

  606. 	}

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

  608. 	    tree.addFocusListener(focusListener);

  609. 	}

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

  611. 	    tree.addKeyListener(keyListener);

  612. 	}

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

  614. 	    tree.addTreeExpansionListener(treeExpansionListener);

  615. 	}

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

  617. 	   treeModel != null) {

  618. 	    treeModel.addTreeModelListener(treeModelListener);

  619. 	}

  620. 	if((selectionModelPropertyChangeListener =

  621. 	    createSelectionModelPropertyChangeListener()) != null &&

  622. 	   treeSelectionModel != null) {

  623. 	    treeSelectionModel.addPropertyChangeListener

  624. 		(selectionModelPropertyChangeListener);

  625. 	}

  626. 	if((treeSelectionListener = createTreeSelectionListener()) != null &&

  627. 	   treeSelectionModel != null) {

  628. 	    treeSelectionModel.addTreeSelectionListener(treeSelectionListener);

  629. 	}

  630.     }

  631. 

  632.     private void registerKeyAction(ActionListener action, KeyStroke ks) {

  633. 	keyActions.addElement(ks);

  634. 	tree.registerKeyboardAction(action, ks, JComponent.WHEN_FOCUSED);

  635.     }

  636. 

  637.     protected void installKeyboardActions() {

  638. 	// PENDING(sky): All these names need to be rethought, and the values

  639. 	// need to come from the defaults manager.

  640. 	boolean changeSelection = changeSelectionWithFocus();

  641. 

  642. 	// YES! 33 key actions, yeesh!

  643.         // hania: This became 43 when I added the keypad arrow key actions.

  644. 	// hania: is counding the number of calls below really the best way

  645.         // to determine the size this vector needs to be initialized to?

  646. 	keyActions = new Vector(43);

  647. 	registerKeyAction(new TreeIncrementAction(-1, "UP", false,

  648. 		  changeSelection), KeyStroke.getKeyStroke(KeyEvent.VK_UP,0));

  649. 	registerKeyAction(new TreeIncrementAction(-1, "UP", false,

  650. 		  changeSelection), KeyStroke.getKeyStroke("KP_UP"));

  651. 	registerKeyAction(new TreeIncrementAction(-1, "SELECT_UP", true,

  652.                           true), KeyStroke.getKeyStroke(KeyEvent.VK_UP,

  653. 			  InputEvent.SHIFT_MASK));

  654. 	registerKeyAction(new TreeIncrementAction(-1, "SELECT_UP", true,

  655.                           true), KeyStroke.getKeyStroke("shift KP_UP"));

  656. 	registerKeyAction(new TreeIncrementAction(1, "DOWN", false,

  657. 		changeSelection), KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0));

  658. 	registerKeyAction(new TreeIncrementAction(1, "DOWN", false,

  659. 		changeSelection), KeyStroke.getKeyStroke("KP_DOWN" ));

  660. 	registerKeyAction(new TreeIncrementAction(1, "SELECT_DOWN",

  661. 			  true, true), KeyStroke.getKeyStroke(KeyEvent.VK_DOWN,

  662. 			  InputEvent.SHIFT_MASK));

  663. 	registerKeyAction(new TreeIncrementAction(1, "SELECT_DOWN",

  664. 			  true, true), KeyStroke.getKeyStroke("shift KP_DOWN"));

  665. 	registerKeyAction(new TreeTraverseAction(1, "RIGHT",

  666. 				 changeSelection),

  667. 				 KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT,0));

  668. 	registerKeyAction(new TreeTraverseAction(1, "RIGHT",

  669. 				 changeSelection),

  670. 				 KeyStroke.getKeyStroke("KP_RIGHT"));

  671. 	registerKeyAction(new TreeTraverseAction(-1, "LEFT",

  672. 				 changeSelection),

  673. 				 KeyStroke.getKeyStroke(KeyEvent.VK_LEFT,0));

  674. 	registerKeyAction(new TreeTraverseAction(-1, "LEFT",

  675. 				 changeSelection),

  676. 				 KeyStroke.getKeyStroke("KP_LEFT"));

  677. 	registerKeyAction(new TreePageAction(-1, "P_UP", false,

  678. 			       changeSelection),

  679. 			       KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP,0));

  680. 	registerKeyAction(new TreePageAction(-1, "SELECT_P_UP",

  681. 			      true, true),

  682. 			      KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP,

  683. 			      InputEvent.SHIFT_MASK));

  684. 	registerKeyAction(new TreePageAction(1, "P_DOWN", false,

  685. 			  changeSelection),

  686. 			  KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_DOWN,0));

  687. 	registerKeyAction(new TreePageAction(1, "SELECT_P_DOWN",

  688. 			      true, true), KeyStroke.getKeyStroke(KeyEvent.

  689. 			      VK_PAGE_DOWN, InputEvent.SHIFT_MASK));

  690. 	registerKeyAction(new TreeHomeAction(-1, "HOME", false,

  691. 	         changeSelection), KeyStroke.getKeyStroke(KeyEvent.VK_HOME,0));

  692. 	registerKeyAction(new TreeHomeAction(-1, "SELECT_HOME",true, 

  693. 			     true), KeyStroke.getKeyStroke(KeyEvent.VK_HOME,

  694.                              InputEvent.SHIFT_MASK));

  695. 	registerKeyAction(new TreeHomeAction(1, "END", false,

  696. 		    changeSelection),KeyStroke.getKeyStroke

  697. 			  (KeyEvent.VK_END,0));

  698. 	registerKeyAction(new TreeHomeAction(1, "SELECT_END", true,

  699. 			      true), KeyStroke.getKeyStroke(KeyEvent.VK_END,

  700. 			      InputEvent.SHIFT_MASK));

  701. 	registerKeyAction(new TreeToggleAction("TOGGLE"),

  702. 				 KeyStroke.getKeyStroke(KeyEvent.VK_ENTER,0));

  703. 	KeyStroke ks = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);

  704. 	tree.registerKeyboardAction(new TreeCancelEditingAction("ESCAPE"), ks,

  705. 				JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

  706. 	keyActions.addElement(ks);

  707. 	registerKeyAction(new TreeEditAction("EDIT_NODE"),

  708. 				    KeyStroke.getKeyStroke(KeyEvent.VK_F2, 0));

  709. 	ActionListener  saAction = new TreeSelectAllAction("SELECT_ALL",true);

  710. 	registerKeyAction(saAction, KeyStroke.getKeyStroke

  711. 				    (KeyEvent.VK_A, InputEvent.CTRL_MASK));

  712. 	registerKeyAction(saAction, KeyStroke.getKeyStroke

  713. 				    (KeyEvent.VK_SLASH, InputEvent.CTRL_MASK));

  714. 	registerKeyAction(new TreeSelectAllAction("UNSELECT_ALL",

  715. 			 false), KeyStroke.getKeyStroke(KeyEvent.VK_BACK_SLASH,

  716. 			 InputEvent.CTRL_MASK));

  717. 	registerKeyAction(new TreeAddSelectionAction("SELECT_NODE", false),

  718. 			    KeyStroke.getKeyStroke(KeyEvent.VK_SPACE,

  719. 			    InputEvent.CTRL_MASK));

  720. 	registerKeyAction(new TreeExtendSelectionAction

  721. 			    ("EXTEND_SELECTION"),

  722. 			    KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 

  723. 			    InputEvent.SHIFT_MASK));

  724. 	if(changeSelection) {

  725. 	    registerKeyAction(new TreeHomeAction(-1, "HOME", false,

  726. 			 false), KeyStroke.getKeyStroke(KeyEvent.VK_HOME,

  727. 			 InputEvent.CTRL_MASK));

  728. 	    registerKeyAction(new TreeHomeAction(1, "END", false,

  729. 		         false),KeyStroke.getKeyStroke(KeyEvent.VK_END,

  730.                          InputEvent.CTRL_MASK));

  731. 	    registerKeyAction(new TreeIncrementAction(-1, "UP",

  732. 			 false, false), KeyStroke.getKeyStroke(KeyEvent.VK_UP,

  733. 			 InputEvent.CTRL_MASK));

  734. 	    registerKeyAction(new TreeIncrementAction(-1, "UP",

  735. 			 false, false), KeyStroke.getKeyStroke("ctrl KP_UP"));

  736. 	    registerKeyAction(new TreeIncrementAction(1, "DOWN",

  737. 			 false, false), KeyStroke.getKeyStroke

  738. 			 (KeyEvent.VK_DOWN, InputEvent.CTRL_MASK));

  739. 	    registerKeyAction(new TreeIncrementAction(1, "DOWN",

  740. 			 false, false), KeyStroke.getKeyStroke

  741. 			 ("ctrl KP_DOWN"));

  742. 	    registerKeyAction(new TreePageAction(1, "LEAD_P_DOWN", false,

  743. 			      false), KeyStroke.getKeyStroke

  744. 			      (KeyEvent.VK_PAGE_DOWN, InputEvent.CTRL_MASK));

  745. 	    registerKeyAction(new TreePageAction(1, "SELECT_P_DOWN", true,

  746. 			      true), KeyStroke.getKeyStroke

  747. 			      (KeyEvent.VK_PAGE_DOWN, InputEvent.CTRL_MASK |

  748. 			      InputEvent.SHIFT_MASK));

  749. 	    registerKeyAction(new TreePageAction(-1, "LEAD_P_UP", false,

  750. 			      false), KeyStroke.getKeyStroke

  751. 			      (KeyEvent.VK_PAGE_UP, InputEvent.CTRL_MASK));

  752. 	    registerKeyAction(new TreePageAction(-1, "SELECT_P_UP", true,

  753. 			      true), KeyStroke.getKeyStroke

  754. 			      (KeyEvent.VK_PAGE_UP, InputEvent.CTRL_MASK |

  755. 			      InputEvent.SHIFT_MASK));

  756. 	    registerKeyAction(new ScrollAction(tree, SwingConstants.

  757. 			      HORIZONTAL, -10), KeyStroke.getKeyStroke

  758. 			      (KeyEvent.VK_LEFT, InputEvent.CTRL_MASK));

  759. 	    registerKeyAction(new ScrollAction(tree, SwingConstants.

  760. 			      HORIZONTAL, -10), KeyStroke.getKeyStroke

  761. 			      ("ctrl KP_LEFT"));

  762. 	    registerKeyAction(new ScrollAction(tree, SwingConstants.

  763. 			      HORIZONTAL, 10), KeyStroke.getKeyStroke

  764. 			      (KeyEvent.VK_RIGHT, InputEvent.CTRL_MASK));

  765. 	    registerKeyAction(new ScrollAction(tree, SwingConstants.

  766. 			      HORIZONTAL, 10), KeyStroke.getKeyStroke

  767. 			      ("ctrl KP_RIGHT"));

  768. 	    registerKeyAction(new TreeAddSelectionAction("SELECT_NODE", false),

  769. 			    KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0));

  770. 	}

  771. 	else {

  772. 	    registerKeyAction(new TreeScrollLRAction(1, "CTRL_P_DOWN",

  773. 			  false), KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_DOWN,

  774. 			  InputEvent.CTRL_MASK));

  775. 	    registerKeyAction(new TreeScrollLRAction(-1, "CTRL_P_UP",

  776. 			    false), KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP,

  777. 			    InputEvent.CTRL_MASK));

  778. 	    registerKeyAction(new TreeScrollLRAction(-1,

  779. 			    "SELECT_CTRL_P_UP", true), KeyStroke.

  780. 			    getKeyStroke(KeyEvent.VK_PAGE_UP,

  781. 			    InputEvent.CTRL_MASK | InputEvent.SHIFT_MASK));

  782. 	    registerKeyAction(new TreeScrollLRAction(1,

  783.                           "SELECT_CTRL_P_DOWN", true), KeyStroke.

  784.                           getKeyStroke(KeyEvent.VK_PAGE_DOWN,

  785. 			  InputEvent.CTRL_MASK | InputEvent.SHIFT_MASK));

  786. 	    registerKeyAction(new TreeAddSelectionAction("SELECT_NODE", true),

  787. 			    KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0));

  788. 	}

  789.     }

  790. 

  791.     /**

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

  793.      */

  794.     protected void installComponents() {

  795. 	if ((rendererPane = createCellRendererPane()) != null) {

  796. 	    tree.add( rendererPane );

  797. 	}

  798.     }

  799. 

  800.     //

  801.     // Create methods.

  802.     //

  803. 

  804.     /**

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

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

  807.      */

  808.     protected AbstractLayoutCache.NodeDimensions createNodeDimensions() {

  809. 	return new NodeDimensionsHandler();

  810.     }

  811. 

  812.     /**

  813.      * Creates a listener that is responsible that updates the UI based on

  814.      * how the tree changes.

  815.      */

  816.     protected PropertyChangeListener createPropertyChangeListener() {

  817.         return new PropertyChangeHandler();

  818.     }

  819. 

  820.     /**

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

  822.      * mouse events.

  823.      */

  824.     protected MouseListener createMouseListener() {

  825.         return new MouseHandler();

  826.     }

  827. 

  828.     /**

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

  830.      * when focus is lost/gained.

  831.      */

  832.     protected FocusListener createFocusListener() {

  833.         return new FocusHandler();

  834.     }

  835. 

  836.     /**

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

  838.      * the tree.

  839.      */

  840.     protected KeyListener createKeyListener() {

  841.         return new KeyHandler();

  842.     }

  843. 

  844.     /**

  845.      * Creates the listener responsible for getting property change

  846.      * events from the selection model.

  847.      */

  848.     protected PropertyChangeListener createSelectionModelPropertyChangeListener() {

  849. 	return new SelectionModelPropertyChangeHandler();

  850.     }

  851. 

  852.     /**

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

  854.      * methods.

  855.      */

  856.     protected TreeSelectionListener createTreeSelectionListener() {

  857. 	return new TreeSelectionHandler();

  858.     }

  859. 

  860.     /**

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

  862.      */

  863.     protected CellEditorListener createCellEditorListener() {

  864. 	return new CellEditorHandler();

  865.     }

  866. 

  867.     /**

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

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

  870.      * when the component moves.

  871.      */

  872.     protected ComponentListener createComponentListener() {

  873. 	return new ComponentHandler();

  874.     }

  875. 

  876.     /**

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

  878.      * when nodes expanded state changes.

  879.      */

  880.     protected TreeExpansionListener createTreeExpansionListener() {

  881. 	return new TreeExpansionHandler();

  882.     }

  883. 

  884.     /**

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

  886.      * well as the size of nodes.

  887.      */

  888.     protected AbstractLayoutCache createLayoutCache() {

  889. 	if(isLargeModel() && getRowHeight() > 0) {

  890. 	    return new FixedHeightLayoutCache();

  891. 	}

  892. 	return new VariableHeightLayoutCache();

  893.     }

  894. 

  895.     /**

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

  897.      */

  898.     protected CellRendererPane createCellRendererPane() {

  899.         return new CellRendererPane();

  900.     }

  901. 

  902.     /**

  903.       * Creates a default cell editor.

  904.       */

  905.     protected TreeCellEditor createDefaultCellEditor() {

  906. 	if(currentCellRenderer != null &&

  907. 	   (currentCellRenderer instanceof DefaultTreeCellRenderer)) {

  908. 	    DefaultTreeCellEditor editor = new DefaultTreeCellEditor

  909. 		        (tree, (DefaultTreeCellRenderer)currentCellRenderer);

  910. 

  911. 	    return editor;

  912. 	}

  913. 	return new DefaultTreeCellEditor(tree, null);

  914.     }

  915. 

  916.     /**

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

  918.       * stamping of each node.

  919.       */

  920.     protected TreeCellRenderer createDefaultCellRenderer() {

  921. 	return new DefaultTreeCellRenderer();

  922.     }

  923. 

  924.     /**

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

  926.      */

  927.     protected TreeModelListener createTreeModelListener() {

  928. 	return new TreeModelHandler();

  929.     }

  930. 

  931.     //

  932.     // Uninstall methods

  933.     //

  934. 

  935.     public void uninstallUI(JComponent c) {

  936. 	completeEditing();

  937. 

  938. 	prepareForUIUninstall();

  939. 

  940. 	uninstallDefaults();

  941. 	uninstallListeners();

  942. 	uninstallKeyboardActions();

  943. 	uninstallComponents();

  944. 

  945. 	completeUIUninstall();

  946.     }

  947. 

  948.     protected void prepareForUIUninstall() {

  949.     }

  950. 

  951.     protected void completeUIUninstall() {

  952. 	if(createdRenderer) {

  953. 	    tree.setCellRenderer(null);

  954. 	}

  955. 	if(createdCellEditor) {

  956. 	    tree.setCellEditor(null);

  957. 	}

  958. 	cellEditor = null;

  959. 	currentCellRenderer = null;

  960. 	rendererPane = null;

  961.         componentListener = null;

  962. 	propertyChangeListener = null;

  963. 	mouseListener = null;

  964. 	focusListener = null;

  965. 	keyListener = null;

  966. 	treeState = null;

  967. 	setSelectionModel(null);

  968. 	drawingCache = null;

  969. 	selectionModelPropertyChangeListener = null;

  970. 	tree = null;

  971. 	treeModel = null;

  972. 	treeSelectionModel = null;

  973. 	treeSelectionListener = null;

  974. 	treeExpansionListener = null;

  975.     }

  976. 

  977.     protected void uninstallDefaults() {

  978.     }

  979. 

  980.     protected void uninstallListeners() {

  981. 	if(componentListener != null) {

  982. 	    tree.removeComponentListener(componentListener);

  983. 	}

  984.         if (propertyChangeListener != null) {

  985. 	    tree.removePropertyChangeListener(propertyChangeListener);

  986. 	}

  987.         if (mouseListener != null) {

  988. 	    tree.removeMouseListener(mouseListener);

  989. 	}

  990.         if (focusListener != null) {

  991. 	    tree.removeFocusListener(focusListener);

  992. 	}

  993.         if (keyListener != null) {

  994. 	    tree.removeKeyListener(keyListener);

  995. 	}

  996. 	if(treeExpansionListener != null) {

  997. 	    tree.removeTreeExpansionListener(treeExpansionListener);

  998. 	}

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

  1000. 	    treeModel.removeTreeModelListener(treeModelListener);

  1001. 	}

  1002. 	if(selectionModelPropertyChangeListener != null &&

  1003. 	   treeSelectionModel != null) {

  1004. 	    treeSelectionModel.removePropertyChangeListener

  1005. 		(selectionModelPropertyChangeListener);

  1006. 	}

  1007. 	if(treeSelectionListener != null && treeSelectionModel != null) {

  1008. 	    treeSelectionModel.removeTreeSelectionListener

  1009. 		               (treeSelectionListener);

  1010. 	}

  1011.     }

  1012. 

  1013.     protected void uninstallKeyboardActions() {

  1014. 	for(int counter = keyActions.size() - 1; counter >= 0; counter--) {

  1015. 	    tree.unregisterKeyboardAction((KeyStroke)keyActions.

  1016. 					  elementAt(counter));

  1017. 	}

  1018. 	keyActions = null;

  1019.     }

  1020. 

  1021.     /**

  1022.      * Uninstalls the renderer pane.

  1023.      */

  1024.     protected void uninstallComponents() {

  1025. 	if(rendererPane != null) {

  1026. 	    tree.remove(rendererPane);

  1027. 	}

  1028.     }

  1029. 

  1030.     //

  1031.     // Painting routines.

  1032.     //

  1033. 

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

  1035. 	if (tree != c) {

  1036. 	    throw new InternalError("incorrect component");

  1037. 	}

  1038. 

  1039. 	// Should never happen if installed for a UI

  1040. 	if(treeState == null) {

  1041. 	    return;

  1042. 	}

  1043. 

  1044. 	Rectangle        paintBounds = g.getClipBounds();

  1045. 	Insets           insets = tree.getInsets();

  1046. 

  1047. 	if(insets == null)

  1048. 	    insets = EMPTY_INSETS;

  1049. 

  1050. 	TreePath         initialPath = getClosestPathForLocation

  1051. 	                               (tree, 0, paintBounds.y);

  1052. 	Enumeration      paintingEnumerator = treeState.getVisiblePathsFrom

  1053. 	                                      (initialPath);

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

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

  1056. 

  1057. 	drawingCache.clear();

  1058. 

  1059. 	if(initialPath != null && paintingEnumerator != null) {

  1060. 	    TreePath   parentPath = initialPath;

  1061. 

  1062. 	    // Draw the lines, knobs, and rows

  1063. 

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

  1065. 	    parentPath = parentPath.getParentPath();

  1066. 	    while(parentPath != null) {

  1067. 		paintVerticalPartOfLeg(g, paintBounds, insets, parentPath);

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

  1069. 		parentPath = parentPath.getParentPath();

  1070. 	    }

  1071. 

  1072. 	    boolean         done = false;

  1073. 	    // Information for the node being rendered.

  1074. 	    boolean         isExpanded;

  1075. 	    boolean         hasBeenExpanded;

  1076. 	    boolean         isLeaf;

  1077. 	    Rectangle       boundsBuffer = new Rectangle();

  1078. 	    Rectangle       bounds;

  1079. 	    TreePath        path;

  1080. 	    boolean         rootVisible = isRootVisible();

  1081. 

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

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

  1084. 		if(path != null) {

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

  1086. 		    if(isLeaf)

  1087. 			isExpanded = hasBeenExpanded = false;

  1088. 		    else {

  1089. 			isExpanded = treeState.getExpandedState(path);

  1090. 			hasBeenExpanded = tree.hasBeenExpanded(path);

  1091. 		    }

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

  1093. 		    if(bounds == null)

  1094. 			// This will only happen if the model changes out

  1095. 			// from under us (usually in another thread).

  1096. 			// Swing isn't multithreaded, but I'll put this

  1097. 			// check in anyway.

  1098. 			return;

  1099. 		    bounds.x += insets.left;

  1100. 		    bounds.y += insets.top;

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

  1102. 		    parentPath = path.getParentPath();

  1103. 		    if(parentPath != null) {

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

  1105. 			    paintVerticalPartOfLeg(g, paintBounds,

  1106. 						   insets, parentPath);

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

  1108. 			}

  1109. 			paintHorizontalPartOfLeg(g, paintBounds, insets,

  1110. 						 bounds, path, row,

  1111. 						 isExpanded,

  1112. 						 hasBeenExpanded, isLeaf);

  1113. 		    }

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

  1115. 			paintHorizontalPartOfLeg(g, paintBounds, insets,

  1116. 						 bounds, path, row,

  1117. 						 isExpanded,

  1118. 						 hasBeenExpanded, isLeaf);

  1119. 		    }

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

  1121. 						hasBeenExpanded, isLeaf)) {

  1122. 			paintExpandControl(g, paintBounds, insets, bounds,

  1123. 					   path, row, isExpanded,

  1124. 					   hasBeenExpanded, isLeaf);

  1125. 		    }

  1126. 		    paintRow(g, paintBounds, insets, bounds, path,

  1127. 				 row, isExpanded, hasBeenExpanded, isLeaf);

  1128. 		    if((bounds.y + bounds.height) >= endY)

  1129. 			done = true;

  1130. 		}

  1131. 		else {

  1132. 		    done = true;

  1133. 		}

  1134. 		row++;

  1135. 	    }

  1136. 	}

  1137.     }

  1138. 

  1139.     /**

  1140.      * Paints the horizontal part of the leg. The reciever should

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

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

  1143.      */

  1144.     protected void paintHorizontalPartOfLeg(Graphics g, Rectangle clipBounds,

  1145. 					    Insets insets, Rectangle bounds,

  1146. 					    TreePath path, int row,

  1147. 					    boolean isExpanded,

  1148. 					    boolean hasBeenExpanded, boolean

  1149. 					    isLeaf) {

  1150. 	int clipLeft = clipBounds.x;

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

  1152. 	int clipTop = clipBounds.y;

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

  1154. 	int lineY = bounds.y + bounds.height / 2;

  1155. 	// Offset leftX from parents indent.

  1156. 	int leftX = bounds.x - totalChildIndent + 8;

  1157. 	int nodeX = bounds.x - getHorizontalLegBuffer();

  1158. 	

  1159. 	if(lineY > clipTop && lineY < clipBottom && nodeX > clipLeft &&

  1160. 	   leftX < clipRight ) {

  1161. 	    leftX = Math.max(leftX, clipLeft);

  1162. 	    nodeX = Math.min(nodeX, clipRight);

  1163. 

  1164. 	    g.setColor(getHashColor());

  1165. 	    paintHorizontalLine(g, tree, lineY, leftX, nodeX);

  1166. 	}

  1167.     }

  1168. 

  1169.     /**

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

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

  1172.      */

  1173.     protected void paintVerticalPartOfLeg(Graphics g, Rectangle clipBounds,

  1174. 					  Insets insets, TreePath path) {

  1175.         int lineX = ((path.getPathCount() - 1 + depthOffset) *

  1176. 		     totalChildIndent) + 8 + insets.left;

  1177. 	int clipLeft = clipBounds.x;

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

  1179. 

  1180. 	if (lineX > clipLeft && lineX < clipRight) {

  1181. 	    int clipTop = clipBounds.y;

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

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

  1184. 	    Rectangle lastChildBounds = getPathBounds(tree,

  1185. 						     getLastChildPath(path));

  1186. 

  1187. 	    if(lastChildBounds == null)

  1188. 		// This shouldn't happen, but if the model is modified

  1189. 		// in another thread it is possible for this to happen.

  1190. 		// Swing isn't multithreaded, but I'll add this check in

  1191. 		// anyway.

  1192. 		return;

  1193. 

  1194. 	    int       top;

  1195. 

  1196. 	    if(parentBounds == null) {

  1197. 		top = Math.max(insets.top + getVerticalLegBuffer(),

  1198. 			       clipTop);

  1199. 	    }

  1200. 	    else

  1201. 		top = Math.max(parentBounds.y + parentBounds.height +

  1202. 			       getVerticalLegBuffer(), clipTop);

  1203. 	    if(path.getPathCount() == 1 && !isRootVisible()) {

  1204. 		TreeModel      model = getModel();

  1205. 

  1206. 		if(model != null) {

  1207. 		    Object        root = model.getRoot();

  1208. 

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

  1210. 			parentBounds = getPathBounds(tree, path.

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

  1212. 			if(parentBounds != null)

  1213. 			    top = Math.max(insets.top + getVerticalLegBuffer(),

  1214. 					   parentBounds.y +

  1215. 					   parentBounds.height / 2);

  1216. 		    }

  1217. 		}

  1218. 	    }

  1219. 

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

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

  1222. 

  1223. 	    g.setColor(getHashColor());

  1224. 	    paintVerticalLine(g, tree, lineX, top, bottom);

  1225. 	}

  1226.     }

  1227. 

  1228.     /**

  1229.      * Paints the expand (toggle) part of a row. The reciever should

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

  1231.      */

  1232.     protected void paintExpandControl(Graphics g,

  1233. 				      Rectangle clipBounds, Insets insets,

  1234. 				      Rectangle bounds, TreePath path,

  1235. 				      int row, boolean isExpanded,

  1236. 				      boolean hasBeenExpanded,

  1237. 				      boolean isLeaf) {

  1238. 	Object       value = path.getLastPathComponent();

  1239. 

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

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

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

  1243. 			treeModel.getChildCount(value) > 0)) {

  1244. 	    int middleXOfKnob = bounds.x - (getRightChildIndent() - 1);

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

  1246. 

  1247. 	    if (isExpanded) {

  1248. 		Icon expandedIcon = getExpandedIcon();

  1249. 		if(expandedIcon != null)

  1250. 		  drawCentered(tree, g, expandedIcon, middleXOfKnob,

  1251. 			       middleYOfKnob );

  1252. 	    }

  1253. 	    else {

  1254. 		Icon collapsedIcon = getCollapsedIcon();

  1255. 		if(collapsedIcon != null)

  1256. 		  drawCentered(tree, g, collapsedIcon, middleXOfKnob,

  1257. 			       middleYOfKnob);

  1258. 	    }

  1259. 	}

  1260.     }

  1261. 

  1262.     /**

  1263.      * Paints the renderer part of a row. The reciever should

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

  1265.      */

  1266.     protected void paintRow(Graphics g, Rectangle clipBounds,

  1267. 			    Insets insets, Rectangle bounds, TreePath path,

  1268. 			    int row, boolean isExpanded,

  1269. 			    boolean hasBeenExpanded, boolean isLeaf) {

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

  1271. 	if(editingComponent != null && editingRow == row)

  1272. 	    return;

  1273. 

  1274. 	int leadIndex;

  1275. 

  1276. 	if(tree.hasFocus()) {

  1277. 	    leadIndex = getLeadRow();

  1278. 	}

  1279. 	else

  1280. 	    leadIndex = -1;

  1281. 

  1282. 	Component component;

  1283. 

  1284. 	component = currentCellRenderer.getTreeCellRendererComponent

  1285. 	              (tree, path.getLastPathComponent(),

  1286. 		       tree.isRowSelected(row), isExpanded, isLeaf, row,

  1287. 		       (leadIndex == row));

  1288. 	

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

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

  1291.     }

  1292. 

  1293.     /**

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

  1295.      * the specified row.

  1296.      */

  1297.     protected boolean shouldPaintExpandControl(TreePath path, int row,

  1298. 					       boolean isExpanded,

  1299. 					       boolean hasBeenExpanded,

  1300. 					       boolean isLeaf) {

  1301. 	if(isLeaf)

  1302. 	    return false;

  1303. 

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

  1305. 

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

  1307. 	   !getShowsRootHandles())

  1308. 	    return false;

  1309. 	return true;

  1310.     }

  1311. 

  1312.     /**

  1313.      * Paints a vertical line.

  1314.      */

  1315.     protected void paintVerticalLine(Graphics g, JComponent c, int x, int top,

  1316. 				    int bottom) {

  1317. 	g.drawLine(x, top, x, bottom);

  1318.     }

  1319. 

  1320.     /**

  1321.      * Paints a horizontal line.

  1322.      */

  1323.     protected void paintHorizontalLine(Graphics g, JComponent c, int y,

  1324. 				      int left, int right) {

  1325. 	g.drawLine(left, y, right, y);

  1326.     }

  1327. 

  1328.     /**

  1329.      * The vertical element of legs between nodes starts at the bottom of the

  1330.      * parent node by default.  This method makes the leg start below that.

  1331.      */

  1332.     protected int getVerticalLegBuffer() {

  1333. 	return 0;

  1334.     } 

  1335. 

  1336.     /**

  1337.      * The horizontal element of legs between nodes starts at the

  1338.      * right of the left-hand side of the child node by default.  This

  1339.      * method makes the leg end before that.

  1340.      */

  1341.     protected int getHorizontalLegBuffer() {

  1342. 	return 0;

  1343.     } 

  1344. 

  1345.     //

  1346.     // Generic painting methods

  1347.     //

  1348. 

  1349.     // Draws the icon centered at (x,y)

  1350.     protected void drawCentered(Component c, Graphics graphics, Icon icon,

  1351. 				int x, int y) {

  1352. 	icon.paintIcon(c, graphics, x - icon.getIconWidth()/2, y -

  1353. 		       icon.getIconHeight()/2);

  1354.     }

  1355. 

  1356.     // This method is slow -- revisit when Java2D is ready.

  1357.     // assumes x1 <= x2

  1358.     protected void drawDashedHorizontalLine(Graphics g, int y, int x1, int x2){

  1359. 	// Drawing only even coordinates helps join line segments so they

  1360. 	// appear as one line.  This can be defeated by translating the

  1361. 	// Graphics by an odd amount.

  1362. 	x1 += (x1 % 2);

  1363. 

  1364. 	for (int x = x1; x <= x2; x+=2) {

  1365. 	    g.drawLine(x, y, x, y);

  1366. 	}

  1367.     }

  1368. 

  1369.     // This method is slow -- revisit when Java2D is ready.

  1370.     // assumes y1 <= y2

  1371.     protected void drawDashedVerticalLine(Graphics g, int x, int y1, int y2) {

  1372. 	// Drawing only even coordinates helps join line segments so they

  1373. 	// appear as one line.  This can be defeated by translating the

  1374. 	// Graphics by an odd amount.

  1375. 	y1 += (y1 % 2);

  1376. 

  1377. 	for (int y = y1; y <= y2; y+=2) {

  1378. 	    g.drawLine(x, y, x, y);

  1379. 	}

  1380.     }

  1381. 

  1382.     //

  1383.     // Various local methods

  1384.     //

  1385. 

  1386.     /**

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

  1388.      * This invokes updateExpandedDescendants with the root path.

  1389.      */

  1390.     protected void updateLayoutCacheExpandedNodes() {

  1391. 	if(treeModel != null)

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

  1393.     }

  1394. 

  1395.     /**

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

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

  1398.      * to the tree state.

  1399.      */

  1400.     protected void updateExpandedDescendants(TreePath path) {

  1401. 	completeEditing();

  1402. 	if(treeState != null) {

  1403. 	    treeState.setExpandedState(path, true);

  1404. 

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

  1406. 

  1407. 	    if(descendants != null) {

  1408. 		while(descendants.hasMoreElements()) {

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

  1410. 		    treeState.setExpandedState(path, true);

  1411. 		}

  1412. 	    }

  1413. 	    updateLeadRow();

  1414. 	    updateSize();

  1415. 	}

  1416.     }

  1417. 

  1418.     /**

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

  1420.      */

  1421.     protected TreePath getLastChildPath(TreePath parent) {

  1422. 	if(treeModel != null) {

  1423. 	    int         childCount = treeModel.getChildCount

  1424. 		(parent.getLastPathComponent());

  1425. 	    

  1426. 	    if(childCount > 0)

  1427. 		return parent.pathByAddingChild(treeModel.getChild

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

  1429. 	}

  1430. 	return null;

  1431.     }

  1432. 

  1433.     /**

  1434.      * Updates how much each depth should be offset by.

  1435.      */

  1436.     protected void updateDepthOffset() {

  1437. 	if(isRootVisible()) {

  1438. 	    if(getShowsRootHandles())

  1439. 		depthOffset = 1;

  1440. 	    else

  1441. 		depthOffset = 0;

  1442. 	}

  1443. 	else if(!getShowsRootHandles())

  1444. 	    depthOffset = -1;

  1445. 	else

  1446. 	    depthOffset = 0;

  1447.     }

  1448. 

  1449.     /** 

  1450.       * Updates the cellEditor based on the editability of the JTree that

  1451.       * we're contained in.  If the tree is editable but doesn't have a

  1452.       * cellEditor, a basic one will be used.

  1453.       */

  1454.     protected void updateCellEditor() {

  1455. 	TreeCellEditor        newEditor;

  1456. 

  1457. 	completeEditing();

  1458. 	if(tree == null)

  1459. 	    newEditor = null;

  1460. 	else {

  1461. 	    if(tree.isEditable()) {

  1462. 		newEditor = tree.getCellEditor();

  1463. 		if(newEditor == null) {

  1464. 		    newEditor = createDefaultCellEditor();

  1465. 		    if(newEditor != null) {

  1466. 			tree.setCellEditor(newEditor);

  1467. 			createdCellEditor = true;

  1468. 		    }

  1469. 		}

  1470. 	    }

  1471. 	    else

  1472. 		newEditor = null;

  1473. 	}

  1474. 	if(newEditor != cellEditor) {

  1475. 	    if(cellEditor != null && cellEditorListener != null)

  1476. 		cellEditor.removeCellEditorListener(cellEditorListener);

  1477. 	    cellEditor = newEditor;

  1478. 	    if(cellEditorListener == null)

  1479. 		cellEditorListener = createCellEditorListener();

  1480. 	    if(newEditor != null && cellEditorListener != null)

  1481. 		newEditor.addCellEditorListener(cellEditorListener);

  1482. 	    createdCellEditor = false;

  1483. 	}

  1484.     }

  1485. 

  1486.     /**

  1487.       * Messaged from the tree we're in when the renderer has changed.

  1488.       */

  1489.     protected void updateRenderer() {

  1490. 	if(tree != null) {

  1491. 	    TreeCellRenderer      newCellRenderer;

  1492. 

  1493. 	    newCellRenderer = tree.getCellRenderer();

  1494. 	    if(newCellRenderer == null) {

  1495. 		tree.setCellRenderer(createDefaultCellRenderer());

  1496. 		createdRenderer = true;

  1497. 	    }

  1498. 	    else {

  1499. 		createdRenderer = false;

  1500. 		currentCellRenderer = newCellRenderer;

  1501. 		if(createdCellEditor) {

  1502. 		    tree.setCellEditor(null);

  1503. 		}

  1504. 	    }

  1505. 	}

  1506. 	else {

  1507. 	    createdRenderer = false;

  1508. 	    currentCellRenderer = null;

  1509. 	}

  1510. 	updateCellEditor();

  1511.     }

  1512. 

  1513.     /**

  1514.      * Resets the TreeState instance based on the tree we're providing the

  1515.      * look and feel for.

  1516.      */

  1517.     protected void configureLayoutCache() {

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

  1519. 	    if(nodeDimensions == null)

  1520. 		nodeDimensions = createNodeDimensions();

  1521. 	    treeState.setNodeDimensions(nodeDimensions);

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

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

  1524. 	    treeState.setSelectionModel(getSelectionModel());

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

  1526. 	    // same model as it currently has.

  1527. 	    if(treeState.getModel() != tree.getModel())

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

  1529. 	    updateLayoutCacheExpandedNodes();

  1530.