home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &… the Search for Life CD 3 / 0_CD-ROM.iso / install / jre1_3 / lib / rt.jar / javax / swing / tree / FixedHeightLayoutCache.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  8.4 KB  |  473 lines
  1. package javax.swing.tree;
  2.  
  3. import java.awt.Rectangle;
  4. import java.util.Enumeration;
  5. import java.util.Hashtable;
  6. import java.util.Stack;
  7. import java.util.Vector;
  8. import javax.swing.event.TreeModelEvent;
  9.  
  10. public class FixedHeightLayoutCache extends AbstractLayoutCache {
  11.    private FHTreeStateNode root;
  12.    private int rowCount;
  13.    private Rectangle boundsBuffer = new Rectangle();
  14.    private Hashtable treePathMapping = new Hashtable();
  15.    private SearchInfo info = new SearchInfo(this, (1)null);
  16.    private Stack tempStacks = new Stack();
  17.  
  18.    public FixedHeightLayoutCache() {
  19.       this.setRowHeight(1);
  20.    }
  21.  
  22.    public void setModel(TreeModel var1) {
  23.       super.setModel(var1);
  24.       this.rebuild();
  25.    }
  26.  
  27.    public void setRootVisible(boolean var1) {
  28.       if (((AbstractLayoutCache)this).isRootVisible() != var1) {
  29.          super.setRootVisible(var1);
  30.          if (this.root != null) {
  31.             if (var1) {
  32.                ++this.rowCount;
  33.                this.root.adjustRowBy(1);
  34.             } else {
  35.                --this.rowCount;
  36.                this.root.adjustRowBy(-1);
  37.             }
  38.  
  39.             this.visibleNodesChanged();
  40.          }
  41.       }
  42.  
  43.    }
  44.  
  45.    public void setRowHeight(int var1) {
  46.       if (var1 <= 0) {
  47.          throw new IllegalArgumentException("FixedHeightLayoutCache only supports row heights greater than 0");
  48.       } else {
  49.          if (((AbstractLayoutCache)this).getRowHeight() != var1) {
  50.             super.setRowHeight(var1);
  51.             this.visibleNodesChanged();
  52.          }
  53.  
  54.       }
  55.    }
  56.  
  57.    public int getRowCount() {
  58.       return this.rowCount;
  59.    }
  60.  
  61.    public void invalidatePathBounds(TreePath var1) {
  62.    }
  63.  
  64.    public void invalidateSizes() {
  65.       this.visibleNodesChanged();
  66.    }
  67.  
  68.    public boolean isExpanded(TreePath var1) {
  69.       if (var1 == null) {
  70.          return false;
  71.       } else {
  72.          FHTreeStateNode var2 = this.getNodeForPath(var1, true, false);
  73.          return var2 != null && var2.isExpanded();
  74.       }
  75.    }
  76.  
  77.    public Rectangle getBounds(TreePath var1, Rectangle var2) {
  78.       if (var1 == null) {
  79.          return null;
  80.       } else {
  81.          FHTreeStateNode var3 = this.getNodeForPath(var1, true, false);
  82.          if (var3 != null) {
  83.             return this.getBounds(var3, -1, var2);
  84.          } else {
  85.             TreePath var4 = var1.getParentPath();
  86.             var3 = this.getNodeForPath(var4, true, false);
  87.             if (var3 != null) {
  88.                int var5 = super.treeModel.getIndexOfChild(var4.getLastPathComponent(), var1.getLastPathComponent());
  89.                if (var5 != -1) {
  90.                   return this.getBounds(var3, var5, var2);
  91.                }
  92.             }
  93.  
  94.             return null;
  95.          }
  96.       }
  97.    }
  98.  
  99.    public TreePath getPathForRow(int var1) {
  100.       return var1 >= 0 && var1 < this.getRowCount() && this.root.getPathForRow(var1, this.getRowCount(), this.info) ? this.info.getPath() : null;
  101.    }
  102.  
  103.    public int getRowForPath(TreePath var1) {
  104.       if (var1 != null && this.root != null) {
  105.          FHTreeStateNode var2 = this.getNodeForPath(var1, true, false);
  106.          if (var2 != null) {
  107.             return var2.getRow();
  108.          } else {
  109.             TreePath var3 = var1.getParentPath();
  110.             var2 = this.getNodeForPath(var3, true, false);
  111.             return var2 != null && var2.isExpanded() ? var2.getRowToModelIndex(super.treeModel.getIndexOfChild(var3.getLastPathComponent(), var1.getLastPathComponent())) : -1;
  112.          }
  113.       } else {
  114.          return -1;
  115.       }
  116.    }
  117.  
  118.    public TreePath getPathClosestTo(int var1, int var2) {
  119.       if (this.getRowCount() == 0) {
  120.          return null;
  121.       } else {
  122.          int var3 = this.getRowContainingYLocation(var2);
  123.          return this.getPathForRow(var3);
  124.       }
  125.    }
  126.  
  127.    public int getVisibleChildCount(TreePath var1) {
  128.       FHTreeStateNode var2 = this.getNodeForPath(var1, true, false);
  129.       return var2 == null ? 0 : var2.getTotalChildCount();
  130.    }
  131.  
  132.    public Enumeration getVisiblePathsFrom(TreePath var1) {
  133.       if (var1 == null) {
  134.          return null;
  135.       } else {
  136.          FHTreeStateNode var2 = this.getNodeForPath(var1, true, false);
  137.          if (var2 != null) {
  138.             return new VisibleFHTreeStateNodeEnumeration(this, var2);
  139.          } else {
  140.             TreePath var3 = var1.getParentPath();
  141.             var2 = this.getNodeForPath(var3, true, false);
  142.             return var2 != null && var2.isExpanded() ? new VisibleFHTreeStateNodeEnumeration(this, var2, super.treeModel.getIndexOfChild(var3.getLastPathComponent(), var1.getLastPathComponent())) : null;
  143.          }
  144.       }
  145.    }
  146.  
  147.    public void setExpandedState(TreePath var1, boolean var2) {
  148.       if (var2) {
  149.          this.ensurePathIsExpanded(var1, true);
  150.       } else if (var1 != null) {
  151.          TreePath var3 = var1.getParentPath();
  152.          if (var3 != null) {
  153.             FHTreeStateNode var4 = this.getNodeForPath(var3, false, true);
  154.             if (var4 != null) {
  155.                var4.makeVisible();
  156.             }
  157.          }
  158.  
  159.          FHTreeStateNode var5 = this.getNodeForPath(var1, true, false);
  160.          if (var5 != null) {
  161.             var5.collapse(true);
  162.          }
  163.       }
  164.  
  165.    }
  166.  
  167.    public boolean getExpandedState(TreePath var1) {
  168.       FHTreeStateNode var2 = this.getNodeForPath(var1, true, false);
  169.       return var2 != null ? var2.isVisible() && var2.isExpanded() : false;
  170.    }
  171.  
  172.    public void treeNodesChanged(TreeModelEvent var1) {
  173.       if (var1 != null) {
  174.          FHTreeStateNode var3 = this.getNodeForPath(var1.getTreePath(), false, false);
  175.          int[] var2 = var1.getChildIndices();
  176.          if (var3 != null) {
  177.             int var4;
  178.             if (var2 != null && (var4 = var2.length) > 0) {
  179.                Object var5 = ((DefaultMutableTreeNode)var3).getUserObject();
  180.  
  181.                for(int var6 = 0; var6 < var4; ++var6) {
  182.                   FHTreeStateNode var7 = var3.getChildAtModelIndex(var2[var6]);
  183.                   if (var7 != null) {
  184.                      var7.setUserObject(super.treeModel.getChild(var5, var2[var6]));
  185.                   }
  186.                }
  187.  
  188.                if (var3.isVisible() && var3.isExpanded()) {
  189.                   this.visibleNodesChanged();
  190.                }
  191.             } else if (var3 == this.root && var3.isVisible() && var3.isExpanded()) {
  192.                this.visibleNodesChanged();
  193.             }
  194.          }
  195.       }
  196.  
  197.    }
  198.  
  199.    public void treeNodesInserted(TreeModelEvent var1) {
  200.       if (var1 != null) {
  201.          FHTreeStateNode var3 = this.getNodeForPath(var1.getTreePath(), false, false);
  202.          int[] var2 = var1.getChildIndices();
  203.          int var4;
  204.          if (var3 != null && var2 != null && (var4 = var2.length) > 0) {
  205.             boolean var5 = var3.isVisible() && var3.isExpanded();
  206.  
  207.             for(int var6 = 0; var6 < var4; ++var6) {
  208.                var3.childInsertedAtModelIndex(var2[var6], var5);
  209.             }
  210.  
  211.             if (var5 && super.treeSelectionModel != null) {
  212.                super.treeSelectionModel.resetRowSelection();
  213.             }
  214.  
  215.             if (var3.isVisible()) {
  216.                this.visibleNodesChanged();
  217.             }
  218.          }
  219.       }
  220.  
  221.    }
  222.  
  223.    public void treeNodesRemoved(TreeModelEvent var1) {
  224.       if (var1 != null) {
  225.          TreePath var4 = var1.getTreePath();
  226.          FHTreeStateNode var5 = this.getNodeForPath(var4, false, false);
  227.          int[] var2 = var1.getChildIndices();
  228.          int var3;
  229.          if (var5 != null && var2 != null && (var3 = var2.length) > 0) {
  230.             Object[] var6 = var1.getChildren();
  231.             boolean var7 = var5.isVisible() && var5.isExpanded();
  232.  
  233.             for(int var8 = var3 - 1; var8 >= 0; --var8) {
  234.                var5.removeChildAtModelIndex(var2[var8], var7);
  235.             }
  236.  
  237.             if (var7) {
  238.                if (super.treeSelectionModel != null) {
  239.                   super.treeSelectionModel.resetRowSelection();
  240.                }
  241.  
  242.                this.visibleNodesChanged();
  243.             } else if (var5.isVisible()) {
  244.                this.visibleNodesChanged();
  245.             }
  246.          }
  247.       }
  248.  
  249.    }
  250.  
  251.    public void treeStructureChanged(TreeModelEvent var1) {
  252.       if (var1 != null) {
  253.          TreePath var2 = var1.getTreePath();
  254.          if (var2 != null && var2.getPathCount() > 0) {
  255.             if (var2.getPathCount() == 1) {
  256.                this.rebuild();
  257.             } else {
  258.                FHTreeStateNode var3 = this.getNodeForPath(var2, false, false);
  259.                if (var3 != null) {
  260.                   FHTreeStateNode var7 = (FHTreeStateNode)((DefaultMutableTreeNode)var3).getParent();
  261.                   int var8 = var3.getRow();
  262.                   boolean var4 = var3.isExpanded();
  263.                   boolean var5 = var3.isVisible();
  264.                   if (var5 && var4) {
  265.                      var3.collapse(true);
  266.                      ((DefaultMutableTreeNode)var3).removeFromParent();
  267.                      var3 = this.getNodeForPath(var2, false, true);
  268.                      var3.expand();
  269.                   } else {
  270.                      ((DefaultMutableTreeNode)var3).removeFromParent();
  271.                   }
  272.  
  273.                   if (super.treeSelectionModel != null && var5 && var4) {
  274.                      super.treeSelectionModel.resetRowSelection();
  275.                   }
  276.  
  277.                   if (var5) {
  278.                      this.visibleNodesChanged();
  279.                   }
  280.                }
  281.             }
  282.          }
  283.       }
  284.  
  285.    }
  286.  
  287.    private void visibleNodesChanged() {
  288.    }
  289.  
  290.    private Rectangle getBounds(FHTreeStateNode var1, int var2, Rectangle var3) {
  291.       boolean var4;
  292.       int var5;
  293.       int var6;
  294.       Object var7;
  295.       if (var2 == -1) {
  296.          var6 = var1.getRow();
  297.          var7 = ((DefaultMutableTreeNode)var1).getUserObject();
  298.          var4 = var1.isExpanded();
  299.          var5 = ((DefaultMutableTreeNode)var1).getLevel();
  300.       } else {
  301.          var6 = var1.getRowToModelIndex(var2);
  302.          var7 = super.treeModel.getChild(((DefaultMutableTreeNode)var1).getUserObject(), var2);
  303.          var4 = false;
  304.          var5 = ((DefaultMutableTreeNode)var1).getLevel() + 1;
  305.       }
  306.  
  307.       Rectangle var8 = ((AbstractLayoutCache)this).getNodeDimensions(var7, var6, var5, var4, this.boundsBuffer);
  308.       if (var8 == null) {
  309.          return null;
  310.       } else {
  311.          if (var3 == null) {
  312.             var3 = new Rectangle();
  313.          }
  314.  
  315.          var3.x = var8.x;
  316.          var3.height = ((AbstractLayoutCache)this).getRowHeight();
  317.          var3.y = var6 * var3.height;
  318.          var3.width = var8.width;
  319.          return var3;
  320.       }
  321.    }
  322.  
  323.    private void adjustRowCountBy(int var1) {
  324.       this.rowCount += var1;
  325.    }
  326.  
  327.    private void addMapping(FHTreeStateNode var1) {
  328.       this.treePathMapping.put(var1.getTreePath(), var1);
  329.    }
  330.  
  331.    private void removeMapping(FHTreeStateNode var1) {
  332.       this.treePathMapping.remove(var1.getTreePath());
  333.    }
  334.  
  335.    private FHTreeStateNode getMapping(TreePath var1) {
  336.       return (FHTreeStateNode)this.treePathMapping.get(var1);
  337.    }
  338.  
  339.    private void rebuild() {
  340.       this.treePathMapping.clear();
  341.       if (super.treeModel != null) {
  342.          Object var1 = super.treeModel.getRoot();
  343.          this.root = this.createNodeForValue(var1, 0);
  344.          this.root.path = new TreePath(var1);
  345.          this.addMapping(this.root);
  346.          if (((AbstractLayoutCache)this).isRootVisible()) {
  347.             this.rowCount = 1;
  348.             this.root.row = 0;
  349.          } else {
  350.             this.rowCount = 0;
  351.             this.root.row = -1;
  352.          }
  353.  
  354.          this.root.expand();
  355.       } else {
  356.          this.root = null;
  357.          this.rowCount = 0;
  358.       }
  359.  
  360.       if (super.treeSelectionModel != null) {
  361.          super.treeSelectionModel.clearSelection();
  362.       }
  363.  
  364.       this.visibleNodesChanged();
  365.    }
  366.  
  367.    private int getRowContainingYLocation(int var1) {
  368.       return this.getRowCount() == 0 ? -1 : Math.max(0, Math.min(this.getRowCount() - 1, var1 / ((AbstractLayoutCache)this).getRowHeight()));
  369.    }
  370.  
  371.    private boolean ensurePathIsExpanded(TreePath var1, boolean var2) {
  372.       if (var1 != null) {
  373.          if (super.treeModel.isLeaf(var1.getLastPathComponent())) {
  374.             var1 = var1.getParentPath();
  375.             var2 = true;
  376.          }
  377.  
  378.          if (var1 != null) {
  379.             FHTreeStateNode var3 = this.getNodeForPath(var1, false, true);
  380.             if (var3 != null) {
  381.                var3.makeVisible();
  382.                if (var2) {
  383.                   var3.expand();
  384.                }
  385.  
  386.                return true;
  387.             }
  388.          }
  389.       }
  390.  
  391.       return false;
  392.    }
  393.  
  394.    private FHTreeStateNode createNodeForValue(Object var1, int var2) {
  395.       return new FHTreeStateNode(this, var1, var2, -1);
  396.    }
  397.  
  398.    private FHTreeStateNode getNodeForPath(TreePath var1, boolean var2, boolean var3) {
  399.       if (var1 != null) {
  400.          FHTreeStateNode var4 = this.getMapping(var1);
  401.          if (var4 != null) {
  402.             return var2 && !var4.isVisible() ? null : var4;
  403.          } else if (var2) {
  404.             return null;
  405.          } else {
  406.             Stack var5;
  407.             if (this.tempStacks.size() == 0) {
  408.                var5 = new Stack();
  409.             } else {
  410.                var5 = (Stack)this.tempStacks.pop();
  411.             }
  412.  
  413.             try {
  414.                var5.push(var1);
  415.                var1 = var1.getParentPath();
  416.  
  417.                for(Object var13 = null; var1 != null; var1 = var1.getParentPath()) {
  418.                   var4 = this.getMapping(var1);
  419.                   if (var4 != null) {
  420.                      while(var4 != null && ((Vector)var5).size() > 0) {
  421.                         var1 = (TreePath)var5.pop();
  422.                         var4 = var4.createChildFor(var1.getLastPathComponent());
  423.                      }
  424.  
  425.                      FHTreeStateNode var6 = var4;
  426.                      return var6;
  427.                   }
  428.  
  429.                   var5.push(var1);
  430.                }
  431.  
  432.                return null;
  433.             } finally {
  434.                ((Vector)var5).removeAllElements();
  435.                this.tempStacks.push(var5);
  436.             }
  437.          }
  438.       } else {
  439.          return null;
  440.       }
  441.    }
  442.  
  443.    // $FF: synthetic method
  444.    static void access$100(FixedHeightLayoutCache var0, FHTreeStateNode var1) {
  445.       var0.addMapping(var1);
  446.    }
  447.  
  448.    // $FF: synthetic method
  449.    static void access$200(FixedHeightLayoutCache var0, FHTreeStateNode var1) {
  450.       var0.removeMapping(var1);
  451.    }
  452.  
  453.    // $FF: synthetic method
  454.    static FHTreeStateNode access$300(FixedHeightLayoutCache var0, Object var1, int var2) {
  455.       return var0.createNodeForValue(var1, var2);
  456.    }
  457.  
  458.    // $FF: synthetic method
  459.    static void access$400(FixedHeightLayoutCache var0, int var1) {
  460.       var0.adjustRowCountBy(var1);
  461.    }
  462.  
  463.    // $FF: synthetic method
  464.    static int access$502(FixedHeightLayoutCache var0, int var1) {
  465.       return var0.rowCount = var1;
  466.    }
  467.  
  468.    // $FF: synthetic method
  469.    static FHTreeStateNode access$600(FixedHeightLayoutCache var0) {
  470.       return var0.root;
  471.    }
  472. }
  473.