home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 144 / DPCS0200.iso / Internet / Supanet / system / swing.jar / javax / swing / plaf / basic / BasicTreeUI.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-11-05  |  35.1 KB  |  1,495 lines

  1. package javax.swing.plaf.basic;
  2.  
  3. import java.awt.Color;
  4. import java.awt.Component;
  5. import java.awt.Dimension;
  6. import java.awt.Graphics;
  7. import java.awt.Insets;
  8. import java.awt.Point;
  9. import java.awt.Rectangle;
  10. import java.awt.event.ComponentListener;
  11. import java.awt.event.FocusListener;
  12. import java.awt.event.InputEvent;
  13. import java.awt.event.KeyListener;
  14. import java.awt.event.MouseEvent;
  15. import java.awt.event.MouseListener;
  16. import java.beans.PropertyChangeListener;
  17. import java.util.Enumeration;
  18. import java.util.Hashtable;
  19. import java.util.Vector;
  20. import javax.swing.Action;
  21. import javax.swing.CellRendererPane;
  22. import javax.swing.Icon;
  23. import javax.swing.JComponent;
  24. import javax.swing.JTree;
  25. import javax.swing.KeyStroke;
  26. import javax.swing.RepaintManager;
  27. import javax.swing.SwingUtilities;
  28. import javax.swing.UIManager;
  29. import javax.swing.event.CellEditorListener;
  30. import javax.swing.event.TreeExpansionListener;
  31. import javax.swing.event.TreeModelListener;
  32. import javax.swing.event.TreeSelectionListener;
  33. import javax.swing.plaf.ComponentUI;
  34. import javax.swing.plaf.TreeUI;
  35. import javax.swing.plaf.UIResource;
  36. import javax.swing.tree.AbstractLayoutCache;
  37. import javax.swing.tree.DefaultTreeCellEditor;
  38. import javax.swing.tree.DefaultTreeCellRenderer;
  39. import javax.swing.tree.FixedHeightLayoutCache;
  40. import javax.swing.tree.TreeCellEditor;
  41. import javax.swing.tree.TreeCellRenderer;
  42. import javax.swing.tree.TreeModel;
  43. import javax.swing.tree.TreePath;
  44. import javax.swing.tree.TreeSelectionModel;
  45. import javax.swing.tree.VariableHeightLayoutCache;
  46.  
  47. public class BasicTreeUI extends TreeUI {
  48.    private static final Insets EMPTY_INSETS = new Insets(0, 0, 0, 0);
  49.    protected transient Icon collapsedIcon;
  50.    protected transient Icon expandedIcon;
  51.    private Color hashColor;
  52.    protected int leftChildIndent;
  53.    protected int rightChildIndent;
  54.    protected int totalChildIndent;
  55.    protected Dimension preferredMinSize;
  56.    protected int lastSelectedRow;
  57.    protected JTree tree;
  58.    protected transient TreeCellRenderer currentCellRenderer;
  59.    protected boolean createdRenderer;
  60.    protected transient TreeCellEditor cellEditor;
  61.    protected boolean createdCellEditor;
  62.    protected boolean stopEditingInCompleteEditing;
  63.    protected CellRendererPane rendererPane;
  64.    protected Dimension preferredSize;
  65.    protected boolean validCachedPreferredSize;
  66.    protected AbstractLayoutCache treeState;
  67.    protected Hashtable drawingCache;
  68.    protected boolean largeModel;
  69.    protected AbstractLayoutCache.NodeDimensions nodeDimensions;
  70.    protected TreeModel treeModel;
  71.    protected TreeSelectionModel treeSelectionModel;
  72.    protected int depthOffset;
  73.    protected Component editingComponent;
  74.    protected TreePath editingPath;
  75.    protected int editingRow;
  76.    protected boolean editorHasDifferentSize;
  77.    private TreePath anchorPath;
  78.    private TreePath leadPath;
  79.    private int leadRow;
  80.    private boolean changeSelectionWithFocus;
  81.    private Vector keyActions;
  82.    private PropertyChangeListener propertyChangeListener;
  83.    private PropertyChangeListener selectionModelPropertyChangeListener;
  84.    private MouseListener mouseListener;
  85.    private FocusListener focusListener;
  86.    private KeyListener keyListener;
  87.    private ComponentListener componentListener;
  88.    private CellEditorListener cellEditorListener;
  89.    private TreeSelectionListener treeSelectionListener;
  90.    private TreeModelListener treeModelListener;
  91.    private TreeExpansionListener treeExpansionListener;
  92.  
  93.    // $FF: synthetic method
  94.    static void access$0(BasicTreeUI var0) {
  95.       var0.updateLeadRow();
  96.    }
  97.  
  98.    // $FF: synthetic method
  99.    static TreePath access$1(BasicTreeUI var0) {
  100.       return var0.leadPath;
  101.    }
  102.  
  103.    // $FF: synthetic method
  104.    static void access$2(BasicTreeUI var0, TreePath var1) {
  105.       var0.setAnchorPath(var1);
  106.    }
  107.  
  108.    // $FF: synthetic method
  109.    static void access$3(BasicTreeUI var0, TreePath var1) {
  110.       var0.setLeadPath(var1);
  111.    }
  112.  
  113.    // $FF: synthetic method
  114.    static TreePath access$4(BasicTreeUI var0) {
  115.       return var0.getLeadPath();
  116.    }
  117.  
  118.    // $FF: synthetic method
  119.    static int access$5(BasicTreeUI var0) {
  120.       return var0.getLeadRow();
  121.    }
  122.  
  123.    // $FF: synthetic method
  124.    static void access$6(BasicTreeUI var0, TreePath var1, boolean var2) {
  125.       var0.setLeadPath(var1, var2);
  126.    }
  127.  
  128.    // $FF: synthetic method
  129.    static void access$7(BasicTreeUI var0, TreePath var1) {
  130.       var0.extendSelection(var1);
  131.    }
  132.  
  133.    // $FF: synthetic method
  134.    static boolean access$8(BasicTreeUI var0) {
  135.       return var0.changeSelectionWithFocus();
  136.    }
  137.  
  138.    // $FF: synthetic method
  139.    static TreePath access$9(BasicTreeUI var0) {
  140.       return var0.getAnchorPath();
  141.    }
  142.  
  143.    public void cancelEditing(JTree var1) {
  144.       if (this.editingComponent != null) {
  145.          this.completeEditing(false, true, false);
  146.       }
  147.  
  148.    }
  149.  
  150.    private boolean changeSelectionWithFocus() {
  151.       return this.changeSelectionWithFocus;
  152.    }
  153.  
  154.    protected void checkForClickInExpandControl(TreePath var1, int var2, int var3) {
  155.       if (this.isLocationInExpandControl(var1, var2, var3)) {
  156.          this.handleExpandControlClick(var1, var2, var3);
  157.       }
  158.  
  159.    }
  160.  
  161.    protected void completeEditing() {
  162.       if (this.tree.getInvokesStopCellEditing() && this.stopEditingInCompleteEditing && this.editingComponent != null) {
  163.          this.cellEditor.stopCellEditing();
  164.       }
  165.  
  166.       this.completeEditing(false, true, false);
  167.    }
  168.  
  169.    protected void completeEditing(boolean var1, boolean var2, boolean var3) {
  170.       if (this.stopEditingInCompleteEditing && this.editingComponent != null) {
  171.          Component var4 = this.editingComponent;
  172.          TreePath var5 = this.editingPath;
  173.          TreeCellEditor var6 = this.cellEditor;
  174.          Object var7 = var6.getCellEditorValue();
  175.          Rectangle var8 = this.getPathBounds(this.tree, this.editingPath);
  176.          boolean var9 = this.tree != null && (this.tree.hasFocus() || SwingUtilities.findFocusOwner(this.editingComponent) != null);
  177.          this.editingComponent = null;
  178.          this.editingPath = null;
  179.          if (var1) {
  180.             var6.stopCellEditing();
  181.          } else if (var2) {
  182.             var6.cancelCellEditing();
  183.          }
  184.  
  185.          this.tree.remove(var4);
  186.          if (this.editorHasDifferentSize) {
  187.             this.treeState.invalidatePathBounds(var5);
  188.             this.updateSize();
  189.          } else {
  190.             var8.x = 0;
  191.             var8.width = this.tree.getSize().width;
  192.             this.tree.repaint(var8);
  193.          }
  194.  
  195.          if (var9) {
  196.             this.tree.requestFocus();
  197.          }
  198.  
  199.          if (var3) {
  200.             this.treeModel.valueForPathChanged(var5, var7);
  201.          }
  202.       }
  203.  
  204.    }
  205.  
  206.    protected void completeUIInstall() {
  207.       this.setShowsRootHandles(this.tree.getShowsRootHandles());
  208.       this.updateRenderer();
  209.       this.updateDepthOffset();
  210.       this.setSelectionModel(this.tree.getSelectionModel());
  211.       this.treeState = this.createLayoutCache();
  212.       this.configureLayoutCache();
  213.       this.updateSize();
  214.    }
  215.  
  216.    protected void completeUIUninstall() {
  217.       if (this.createdRenderer) {
  218.          this.tree.setCellRenderer((TreeCellRenderer)null);
  219.       }
  220.  
  221.       if (this.createdCellEditor) {
  222.          this.tree.setCellEditor((TreeCellEditor)null);
  223.       }
  224.  
  225.       this.cellEditor = null;
  226.       this.currentCellRenderer = null;
  227.       this.rendererPane = null;
  228.       this.componentListener = null;
  229.       this.propertyChangeListener = null;
  230.       this.mouseListener = null;
  231.       this.focusListener = null;
  232.       this.keyListener = null;
  233.       this.treeState = null;
  234.       this.setSelectionModel((TreeSelectionModel)null);
  235.       this.drawingCache = null;
  236.       this.selectionModelPropertyChangeListener = null;
  237.       this.tree = null;
  238.       this.treeModel = null;
  239.       this.treeSelectionModel = null;
  240.       this.treeSelectionListener = null;
  241.       this.treeExpansionListener = null;
  242.    }
  243.  
  244.    protected void configureLayoutCache() {
  245.       if (this.treeState != null && this.tree != null) {
  246.          if (this.nodeDimensions == null) {
  247.             this.nodeDimensions = this.createNodeDimensions();
  248.          }
  249.  
  250.          this.treeState.setNodeDimensions(this.nodeDimensions);
  251.          this.treeState.setRootVisible(this.tree.isRootVisible());
  252.          this.treeState.setRowHeight(this.tree.getRowHeight());
  253.          this.treeState.setSelectionModel(this.getSelectionModel());
  254.          if (this.treeState.getModel() != this.tree.getModel()) {
  255.             this.treeState.setModel(this.tree.getModel());
  256.          }
  257.  
  258.          this.updateLayoutCacheExpandedNodes();
  259.          if (this.isLargeModel()) {
  260.             if (this.componentListener == null) {
  261.                this.componentListener = this.createComponentListener();
  262.                if (this.componentListener != null) {
  263.                   this.tree.addComponentListener(this.componentListener);
  264.                }
  265.             }
  266.          } else if (this.componentListener != null) {
  267.             this.tree.removeComponentListener(this.componentListener);
  268.             this.componentListener = null;
  269.          }
  270.       } else if (this.componentListener != null) {
  271.          this.tree.removeComponentListener(this.componentListener);
  272.          this.componentListener = null;
  273.       }
  274.  
  275.    }
  276.  
  277.    protected CellEditorListener createCellEditorListener() {
  278.       return new CellEditorHandler(this);
  279.    }
  280.  
  281.    protected CellRendererPane createCellRendererPane() {
  282.       return new CellRendererPane();
  283.    }
  284.  
  285.    protected ComponentListener createComponentListener() {
  286.       return new ComponentHandler(this);
  287.    }
  288.  
  289.    protected TreeCellEditor createDefaultCellEditor() {
  290.       if (this.currentCellRenderer != null && this.currentCellRenderer instanceof DefaultTreeCellRenderer) {
  291.          DefaultTreeCellEditor var1 = new DefaultTreeCellEditor(this.tree, (DefaultTreeCellRenderer)this.currentCellRenderer);
  292.          return var1;
  293.       } else {
  294.          return new DefaultTreeCellEditor(this.tree, (DefaultTreeCellRenderer)null);
  295.       }
  296.    }
  297.  
  298.    protected TreeCellRenderer createDefaultCellRenderer() {
  299.       return new DefaultTreeCellRenderer();
  300.    }
  301.  
  302.    protected FocusListener createFocusListener() {
  303.       return new FocusHandler(this);
  304.    }
  305.  
  306.    protected KeyListener createKeyListener() {
  307.       return new KeyHandler(this);
  308.    }
  309.  
  310.    protected AbstractLayoutCache createLayoutCache() {
  311.       return (AbstractLayoutCache)(this.isLargeModel() && this.getRowHeight() > 0 ? new FixedHeightLayoutCache() : new VariableHeightLayoutCache());
  312.    }
  313.  
  314.    protected MouseListener createMouseListener() {
  315.       return new MouseHandler(this);
  316.    }
  317.  
  318.    protected AbstractLayoutCache.NodeDimensions createNodeDimensions() {
  319.       return new NodeDimensionsHandler(this);
  320.    }
  321.  
  322.    protected PropertyChangeListener createPropertyChangeListener() {
  323.       return new PropertyChangeHandler(this);
  324.    }
  325.  
  326.    protected PropertyChangeListener createSelectionModelPropertyChangeListener() {
  327.       return new SelectionModelPropertyChangeHandler(this);
  328.    }
  329.  
  330.    protected TreeExpansionListener createTreeExpansionListener() {
  331.       return new TreeExpansionHandler(this);
  332.    }
  333.  
  334.    protected TreeModelListener createTreeModelListener() {
  335.       return new TreeModelHandler(this);
  336.    }
  337.  
  338.    protected TreeSelectionListener createTreeSelectionListener() {
  339.       return new TreeSelectionHandler(this);
  340.    }
  341.  
  342.    public static ComponentUI createUI(JComponent var0) {
  343.       return new BasicTreeUI();
  344.    }
  345.  
  346.    protected void drawCentered(Component var1, Graphics var2, Icon var3, int var4, int var5) {
  347.       var3.paintIcon(var1, var2, var4 - var3.getIconWidth() / 2, var5 - var3.getIconHeight() / 2);
  348.    }
  349.  
  350.    protected void drawDashedHorizontalLine(Graphics var1, int var2, int var3, int var4) {
  351.       var3 += var3 % 2;
  352.  
  353.       for(int var5 = var3; var5 <= var4; var5 += 2) {
  354.          var1.drawLine(var5, var2, var5, var2);
  355.       }
  356.  
  357.    }
  358.  
  359.    protected void drawDashedVerticalLine(Graphics var1, int var2, int var3, int var4) {
  360.       var3 += var3 % 2;
  361.  
  362.       for(int var5 = var3; var5 <= var4; var5 += 2) {
  363.          var1.drawLine(var2, var5, var2, var5);
  364.       }
  365.  
  366.    }
  367.  
  368.    protected void ensureRowsAreVisible(int var1, int var2) {
  369.       if (this.tree != null && var1 >= 0 && var2 < this.getRowCount(this.tree)) {
  370.          if (var1 == var2) {
  371.             Rectangle var3 = this.getPathBounds(this.tree, this.getPathForRow(this.tree, var1));
  372.             if (var3 != null) {
  373.                var3.width += var3.x;
  374.                var3.x = 0;
  375.                this.tree.scrollRectToVisible(var3);
  376.             }
  377.          } else {
  378.             Rectangle var10 = this.getPathBounds(this.tree, this.getPathForRow(this.tree, var1));
  379.             Rectangle var4 = this.tree.getVisibleRect();
  380.             Rectangle var5 = var10;
  381.             int var6 = var10.y;
  382.             int var7 = var6 + var4.height;
  383.  
  384.             for(int var8 = var1 + 1; var8 <= var2; ++var8) {
  385.                var5 = this.getPathBounds(this.tree, this.getPathForRow(this.tree, var8));
  386.                if (var5.y + var5.height > var7) {
  387.                   var8 = var2;
  388.                }
  389.             }
  390.  
  391.             RepaintManager var9 = RepaintManager.currentManager(this.tree);
  392.             if (var9 != null) {
  393.                var9.validateInvalidComponents();
  394.             }
  395.  
  396.             this.tree.scrollRectToVisible(new Rectangle(var4.x, var6, 1, var5.y + var5.height - var6));
  397.          }
  398.       }
  399.  
  400.    }
  401.  
  402.    private void extendSelection(TreePath var1) {
  403.       TreePath var2 = this.getAnchorPath();
  404.       int var3 = var2 == null ? -1 : this.getRowForPath(this.tree, var2);
  405.       int var4 = this.getRowForPath(this.tree, var1);
  406.       if (var3 == -1) {
  407.          this.tree.setSelectionRow(var4);
  408.       } else {
  409.          if (var3 < var4) {
  410.             this.tree.setSelectionInterval(var3, var4);
  411.          } else {
  412.             this.tree.setSelectionInterval(var4, var3);
  413.          }
  414.  
  415.          this.setAnchorPath(var2);
  416.          this.setLeadPath(var1);
  417.       }
  418.  
  419.    }
  420.  
  421.    private TreePath getAnchorPath() {
  422.       return this.anchorPath;
  423.    }
  424.  
  425.    protected TreeCellEditor getCellEditor() {
  426.       return this.tree != null ? this.tree.getCellEditor() : null;
  427.    }
  428.  
  429.    protected TreeCellRenderer getCellRenderer() {
  430.       return this.currentCellRenderer;
  431.    }
  432.  
  433.    public TreePath getClosestPathForLocation(JTree var1, int var2, int var3) {
  434.       if (var1 != null && this.treeState != null) {
  435.          Insets var4 = ((JComponent)var1).getInsets();
  436.          if (var4 == null) {
  437.             var4 = EMPTY_INSETS;
  438.          }
  439.  
  440.          return this.treeState.getPathClosestTo(var2 - var4.left, var3 - var4.top);
  441.       } else {
  442.          return null;
  443.       }
  444.    }
  445.  
  446.    public Icon getCollapsedIcon() {
  447.       return this.collapsedIcon;
  448.    }
  449.  
  450.    public TreePath getEditingPath(JTree var1) {
  451.       return this.editingPath;
  452.    }
  453.  
  454.    public Icon getExpandedIcon() {
  455.       return this.expandedIcon;
  456.    }
  457.  
  458.    protected Color getHashColor() {
  459.       return this.hashColor;
  460.    }
  461.  
  462.    protected int getHorizontalLegBuffer() {
  463.       return 0;
  464.    }
  465.  
  466.    protected TreePath getLastChildPath(TreePath var1) {
  467.       if (this.treeModel != null) {
  468.          int var2 = this.treeModel.getChildCount(var1.getLastPathComponent());
  469.          if (var2 > 0) {
  470.             return var1.pathByAddingChild(this.treeModel.getChild(var1.getLastPathComponent(), var2 - 1));
  471.          }
  472.       }
  473.  
  474.       return null;
  475.    }
  476.  
  477.    private TreePath getLeadPath() {
  478.       return this.leadPath;
  479.    }
  480.  
  481.    private int getLeadRow() {
  482.       return this.leadRow;
  483.    }
  484.  
  485.    public int getLeftChildIndent() {
  486.       return this.leftChildIndent;
  487.    }
  488.  
  489.    public Dimension getMaximumSize(JComponent var1) {
  490.       if (this.tree != null) {
  491.          return this.getPreferredSize(this.tree);
  492.       } else {
  493.          return this.getPreferredMinSize() != null ? this.getPreferredMinSize() : new Dimension(0, 0);
  494.       }
  495.    }
  496.  
  497.    public Dimension getMinimumSize(JComponent var1) {
  498.       return this.getPreferredMinSize() != null ? this.getPreferredMinSize() : new Dimension(0, 0);
  499.    }
  500.  
  501.    protected TreeModel getModel() {
  502.       return this.treeModel;
  503.    }
  504.  
  505.    public Rectangle getPathBounds(JTree var1, TreePath var2) {
  506.       if (var1 != null && this.treeState != null) {
  507.          Insets var3 = ((JComponent)var1).getInsets();
  508.          Rectangle var4 = this.treeState.getBounds(var2, (Rectangle)null);
  509.          if (var4 != null && var3 != null) {
  510.             var4.x += var3.left;
  511.             var4.y += var3.top;
  512.          }
  513.  
  514.          return var4;
  515.       } else {
  516.          return null;
  517.       }
  518.    }
  519.  
  520.    public TreePath getPathForRow(JTree var1, int var2) {
  521.       return this.treeState != null ? this.treeState.getPathForRow(var2) : null;
  522.    }
  523.  
  524.    public Dimension getPreferredMinSize() {
  525.       return this.preferredMinSize == null ? null : new Dimension(this.preferredMinSize);
  526.    }
  527.  
  528.    public Dimension getPreferredSize(JComponent var1) {
  529.       return this.getPreferredSize(var1, true);
  530.    }
  531.  
  532.    public Dimension getPreferredSize(JComponent var1, boolean var2) {
  533.       Dimension var3 = this.getPreferredMinSize();
  534.       if (!this.validCachedPreferredSize) {
  535.          this.updateCachedPreferredSize();
  536.       }
  537.  
  538.       if (this.tree != null) {
  539.          return var3 != null ? new Dimension(Math.max(var3.width, this.preferredSize.width), Math.max(var3.height, this.preferredSize.height)) : new Dimension(this.preferredSize.width, this.preferredSize.height);
  540.       } else {
  541.          return var3 != null ? var3 : new Dimension(0, 0);
  542.       }
  543.    }
  544.  
  545.    public int getRightChildIndent() {
  546.       return this.rightChildIndent;
  547.    }
  548.  
  549.    public int getRowCount(JTree var1) {
  550.       return this.treeState != null ? this.treeState.getRowCount() : 0;
  551.    }
  552.  
  553.    public int getRowForPath(JTree var1, TreePath var2) {
  554.       return this.treeState != null ? this.treeState.getRowForPath(var2) : -1;
  555.    }
  556.  
  557.    protected int getRowHeight() {
  558.       return this.tree == null ? -1 : this.tree.getRowHeight();
  559.    }
  560.  
  561.    protected TreeSelectionModel getSelectionModel() {
  562.       return this.treeSelectionModel;
  563.    }
  564.  
  565.    protected boolean getShowsRootHandles() {
  566.       return this.tree != null ? this.tree.getShowsRootHandles() : false;
  567.    }
  568.  
  569.    protected int getVerticalLegBuffer() {
  570.       return 0;
  571.    }
  572.  
  573.    protected void handleExpandControlClick(TreePath var1, int var2, int var3) {
  574.       this.toggleExpandState(var1);
  575.    }
  576.  
  577.    protected void installComponents() {
  578.       if ((this.rendererPane = this.createCellRendererPane()) != null) {
  579.          this.tree.add(this.rendererPane);
  580.       }
  581.  
  582.    }
  583.  
  584.    protected void installDefaults() {
  585.       if (this.tree.getBackground() == null || this.tree.getBackground() instanceof UIResource) {
  586.          this.tree.setBackground(UIManager.getColor("Tree.background"));
  587.       }
  588.  
  589.       if (this.getHashColor() == null || this.getHashColor() instanceof UIResource) {
  590.          this.setHashColor(UIManager.getColor("Tree.hash"));
  591.       }
  592.  
  593.       if (this.tree.getFont() == null || this.tree.getFont() instanceof UIResource) {
  594.          this.tree.setFont(UIManager.getFont("Tree.font"));
  595.       }
  596.  
  597.       this.setExpandedIcon((Icon)UIManager.get("Tree.expandedIcon"));
  598.       this.setCollapsedIcon((Icon)UIManager.get("Tree.collapsedIcon"));
  599.       this.setLeftChildIndent((Integer)UIManager.get("Tree.leftChildIndent"));
  600.       this.setRightChildIndent((Integer)UIManager.get("Tree.rightChildIndent"));
  601.       this.changeSelectionWithFocus = (Boolean)UIManager.get("Tree.changeSelectionWithFocus");
  602.    }
  603.  
  604.    protected void installKeyboardActions() {
  605.       boolean var1 = this.changeSelectionWithFocus();
  606.       this.keyActions = new Vector(33);
  607.       this.registerKeyAction(new TreeIncrementAction(this, (1)null, -1, "UP", false, var1), KeyStroke.getKeyStroke(38, 0));
  608.       this.registerKeyAction(new TreeIncrementAction(this, (1)null, -1, "SELECT_UP", true, true), KeyStroke.getKeyStroke(38, 1));
  609.       this.registerKeyAction(new TreeIncrementAction(this, (1)null, 1, "DOWN", false, var1), KeyStroke.getKeyStroke(40, 0));
  610.       this.registerKeyAction(new TreeIncrementAction(this, (1)null, 1, "SELECT_DOWN", true, true), KeyStroke.getKeyStroke(40, 1));
  611.       this.registerKeyAction(new TreeTraverseAction(this, (1)null, 1, "RIGHT", var1), KeyStroke.getKeyStroke(39, 0));
  612.       this.registerKeyAction(new TreeTraverseAction(this, (1)null, -1, "LEFT", var1), KeyStroke.getKeyStroke(37, 0));
  613.       this.registerKeyAction(new TreePageAction(this, (1)null, -1, "P_UP", false, var1), KeyStroke.getKeyStroke(33, 0));
  614.       this.registerKeyAction(new TreePageAction(this, (1)null, -1, "SELECT_P_UP", true, true), KeyStroke.getKeyStroke(33, 1));
  615.       this.registerKeyAction(new TreePageAction(this, (1)null, 1, "P_DOWN", false, var1), KeyStroke.getKeyStroke(34, 0));
  616.       this.registerKeyAction(new TreePageAction(this, (1)null, 1, "SELECT_P_DOWN", true, true), KeyStroke.getKeyStroke(34, 1));
  617.       this.registerKeyAction(new TreeHomeAction(this, (1)null, -1, "HOME", false, var1), KeyStroke.getKeyStroke(36, 0));
  618.       this.registerKeyAction(new TreeHomeAction(this, (1)null, -1, "SELECT_HOME", true, true), KeyStroke.getKeyStroke(36, 1));
  619.       this.registerKeyAction(new TreeHomeAction(this, (1)null, 1, "END", false, var1), KeyStroke.getKeyStroke(35, 0));
  620.       this.registerKeyAction(new TreeHomeAction(this, (1)null, 1, "SELECT_END", true, true), KeyStroke.getKeyStroke(35, 1));
  621.       this.registerKeyAction(new TreeToggleAction(this, "TOGGLE"), KeyStroke.getKeyStroke(10, 0));
  622.       KeyStroke var2 = KeyStroke.getKeyStroke(27, 0);
  623.       this.tree.registerKeyboardAction(new TreeCancelEditingAction(this, "ESCAPE"), var2, 1);
  624.       this.keyActions.addElement(var2);
  625.       this.registerKeyAction(new TreeEditAction(this, "EDIT_NODE"), KeyStroke.getKeyStroke(113, 0));
  626.       TreeSelectAllAction var3 = new TreeSelectAllAction(this, "SELECT_ALL", true);
  627.       this.registerKeyAction(var3, KeyStroke.getKeyStroke(65, 2));
  628.       this.registerKeyAction(var3, KeyStroke.getKeyStroke(47, 2));
  629.       this.registerKeyAction(new TreeSelectAllAction(this, "UNSELECT_ALL", false), KeyStroke.getKeyStroke(92, 2));
  630.       this.registerKeyAction(new TreeAddSelectionAction(this, "SELECT_NODE", false), KeyStroke.getKeyStroke(32, 2));
  631.       this.registerKeyAction(new TreeExtendSelectionAction(this, "EXTEND_SELECTION"), KeyStroke.getKeyStroke(32, 1));
  632.       if (var1) {
  633.          this.registerKeyAction(new TreeHomeAction(this, (1)null, -1, "HOME", false, false), KeyStroke.getKeyStroke(36, 2));
  634.          this.registerKeyAction(new TreeHomeAction(this, (1)null, 1, "END", false, false), KeyStroke.getKeyStroke(35, 2));
  635.          this.registerKeyAction(new TreeIncrementAction(this, (1)null, -1, "UP", false, false), KeyStroke.getKeyStroke(38, 2));
  636.          this.registerKeyAction(new TreeIncrementAction(this, (1)null, 1, "DOWN", false, false), KeyStroke.getKeyStroke(40, 2));
  637.          this.registerKeyAction(new TreePageAction(this, (1)null, 1, "LEAD_P_DOWN", false, false), KeyStroke.getKeyStroke(34, 2));
  638.          this.registerKeyAction(new TreePageAction(this, (1)null, 1, "SELECT_P_DOWN", true, true), KeyStroke.getKeyStroke(34, 3));
  639.          this.registerKeyAction(new TreePageAction(this, (1)null, -1, "LEAD_P_UP", false, false), KeyStroke.getKeyStroke(33, 2));
  640.          this.registerKeyAction(new TreePageAction(this, (1)null, -1, "SELECT_P_UP", true, true), KeyStroke.getKeyStroke(33, 3));
  641.          this.registerKeyAction(new ScrollAction(this.tree, 0, -10), KeyStroke.getKeyStroke(37, 2));
  642.          this.registerKeyAction(new ScrollAction(this.tree, 0, 10), KeyStroke.getKeyStroke(39, 2));
  643.          this.registerKeyAction(new TreeAddSelectionAction(this, "SELECT_NODE", false), KeyStroke.getKeyStroke(32, 0));
  644.       } else {
  645.          this.registerKeyAction(new TreeScrollLRAction(this, 1, "CTRL_P_DOWN", false), KeyStroke.getKeyStroke(34, 2));
  646.          this.registerKeyAction(new TreeScrollLRAction(this, -1, "CTRL_P_UP", false), KeyStroke.getKeyStroke(33, 2));
  647.          this.registerKeyAction(new TreeScrollLRAction(this, -1, "SELECT_CTRL_P_UP", true), KeyStroke.getKeyStroke(33, 3));
  648.          this.registerKeyAction(new TreeScrollLRAction(this, 1, "SELECT_CTRL_P_DOWN", true), KeyStroke.getKeyStroke(34, 3));
  649.          this.registerKeyAction(new TreeAddSelectionAction(this, "SELECT_NODE", true), KeyStroke.getKeyStroke(32, 0));
  650.       }
  651.  
  652.    }
  653.  
  654.    protected void installListeners() {
  655.       if ((this.propertyChangeListener = this.createPropertyChangeListener()) != null) {
  656.          this.tree.addPropertyChangeListener(this.propertyChangeListener);
  657.       }
  658.  
  659.       if ((this.mouseListener = this.createMouseListener()) != null) {
  660.          this.tree.addMouseListener(this.mouseListener);
  661.       }
  662.  
  663.       if ((this.focusListener = this.createFocusListener()) != null) {
  664.          this.tree.addFocusListener(this.focusListener);
  665.       }
  666.  
  667.       if ((this.keyListener = this.createKeyListener()) != null) {
  668.          this.tree.addKeyListener(this.keyListener);
  669.       }
  670.  
  671.       if ((this.treeExpansionListener = this.createTreeExpansionListener()) != null) {
  672.          this.tree.addTreeExpansionListener(this.treeExpansionListener);
  673.       }
  674.  
  675.       if ((this.treeModelListener = this.createTreeModelListener()) != null && this.treeModel != null) {
  676.          this.treeModel.addTreeModelListener(this.treeModelListener);
  677.       }
  678.  
  679.       if ((this.selectionModelPropertyChangeListener = this.createSelectionModelPropertyChangeListener()) != null && this.treeSelectionModel != null) {
  680.          this.treeSelectionModel.addPropertyChangeListener(this.selectionModelPropertyChangeListener);
  681.       }
  682.  
  683.       if ((this.treeSelectionListener = this.createTreeSelectionListener()) != null && this.treeSelectionModel != null) {
  684.          this.treeSelectionModel.addTreeSelectionListener(this.treeSelectionListener);
  685.       }
  686.  
  687.    }
  688.  
  689.    public void installUI(JComponent var1) {
  690.       if (var1 == null) {
  691.          throw new NullPointerException("null component passed to BasicTreeUI.installUI()");
  692.       } else {
  693.          this.tree = (JTree)var1;
  694.          this.prepareForUIInstall();
  695.          this.installDefaults();
  696.          this.installListeners();
  697.          this.installKeyboardActions();
  698.          this.installComponents();
  699.          this.completeUIInstall();
  700.       }
  701.    }
  702.  
  703.    protected boolean isEditable() {
  704.       return this.tree != null ? this.tree.isEditable() : false;
  705.    }
  706.  
  707.    public boolean isEditing(JTree var1) {
  708.       return this.editingComponent != null;
  709.    }
  710.  
  711.    protected boolean isLargeModel() {
  712.       return this.largeModel;
  713.    }
  714.  
  715.    protected boolean isLeaf(int var1) {
  716.       TreePath var2 = this.getPathForRow(this.tree, var1);
  717.       return var2 != null ? this.treeModel.isLeaf(var2.getLastPathComponent()) : true;
  718.    }
  719.  
  720.    protected boolean isLocationInExpandControl(TreePath var1, int var2, int var3) {
  721.       if (var1 != null && !this.treeModel.isLeaf(var1.getLastPathComponent())) {
  722.          Insets var5 = this.tree.getInsets();
  723.          int var4;
  724.          if (this.getExpandedIcon() != null) {
  725.             var4 = this.getExpandedIcon().getIconWidth();
  726.          } else {
  727.             var4 = 8;
  728.          }
  729.  
  730.          int var6 = var5 != null ? var5.left : 0;
  731.          var6 += (var1.getPathCount() + this.depthOffset - 2) * this.totalChildIndent + this.getLeftChildIndent() - var4 / 2;
  732.          int var7 = var6 + var4;
  733.          return var2 >= var6 && var2 <= var7;
  734.       } else {
  735.          return false;
  736.       }
  737.    }
  738.  
  739.    protected boolean isMultiSelectEvent(MouseEvent var1) {
  740.       return SwingUtilities.isLeftMouseButton(var1) && ((InputEvent)var1).isShiftDown();
  741.    }
  742.  
  743.    protected boolean isRootVisible() {
  744.       return this.tree != null ? this.tree.isRootVisible() : false;
  745.    }
  746.  
  747.    protected boolean isToggleEvent(MouseEvent var1) {
  748.       if (!SwingUtilities.isLeftMouseButton(var1)) {
  749.          return false;
  750.       } else {
  751.          byte var2 = 2;
  752.          if (var2 <= 0) {
  753.             return false;
  754.          } else {
  755.             return var1.getClickCount() == var2;
  756.          }
  757.       }
  758.    }
  759.  
  760.    protected boolean isToggleSelectionEvent(MouseEvent var1) {
  761.       return SwingUtilities.isLeftMouseButton(var1) && ((InputEvent)var1).isControlDown();
  762.    }
  763.  
  764.    public void paint(Graphics var1, JComponent var2) {
  765.       if (this.tree != var2) {
  766.          throw new InternalError("incorrect component");
  767.       } else if (this.treeState != null) {
  768.          Rectangle var3 = var1.getClipBounds();
  769.          Insets var4 = this.tree.getInsets();
  770.          if (var4 == null) {
  771.             var4 = EMPTY_INSETS;
  772.          }
  773.  
  774.          TreePath var5 = this.getClosestPathForLocation(this.tree, 0, var3.y);
  775.          Enumeration var6 = this.treeState.getVisiblePathsFrom(var5);
  776.          int var7 = this.treeState.getRowForPath(var5);
  777.          int var8 = var3.y + var3.height;
  778.          this.drawingCache.clear();
  779.          if (var5 != null && var6 != null) {
  780.             for(TreePath var9 = var5.getParentPath(); var9 != null; var9 = var9.getParentPath()) {
  781.                this.paintVerticalPartOfLeg(var1, var3, var4, var9);
  782.                this.drawingCache.put(var9, Boolean.TRUE);
  783.             }
  784.  
  785.             boolean var10 = false;
  786.             Rectangle var14 = new Rectangle();
  787.  
  788.             for(boolean var17 = this.isRootVisible(); !var10 && var6.hasMoreElements(); ++var7) {
  789.                TreePath var16 = (TreePath)var6.nextElement();
  790.                if (var16 != null) {
  791.                   boolean var13 = this.treeModel.isLeaf(var16.getLastPathComponent());
  792.                   boolean var11;
  793.                   boolean var12;
  794.                   if (var13) {
  795.                      var12 = false;
  796.                      var11 = false;
  797.                   } else {
  798.                      var11 = this.treeState.getExpandedState(var16);
  799.                      var12 = this.tree.hasBeenExpanded(var16);
  800.                   }
  801.  
  802.                   Rectangle var15 = this.treeState.getBounds(var16, var14);
  803.                   if (var15 == null) {
  804.                      return;
  805.                   }
  806.  
  807.                   var15.x += var4.left;
  808.                   var15.y += var4.top;
  809.                   TreePath var18 = var16.getParentPath();
  810.                   if (var18 != null) {
  811.                      if (this.drawingCache.get(var18) == null) {
  812.                         this.paintVerticalPartOfLeg(var1, var3, var4, var18);
  813.                         this.drawingCache.put(var18, Boolean.TRUE);
  814.                      }
  815.  
  816.                      this.paintHorizontalPartOfLeg(var1, var3, var4, var15, var16, var7, var11, var12, var13);
  817.                   } else if (var17 && var7 == 0) {
  818.                      this.paintHorizontalPartOfLeg(var1, var3, var4, var15, var16, var7, var11, var12, var13);
  819.                   }
  820.  
  821.                   if (this.shouldPaintExpandControl(var16, var7, var11, var12, var13)) {
  822.                      this.paintExpandControl(var1, var3, var4, var15, var16, var7, var11, var12, var13);
  823.                   }
  824.  
  825.                   this.paintRow(var1, var3, var4, var15, var16, var7, var11, var12, var13);
  826.                   if (var15.y + var15.height >= var8) {
  827.                      var10 = true;
  828.                   }
  829.                } else {
  830.                   var10 = true;
  831.                }
  832.             }
  833.          }
  834.  
  835.       }
  836.    }
  837.  
  838.    protected void paintExpandControl(Graphics var1, Rectangle var2, Insets var3, Rectangle var4, TreePath var5, int var6, boolean var7, boolean var8, boolean var9) {
  839.       Object var10 = var5.getLastPathComponent();
  840.       if (!var9 && (!var8 || this.treeModel.getChildCount(var10) > 0)) {
  841.          int var11 = var4.x - (this.getRightChildIndent() - 1);
  842.          int var12 = var4.y + var4.height / 2;
  843.          if (var7) {
  844.             Icon var13 = this.getExpandedIcon();
  845.             if (var13 != null) {
  846.                this.drawCentered(this.tree, var1, var13, var11, var12);
  847.             }
  848.          } else {
  849.             Icon var14 = this.getCollapsedIcon();
  850.             if (var14 != null) {
  851.                this.drawCentered(this.tree, var1, var14, var11, var12);
  852.             }
  853.          }
  854.       }
  855.  
  856.    }
  857.  
  858.    protected void paintHorizontalLine(Graphics var1, JComponent var2, int var3, int var4, int var5) {
  859.       var1.drawLine(var4, var3, var5, var3);
  860.    }
  861.  
  862.    protected void paintHorizontalPartOfLeg(Graphics var1, Rectangle var2, Insets var3, Rectangle var4, TreePath var5, int var6, boolean var7, boolean var8, boolean var9) {
  863.       int var10 = var2.x;
  864.       int var11 = var2.x + (var2.width - 1);
  865.       int var12 = var2.y;
  866.       int var13 = var2.y + (var2.height - 1);
  867.       int var14 = var4.y + var4.height / 2;
  868.       int var15 = var4.x - this.totalChildIndent + 8;
  869.       int var16 = var4.x - this.getHorizontalLegBuffer();
  870.       if (var14 > var12 && var14 < var13 && var16 > var10 && var15 < var11) {
  871.          var15 = Math.max(var15, var10);
  872.          var16 = Math.min(var16, var11);
  873.          var1.setColor(this.getHashColor());
  874.          this.paintHorizontalLine(var1, this.tree, var14, var15, var16);
  875.       }
  876.  
  877.    }
  878.  
  879.    protected void paintRow(Graphics var1, Rectangle var2, Insets var3, Rectangle var4, TreePath var5, int var6, boolean var7, boolean var8, boolean var9) {
  880.       if (this.editingComponent == null || this.editingRow != var6) {
  881.          int var10;
  882.          if (this.tree.hasFocus()) {
  883.             var10 = this.getLeadRow();
  884.          } else {
  885.             var10 = -1;
  886.          }
  887.  
  888.          Component var11 = this.currentCellRenderer.getTreeCellRendererComponent(this.tree, var5.getLastPathComponent(), this.tree.isRowSelected(var6), var7, var9, var6, var10 == var6);
  889.          this.rendererPane.paintComponent(var1, var11, this.tree, var4.x, var4.y, var4.width, var4.height, true);
  890.       }
  891.    }
  892.  
  893.    protected void paintVerticalLine(Graphics var1, JComponent var2, int var3, int var4, int var5) {
  894.       var1.drawLine(var3, var4, var3, var5);
  895.    }
  896.  
  897.    protected void paintVerticalPartOfLeg(Graphics var1, Rectangle var2, Insets var3, TreePath var4) {
  898.       int var5 = (var4.getPathCount() - 1 + this.depthOffset) * this.totalChildIndent + 8 + var3.left;
  899.       int var6 = var2.x;
  900.       int var7 = var2.x + (var2.width - 1);
  901.       if (var5 > var6 && var5 < var7) {
  902.          int var8 = var2.y;
  903.          int var9 = var2.y + var2.height;
  904.          Rectangle var10 = this.getPathBounds(this.tree, var4);
  905.          Rectangle var11 = this.getPathBounds(this.tree, this.getLastChildPath(var4));
  906.          if (var11 == null) {
  907.             return;
  908.          }
  909.  
  910.          int var12;
  911.          if (var10 == null) {
  912.             var12 = Math.max(var3.top + this.getVerticalLegBuffer(), var8);
  913.          } else {
  914.             var12 = Math.max(var10.y + var10.height + this.getVerticalLegBuffer(), var8);
  915.          }
  916.  
  917.          if (var4.getPathCount() == 1 && !this.isRootVisible()) {
  918.             TreeModel var13 = this.getModel();
  919.             if (var13 != null) {
  920.                Object var14 = var13.getRoot();
  921.                if (var13.getChildCount(var14) > 0) {
  922.                   var10 = this.getPathBounds(this.tree, var4.pathByAddingChild(var13.getChild(var14, 0)));
  923.                   if (var10 != null) {
  924.                      var12 = Math.max(var3.top + this.getVerticalLegBuffer(), var10.y + var10.height / 2);
  925.                   }
  926.                }
  927.             }
  928.          }
  929.  
  930.          int var16 = Math.min(var11.y + var11.height / 2, var9);
  931.          var1.setColor(this.getHashColor());
  932.          this.paintVerticalLine(var1, this.tree, var5, var12, var16);
  933.       }
  934.  
  935.    }
  936.  
  937.    protected void pathWasCollapsed(TreePath var1) {
  938.       if (this.tree != null) {
  939.          this.tree.fireTreeCollapsed(var1);
  940.       }
  941.  
  942.    }
  943.  
  944.    protected void pathWasExpanded(TreePath var1) {
  945.       if (this.tree != null) {
  946.          this.tree.fireTreeExpanded(var1);
  947.       }
  948.  
  949.    }
  950.  
  951.    protected void prepareForUIInstall() {
  952.       this.drawingCache = new Hashtable(7);
  953.       this.stopEditingInCompleteEditing = true;
  954.       this.lastSelectedRow = -1;
  955.       this.leadPath = this.anchorPath = null;
  956.       this.leadRow = -1;
  957.       this.preferredSize = new Dimension();
  958.       this.tree.setRowHeight(UIManager.getInt("Tree.rowHeight"));
  959.       Object var1 = UIManager.get("Tree.scrollsOnExpand");
  960.       if (var1 != null) {
  961.          this.tree.setScrollsOnExpand((Boolean)var1);
  962.       }
  963.  
  964.       this.largeModel = this.tree.isLargeModel();
  965.       if (this.getRowHeight() <= 0) {
  966.          this.largeModel = false;
  967.       }
  968.  
  969.       this.setModel(this.tree.getModel());
  970.    }
  971.  
  972.    protected void prepareForUIUninstall() {
  973.    }
  974.  
  975.    private void registerKeyAction(Action var1, KeyStroke var2) {
  976.       this.keyActions.addElement(var2);
  977.       this.tree.registerKeyboardAction(var1, var2, 0);
  978.    }
  979.  
  980.    protected void selectPathForEvent(TreePath var1, MouseEvent var2) {
  981.       if (this.isToggleSelectionEvent(var2)) {
  982.          if (this.tree.isPathSelected(var1)) {
  983.             this.tree.removeSelectionPath(var1);
  984.          } else {
  985.             this.tree.addSelectionPath(var1);
  986.          }
  987.  
  988.          this.lastSelectedRow = this.getRowForPath(this.tree, var1);
  989.          this.setAnchorPath(var1);
  990.          this.setLeadPath(var1);
  991.       } else if (this.isMultiSelectEvent(var2)) {
  992.          TreePath var3 = this.getAnchorPath();
  993.          int var4 = var3 == null ? -1 : this.getRowForPath(this.tree, var3);
  994.          if (var4 == -1) {
  995.             this.tree.setSelectionPath(var1);
  996.          } else {
  997.             int var5 = this.getRowForPath(this.tree, var1);
  998.             if (var5 < var4) {
  999.                this.tree.setSelectionInterval(var5, var4);
  1000.             } else {
  1001.                this.tree.setSelectionInterval(var4, var5);
  1002.             }
  1003.  
  1004.             this.lastSelectedRow = var5;
  1005.             this.setAnchorPath(var3);
  1006.          }
  1007.       } else if (SwingUtilities.isLeftMouseButton(var2)) {
  1008.          this.tree.setSelectionPath(var1);
  1009.          if (this.isToggleEvent(var2)) {
  1010.             this.toggleExpandState(var1);
  1011.          }
  1012.       }
  1013.  
  1014.    }
  1015.  
  1016.    private void setAnchorPath(TreePath var1) {
  1017.       this.anchorPath = var1;
  1018.    }
  1019.  
  1020.    protected void setCellEditor(TreeCellEditor var1) {
  1021.       this.updateCellEditor();
  1022.    }
  1023.  
  1024.    protected void setCellRenderer(TreeCellRenderer var1) {
  1025.       this.completeEditing();
  1026.       this.updateRenderer();
  1027.       if (this.treeState != null) {
  1028.          this.treeState.invalidateSizes();
  1029.          this.updateSize();
  1030.       }
  1031.  
  1032.    }
  1033.  
  1034.    public void setCollapsedIcon(Icon var1) {
  1035.       this.collapsedIcon = var1;
  1036.    }
  1037.  
  1038.    protected void setEditable(boolean var1) {
  1039.       this.updateCellEditor();
  1040.    }
  1041.  
  1042.    public void setExpandedIcon(Icon var1) {
  1043.       this.expandedIcon = var1;
  1044.    }
  1045.  
  1046.    protected void setHashColor(Color var1) {
  1047.       this.hashColor = var1;
  1048.    }
  1049.  
  1050.    protected void setLargeModel(boolean var1) {
  1051.       if (this.getRowHeight() < 1) {
  1052.          var1 = false;
  1053.       }
  1054.  
  1055.       if (this.largeModel != var1) {
  1056.          this.completeEditing();
  1057.          this.largeModel = var1;
  1058.          this.treeState = this.createLayoutCache();
  1059.          this.configureLayoutCache();
  1060.          this.updateLayoutCacheExpandedNodes();
  1061.          this.updateSize();
  1062.       }
  1063.  
  1064.    }
  1065.  
  1066.    private void setLeadPath(TreePath var1) {
  1067.       this.setLeadPath(var1, false);
  1068.    }
  1069.  
  1070.    private void setLeadPath(TreePath var1, boolean var2) {
  1071.       Rectangle var3 = var2 ? this.getPathBounds(this.tree, this.leadPath) : null;
  1072.       this.leadPath = var1;
  1073.       this.leadRow = this.getRowForPath(this.tree, this.leadPath);
  1074.       if (var2) {
  1075.          if (var3 != null) {
  1076.             this.tree.repaint(var3);
  1077.          }
  1078.  
  1079.          var3 = this.getPathBounds(this.tree, this.leadPath);
  1080.          if (var3 != null) {
  1081.             this.tree.repaint(var3);
  1082.          }
  1083.       }
  1084.  
  1085.    }
  1086.  
  1087.    public void setLeftChildIndent(int var1) {
  1088.       this.leftChildIndent = var1;
  1089.       this.totalChildIndent = this.leftChildIndent + this.rightChildIndent;
  1090.       if (this.treeState != null) {
  1091.          this.treeState.invalidateSizes();
  1092.       }
  1093.  
  1094.       this.updateSize();
  1095.    }
  1096.  
  1097.    protected void setModel(TreeModel var1) {
  1098.       this.completeEditing();
  1099.       if (this.treeModel != null && this.treeModelListener != null) {
  1100.          this.treeModel.removeTreeModelListener(this.treeModelListener);
  1101.       }
  1102.  
  1103.       this.treeModel = var1;
  1104.       if (this.treeModel != null && this.treeModelListener != null) {
  1105.          this.treeModel.addTreeModelListener(this.treeModelListener);
  1106.       }
  1107.  
  1108.       if (this.treeState != null) {
  1109.          this.treeState.setModel(var1);
  1110.          this.updateLayoutCacheExpandedNodes();
  1111.          this.updateSize();
  1112.       }
  1113.  
  1114.    }
  1115.  
  1116.    public void setPreferredMinSize(Dimension var1) {
  1117.       this.preferredMinSize = var1;
  1118.    }
  1119.  
  1120.    public void setRightChildIndent(int var1) {
  1121.       this.rightChildIndent = var1;
  1122.       this.totalChildIndent = this.leftChildIndent + this.rightChildIndent;
  1123.       if (this.treeState != null) {
  1124.          this.treeState.invalidateSizes();
  1125.       }
  1126.  
  1127.       this.updateSize();
  1128.    }
  1129.  
  1130.    protected void setRootVisible(boolean var1) {
  1131.       this.completeEditing();
  1132.       this.updateDepthOffset();
  1133.       if (this.treeState != null) {
  1134.          this.treeState.setRootVisible(var1);
  1135.          this.treeState.invalidateSizes();
  1136.          this.updateSize();
  1137.       }
  1138.  
  1139.    }
  1140.  
  1141.    protected void setRowHeight(int var1) {
  1142.       this.completeEditing();
  1143.       if (this.treeState != null) {
  1144.          this.setLargeModel(this.tree.isLargeModel());
  1145.          this.treeState.setRowHeight(var1);
  1146.          this.updateSize();
  1147.       }
  1148.  
  1149.    }
  1150.  
  1151.    protected void setSelectionModel(TreeSelectionModel var1) {
  1152.       this.completeEditing();
  1153.       if (this.selectionModelPropertyChangeListener != null && this.treeSelectionModel != null) {
  1154.          this.treeSelectionModel.removePropertyChangeListener(this.selectionModelPropertyChangeListener);
  1155.       }
  1156.  
  1157.       if (this.treeSelectionListener != null && this.treeSelectionModel != null) {
  1158.          this.treeSelectionModel.removeTreeSelectionListener(this.treeSelectionListener);
  1159.       }
  1160.  
  1161.       this.treeSelectionModel = var1;
  1162.       if (this.treeSelectionModel != null) {
  1163.          if (this.selectionModelPropertyChangeListener != null) {
  1164.             this.treeSelectionModel.addPropertyChangeListener(this.selectionModelPropertyChangeListener);
  1165.          }
  1166.  
  1167.          if (this.treeSelectionListener != null) {
  1168.             this.treeSelectionModel.addTreeSelectionListener(this.treeSelectionListener);
  1169.          }
  1170.  
  1171.          if (this.treeState != null) {
  1172.             this.treeState.setSelectionModel(this.treeSelectionModel);
  1173.          }
  1174.       } else if (this.treeState != null) {
  1175.          this.treeState.setSelectionModel((TreeSelectionModel)null);
  1176.       }
  1177.  
  1178.       if (this.tree != null) {
  1179.          this.tree.repaint();
  1180.       }
  1181.  
  1182.    }
  1183.  
  1184.    protected void setShowsRootHandles(boolean var1) {
  1185.       this.completeEditing();
  1186.       this.updateDepthOffset();
  1187.       if (this.treeState != null) {
  1188.          this.treeState.invalidateSizes();
  1189.          this.updateSize();
  1190.       }
  1191.  
  1192.    }
  1193.  
  1194.    protected boolean shouldPaintExpandControl(TreePath var1, int var2, boolean var3, boolean var4, boolean var5) {
  1195.       if (var3) {
  1196.          return true;
  1197.       } else if (var5) {
  1198.          return false;
  1199.       } else {
  1200.          int var6 = var1.getPathCount() - 1;
  1201.          return this.getShowsRootHandles() || var6 != 0 && (var6 != 1 || this.isRootVisible());
  1202.       }
  1203.    }
  1204.  
  1205.    protected boolean startEditing(TreePath var1, MouseEvent var2) {
  1206.       this.completeEditing();
  1207.       if (this.cellEditor != null && this.tree.isPathEditable(var1)) {
  1208.          int var3 = this.getRowForPath(this.tree, var1);
  1209.          this.editingComponent = this.cellEditor.getTreeCellEditorComponent(this.tree, var1.getLastPathComponent(), this.tree.isPathSelected(var1), this.tree.isExpanded(var1), this.treeModel.isLeaf(var1.getLastPathComponent()), var3);
  1210.          if (this.cellEditor.isCellEditable(var2)) {
  1211.             Rectangle var4 = this.getPathBounds(this.tree, var1);
  1212.             this.editingRow = var3;
  1213.             Dimension var5 = this.editingComponent.getPreferredSize();
  1214.             if (var5.height != var4.height && this.getRowHeight() > 0) {
  1215.                var5.height = this.getRowHeight();
  1216.             }
  1217.  
  1218.             if (var5.width == var4.width && var5.height == var4.height) {
  1219.                this.editorHasDifferentSize = false;
  1220.             } else {
  1221.                this.editorHasDifferentSize = true;
  1222.                this.treeState.invalidatePathBounds(var1);
  1223.                this.updateSize();
  1224.             }
  1225.  
  1226.             this.tree.add(this.editingComponent);
  1227.             this.editingComponent.setBounds(var4.x, var4.y, var5.width, var5.height);
  1228.             this.editingPath = var1;
  1229.             this.editingComponent.validate();
  1230.             Rectangle var6 = this.tree.getVisibleRect();
  1231.             this.tree.paintImmediately(var4.x, var4.y, var6.width + var6.x - var4.x, var5.height);
  1232.             if (this.cellEditor.shouldSelectCell(var2)) {
  1233.                this.stopEditingInCompleteEditing = false;
  1234.  
  1235.                try {
  1236.                   this.tree.setSelectionRow(var3);
  1237.                } catch (Exception var8) {
  1238.                   System.err.println("Editing exception: " + var8);
  1239.                }
  1240.  
  1241.                this.stopEditingInCompleteEditing = true;
  1242.             }
  1243.  
  1244.             if (var2 != null && var2 instanceof MouseEvent) {
  1245.                Point var7 = SwingUtilities.convertPoint(this.tree, new Point(var2.getX(), var2.getY()), this.editingComponent);
  1246.                new MouseInputHandler(this, this.tree, SwingUtilities.getDeepestComponentAt(this.editingComponent, var7.x, var7.y), var2);
  1247.             }
  1248.  
  1249.             return true;
  1250.          }
  1251.  
  1252.          this.editingComponent = null;
  1253.       }
  1254.  
  1255.       return false;
  1256.    }
  1257.  
  1258.    public void startEditingAtPath(JTree var1, TreePath var2) {
  1259.       var1.scrollPathToVisible(var2);
  1260.       if (var2 != null && var1.isVisible(var2)) {
  1261.          this.startEditing(var2, (MouseEvent)null);
  1262.       }
  1263.  
  1264.    }
  1265.  
  1266.    public boolean stopEditing(JTree var1) {
  1267.       if (this.editingComponent != null && this.cellEditor.stopCellEditing()) {
  1268.          this.completeEditing(false, false, true);
  1269.          return true;
  1270.       } else {
  1271.          return false;
  1272.       }
  1273.    }
  1274.  
  1275.    protected void toggleExpandState(TreePath var1) {
  1276.       if (!this.tree.isExpanded(var1)) {
  1277.          int var2 = this.getRowForPath(this.tree, var1);
  1278.          this.tree.expandPath(var1);
  1279.          this.updateSize();
  1280.          if (var2 != -1) {
  1281.             if (this.tree.getScrollsOnExpand()) {
  1282.                this.ensureRowsAreVisible(var2, var2 + this.treeState.getVisibleChildCount(var1));
  1283.             } else {
  1284.                this.ensureRowsAreVisible(var2, var2);
  1285.             }
  1286.          }
  1287.       } else {
  1288.          this.tree.collapsePath(var1);
  1289.          this.updateSize();
  1290.       }
  1291.  
  1292.    }
  1293.  
  1294.    protected void uninstallComponents() {
  1295.       if (this.rendererPane != null) {
  1296.          this.tree.remove(this.rendererPane);
  1297.       }
  1298.  
  1299.    }
  1300.  
  1301.    protected void uninstallDefaults() {
  1302.    }
  1303.  
  1304.    protected void uninstallKeyboardActions() {
  1305.       for(int var1 = this.keyActions.size() - 1; var1 >= 0; --var1) {
  1306.          this.tree.unregisterKeyboardAction((KeyStroke)this.keyActions.elementAt(var1));
  1307.       }
  1308.  
  1309.       this.keyActions = null;
  1310.    }
  1311.  
  1312.    protected void uninstallListeners() {
  1313.       if (this.componentListener != null) {
  1314.          this.tree.removeComponentListener(this.componentListener);
  1315.       }
  1316.  
  1317.       if (this.propertyChangeListener != null) {
  1318.          this.tree.removePropertyChangeListener(this.propertyChangeListener);
  1319.       }
  1320.  
  1321.       if (this.mouseListener != null) {
  1322.          this.tree.removeMouseListener(this.mouseListener);
  1323.       }
  1324.  
  1325.       if (this.focusListener != null) {
  1326.          this.tree.removeFocusListener(this.focusListener);
  1327.       }
  1328.  
  1329.       if (this.keyListener != null) {
  1330.          this.tree.removeKeyListener(this.keyListener);
  1331.       }
  1332.  
  1333.       if (this.treeExpansionListener != null) {
  1334.          this.tree.addTreeExpansionListener(this.treeExpansionListener);
  1335.       }
  1336.  
  1337.       if (this.treeModel != null && this.treeModelListener != null) {
  1338.          this.treeModel.removeTreeModelListener(this.treeModelListener);
  1339.       }
  1340.  
  1341.       if (this.selectionModelPropertyChangeListener != null && this.treeSelectionModel != null) {
  1342.          this.treeSelectionModel.removePropertyChangeListener(this.selectionModelPropertyChangeListener);
  1343.       }
  1344.  
  1345.       if (this.treeSelectionListener != null && this.treeSelectionModel != null) {
  1346.          this.treeSelectionModel.removeTreeSelectionListener(this.treeSelectionListener);
  1347.       }
  1348.  
  1349.    }
  1350.  
  1351.    public void uninstallUI(JComponent var1) {
  1352.       this.completeEditing();
  1353.       this.prepareForUIUninstall();
  1354.       this.uninstallDefaults();
  1355.       this.uninstallListeners();
  1356.       this.uninstallKeyboardActions();
  1357.       this.uninstallComponents();
  1358.       this.completeUIUninstall();
  1359.    }
  1360.  
  1361.    protected void updateCachedPreferredSize() {
  1362.       if (this.treeState != null) {
  1363.          Insets var1 = this.tree.getInsets();
  1364.          if (this.isLargeModel()) {
  1365.             Rectangle var2 = this.tree.getVisibleRect();
  1366.             if (var1 != null) {
  1367.                var2.x -= var1.left;
  1368.                var2.y -= var1.top;
  1369.             }
  1370.  
  1371.             this.preferredSize.width = this.treeState.getPreferredWidth(var2);
  1372.          } else {
  1373.             this.preferredSize.width = this.treeState.getPreferredWidth((Rectangle)null);
  1374.          }
  1375.  
  1376.          this.preferredSize.height = this.treeState.getPreferredHeight();
  1377.          if (var1 != null) {
  1378.             Dimension var10000 = this.preferredSize;
  1379.             var10000.width += var1.left + var1.right;
  1380.             var10000 = this.preferredSize;
  1381.             var10000.height += var1.top + var1.bottom;
  1382.          }
  1383.       }
  1384.  
  1385.       this.validCachedPreferredSize = true;
  1386.    }
  1387.  
  1388.    protected void updateCellEditor() {
  1389.       this.completeEditing();
  1390.       TreeCellEditor var1;
  1391.       if (this.tree == null) {
  1392.          var1 = null;
  1393.       } else if (this.tree.isEditable()) {
  1394.          var1 = this.tree.getCellEditor();
  1395.          if (var1 == null) {
  1396.             var1 = this.createDefaultCellEditor();
  1397.             if (var1 != null) {
  1398.                this.tree.setCellEditor(var1);
  1399.                this.createdCellEditor = true;
  1400.             }
  1401.          }
  1402.       } else {
  1403.          var1 = null;
  1404.       }
  1405.  
  1406.       if (var1 != this.cellEditor) {
  1407.          if (this.cellEditor != null && this.cellEditorListener != null) {
  1408.             this.cellEditor.removeCellEditorListener(this.cellEditorListener);
  1409.          }
  1410.  
  1411.          this.cellEditor = var1;
  1412.          if (this.cellEditorListener == null) {
  1413.             this.cellEditorListener = this.createCellEditorListener();
  1414.          }
  1415.  
  1416.          if (var1 != null && this.cellEditorListener != null) {
  1417.             var1.addCellEditorListener(this.cellEditorListener);
  1418.          }
  1419.  
  1420.          this.createdCellEditor = false;
  1421.       }
  1422.  
  1423.    }
  1424.  
  1425.    protected void updateDepthOffset() {
  1426.       if (this.isRootVisible()) {
  1427.          if (this.getShowsRootHandles()) {
  1428.             this.depthOffset = 1;
  1429.          } else {
  1430.             this.depthOffset = 0;
  1431.          }
  1432.       } else if (!this.getShowsRootHandles()) {
  1433.          this.depthOffset = -1;
  1434.       } else {
  1435.          this.depthOffset = 0;
  1436.       }
  1437.  
  1438.    }
  1439.  
  1440.    protected void updateExpandedDescendants(TreePath var1) {
  1441.       this.completeEditing();
  1442.       if (this.treeState != null) {
  1443.          this.treeState.setExpandedState(var1, true);
  1444.          Enumeration var2 = this.tree.getExpandedDescendants(var1);
  1445.          if (var2 != null) {
  1446.             while(var2.hasMoreElements()) {
  1447.                var1 = (TreePath)var2.nextElement();
  1448.                this.treeState.setExpandedState(var1, true);
  1449.             }
  1450.          }
  1451.  
  1452.          this.updateLeadRow();
  1453.          this.updateSize();
  1454.       }
  1455.  
  1456.    }
  1457.  
  1458.    protected void updateLayoutCacheExpandedNodes() {
  1459.       if (this.treeModel != null) {
  1460.          this.updateExpandedDescendants(new TreePath(this.treeModel.getRoot()));
  1461.       }
  1462.  
  1463.    }
  1464.  
  1465.    private void updateLeadRow() {
  1466.       this.leadRow = this.getRowForPath(this.tree, this.leadPath);
  1467.    }
  1468.  
  1469.    protected void updateRenderer() {
  1470.       if (this.tree != null) {
  1471.          TreeCellRenderer var1 = this.tree.getCellRenderer();
  1472.          if (var1 == null) {
  1473.             this.tree.setCellRenderer(this.createDefaultCellRenderer());
  1474.             this.createdRenderer = true;
  1475.          } else {
  1476.             this.createdRenderer = false;
  1477.             this.currentCellRenderer = var1;
  1478.             if (this.createdCellEditor) {
  1479.                this.tree.setCellEditor((TreeCellEditor)null);
  1480.             }
  1481.          }
  1482.       } else {
  1483.          this.createdRenderer = false;
  1484.          this.currentCellRenderer = null;
  1485.       }
  1486.  
  1487.       this.updateCellEditor();
  1488.    }
  1489.  
  1490.    protected void updateSize() {
  1491.       this.validCachedPreferredSize = false;
  1492.       this.tree.treeDidChange();
  1493.    }
  1494. }
  1495.