home *** CD-ROM | disk | FTP | other *** search
/ PC Plus SuperCD (UK) 2000 March / pcp161a.iso / handson / files / copyjava.exe / com / sun / java / swing / plaf / basic / VisibleTreeNode.class (.txt) < prev   
Encoding:
Java Class File  |  1998-02-26  |  7.8 KB  |  402 lines
  1. package com.sun.java.swing.plaf.basic;
  2.  
  3. import com.sun.java.swing.tree.DefaultMutableTreeNode;
  4. import com.sun.java.swing.tree.MutableTreeNode;
  5. import com.sun.java.swing.tree.TreeModel;
  6. import com.sun.java.swing.tree.TreePath;
  7. import com.sun.java.swing.tree.TreeSelectionModel;
  8. import java.awt.Dimension;
  9. import java.awt.Rectangle;
  10. import java.util.Enumeration;
  11. import java.util.Vector;
  12.  
  13. public class VisibleTreeNode extends DefaultMutableTreeNode {
  14.    protected AbstractTreeUI treeUI;
  15.    protected Dimension preferredSize;
  16.    protected int yOrigin;
  17.    protected boolean expanded;
  18.    protected boolean hasBeenExpanded;
  19.    protected boolean isValid;
  20.    public static final Dimension EMPTY_SIZE = new Dimension(0, 0);
  21.  
  22.    public VisibleTreeNode(AbstractTreeUI var1, Object var2, int var3) {
  23.       super(var2);
  24.       this.treeUI = var1;
  25.       this.isValid = true;
  26.       this.updatePreferredSize(var3);
  27.    }
  28.  
  29.    public void setParent(MutableTreeNode var1) {
  30.       super.setParent(var1);
  31.       if (var1 == null) {
  32.          this.markInvalid();
  33.       }
  34.  
  35.    }
  36.  
  37.    void markInvalid() {
  38.       this.isValid = false;
  39.       if (super.children != null) {
  40.          for(int var1 = super.children.size() - 1; var1 >= 0; --var1) {
  41.             ((VisibleTreeNode)super.children.elementAt(var1)).markInvalid();
  42.          }
  43.       }
  44.  
  45.    }
  46.  
  47.    protected void setYOrigin(int var1) {
  48.       this.yOrigin = var1;
  49.    }
  50.  
  51.    public int getYOrigin() {
  52.       if (this.treeUI.isFixedRowHeight()) {
  53.          int var1 = this.getRow();
  54.          return var1 == -1 ? -1 : this.treeUI.getRowHeight() * var1;
  55.       } else {
  56.          return this.yOrigin;
  57.       }
  58.    }
  59.  
  60.    protected void shiftYOriginBy(int var1) {
  61.       this.yOrigin += var1;
  62.    }
  63.  
  64.    public void updatePreferredSize() {
  65.       this.updatePreferredSize(-1);
  66.    }
  67.  
  68.    protected void updatePreferredSize(int var1) {
  69.       this.preferredSize = this.treeUI.getSizeOfNode(this, var1);
  70.       if (this.preferredSize == null) {
  71.          this.preferredSize = EMPTY_SIZE;
  72.          this.treeUI.updateNodeSizes = true;
  73.       } else if (this.preferredSize.height == 0) {
  74.          this.treeUI.updateNodeSizes = true;
  75.       }
  76.  
  77.       int var2 = this.treeUI.getRowHeight();
  78.       if (var2 > 0) {
  79.          this.preferredSize.height = var2;
  80.       }
  81.  
  82.    }
  83.  
  84.    public boolean hasValidSize() {
  85.       return this.preferredSize == null || this.preferredSize.height == 0;
  86.    }
  87.  
  88.    public Dimension getPreferredSize() {
  89.       return this.preferredSize;
  90.    }
  91.  
  92.    public Rectangle getNodeBounds() {
  93.       Dimension var1 = this.getPreferredSize();
  94.       return new Rectangle(this.treeUI.getXOriginOfNode(this), this.getYOrigin(), var1.width, var1.height);
  95.    }
  96.  
  97.    public int getVisibleLevel() {
  98.       return this.treeUI.isRootVisible() ? ((DefaultMutableTreeNode)this).getLevel() : ((DefaultMutableTreeNode)this).getLevel() - 1;
  99.    }
  100.  
  101.    public int getRow() {
  102.       return this.treeUI.visibleNodes.indexOf(this);
  103.    }
  104.  
  105.    public boolean hasBeenExpanded() {
  106.       return this.hasBeenExpanded;
  107.    }
  108.  
  109.    public boolean isExpanded() {
  110.       return this.expanded;
  111.    }
  112.  
  113.    public boolean isSelected() {
  114.       return this.treeUI.isSelectedIndex(this.getRow());
  115.    }
  116.  
  117.    public boolean isLeaf() {
  118.       return this.treeUI.getModel().isLeaf(this.getValue());
  119.    }
  120.  
  121.    public VisibleTreeNode getLastVisibleNode() {
  122.       VisibleTreeNode var1;
  123.       for(var1 = this; var1.isExpanded() && ((DefaultMutableTreeNode)var1).getChildCount() > 0; var1 = (VisibleTreeNode)((DefaultMutableTreeNode)var1).getLastChild()) {
  124.       }
  125.  
  126.       return var1;
  127.    }
  128.  
  129.    public Enumeration getLoadedChildren(boolean var1) {
  130.       if (var1 && !this.hasBeenExpanded) {
  131.          Object var3 = this.getValue();
  132.          TreeModel var4 = this.treeUI.getModel();
  133.          int var5 = var4.getChildCount(var3);
  134.          this.hasBeenExpanded = true;
  135.          int var6 = this.getRow();
  136.          if (var6 == -1) {
  137.             for(int var7 = 0; var7 < var5; ++var7) {
  138.                VisibleTreeNode var2 = this.treeUI.createNodeForValue(var4.getChild(var3, var7), -1);
  139.                ((DefaultMutableTreeNode)this).add(var2);
  140.             }
  141.          } else {
  142.             ++var6;
  143.  
  144.             for(int var10 = 0; var10 < var5; ++var10) {
  145.                VisibleTreeNode var8 = this.treeUI.createNodeForValue(var4.getChild(var3, var10), var6++);
  146.                ((DefaultMutableTreeNode)this).add(var8);
  147.             }
  148.          }
  149.  
  150.          return super.children();
  151.       } else {
  152.          return super.children();
  153.       }
  154.    }
  155.  
  156.    public Enumeration children() {
  157.       return !this.isExpanded() ? DefaultMutableTreeNode.EMPTY_ENUMERATION : super.children();
  158.    }
  159.  
  160.    public boolean isVisible() {
  161.       return this.treeUI.visibleNodes.contains(this);
  162.    }
  163.  
  164.    public void modelChildCountChanged() {
  165.    }
  166.  
  167.    public int getModelChildCount() {
  168.       return this.hasBeenExpanded ? super.getChildCount() : this.treeUI.getModel().getChildCount(this.getValue());
  169.    }
  170.  
  171.    public int visibleChildCount() {
  172.       int var1 = -1;
  173.       Enumeration var2 = ((DefaultMutableTreeNode)this).preorderEnumeration();
  174.  
  175.       while(var2.hasMoreElements()) {
  176.          ++var1;
  177.          var2.nextElement();
  178.       }
  179.  
  180.       return var1;
  181.    }
  182.  
  183.    public void toggleExpanded() {
  184.       if (this.isExpanded()) {
  185.          this.collapse();
  186.       } else {
  187.          this.expand();
  188.       }
  189.    }
  190.  
  191.    protected void didAdjustTree() {
  192.    }
  193.  
  194.    public void expand() {
  195.       this.expand(true);
  196.    }
  197.  
  198.    protected void expand(boolean var1) {
  199.       if (!this.isExpanded() && !this.isLeaf()) {
  200.          Vector var2 = this.getVisibleNodes();
  201.          boolean var3 = this.treeUI.isFixedRowHeight();
  202.          this.expanded = true;
  203.          int var4 = this.getRow();
  204.          if (!this.hasBeenExpanded) {
  205.             Object var6 = this.getValue();
  206.             TreeModel var7 = this.treeUI.getModel();
  207.             int var8 = var7.getChildCount(var6);
  208.             this.hasBeenExpanded = true;
  209.             if (var4 == -1) {
  210.                for(int var20 = 0; var20 < var8; ++var20) {
  211.                   VisibleTreeNode var12 = this.treeUI.createNodeForValue(var7.getChild(var6, var20), -1);
  212.                   ((DefaultMutableTreeNode)this).add(var12);
  213.                }
  214.             } else {
  215.                int var9 = var4 + 1;
  216.  
  217.                for(int var10 = 0; var10 < var8; ++var10) {
  218.                   VisibleTreeNode var5 = this.treeUI.createNodeForValue(var7.getChild(var6, var10), var9);
  219.                   ((DefaultMutableTreeNode)this).add(var5);
  220.                }
  221.             }
  222.          }
  223.  
  224.          int var13 = var4;
  225.          Enumeration var16 = ((DefaultMutableTreeNode)this).preorderEnumeration();
  226.          var16.nextElement();
  227.          int var17;
  228.          if (var3) {
  229.             var17 = 0;
  230.          } else if (this == this.treeUI.treeCacheRoot && !this.treeUI.isRootVisible()) {
  231.             var17 = 0;
  232.          } else {
  233.             var17 = this.getYOrigin() + this.getPreferredSize().height;
  234.          }
  235.  
  236.          if (!var3) {
  237.             boolean var21 = this.treeUI.updateNodeSizes;
  238.  
  239.             while(var16.hasMoreElements()) {
  240.                VisibleTreeNode var19 = (VisibleTreeNode)var16.nextElement();
  241.                if (!var21 && !var19.hasValidSize()) {
  242.                   var19.updatePreferredSize(var13 + 1);
  243.                }
  244.  
  245.                var19.setYOrigin(var17);
  246.                var17 += var19.getPreferredSize().height;
  247.                ++var13;
  248.                var2.insertElementAt(var19, var13);
  249.             }
  250.          } else {
  251.             while(var16.hasMoreElements()) {
  252.                VisibleTreeNode var18 = (VisibleTreeNode)var16.nextElement();
  253.                ++var13;
  254.                var2.insertElementAt(var18, var13);
  255.             }
  256.          }
  257.  
  258.          int var22 = var13;
  259.          if (var4 != var13 && var1) {
  260.             if (!var3 && ((DefaultMutableTreeNode)this).getChildCount() > 0) {
  261.                ++var13;
  262.                if (var13 < this.treeUI.getRowCount()) {
  263.                   int var11 = var17 - (this.getYOrigin() + this.getPreferredSize().height);
  264.  
  265.                   for(int var23 = var2.size() - 1; var23 >= var13; --var23) {
  266.                      ((VisibleTreeNode)var2.elementAt(var23)).shiftYOriginBy(var11);
  267.                   }
  268.                }
  269.             }
  270.  
  271.             this.didAdjustTree();
  272.             this.treeUI.visibleNodesChanged();
  273.          }
  274.  
  275.          this.treeUI.pathWasExpanded(this.getTreePath());
  276.          TreeSelectionModel var24 = this.treeUI.getSelectionModel();
  277.          if (var24 != null) {
  278.             if (var4 != -1 && var4 < var22 && var24.isRowSelected(var4) && var24.isRowSelected(var4 + 1)) {
  279.                TreePath[] var25 = new TreePath[var22 - var4];
  280.  
  281.                for(int var15 = var22; var15 > var4; --var15) {
  282.                   var25[var22 - var15] = this.treeUI.getNode(var15).getTreePath();
  283.                }
  284.  
  285.                var24.addSelectionPaths(var25);
  286.                return;
  287.             }
  288.  
  289.             var24.resetRowSelection();
  290.          }
  291.       }
  292.  
  293.    }
  294.  
  295.    public void collapse() {
  296.       this.collapse(true);
  297.    }
  298.  
  299.    protected void collapse(boolean var1) {
  300.       if (this.isExpanded()) {
  301.          Vector var2 = null;
  302.          Enumeration var3 = ((DefaultMutableTreeNode)this).preorderEnumeration();
  303.          var3.nextElement();
  304.          int var4 = 0;
  305.          boolean var5 = this.treeUI.isFixedRowHeight();
  306.          int var6;
  307.          if (var5) {
  308.             var6 = 0;
  309.          } else {
  310.             var6 = this.getPreferredSize().height + this.getYOrigin();
  311.          }
  312.  
  313.          int var7 = var6;
  314.          int var8 = this.getRow();
  315.          Vector var9 = this.getVisibleNodes();
  316.          TreeSelectionModel var10 = this.treeUI.getSelectionModel();
  317.          if (!var5) {
  318.             while(var3.hasMoreElements()) {
  319.                VisibleTreeNode var14 = (VisibleTreeNode)var3.nextElement();
  320.                if (var9.contains(var14)) {
  321.                   ++var4;
  322.                   if (var10 != null && var10.isRowSelected(var4 + var8)) {
  323.                      if (var2 == null) {
  324.                         var2 = new Vector();
  325.                      }
  326.  
  327.                      var2.addElement(var14.getTreePath());
  328.                   }
  329.  
  330.                   var9.removeElement(var14);
  331.                   var6 = var14.getYOrigin() + var14.getPreferredSize().height;
  332.                }
  333.             }
  334.          } else {
  335.             while(var3.hasMoreElements()) {
  336.                VisibleTreeNode var11 = (VisibleTreeNode)var3.nextElement();
  337.                if (var9.contains(var11)) {
  338.                   ++var4;
  339.                   if (var10 != null && var10.isRowSelected(var4 + var8)) {
  340.                      if (var2 == null) {
  341.                         var2 = new Vector();
  342.                      }
  343.  
  344.                      var2.addElement(var11.getTreePath());
  345.                   }
  346.  
  347.                   var9.removeElement(var11);
  348.                }
  349.             }
  350.          }
  351.  
  352.          if (var4 > 0 && var1 && var8 != -1) {
  353.             if (!var5 && var8 + 1 < this.treeUI.getRowCount() && var7 != var6) {
  354.                int var13 = var7 - var6;
  355.                int var15 = var8 + 1;
  356.  
  357.                for(int var12 = var9.size(); var15 < var12; ++var15) {
  358.                   ((VisibleTreeNode)var9.elementAt(var15)).shiftYOriginBy(var13);
  359.                }
  360.             }
  361.  
  362.             this.expanded = false;
  363.             this.didAdjustTree();
  364.             this.treeUI.visibleNodesChanged();
  365.          } else {
  366.             this.expanded = false;
  367.          }
  368.  
  369.          this.treeUI.pathWasCollapsed(this.getTreePath());
  370.          if (var10 != null && var4 > 0 && var8 != -1) {
  371.             if (var2 != null) {
  372.                int var16 = var2.size();
  373.                TreePath[] var17 = new TreePath[var16];
  374.                var2.copyInto(var17);
  375.                var10.removeSelectionPaths(var17);
  376.                var10.addSelectionPath(this.getTreePath());
  377.                return;
  378.             }
  379.  
  380.             var10.resetRowSelection();
  381.          }
  382.       }
  383.  
  384.    }
  385.  
  386.    public Object getValue() {
  387.       return ((DefaultMutableTreeNode)this).getUserObject();
  388.    }
  389.  
  390.    protected TreePath getTreePath() {
  391.       return this.treeUI.createTreePathFor(this);
  392.    }
  393.  
  394.    protected Vector getVisibleNodes() {
  395.       return this.treeUI.visibleNodes;
  396.    }
  397.  
  398.    protected void updateTreeYLocationsFrom(int var1) {
  399.       this.treeUI.updateYLocationsFrom(var1);
  400.    }
  401. }
  402.