PC Plus SuperCD (UK) 2000 March/pcp161a.iso/handson/files/copyjava.exe/com/sun/java/swing/plaf/basic/BasicTreeUI.class

Java Class File | 1998-02-26 | 30.3 KB | 1,352 lines

package com.sun.java.swing.plaf.basic;

import com.sun.java.swing.Action;
import com.sun.java.swing.CellRendererPane;
import com.sun.java.swing.Icon;
import com.sun.java.swing.JComponent;
import com.sun.java.swing.JTree;
import com.sun.java.swing.KeyStroke;
import com.sun.java.swing.SwingUtilities;
import com.sun.java.swing.UIManager;
import com.sun.java.swing.event.CellEditorListener;
import com.sun.java.swing.event.ChangeEvent;
import com.sun.java.swing.event.TreeSelectionEvent;
import com.sun.java.swing.plaf.ComponentUI;
import com.sun.java.swing.plaf.UIResource;
import com.sun.java.swing.tree.DefaultMutableTreeNode;
import com.sun.java.swing.tree.TreeCellEditor;
import com.sun.java.swing.tree.TreeCellRenderer;
import com.sun.java.swing.tree.TreeModel;
import com.sun.java.swing.tree.TreePath;
import com.sun.java.swing.tree.TreeSelectionModel;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.EventObject;
import java.util.Vector;

public class BasicTreeUI extends AbstractTreeUI implements CellEditorListener, FocusListener, KeyListener, MouseListener, PropertyChangeListener {
   private static final int LEFT_CHILD_INDENT = 7;
   private static final int RIGHT_CHILD_INDENT = 13;
   private static final Insets EMPTY_INSETS = new Insets(0, 0, 0, 0);
   protected transient Icon collapsedIcon;
   protected transient Icon expandedIcon;
   private Color hashColor;
   protected int leftChildIndent;
   protected int rightChildIndent;
   protected int totalChildIndent;
   protected Dimension preferredMinSize;
   protected int lastSelectedRow;
   protected JTree tree;
   protected transient TreeCellRenderer currentCellRenderer;
   protected boolean createdRenderer;
   protected transient TreeCellEditor cellEditor;
   protected boolean createdCellEditor;
   protected Component editingComponent;
   protected TreePath editingPath;
   protected Action repeatKeyAction;
   protected boolean isKeyDown;
   protected boolean stopEditingInCompleteEditing;
   protected CellRendererPane rendererPane;
   protected Dimension cPreferredSize;
   protected boolean validCachedPreferredSize;
   protected transient ComponentAdapter componentListener;
   protected Vector drawingCache;
   private PropertyChangeListener propertyChangeListener;
   private MouseListener mouseListener;
   private FocusListener focusListener;
   private KeyListener keyListener;

   public static ComponentUI createUI(JComponent var0) {
      return new BasicTreeUI();
   }

   protected Color getHashColor() {
      return this.hashColor;
   }

   protected void setHashColor(Color var1) {
      this.hashColor = var1;
   }

   public void setLeftChildIndent(int var1) {
      this.leftChildIndent = var1;
      this.totalChildIndent = this.leftChildIndent + this.rightChildIndent;
   }

   public int getLeftChildIndent() {
      return this.leftChildIndent;
   }

   public void setRightChildIndent(int var1) {
      this.rightChildIndent = var1;
      this.totalChildIndent = this.leftChildIndent + this.rightChildIndent;
   }

   public int getRightChildIndent() {
      return this.rightChildIndent;
   }

   public void setExpandedIcon(Icon var1) {
      this.expandedIcon = var1;
   }

   public Icon getExpandedIcon() {
      return this.expandedIcon;
   }

   public void setCollapsedIcon(Icon var1) {
      this.collapsedIcon = var1;
   }

   public Icon getCollapsedIcon() {
      return this.collapsedIcon;
   }

   public void setLargeModel(boolean var1) {
      if (var1 && this.tree != null && this.componentListener == null) {
         this.componentListener = new 1(this);
         this.tree.addComponentListener(this.componentListener);
      } else if (!var1 && this.tree != null && this.componentListener != null) {
         this.tree.removeComponentListener(this.componentListener);
         this.componentListener = null;
      }

      super.setLargeModel(var1);
   }

   public void installUI(JComponent var1) {
      if (var1 == null) {
         throw new NullPointerException("null component passed to BasicTreeUI.installUI()");
      } else {
         this.tree = (JTree)var1;
         this.drawingCache = new Vector();
         this.stopEditingInCompleteEditing = true;
         this.lastSelectedRow = -1;
         this.setLeftChildIndent(7);
         this.setRightChildIndent(13);
         this.cPreferredSize = new Dimension();
         if ((this.rendererPane = this.createCellRendererPane(var1)) != null) {
            this.tree.add(this.rendererPane);
         }

         this.installDefaults(var1);
         this.installListeners(var1);
         this.installKeyboardActions(var1);
         ((AbstractTreeUI)this).setRowHeight(this.tree.getRowHeight());
         ((AbstractTreeUI)this).setRootVisible(this.tree.isRootVisible());
         ((AbstractTreeUI)this).setShowsRootHandles(this.tree.getShowsRootHandles());
         this.setModel(this.tree.getModel());
         this.setSelectionModel(this.tree.getSelectionModel());
         this.setLargeModel(this.tree.isLargeModel());
         this.updateRenderer();
         this.validCachedPreferredSize = false;
      }
   }

   protected void installDefaults(JComponent var1) {
      if (((Component)var1).getBackground() == null || ((Component)var1).getBackground() instanceof UIResource) {
         ((Component)var1).setBackground(UIManager.getColor("Tree.background"));
      }

      if (this.getHashColor() == null || this.getHashColor() instanceof UIResource) {
         this.setHashColor(UIManager.getColor("Tree.hash"));
      }

      this.setExpandedIcon((Icon)UIManager.get("Tree.expandedIcon"));
      this.setCollapsedIcon((Icon)UIManager.get("Tree.collapsedIcon"));
   }

   protected void installListeners(JComponent var1) {
      if ((this.propertyChangeListener = this.createPropertyChangeListener(var1)) != null) {
         var1.addPropertyChangeListener(this.propertyChangeListener);
      }

      if ((this.mouseListener = this.createMouseListener(var1)) != null) {
         ((Component)var1).addMouseListener(this.mouseListener);
      }

      if ((this.focusListener = this.createFocusListener(var1)) != null) {
         ((Component)var1).addFocusListener(this.focusListener);
      }

      if ((this.keyListener = this.createKeyListener(var1)) != null) {
         ((Component)var1).addKeyListener(this.keyListener);
      }

   }

   protected PropertyChangeListener createPropertyChangeListener(JComponent var1) {
      return this;
   }

   protected MouseListener createMouseListener(JComponent var1) {
      return this;
   }

   protected FocusListener createFocusListener(JComponent var1) {
      return this;
   }

   protected KeyListener createKeyListener(JComponent var1) {
      return this;
   }

   protected CellRendererPane createCellRendererPane(JComponent var1) {
      return new CellRendererPane();
   }

   public void uninstallUI(JComponent var1) {
      this.completeEditing();
      this.tree.remove(this.rendererPane);
      this.uninstallDefaults(var1);
      this.uninstallListeners(var1);
      this.uninstallKeyboardActions(var1);
      this.checkConsistency();
      if (this.createdRenderer) {
         this.tree.setCellRenderer((TreeCellRenderer)null);
      }

      if (this.createdCellEditor) {
         this.tree.setCellEditor((TreeCellEditor)null);
      }

      this.rendererPane = null;
      this.componentListener = null;
      this.propertyChangeListener = null;
      this.mouseListener = null;
      this.focusListener = null;
      this.keyListener = null;
      this.setSelectionModel((TreeSelectionModel)null);
      this.setModel((TreeModel)null);
      this.tree = null;
      this.drawingCache = null;
   }

   protected void uninstallDefaults(JComponent var1) {
   }

   protected void uninstallListeners(JComponent var1) {
      if (this.componentListener != null) {
         this.tree.removeComponentListener(this.componentListener);
      }

      if (this.propertyChangeListener != null) {
         var1.removePropertyChangeListener(this.propertyChangeListener);
      }

      if (this.mouseListener != null) {
         ((Component)var1).removeMouseListener(this.mouseListener);
      }

      if (this.focusListener != null) {
         ((Component)var1).removeFocusListener(this.focusListener);
      }

      if (this.keyListener != null) {
         ((Component)var1).removeKeyListener(this.keyListener);
      }

   }

   public void propertyChange(PropertyChangeEvent var1) {
      if (((EventObject)var1).getSource() == this.tree) {
         String var2 = var1.getPropertyName();
         this.completeEditing();
         if (var2.equals("cellRenderer")) {
            this.updateRenderer();
            this.tree.repaint();
            return;
         }

         if (var2.equals("treeModel")) {
            this.setModel((TreeModel)var1.getNewValue());
            return;
         }

         if (var2.equals("rootVisible")) {
            ((AbstractTreeUI)this).setRootVisible((Boolean)var1.getNewValue());
            this.tree.repaint();
            return;
         }

         if (var2.equals("showsRootHandles")) {
            ((AbstractTreeUI)this).setShowsRootHandles((Boolean)var1.getNewValue());
            this.tree.repaint();
            return;
         }

         if (var2.equals("rowHeight")) {
            ((AbstractTreeUI)this).setRowHeight((Integer)var1.getNewValue());
            return;
         }

         if (var2.equals("cellEditor")) {
            this.updateCellEditor();
            return;
         }

         if (var2.equals("editable")) {
            this.updateCellEditor();
            return;
         }

         if (var2.equals("largeModel")) {
            this.setLargeModel(this.tree.isLargeModel());
            return;
         }

         if (var2.equals("selectionModel")) {
            this.setSelectionModel(this.tree.getSelectionModel());
            return;
         }
      } else if (((EventObject)var1).getSource() == super.treeSelectionModel) {
         super.treeSelectionModel.resetRowSelection();
      }

   }

   protected void installKeyboardActions(JComponent var1) {
      var1.registerKeyboardAction(new TreeIncrementAction(this, -1, "UP"), KeyStroke.getKeyStroke(38, 0), 0);
      var1.registerKeyboardAction(new TreeIncrementAction(this, 1, "DOWN"), KeyStroke.getKeyStroke(40, 0), 0);
      var1.registerKeyboardAction(new TreeTraverseAction(this, 1, "RIGHT"), KeyStroke.getKeyStroke(39, 0), 0);
      var1.registerKeyboardAction(new TreeTraverseAction(this, -1, "LEFT"), KeyStroke.getKeyStroke(37, 0), 0);
      var1.registerKeyboardAction(new TreePageAction(this, -1, "P_UP"), KeyStroke.getKeyStroke(33, 0), 0);
      var1.registerKeyboardAction(new TreePageAction(this, 1, "P_DOWN"), KeyStroke.getKeyStroke(34, 0), 0);
      var1.registerKeyboardAction(new TreeHomeAction(this, -1, "HOME"), KeyStroke.getKeyStroke(36, 0), 0);
      var1.registerKeyboardAction(new TreeHomeAction(this, 1, "END"), KeyStroke.getKeyStroke(35, 0), 0);
      var1.registerKeyboardAction(new TreeToggleAction(this, "TOGGLE"), KeyStroke.getKeyStroke(10, 0), 0);
   }

   protected void uninstallKeyboardActions(JComponent var1) {
      var1.unregisterKeyboardAction(KeyStroke.getKeyStroke(38, 0));
      var1.unregisterKeyboardAction(KeyStroke.getKeyStroke(40, 0));
      var1.unregisterKeyboardAction(KeyStroke.getKeyStroke(37, 0));
      var1.unregisterKeyboardAction(KeyStroke.getKeyStroke(39, 0));
      var1.unregisterKeyboardAction(KeyStroke.getKeyStroke(33, 0));
      var1.unregisterKeyboardAction(KeyStroke.getKeyStroke(34, 0));
      var1.unregisterKeyboardAction(KeyStroke.getKeyStroke(36, 0));
      var1.unregisterKeyboardAction(KeyStroke.getKeyStroke(35, 0));
      var1.unregisterKeyboardAction(KeyStroke.getKeyStroke(10, 0));
   }

   protected void updateCellEditor() {
      this.completeEditing();
      TreeCellEditor var1;
      if (this.tree == null) {
         var1 = null;
      } else if (this.tree.isEditable()) {
         var1 = this.tree.getCellEditor();
         if (var1 == null) {
            var1 = this.createDefaultCellEditor();
            if (var1 != null) {
               this.tree.setCellEditor(var1);
               this.createdCellEditor = true;
            }
         }
      } else {
         var1 = null;
      }

      if (var1 != this.cellEditor) {
         if (this.cellEditor != null) {
            this.cellEditor.removeCellEditorListener(this);
         }

         this.cellEditor = var1;
         if (var1 != null) {
            var1.addCellEditorListener(this);
         }

         this.createdCellEditor = false;
      }

   }

   protected void updateRenderer() {
      TreeCellRenderer var1 = this.tree.getCellRenderer();
      if (var1 == null && this.tree != null) {
         this.tree.setCellRenderer(this.createDefaultCellRenderer());
         this.createdRenderer = true;
      } else {
         this.createdRenderer = false;
         this.currentCellRenderer = var1;
         if (!super.largeModel) {
            this.updateNodeSizes(true);
         }

         if (this.createdCellEditor && this.tree != null) {
            this.tree.setCellEditor((TreeCellEditor)null);
         }
      }

      this.updateCellEditor();
   }

   public boolean checkConsistency() {
      if (this.tree != null && super.updateNodeSizes) {
         if (!super.largeModel) {
            this.updateNodeSizes(true);
         }

         return true;
      } else {
         return false;
      }
   }

   public void updateNodeSizes(boolean var1) {
      super.updateNodeSizes(var1);
      this.validCachedPreferredSize = false;
   }

   protected TreeCellEditor createDefaultCellEditor() {
      return this.currentCellRenderer != null && this.currentCellRenderer instanceof BasicTreeCellRenderer ? new BasicTreeCellEditor((BasicTreeCellRenderer)this.currentCellRenderer) : new BasicTreeCellEditor((BasicTreeCellRenderer)null);
   }

   public TreeCellRenderer createDefaultCellRenderer() {
      return new BasicTreeCellRenderer();
   }

   public int getXOriginOfNode(VisibleTreeNode var1) {
      int var2 = var1.getVisibleLevel();
      if (((AbstractTreeUI)this).getShowsRootHandles()) {
         ++var2;
      }

      return this.totalChildIndent * var2;
   }

   public Dimension getSizeOfNode(VisibleTreeNode var1, int var2) {
      Object var3 = null;
      if (this.currentCellRenderer != null) {
         Component var4 = this.currentCellRenderer.getTreeCellRendererComponent(this.tree, var1.getValue(), false, var1.isExpanded(), var1.isLeaf(), var2, false);
         if (this.tree != null) {
            this.rendererPane.add(var4);
            var4.validate();
            return var4.getPreferredSize();
         } else {
            return var4.getPreferredSize();
         }
      } else {
         return new Dimension(0, 0);
      }
   }

   protected Rectangle getLargeBoundsOf(LargeTreeModelNode var1, int var2, Object var3) {
      return this.getLargeBoundsOf(var1, var2, var3, (Component)null, (Rectangle[])null);
   }

   protected Rectangle getLargeBoundsOf(LargeTreeModelNode var1, int var2, Object var3, Component var4, Rectangle[] var5) {
      Rectangle var6;
      if (var5 == null) {
         var6 = new Rectangle();
      } else {
         var6 = var5[0];
      }

      int var7;
      if (var1 == null) {
         var7 = 0;
      } else {
         var7 = var1.getVisibleLevel() + 1;
         if (((AbstractTreeUI)this).getShowsRootHandles()) {
            ++var7;
         }
      }

      var6.x = this.totalChildIndent * var7;
      var6.y = var2 * super.rowHeight;
      var6.height = super.rowHeight;
      if (var4 == null) {
         if (this.currentCellRenderer != null) {
            Component var8 = this.currentCellRenderer.getTreeCellRendererComponent(this.tree, var3, false, false, false, var2, false);
            if (this.tree != null) {
               this.rendererPane.add(var8);
               var8.validate();
            }

            Dimension var9 = var8.getPreferredSize();
            var6.width = var9.width;
         } else {
            var6.width = 0;
         }
      } else {
         Dimension var10 = var4.getPreferredSize();
         var6.width = var10.width;
      }

      return var6;
   }

   protected void updateCachedPreferredSize() {
      if (!super.largeModel) {
         int var1 = ((AbstractTreeUI)this).getRowCount();
         int var2;
         if (var1 > 0) {
            if (!((AbstractTreeUI)this).isFixedRowHeight()) {
               VisibleTreeNode var3 = ((AbstractTreeUI)this).getNode(var1 - 1);
               var2 = var3.getYOrigin() + var3.getPreferredSize().height;
            } else {
               var2 = ((AbstractTreeUI)this).getRowHeight() * var1;
            }
         } else {
            var2 = 0;
         }

         this.cPreferredSize.height = var2;
         this.cPreferredSize.width = ((AbstractTreeUI)this).getMaxNodeWidth();
      } else if (this.tree != null) {
         int var8 = 0;
         Rectangle var4 = this.tree.getVisibleRect();
         int var6 = ((AbstractTreeUI)this).getRowContainingYLocation(var4.y);
         int var7 = ((AbstractTreeUI)this).getRowContainingYLocation(var4.y + var4.height);
         if (var6 != -1 && var6 != -1) {
            for(; var6 <= var7; ++var6) {
               Rectangle var5 = ((AbstractTreeUI)this).getRowBounds(var6);
               if (var5 != null) {
                  var8 = Math.max(var8, var5.x + var5.width);
               }
            }
         }

         this.cPreferredSize.width = var8;
         this.cPreferredSize.height = ((AbstractTreeUI)this).getRowCount() * ((AbstractTreeUI)this).getRowHeight();
      } else {
         this.cPreferredSize.width = this.cPreferredSize.height = 0;
      }

      this.validCachedPreferredSize = true;
   }

   public void visibleNodesChanged() {
      if (this.tree != null) {
         this.validCachedPreferredSize = false;
         this.tree.treeDidChange();
      }

   }

   protected void pathWasExpanded(TreePath var1) {
      if (this.tree != null) {
         this.tree.fireTreeExpanded(var1);
      }

   }

   protected void pathWasCollapsed(TreePath var1) {
      if (this.tree != null) {
         this.tree.fireTreeCollapsed(var1);
      }

   }

   public void ensureRowsAreVisible(int var1, int var2) {
      if (this.tree != null && var1 >= 0 && var2 < ((AbstractTreeUI)this).getRowCount()) {
         if (var1 == var2) {
            this.tree.scrollRectToVisible(((AbstractTreeUI)this).getRowBounds(var1));
            return;
         }

         Rectangle var3 = ((AbstractTreeUI)this).getRowBounds(var1);
         Rectangle var4 = var3;
         int var5 = var3.y;
         int var6 = var3.x + var3.width;
         int var7 = var3.x;
         int var8 = this.tree.getVisibleRect().height;

         for(int var9 = var1 + 1; var9 < var2; ++var9) {
            var4 = ((AbstractTreeUI)this).getRowBounds(var9);
            if (var4.width + var4.x > var6) {
               var6 = var4.width + var4.x;
            }

            if (var4.x < var7) {
               var7 = var4.x;
            }

            if (var4.y + var4.height - var5 > var8) {
               var9 = var2;
            }
         }

         this.tree.scrollRectToVisible(new Rectangle(var7, var5, var6 - var7, var4.y + var4.height - var5));
      }

   }

   public void scrollPathToVisible(TreePath var1) {
      ((AbstractTreeUI)this).makeVisible(var1);
      Rectangle var2 = ((AbstractTreeUI)this).getPathBounds(var1);
      if (var2 != null && this.tree != null) {
         this.tree.scrollRectToVisible(var2);
      }

   }

   public void scrollRowToVisible(int var1) {
      Rectangle var2 = ((AbstractTreeUI)this).getRowBounds(var1);
      if (var2 != null && this.tree != null) {
         this.tree.scrollRectToVisible(var2);
      }

   }

   public TreeCellRenderer getCellRenderer() {
      return this.currentCellRenderer;
   }

   protected LargeTreeModelNode createExpandedNodeForValue(Object var1, int var2) {
      return new BasicLargeTreeModelNode(this, var1, var2);
   }

   public void paint(Graphics var1, JComponent var2) {
      if (this.tree != var2) {
         throw new InternalError("incorrect component");
      } else {
         this.checkConsistency();
         this.getCellRenderer();
         this.tree.getBackground();
         ((Component)var2).getSize();
         Rectangle var3 = var1.getClipBounds();
         int var4 = ((AbstractTreeUI)this).getRowContainingYLocation(var3.y);
         int var5 = ((AbstractTreeUI)this).getRowContainingYLocation(var3.y + var3.height);
         boolean var6 = var4 > -1 && var5 > -1;
         if (var6 && super.largeModel) {
            int[] var14 = new int[1];
            if (((AbstractTreeUI)this).isRootVisible()) {
               var14[0] = 0;
               ((BasicLargeTreeModelNode)super.largeRoot).paintAll(new BasicTreeUIPaintInfo(this, var1), var14, var4, var5, 0, this);
            } else {
               var14[0] = -1;
               ((BasicLargeTreeModelNode)super.largeRoot).paintAll(new BasicTreeUIPaintInfo(this, var1), var14, var4, var5, -1, this);
            }
         } else {
            if (var6) {
               var1.setColor(this.getHashColor());
               VisibleTreeNode var7 = ((AbstractTreeUI)this).getNode(var4);

               for(VisibleTreeNode var8 = (VisibleTreeNode)((DefaultMutableTreeNode)var7).getParent(); var8 != null; var8 = (VisibleTreeNode)((DefaultMutableTreeNode)var8).getParent()) {
                  VisibleTreeNode var9 = (VisibleTreeNode)((DefaultMutableTreeNode)var8).getLastChild();
                  this.drawVerticalPartOfLeg(var1, var2, var8.getVisibleLevel(), this.getNodeY(var8), this.getNodeY(var9), this.getNodeHeight(var8), this.getNodeHeight(var9));
                  this.drawingCache.addElement(var8);
               }

               for(int var16 = var4; var16 <= var5; ++var16) {
                  var7 = ((AbstractTreeUI)this).getNode(var16);
                  VisibleTreeNode var15 = (VisibleTreeNode)((DefaultMutableTreeNode)var7).getParent();
                  if (var15 != null && !this.drawingCache.contains(var15)) {
                     VisibleTreeNode var10 = (VisibleTreeNode)((DefaultMutableTreeNode)var15).getLastChild();
                     this.drawVerticalPartOfLeg(var1, var2, var15.getVisibleLevel(), this.getNodeY(var15), this.getNodeY(var10), this.getNodeHeight(var15), this.getNodeHeight(var10));
                     this.drawingCache.addElement(var15);
                  }

                  if (var15 != null) {
                     this.drawHorizontalPartOfLeg(var1, var2, this.getNodeY(var7) + this.getNodeHeight(var7) / 2, this.getNodeX(var15) + 8, this.getNodeX(var7));
                  }

                  int var17 = this.getNodeX(var7);
                  int var11 = this.getNodeY(var7);
                  int var12 = this.getNodeHeight(var7);
                  if (this.shouldPaintExpandControl(var15, var7)) {
                     this.paintExpandControl(var1, var2, var15, var7, var17, var11, var12, var16);
                  }

                  this.paintRow(var1, var2, var15, var7, var17, var11, var12, var16);
               }

               this.drawingCache.removeAllElements();
            }

         }
      }
   }

   protected boolean shouldPaintExpandControl(VisibleTreeNode var1, VisibleTreeNode var2) {
      boolean var3 = true;
      if (((DefaultMutableTreeNode)var2).getLevel() == 0 && !((AbstractTreeUI)this).getShowsRootHandles() || ((DefaultMutableTreeNode)var2).getLevel() == 1 && !((AbstractTreeUI)this).isRootVisible() && !((AbstractTreeUI)this).getShowsRootHandles()) {
         var3 = false;
      }

      return var3;
   }

   protected int getNodeX(VisibleTreeNode var1) {
      int var2 = ((AbstractTreeUI)this).getShowsRootHandles() ? 1 : 0;
      return (var1.getVisibleLevel() + var2) * this.totalChildIndent;
   }

   protected int getNodeY(VisibleTreeNode var1) {
      return var1.getYOrigin();
   }

   protected int getNodeHeight(VisibleTreeNode var1) {
      return ((AbstractTreeUI)this).isFixedRowHeight() ? ((AbstractTreeUI)this).getRowHeight() : var1.getPreferredSize().height;
   }

   public void drawVerticalPartOfLeg(Graphics var1, JComponent var2, int var3, int var4, int var5, int var6, int var7) {
      int var8 = ((AbstractTreeUI)this).getShowsRootHandles() ? 1 : 0;
      int var9 = (var3 + var8) * this.totalChildIndent + 8;
      Rectangle var10 = var1.getClipBounds();
      int var11 = var10.x;
      int var12 = var10.x + (var10.width - 1);
      if (var9 > var11 && var9 < var12) {
         int var13 = var10.y;
         int var14 = var10.y + var10.height;
         int var15 = Math.max(var4 + var6 + this.getVerticalLegBuffer(), var13);
         int var16 = Math.min(var5 + var7 / 2, var14);
         var1.setColor(this.getHashColor());
         this.drawVerticalLine(var1, var2, var9, var15, var16);
      }

   }

   protected int getVerticalLegBuffer() {
      return 0;
   }

   protected int getHorizontalLegBuffer() {
      return 0;
   }

   protected void drawVerticalLine(Graphics var1, JComponent var2, int var3, int var4, int var5) {
      var1.drawLine(var3, var4, var3, var5);
   }

   public void drawHorizontalPartOfLeg(Graphics var1, JComponent var2, int var3, int var4, int var5) {
      Rectangle var6 = var1.getClipBounds();
      int var7 = var6.x;
      int var8 = var6.x + (var6.width - 1);
      int var9 = var6.y;
      int var10 = var6.y + (var6.height - 1);
      var5 -= this.getHorizontalLegBuffer();
      if (var3 > var9 && var3 < var10 && var5 > var7 && var4 < var8) {
         var4 = Math.max(var4, var7);
         var5 = Math.min(var5, var8);
         var1.setColor(this.getHashColor());
         this.drawHorizontalLine(var1, var2, var3, var4, var5);
      }

   }

   protected void drawHorizontalLine(Graphics var1, JComponent var2, int var3, int var4, int var5) {
      var1.drawLine(var4, var3, var5, var3);
   }

   protected void paintRow(Graphics var1, JComponent var2, VisibleTreeNode var3, VisibleTreeNode var4, int var5, int var6, int var7, int var8) {
      int var9 = -1;
      if (this.tree.hasFocus()) {
         var9 = this.tree.getLeadSelectionRow();
      }

      Component var10 = this.getCellRenderer().getTreeCellRendererComponent(this.tree, var4.getValue(), ((AbstractTreeUI)this).isSelectedIndex(var8), var4.isExpanded(), var4.isLeaf(), var8, var9 == var8);
      this.rendererPane.paintComponent(var1, var10, this.tree, var5, var6, var4.getPreferredSize().width, var7, true);
   }

   protected void paintExpandControl(Graphics var1, JComponent var2, VisibleTreeNode var3, VisibleTreeNode var4, int var5, int var6, int var7, int var8) {
      if (!var4.isLeaf() && (!var4.hasBeenExpanded() || var4.getModelChildCount() > 0)) {
         int var9 = var5 - (this.getRightChildIndent() - 1);
         int var10 = var6 + var7 / 2;
         if (var4.isExpanded()) {
            Icon var11 = this.getExpandedIcon();
            if (var11 != null) {
               this.drawCentered(var2, var1, var11, var9, var10);
               return;
            }
         } else {
            Icon var12 = this.getCollapsedIcon();
            if (var12 != null) {
               this.drawCentered(var2, var1, var12, var9, var10);
            }
         }
      }

   }

   protected void drawCentered(Component var1, Graphics var2, Icon var3, int var4, int var5) {
      var3.paintIcon(var1, var2, var4 - var3.getIconWidth() / 2, var5 - var3.getIconHeight() / 2);
   }

   protected void drawDashedHorizontalLine(Graphics var1, int var2, int var3, int var4) {
      var3 += var3 % 2;

      for(int var5 = var3; var5 <= var4; var5 += 2) {
         var1.drawLine(var5, var2, var5, var2);
      }

   }

   protected void drawDashedVerticalLine(Graphics var1, int var2, int var3, int var4) {
      var3 += var3 % 2;

      for(int var5 = var3; var5 <= var4; var5 += 2) {
         var1.drawLine(var2, var5, var2, var5);
      }

   }

   public void setPreferredMinSize(Dimension var1) {
      this.preferredMinSize = var1;
   }

   public Dimension getPreferredMinSize() {
      return this.preferredMinSize;
   }

   public Dimension getPreferredSize(JComponent var1) {
      return this.getPreferredSize(var1, true);
   }

   public Dimension getPreferredSize(JComponent var1, boolean var2) {
      Dimension var3 = this.getPreferredMinSize();
      if (var2) {
         this.checkConsistency();
      }

      if (!this.validCachedPreferredSize) {
         this.updateCachedPreferredSize();
      }

      if (this.tree != null) {
         return var3 != null ? new Dimension(Math.max(var3.width, this.cPreferredSize.width), Math.max(var3.height, this.cPreferredSize.height)) : new Dimension(this.cPreferredSize.width, this.cPreferredSize.height);
      } else {
         return var3 != null ? var3 : new Dimension(0, 0);
      }
   }

   public Dimension getMinimumSize(JComponent var1) {
      return this.getPreferredMinSize() != null ? this.getPreferredMinSize() : new Dimension(0, 0);
   }

   public Dimension getMaximumSize(JComponent var1) {
      if (this.tree != null) {
         return this.getPreferredSize(this.tree);
      } else {
         return this.getPreferredMinSize() != null ? this.getPreferredMinSize() : new Dimension(0, 0);
      }
   }

   public void valueChanged(TreeSelectionEvent var1) {
      this.completeEditing();
      super.valueChanged(var1);
      this.lastSelectedRow = ((AbstractTreeUI)this).getMinSelectionRow();
      TreePath[] var2 = var1.getPaths();
      Rectangle var4 = this.tree.getVisibleRect();
      boolean var5 = true;
      int var6 = this.tree.getSize().width;
      if (var2 != null) {
         int var8 = var2.length;
         if (var8 > 4) {
            this.tree.repaint();
            var5 = false;
         } else {
            for(int var7 = 0; var7 < var8; ++var7) {
               Rectangle var3 = ((AbstractTreeUI)this).getPathBounds(var2[var7]);
               if (var3 != null && var4.intersects(var3)) {
                  this.tree.repaint(0, var3.y, var6, var3.height);
               }
            }
         }
      }

      if (var5) {
         Rectangle var9 = ((AbstractTreeUI)this).getPathBounds(var1.getOldLeadSelectionPath());
         if (var9 != null && var4.intersects(var9)) {
            this.tree.repaint(0, var9.y, var6, var9.height);
         }

         var9 = ((AbstractTreeUI)this).getPathBounds(var1.getNewLeadSelectionPath());
         if (var9 != null && var4.intersects(var9)) {
            this.tree.repaint(0, var9.y, var6, var9.height);
         }
      }

   }

   public void editingStopped(ChangeEvent var1) {
      this.completeEditing(false, false, true);
   }

   public void editingCanceled(ChangeEvent var1) {
      this.completeEditing(false, false, false);
   }

   public boolean isEditing() {
      return this.editingComponent != null;
   }

   public boolean stopEditing() {
      if (this.editingComponent != null && this.cellEditor.stopCellEditing()) {
         this.completeEditing(false, false, true);
         return true;
      } else {
         return false;
      }
   }

   public void cancelEditing() {
      if (this.editingComponent != null) {
         this.completeEditing(false, true, false);
      }

   }

   protected void completeEditing() {
      if (this.tree.getInvokesStopCellEditing() && this.stopEditingInCompleteEditing && this.editingComponent != null) {
         this.cellEditor.stopCellEditing();
      }

      this.completeEditing(false, true, false);
   }

   protected void completeEditing(boolean var1, boolean var2, boolean var3) {
      if (this.stopEditingInCompleteEditing && this.editingComponent != null) {
         Component var4 = this.editingComponent;
         TreePath var5 = this.editingPath;
         TreeCellEditor var6 = this.cellEditor;
         Object var7 = var6.getCellEditorValue();
         Rectangle var8 = ((AbstractTreeUI)this).getPathBounds(this.editingPath);
         this.editingComponent = null;
         this.editingPath = null;
         if (var1) {
            var6.stopCellEditing();
         } else if (var2) {
            var6.cancelCellEditing();
         }

         this.tree.remove(var4);
         var8.x = 0;
         var8.width = this.tree.getSize().width;
         this.tree.repaint(var8);
         if (var3) {
            super.treeModel.valueForPathChanged(var5, var7);
         }
      }

   }

   public void startEditingAtPath(TreePath var1) {
      this.scrollPathToVisible(var1);
      if (var1 != null && ((AbstractTreeUI)this).isVisible(var1)) {
         this.startEditing(var1, (MouseEvent)null);
      }

   }

   protected boolean startEditing(TreePath var1, MouseEvent var2) {
      this.completeEditing();
      if (this.cellEditor != null && this.tree.isPathEditable(var1)) {
         int var3 = ((AbstractTreeUI)this).getRowForPath(var1);
         this.editingComponent = this.cellEditor.getTreeCellEditorComponent(this.tree, var1.getLastPathComponent(), ((AbstractTreeUI)this).isPathSelected(var1), ((AbstractTreeUI)this).isExpanded(var1), super.treeModel.isLeaf(var1.getLastPathComponent()), var3);
         if (this.cellEditor.isCellEditable(var2)) {
            Rectangle var4 = ((AbstractTreeUI)this).getPathBounds(var1);
            if (this.editingComponent.getFont() == null) {
               this.editingComponent.setFont(this.tree.getFont());
            }

            this.editingComponent.getPreferredSize();
            this.tree.add(this.editingComponent);
            this.editingComponent.setBounds(var4.x, var4.y, var4.width, var4.height);
            this.editingPath = var1;
            this.editingComponent.validate();
            this.tree.paintImmediately(var4.x, var4.y, var4.width, var4.height);
            if (this.cellEditor.shouldSelectCell(var2)) {
               this.stopEditingInCompleteEditing = false;

               try {
                  this.tree.setSelectionRow(var3);
               } catch (Exception var6) {
                  System.out.println("Editing exception: " + var6);
               }

               this.stopEditingInCompleteEditing = true;
            }

            if (var2 != null && var2 instanceof MouseEvent) {
               Point var5 = SwingUtilities.convertPoint(this.tree, new Point(var2.getX(), var2.getY()), this.editingComponent);
               new BasicTreeMouseListener(this, this.tree, SwingUtilities.getDeepestComponentAt(this.editingComponent, var5.x, var5.y), var2);
            }

            return true;
         }

         this.editingComponent = null;
      }

      return false;
   }

   public TreePath getEditingPath() {
      return this.editingPath;
   }

   public void mouseClicked(MouseEvent var1) {
   }

   public void mousePressed(MouseEvent var1) {
      if (this.tree != null && this.tree.isEnabled()) {
         this.tree.requestFocus();
      }

      this.checkConsistency();
      int var2;
      if (this.tree != null && this.tree.isEnabled()) {
         var2 = ((AbstractTreeUI)this).getRowContainingYLocation(var1.getY());
         if (var2 != -1) {
            Rectangle var3 = ((AbstractTreeUI)this).getRowBounds(var2);
            if (var1.getY() > var3.y + var3.height) {
               var2 = -1;
            }
         }
      } else {
         var2 = -1;
      }

      if (var2 > -1 && var2 < ((AbstractTreeUI)this).getRowCount()) {
         int var4 = -1;
         LargeTreeModelNode var5 = null;
         VisibleTreeNode var6 = null;
         int var12;
         if (!super.largeModel) {
            var6 = ((AbstractTreeUI)this).getNode(var2);
            var12 = var6.getVisibleLevel();
         } else if (var2 == 0 && ((AbstractTreeUI)this).isRootVisible()) {
            var5 = super.largeRoot;
            var12 = 0;
         } else {
            int[] var7 = new int[1];
            var5 = ((AbstractTreeUI)this).getLargeParentAndChildIndexOfRow(var2, var7);
            var12 = var5.getVisibleLevel() + 1;
            var4 = var7[0];
         }

         this.checkForClickInExpandControl(var6, var5, var4, var2, var12, var1.getX(), var1.getY());
         int var13 = var1.getX();
         int var8;
         if (((AbstractTreeUI)this).getShowsRootHandles()) {
            var8 = this.totalChildIndent * (var12 + 1);
         } else {
            var8 = this.totalChildIndent * var12;
         }

         if (var13 > var8) {
            int var9;
            if (!super.largeModel) {
               var9 = var6.getPreferredSize().width;
            } else {
               var9 = ((AbstractTreeUI)this).getRowBounds(var2).width;
            }

            if (var13 <= var9 + var8 && !this.startEditing(((AbstractTreeUI)this).getPathForRow(var2), var1)) {
               int var10 = this.lastSelectedRow;
               if (var10 >= ((AbstractTreeUI)this).getRowCount() || !((AbstractTreeUI)this).isSelectedIndex(var10)) {
                  var10 = -1;
               }

               if (((InputEvent)var1).isControlDown()) {
                  if (((AbstractTreeUI)this).isSelectedIndex(var2)) {
                     this.tree.removeSelectionInterval(var2, var2);
                  } else {
                     this.tree.addSelectionInterval(var2, var2);
                  }

                  if (var10 != -1) {
                     this.lastSelectedRow = var10;
                     return;
                  }
               } else if (((InputEvent)var1).isShiftDown()) {
                  if (var10 == -1) {
                     this.tree.addSelectionInterval(var2, var2);
                  } else {
                     if (var2 < var10) {
                        this.tree.setSelectionInterval(var2, var10);
                     } else {
                        this.tree.setSelectionInterval(var10, var2);
                     }

                     this.lastSelectedRow = var10;
                  }

                  if (var10 != -1) {
                     this.lastSelectedRow = var10;
                     return;
                  }
               } else {
                  this.tree.setSelectionInterval(var2, var2);
                  if (var1.getClickCount() == 2) {
                     if (!super.largeModel) {
                        var6.toggleExpanded();
                        this.ensureRowsAreVisible(var2, var2 + Math.min(10, var6.visibleChildCount()));
                        return;
                     }

                     if (var4 == -1) {
                        var5.toggleExpanded();
                        this.ensureRowsAreVisible(var2, var2 + Math.min(10, var5.getTotalChildCount()));
                        return;
                     }

                     if (!((AbstractTreeUI)this).isExpanded(var2)) {
                        ((AbstractTreeUI)this).expandRow(var2);
                     } else {
                        ((AbstractTreeUI)this).collapseRow(var2);
                     }

                     LargeTreeModelNode var11 = ((AbstractTreeUI)this).getLargeTreeModelNodeForRow(var2, false);
                     if (var11 != null) {
                        this.ensureRowsAreVisible(var2, var2 + Math.min(10, var11.getTotalChildCount()));
                        return;
                     }

                     this.ensureRowsAreVisible(var2, var2);
                  }
               }
            }
         }
      }

   }

   protected void checkForClickInExpandControl(VisibleTreeNode var1, LargeTreeModelNode var2, int var3, int var4, int var5, int var6, int var7) {
      if (this.clickedInExpandControl(var1, var2, var4, var5, var6, var7)) {
         this.handleExpandControlClick(var1, var2, var3, var4);
      }

   }

   protected boolean clickedInExpandControl(VisibleTreeNode var1, LargeTreeModelNode var2, int var3, int var4, int var5, int var6) {
      if (var1 != null && var1.isLeaf()) {
         return false;
      } else {
         int var7;
         if (this.getExpandedIcon() != null) {
            var7 = this.getExpandedIcon().getIconWidth();
         } else {
            var7 = 8;
         }

         int var8;
         if (((AbstractTreeUI)this).getShowsRootHandles()) {
            var8 = var4 * this.totalChildIndent + this.getLeftChildIndent() - var7 / 2;
         } else {
            var8 = (var4 - 1) * this.totalChildIndent + this.getLeftChildIndent() - var7 / 2;
         }

         int var9 = var8 + var7;
         return var5 >= var8 && var5 <= var9;
      }
   }

   public void handleExpandControlClick(VisibleTreeNode var1, LargeTreeModelNode var2, int var3, int var4) {
      if (!super.largeModel) {
         var1.toggleExpanded();
         this.ensureRowsAreVisible(var4, var4 + Math.min(10, var1.visibleChildCount()));
      } else if (var3 == -1) {
         var2.toggleExpanded();
         this.ensureRowsAreVisible(var4, var4 + Math.min(10, var2.getTotalChildCount()));
      } else {
         this.toggleExpandState(var4);
         LargeTreeModelNode var5 = ((AbstractTreeUI)this).getLargeTreeModelNodeForRow(var4, false);
         if (var5 != null) {
            this.ensureRowsAreVisible(var4, var4 + Math.min(10, var5.getTotalChildCount()));
         }

      }
   }

   protected void toggleExpandState(int var1) {
      if (!((AbstractTreeUI)this).isExpanded(var1)) {
         ((AbstractTreeUI)this).expandRow(var1);
      } else {
         ((AbstractTreeUI)this).collapseRow(var1);
      }
   }

   public void mouseReleased(MouseEvent var1) {
   }

   public void mouseEntered(MouseEvent var1) {
   }

   public void mouseExited(MouseEvent var1) {
   }

   public void focusGained(FocusEvent var1) {
      if (this.tree != null) {
         int var2 = this.tree.getLeadSelectionRow();
         if (var2 != -1) {
            this.tree.repaint(((AbstractTreeUI)this).getRowBounds(var2));
         }
      }

   }

   public void focusLost(FocusEvent var1) {
      this.focusGained(var1);
   }

   public void keyPressed(KeyEvent var1) {
      if (this.tree.hasFocus() && this.tree.isEnabled()) {
         KeyStroke var2 = KeyStroke.getKeyStroke(var1.getKeyCode(), ((InputEvent)var1).getModifiers());
         if (this.tree.getConditionForKeyStroke(var2) == 0) {
            ActionListener var3 = this.tree.getActionForKeyStroke(var2);
            if (var3 instanceof Action) {
               this.repeatKeyAction = (Action)var3;
            } else {
               this.repeatKeyAction = null;
            }
         } else {
            this.repeatKeyAction = null;
         }

         if (this.isKeyDown && this.repeatKeyAction != null) {
            this.repeatKeyAction.actionPerformed((ActionEvent)null);
            ((InputEvent)var1).consume();
            return;
         }

         this.isKeyDown = true;
      }

   }

   public void keyReleased(KeyEvent var1) {
      this.isKeyDown = false;
   }

   public void keyTyped(KeyEvent var1) {
   }

   public void setModel(TreeModel var1) {
      this.completeEditing();
      super.setModel(var1);
   }

   public void rebuild() {
      this.completeEditing();
      super.rebuild();
   }

   public void setSelectionModel(TreeSelectionModel var1) {
      this.completeEditing();
      if (super.treeSelectionModel != null) {
         super.treeSelectionModel.removePropertyChangeListener(this);
      }

      super.setSelectionModel(var1);
      if (super.treeSelectionModel != null) {
         super.treeSelectionModel.addPropertyChangeListener(this);
      }

      if (this.tree != null) {
         this.tree.repaint();
      }

   }

   protected VisibleTreeNode createNodeForValue(Object var1, int var2) {
      return new BasicVisibleTreeNode(this, var1, var2);
   }

   protected LargeTreeModelNode createLargeTreeModelNodeForValue(Object var1, int var2) {
      return new BasicLargeTreeModelNode(this, var1, var2);
   }

   protected void repaintNode(BasicLargeTreeModelNode var1) {
      if (this.tree != null) {
         this.tree.repaint(0, ((LargeTreeModelNode)var1).getRow() * super.rowHeight, this.tree.getSize().width, super.rowHeight);
      }

   }

   protected void repaintNode(VisibleTreeNode var1) {
      Rectangle var2 = var1.getNodeBounds();
      if (this.tree != null) {
         this.tree.repaint(0, var2.y, this.tree.getSize().width, var2.height);
      }

   }

   private void writeObject(ObjectOutputStream var1) throws IOException {
      Vector var2 = new Vector();
      var1.defaultWriteObject();
      if (this.collapsedIcon != null && this.collapsedIcon instanceof Serializable) {
         var2.addElement("collapsedIcon");
         var2.addElement(this.collapsedIcon);
      }

      if (this.expandedIcon != null && this.expandedIcon instanceof Serializable) {
         var2.addElement("expandedIcon");
         var2.addElement(this.expandedIcon);
      }

      if (this.currentCellRenderer != null && this.currentCellRenderer instanceof Serializable) {
         var2.addElement("currentCellRenderer");
         var2.addElement(this.currentCellRenderer);
      }

      if (this.cellEditor != null && this.cellEditor instanceof Serializable) {
         var2.addElement("cellEditor");
         var2.addElement(this.cellEditor);
      }

      var1.writeObject(var2);
   }

   private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
      var1.defaultReadObject();
      Vector var2 = (Vector)var1.readObject();
      int var3 = 0;
      int var4 = var2.size();
      if (var3 < var4 && var2.elementAt(var3).equals("collapsedIcon")) {
         ++var3;
         this.collapsedIcon = (Icon)var2.elementAt(var3);
         ++var3;
      }

      if (var3 < var4 && var2.elementAt(var3).equals("expandedIcon")) {
         ++var3;
         this.expandedIcon = (Icon)var2.elementAt(var3);
         ++var3;
      }

      if (var3 < var4 && var2.elementAt(var3).equals("currentCellRenderer")) {
         ++var3;
         this.currentCellRenderer = (TreeCellRenderer)var2.elementAt(var3);
         ++var3;
      }

      if (var3 < var4 && var2.elementAt(var3).equals("cellEditor")) {
         ++var3;
         this.cellEditor = (TreeCellEditor)var2.elementAt(var3);
         ++var3;
      }

      if (super.largeModel && this.tree != null && this.componentListener == null) {
         this.componentListener = new 2(this);
         this.tree.addComponentListener(this.componentListener);
      }

   }
}