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 / LargeTreeModelNode.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-02-26  |  6.2 KB  |  389 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.TreeModel;
  5. import com.sun.java.swing.tree.TreePath;
  6. import com.sun.java.swing.tree.TreeSelectionModel;
  7.  
  8. public class LargeTreeModelNode extends DefaultMutableTreeNode {
  9.    protected AbstractTreeUI treeUI;
  10.    protected boolean isExpanded;
  11.    protected int childIndex;
  12.  
  13.    public LargeTreeModelNode(AbstractTreeUI var1, Object var2, int var3) {
  14.       super(var2);
  15.       this.treeUI = var1;
  16.       this.childIndex = var3;
  17.    }
  18.  
  19.    public TreeModel getModel() {
  20.       return this.treeUI.getModel();
  21.    }
  22.  
  23.    public int getChildIndex() {
  24.       return this.childIndex;
  25.    }
  26.  
  27.    public LargeTreeModelNode childAtModelIndex(int var1) {
  28.       for(int var2 = ((DefaultMutableTreeNode)this).getChildCount() - 1; var2 >= 0; --var2) {
  29.          if (((LargeTreeModelNode)((DefaultMutableTreeNode)this).getChildAt(var2)).childIndex == var1) {
  30.             return (LargeTreeModelNode)((DefaultMutableTreeNode)this).getChildAt(var2);
  31.          }
  32.       }
  33.  
  34.       return null;
  35.    }
  36.  
  37.    public boolean isVisible() {
  38.       LargeTreeModelNode var1 = (LargeTreeModelNode)((DefaultMutableTreeNode)this).getParent();
  39.       if (var1 == null) {
  40.          return true;
  41.       } else {
  42.          return var1.isExpanded() && var1.isVisible();
  43.       }
  44.    }
  45.  
  46.    public int getRow() {
  47.       LargeTreeModelNode var1 = (LargeTreeModelNode)((DefaultMutableTreeNode)this).getParent();
  48.       if (var1 == null) {
  49.          return this.treeUI.isRootVisible() ? 0 : -1;
  50.       } else {
  51.          return var1.getCountTo(this.childIndex);
  52.       }
  53.    }
  54.  
  55.    public void expand(boolean var1) {
  56.       if (!this.isExpanded) {
  57.          boolean var2 = this.isVisible();
  58.          this.isExpanded = true;
  59.          if (var2) {
  60.             this.adjustLargeRowCountBy(this.getTotalChildCount());
  61.          }
  62.  
  63.          if (var1) {
  64.             this.didAdjustTree();
  65.             this.treeUI.visibleNodesChanged();
  66.          }
  67.  
  68.          this.treeUI.pathWasExpanded(new TreePath(((DefaultMutableTreeNode)this).getUserObjectPath()));
  69.          if (this.treeUI != null && var2) {
  70.             int var4 = this.getRow();
  71.             TreeSelectionModel var5 = this.treeUI.getSelectionModel();
  72.             int var3;
  73.             if (var5 != null && (var3 = this.getTotalChildCount()) > 0 && var5.isRowSelected(var4) && var5.isRowSelected(var4 + 1)) {
  74.                TreePath[] var6 = new TreePath[var3];
  75.  
  76.                for(int var7 = 0; var7 < var3; ++var7) {
  77.                   var6[var7] = this.treeUI.getPathForRow(var7 + var4 + 1);
  78.                }
  79.  
  80.                var5.addSelectionPaths(var6);
  81.                return;
  82.             }
  83.  
  84.             if (var5 != null) {
  85.                var5.resetRowSelection();
  86.             }
  87.          }
  88.       }
  89.  
  90.    }
  91.  
  92.    public void collapse(boolean var1) {
  93.       if (this.isExpanded) {
  94.          TreeSelectionModel var3 = null;
  95.          TreePath[] var2;
  96.          if (this.treeUI != null && (var3 = this.treeUI.getSelectionModel()) != null) {
  97.             var2 = var3.getSelectionPaths();
  98.          } else {
  99.             var2 = null;
  100.          }
  101.  
  102.          if (this.isVisible()) {
  103.             this.adjustLargeRowCountBy(-this.getTotalChildCount());
  104.          }
  105.  
  106.          this.isExpanded = false;
  107.          if (var1) {
  108.             this.didAdjustTree();
  109.             this.treeUI.visibleNodesChanged();
  110.          }
  111.  
  112.          this.treeUI.pathWasCollapsed(new TreePath(((DefaultMutableTreeNode)this).getUserObjectPath()));
  113.          if (var2 != null) {
  114.             boolean var4 = false;
  115.             TreePath var5 = new TreePath(((DefaultMutableTreeNode)this).getUserObjectPath());
  116.  
  117.             for(int var6 = var2.length - 1; var6 >= 0; --var6) {
  118.                if (var2[var6] != null && var5.isDescendant(var2[var6]) && !var5.equals(var2[var6])) {
  119.                   var4 = true;
  120.                } else {
  121.                   var2[var6] = null;
  122.                }
  123.             }
  124.  
  125.             if (var4) {
  126.                var3.removeSelectionPaths(var2);
  127.             }
  128.          }
  129.       }
  130.  
  131.    }
  132.  
  133.    public int getTotalChildCount() {
  134.       if (!this.isExpanded()) {
  135.          return 0;
  136.       } else {
  137.          int var1 = this.getModel().getChildCount(((DefaultMutableTreeNode)this).getUserObject());
  138.  
  139.          for(int var2 = ((DefaultMutableTreeNode)this).getChildCount() - 1; var2 >= 0; --var2) {
  140.             var1 += ((LargeTreeModelNode)((DefaultMutableTreeNode)this).getChildAt(var2)).getTotalChildCount();
  141.          }
  142.  
  143.          return var1;
  144.       }
  145.    }
  146.  
  147.    public boolean isExpanded() {
  148.       return this.isExpanded;
  149.    }
  150.  
  151.    public void modelChildCountChanged() {
  152.    }
  153.  
  154.    public int getVisibleLevel() {
  155.       return this.treeUI.isRootVisible() ? ((DefaultMutableTreeNode)this).getLevel() : ((DefaultMutableTreeNode)this).getLevel() - 1;
  156.    }
  157.  
  158.    public void toggleExpanded() {
  159.       if (this.isExpanded()) {
  160.          this.collapse(true);
  161.       } else {
  162.          this.expand(true);
  163.       }
  164.    }
  165.  
  166.    protected void adjustLargeRowCountBy(int var1) {
  167.       AbstractTreeUI var10000 = this.treeUI;
  168.       var10000.largeRowCount += var1;
  169.    }
  170.  
  171.    protected void addLargeTreeModelNode(LargeTreeModelNode var1) {
  172.       boolean var2 = false;
  173.       int var3 = var1.getChildIndex();
  174.       int var4 = 0;
  175.  
  176.       for(int var5 = ((DefaultMutableTreeNode)this).getChildCount(); var4 < var5; ++var4) {
  177.          if (((LargeTreeModelNode)((DefaultMutableTreeNode)this).getChildAt(var4)).getChildIndex() > var3) {
  178.             var2 = true;
  179.             ((DefaultMutableTreeNode)this).insert(var1, var4);
  180.             var4 = var5;
  181.          }
  182.       }
  183.  
  184.       if (!var2) {
  185.          ((DefaultMutableTreeNode)this).add(var1);
  186.       }
  187.  
  188.    }
  189.  
  190.    protected void childRemovedAtModelIndex(int var1) {
  191.       int var3 = 0;
  192.  
  193.       for(int var4 = ((DefaultMutableTreeNode)this).getChildCount(); var3 < var4; ++var3) {
  194.          LargeTreeModelNode var2 = (LargeTreeModelNode)((DefaultMutableTreeNode)this).getChildAt(var3);
  195.          if (var2.childIndex >= var1) {
  196.             while(var3 < var4) {
  197.                --((LargeTreeModelNode)((DefaultMutableTreeNode)this).getChildAt(var3)).childIndex;
  198.                ++var3;
  199.             }
  200.          }
  201.       }
  202.  
  203.    }
  204.  
  205.    protected void childInsertedAtModelIndex(int var1) {
  206.       int var3 = 0;
  207.  
  208.       for(int var4 = ((DefaultMutableTreeNode)this).getChildCount(); var3 < var4; ++var3) {
  209.          LargeTreeModelNode var2 = (LargeTreeModelNode)((DefaultMutableTreeNode)this).getChildAt(var3);
  210.          if (var2.childIndex >= var1) {
  211.             while(var3 < var4) {
  212.                ++((LargeTreeModelNode)((DefaultMutableTreeNode)this).getChildAt(var3)).childIndex;
  213.                ++var3;
  214.             }
  215.          }
  216.       }
  217.  
  218.    }
  219.  
  220.    protected boolean getPathForRow(int var1, int[] var2, TreePath[] var3, LargeTreeModelNode[] var4, boolean[] var5, int[] var6) {
  221.       if (var1 == var2[0]) {
  222.          if (var6 != null) {
  223.             var6[0] = this.getChildIndex();
  224.          }
  225.  
  226.          if (var4 != null) {
  227.             var4[0] = this;
  228.             var5[0] = false;
  229.          }
  230.  
  231.          if (var3 != null) {
  232.             var3[0] = new TreePath(((DefaultMutableTreeNode)this).getUserObjectPath());
  233.          }
  234.  
  235.          return true;
  236.       } else {
  237.          int var10002 = var2[0]++;
  238.          if (this.isExpanded) {
  239.             int var8 = 0;
  240.             TreeModel var10 = this.getModel();
  241.             int var11 = 0;
  242.  
  243.             for(int var12 = ((DefaultMutableTreeNode)this).getChildCount(); var11 < var12; ++var11) {
  244.                LargeTreeModelNode var7 = (LargeTreeModelNode)((DefaultMutableTreeNode)this).getChildAt(var11);
  245.                int var9 = var7.childIndex;
  246.                if (var2[0] + (var9 - var8) > var1) {
  247.                   if (var6 != null) {
  248.                      var6[0] = var1 - var2[0] + var8;
  249.                   }
  250.  
  251.                   if (var3 != null) {
  252.                      Object[] var14 = ((DefaultMutableTreeNode)this).getUserObjectPath();
  253.                      int var15 = var14.length;
  254.                      Object[] var16 = new Object[var15 + 1];
  255.                      Object var13 = var10.getChild(super.userObject, var1 - var2[0] + var8);
  256.                      System.arraycopy(var14, 0, var16, 0, var15);
  257.                      var16[var15] = var13;
  258.                      var3[0] = new TreePath(var16);
  259.                   }
  260.  
  261.                   if (var4 != null) {
  262.                      var4[0] = this;
  263.                      var5[0] = true;
  264.                   }
  265.  
  266.                   return true;
  267.                }
  268.  
  269.                var2[0] += var9 - var8;
  270.                var8 = var9 + 1;
  271.                if (var7.getPathForRow(var1, var2, var3, var4, var5, var6)) {
  272.                   return true;
  273.                }
  274.             }
  275.  
  276.             int var17 = var10.getChildCount(super.userObject) - 1;
  277.             if (var17 - var8 >= 0) {
  278.                if (var2[0] + (var17 - var8) >= var1) {
  279.                   if (var6 != null) {
  280.                      var6[0] = var1 - var2[0] + var8;
  281.                   }
  282.  
  283.                   if (var3 != null) {
  284.                      Object[] var19 = ((DefaultMutableTreeNode)this).getUserObjectPath();
  285.                      int var20 = var19.length;
  286.                      Object[] var21 = new Object[var20 + 1];
  287.                      Object var18 = var10.getChild(super.userObject, var1 - var2[0] + var8);
  288.                      System.arraycopy(var19, 0, var21, 0, var20);
  289.                      var21[var20] = var18;
  290.                      var3[0] = new TreePath(var21);
  291.                   }
  292.  
  293.                   if (var4 != null) {
  294.                      var4[0] = this;
  295.                      var5[0] = true;
  296.                   }
  297.  
  298.                   return true;
  299.                }
  300.  
  301.                var2[0] += var17 - var8 + 1;
  302.             }
  303.          }
  304.  
  305.          return false;
  306.       }
  307.    }
  308.  
  309.    protected int getCountTo(int var1) {
  310.       int var3 = var1 + 1;
  311.       int var4 = 0;
  312.  
  313.       for(int var5 = ((DefaultMutableTreeNode)this).getChildCount(); var4 < var5; ++var4) {
  314.          LargeTreeModelNode var2 = (LargeTreeModelNode)((DefaultMutableTreeNode)this).getChildAt(var4);
  315.          if (var2.childIndex >= var1) {
  316.             var4 = var5;
  317.          } else {
  318.             var3 += var2.getTotalChildCount();
  319.          }
  320.       }
  321.  
  322.       if (super.parent != null) {
  323.          return var3 + ((LargeTreeModelNode)((DefaultMutableTreeNode)this).getParent()).getCountTo(this.childIndex);
  324.       } else if (!this.treeUI.isRootVisible()) {
  325.          return var3 - 1;
  326.       } else {
  327.          return var3;
  328.       }
  329.    }
  330.  
  331.    protected boolean getRow(Object[] var1, int var2, int var3, boolean var4, int[] var5) {
  332.       var4 = var4 && var1[var2].equals(super.userObject);
  333.       if (var4) {
  334.          ++var2;
  335.          if (var2 == var3) {
  336.             return true;
  337.          }
  338.       }
  339.  
  340.       int var10002 = var5[0]++;
  341.       if (this.isExpanded) {
  342.          TreeModel var11 = this.getModel();
  343.          int var7;
  344.          if (var4 && var2 + 1 == var3) {
  345.             var7 = var11.getIndexOfChild(super.userObject, var1[var3 - 1]);
  346.          } else {
  347.             var7 = Integer.MAX_VALUE;
  348.          }
  349.  
  350.          int var8 = 0;
  351.          int var10 = var5[0];
  352.          int var12 = 0;
  353.  
  354.          for(int var13 = ((DefaultMutableTreeNode)this).getChildCount(); var12 < var13; ++var12) {
  355.             LargeTreeModelNode var6 = (LargeTreeModelNode)((DefaultMutableTreeNode)this).getChildAt(var12);
  356.             int var9 = var6.childIndex;
  357.             if (var9 >= var7) {
  358.                var5[0] = var10 + (var7 - var8);
  359.                return true;
  360.             }
  361.  
  362.             var10 += var9 - var8;
  363.             var8 = var9 + 1;
  364.             var5[0] = var10;
  365.             if (var6.getRow(var1, var2, var3, var4, var5)) {
  366.                return true;
  367.             }
  368.  
  369.             var10 = var5[0];
  370.          }
  371.  
  372.          int var15 = var11.getChildCount(super.userObject) - 1;
  373.          if (var15 >= 0) {
  374.             if (var15 >= var7) {
  375.                var5[0] = var10 + (var7 - var8);
  376.                return true;
  377.             }
  378.  
  379.             var5[0] += var15 - var8 + 1;
  380.          }
  381.       }
  382.  
  383.       return false;
  384.    }
  385.  
  386.    protected void didAdjustTree() {
  387.    }
  388. }
  389.