home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / javax / swing / tree / VariableHeightLayoutCache.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  10.1 KB  |  667 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 VariableHeightLayoutCache extends AbstractLayoutCache {
  11.    private Vector visibleNodes = new Vector();
  12.    private boolean updateNodeSizes;
  13.    private TreeStateNode root;
  14.    private Rectangle boundsBuffer = new Rectangle();
  15.    private Hashtable treePathMapping = new Hashtable();
  16.    private Stack tempStacks = new Stack();
  17.  
  18.    public void setModel(TreeModel var1) {
  19.       super.setModel(var1);
  20.       this.rebuild();
  21.    }
  22.  
  23.    public void setRootVisible(boolean var1) {
  24.       if (((AbstractLayoutCache)this).isRootVisible() != var1 && this.root != null) {
  25.          if (var1) {
  26.             this.root.updatePreferredSize(0);
  27.             this.visibleNodes.insertElementAt(this.root, 0);
  28.          } else if (this.visibleNodes.size() > 0) {
  29.             this.visibleNodes.removeElementAt(0);
  30.             if (super.treeSelectionModel != null) {
  31.                super.treeSelectionModel.removeSelectionPath(this.root.getTreePath());
  32.             }
  33.          }
  34.  
  35.          if (super.treeSelectionModel != null) {
  36.             super.treeSelectionModel.resetRowSelection();
  37.          }
  38.  
  39.          if (this.getRowCount() > 0) {
  40.             this.getNode(0).setYOrigin(0);
  41.          }
  42.  
  43.          this.updateYLocationsFrom(0);
  44.          this.visibleNodesChanged();
  45.       }
  46.  
  47.       super.setRootVisible(var1);
  48.    }
  49.  
  50.    public void setRowHeight(int var1) {
  51.       if (var1 != ((AbstractLayoutCache)this).getRowHeight()) {
  52.          super.setRowHeight(var1);
  53.          this.invalidateSizes();
  54.          this.visibleNodesChanged();
  55.       }
  56.  
  57.    }
  58.  
  59.    public void setNodeDimensions(AbstractLayoutCache.NodeDimensions var1) {
  60.       super.setNodeDimensions(var1);
  61.       this.invalidateSizes();
  62.       this.visibleNodesChanged();
  63.    }
  64.  
  65.    public void setExpandedState(TreePath var1, boolean var2) {
  66.       if (var1 != null) {
  67.          if (var2) {
  68.             this.ensurePathIsExpanded(var1, true);
  69.          } else {
  70.             TreeStateNode var3 = this.getNodeForPath(var1, false, true);
  71.             if (var3 != null) {
  72.                var3.makeVisible();
  73.                var3.collapse();
  74.             }
  75.          }
  76.       }
  77.  
  78.    }
  79.  
  80.    public boolean getExpandedState(TreePath var1) {
  81.       TreeStateNode var2 = this.getNodeForPath(var1, true, false);
  82.       return var2 != null ? var2.isVisible() && var2.isExpanded() : false;
  83.    }
  84.  
  85.    public Rectangle getBounds(TreePath var1, Rectangle var2) {
  86.       TreeStateNode var3 = this.getNodeForPath(var1, true, false);
  87.       if (var3 != null) {
  88.          if (this.updateNodeSizes) {
  89.             this.updateNodeSizes(false);
  90.          }
  91.  
  92.          return var3.getNodeBounds(var2);
  93.       } else {
  94.          return null;
  95.       }
  96.    }
  97.  
  98.    public TreePath getPathForRow(int var1) {
  99.       return var1 >= 0 && var1 < this.getRowCount() ? this.getNode(var1).getTreePath() : null;
  100.    }
  101.  
  102.    public int getRowForPath(TreePath var1) {
  103.       if (var1 == null) {
  104.          return -1;
  105.       } else {
  106.          TreeStateNode var2 = this.getNodeForPath(var1, true, false);
  107.          return var2 != null ? var2.getRow() : -1;
  108.       }
  109.    }
  110.  
  111.    public int getRowCount() {
  112.       return this.visibleNodes.size();
  113.    }
  114.  
  115.    public void invalidatePathBounds(TreePath var1) {
  116.       TreeStateNode var2 = this.getNodeForPath(var1, true, false);
  117.       if (var2 != null) {
  118.          var2.markSizeInvalid();
  119.          if (var2.isVisible()) {
  120.             this.updateYLocationsFrom(var2.getRow());
  121.          }
  122.       }
  123.  
  124.    }
  125.  
  126.    public int getPreferredHeight() {
  127.       int var1 = this.getRowCount();
  128.       if (var1 > 0) {
  129.          TreeStateNode var2 = this.getNode(var1 - 1);
  130.          return var2.getYOrigin() + var2.getPreferredHeight();
  131.       } else {
  132.          return 0;
  133.       }
  134.    }
  135.  
  136.    public int getPreferredWidth(Rectangle var1) {
  137.       if (this.updateNodeSizes) {
  138.          this.updateNodeSizes(false);
  139.       }
  140.  
  141.       return this.getMaxNodeWidth();
  142.    }
  143.  
  144.    public TreePath getPathClosestTo(int var1, int var2) {
  145.       if (this.getRowCount() == 0) {
  146.          return null;
  147.       } else {
  148.          if (this.updateNodeSizes) {
  149.             this.updateNodeSizes(false);
  150.          }
  151.  
  152.          int var3 = this.getRowContainingYLocation(var2);
  153.          return this.getNode(var3).getTreePath();
  154.       }
  155.    }
  156.  
  157.    public Enumeration getVisiblePathsFrom(TreePath var1) {
  158.       TreeStateNode var2 = this.getNodeForPath(var1, true, false);
  159.       return var2 != null ? new VisibleTreeStateNodeEnumeration(this, var2) : null;
  160.    }
  161.  
  162.    public int getVisibleChildCount(TreePath var1) {
  163.       TreeStateNode var2 = this.getNodeForPath(var1, true, false);
  164.       return var2 != null ? var2.getVisibleChildCount() : 0;
  165.    }
  166.  
  167.    public void invalidateSizes() {
  168.       if (this.root != null) {
  169.          this.root.deepMarkSizeInvalid();
  170.       }
  171.  
  172.       if (!((AbstractLayoutCache)this).isFixedRowHeight() && this.visibleNodes.size() > 0) {
  173.          this.updateNodeSizes(true);
  174.       }
  175.  
  176.    }
  177.  
  178.    public boolean isExpanded(TreePath var1) {
  179.       if (var1 == null) {
  180.          return false;
  181.       } else {
  182.          TreeStateNode var2 = this.getNodeForPath(var1, true, false);
  183.          return var2 != null && var2.isExpanded();
  184.       }
  185.    }
  186.  
  187.    public void treeNodesChanged(TreeModelEvent var1) {
  188.       if (var1 != null) {
  189.          int[] var2 = var1.getChildIndices();
  190.          TreeStateNode var3 = this.getNodeForPath(var1.getTreePath(), false, false);
  191.          if (var3 != null) {
  192.             Object var4 = var3.getValue();
  193.             var3.updatePreferredSize();
  194.             if (var3.hasBeenExpanded() && var2 != null) {
  195.                for(int var5 = 0; var5 < var2.length; ++var5) {
  196.                   TreeStateNode var6 = (TreeStateNode)((DefaultMutableTreeNode)var3).getChildAt(var2[var5]);
  197.                   var6.setUserObject(super.treeModel.getChild(var4, var2[var5]));
  198.                   var6.updatePreferredSize();
  199.                }
  200.             } else if (var3 == this.root) {
  201.                var3.updatePreferredSize();
  202.             }
  203.  
  204.             if (!((AbstractLayoutCache)this).isFixedRowHeight()) {
  205.                int var7 = var3.getRow();
  206.                if (var7 != -1) {
  207.                   this.updateYLocationsFrom(var7);
  208.                }
  209.             }
  210.  
  211.             this.visibleNodesChanged();
  212.          }
  213.       }
  214.  
  215.    }
  216.  
  217.    public void treeNodesInserted(TreeModelEvent var1) {
  218.       if (var1 != null) {
  219.          int[] var2 = var1.getChildIndices();
  220.          TreeStateNode var3 = this.getNodeForPath(var1.getTreePath(), false, false);
  221.          if (var3 != null && var2 != null && var2.length > 0) {
  222.             if (var3.hasBeenExpanded()) {
  223.                int var8 = ((DefaultMutableTreeNode)var3).getChildCount();
  224.                Object var6 = var3.getValue();
  225.                boolean var4 = var3 == this.root && !super.rootVisible || var3.getRow() != -1 && var3.isExpanded();
  226.  
  227.                for(int var5 = 0; var5 < var2.length; ++var5) {
  228.                   this.createNodeAt(var3, var2[var5]);
  229.                }
  230.  
  231.                if (var8 == 0) {
  232.                   var3.updatePreferredSize();
  233.                }
  234.  
  235.                if (super.treeSelectionModel != null) {
  236.                   super.treeSelectionModel.resetRowSelection();
  237.                }
  238.  
  239.                if (!((AbstractLayoutCache)this).isFixedRowHeight() && (var4 || var8 == 0 && var3.isVisible())) {
  240.                   if (var3 == this.root) {
  241.                      this.updateYLocationsFrom(0);
  242.                   } else {
  243.                      this.updateYLocationsFrom(var3.getRow());
  244.                   }
  245.  
  246.                   this.visibleNodesChanged();
  247.                } else if (var4) {
  248.                   this.visibleNodesChanged();
  249.                }
  250.             } else if (super.treeModel.getChildCount(var3.getValue()) - var2.length == 0) {
  251.                var3.updatePreferredSize();
  252.                if (!((AbstractLayoutCache)this).isFixedRowHeight() && var3.isVisible()) {
  253.                   this.updateYLocationsFrom(var3.getRow());
  254.                }
  255.             }
  256.          }
  257.       }
  258.  
  259.    }
  260.  
  261.    public void treeNodesRemoved(TreeModelEvent var1) {
  262.       if (var1 != null) {
  263.          int[] var2 = var1.getChildIndices();
  264.          TreeStateNode var3 = this.getNodeForPath(var1.getTreePath(), false, false);
  265.          if (var3 != null && var2 != null && var2.length > 0) {
  266.             if (var3.hasBeenExpanded()) {
  267.                boolean var4 = var3 == this.root && !super.rootVisible || var3.getRow() != -1 && var3.isExpanded();
  268.  
  269.                for(int var5 = var2.length - 1; var5 >= 0; --var5) {
  270.                   TreeStateNode var7 = (TreeStateNode)((DefaultMutableTreeNode)var3).getChildAt(var2[var5]);
  271.                   if (var7.isExpanded()) {
  272.                      var7.collapse(false);
  273.                   }
  274.  
  275.                   if (var4) {
  276.                      int var6 = var7.getRow();
  277.                      if (var6 != -1) {
  278.                         this.visibleNodes.removeElementAt(var6);
  279.                      }
  280.                   }
  281.  
  282.                   var3.remove(var2[var5]);
  283.                }
  284.  
  285.                if (((DefaultMutableTreeNode)var3).getChildCount() == 0) {
  286.                   var3.updatePreferredSize();
  287.                }
  288.  
  289.                if (super.treeSelectionModel != null) {
  290.                   super.treeSelectionModel.resetRowSelection();
  291.                }
  292.  
  293.                if (!((AbstractLayoutCache)this).isFixedRowHeight() && (var4 || ((DefaultMutableTreeNode)var3).getChildCount() == 0 && var3.isVisible())) {
  294.                   if (var3 == this.root) {
  295.                      if (this.getRowCount() > 0) {
  296.                         this.getNode(0).setYOrigin(0);
  297.                      }
  298.  
  299.                      this.updateYLocationsFrom(0);
  300.                   } else {
  301.                      this.updateYLocationsFrom(var3.getRow());
  302.                   }
  303.  
  304.                   this.visibleNodesChanged();
  305.                } else if (var4) {
  306.                   this.visibleNodesChanged();
  307.                }
  308.             } else if (super.treeModel.getChildCount(var3.getValue()) == 0) {
  309.                var3.updatePreferredSize();
  310.                if (!((AbstractLayoutCache)this).isFixedRowHeight() && var3.isVisible()) {
  311.                   this.updateYLocationsFrom(var3.getRow());
  312.                }
  313.             }
  314.          }
  315.       }
  316.  
  317.    }
  318.  
  319.    public void treeStructureChanged(TreeModelEvent var1) {
  320.       if (var1 != null) {
  321.          TreePath var2 = var1.getTreePath();
  322.          TreeStateNode var3 = this.getNodeForPath(var2, false, false);
  323.          if (var3 == null && var2 != null && var2.getPathCount() == 1) {
  324.             var3 = this.root;
  325.          }
  326.  
  327.          if (var3 != null) {
  328.             boolean var4 = var3.isExpanded();
  329.             boolean var5 = var3.getRow() != -1;
  330.             if (var3 == this.root) {
  331.                this.rebuild();
  332.             } else {
  333.                TreeStateNode var10 = (TreeStateNode)((DefaultMutableTreeNode)var3).getParent();
  334.                int var7 = ((DefaultMutableTreeNode)var10).getIndex(var3);
  335.                if (var5 && var4) {
  336.                   var3.collapse(false);
  337.                }
  338.  
  339.                if (var5) {
  340.                   this.visibleNodes.removeElement(var3);
  341.                }
  342.  
  343.                ((DefaultMutableTreeNode)var3).removeFromParent();
  344.                this.createNodeAt(var10, var7);
  345.                TreeStateNode var9 = (TreeStateNode)((DefaultMutableTreeNode)var10).getChildAt(var7);
  346.                if (var5 && var4) {
  347.                   var9.expand(false);
  348.                }
  349.  
  350.                int var6 = var9.getRow();
  351.                if (!((AbstractLayoutCache)this).isFixedRowHeight() && var5) {
  352.                   if (var6 == 0) {
  353.                      this.updateYLocationsFrom(var6);
  354.                   } else {
  355.                      this.updateYLocationsFrom(var6 - 1);
  356.                   }
  357.  
  358.                   this.visibleNodesChanged();
  359.                } else if (var5) {
  360.                   this.visibleNodesChanged();
  361.                }
  362.             }
  363.          }
  364.       }
  365.  
  366.    }
  367.  
  368.    private void visibleNodesChanged() {
  369.    }
  370.  
  371.    private void addMapping(TreeStateNode var1) {
  372.       this.treePathMapping.put(var1.getTreePath(), var1);
  373.    }
  374.  
  375.    private void removeMapping(TreeStateNode var1) {
  376.       this.treePathMapping.remove(var1.getTreePath());
  377.    }
  378.  
  379.    private TreeStateNode getMapping(TreePath var1) {
  380.       return (TreeStateNode)this.treePathMapping.get(var1);
  381.    }
  382.  
  383.    private Rectangle getBounds(int var1, Rectangle var2) {
  384.       if (this.updateNodeSizes) {
  385.          this.updateNodeSizes(false);
  386.       }
  387.  
  388.       return var1 >= 0 && var1 < this.getRowCount() ? this.getNode(var1).getNodeBounds(var2) : null;
  389.    }
  390.  
  391.    private void rebuild() {
  392.       this.treePathMapping.clear();
  393.       if (super.treeModel != null) {
  394.          Object var1 = super.treeModel.getRoot();
  395.          this.root = this.createNodeForValue(var1);
  396.          this.root.path = new TreePath(var1);
  397.          this.addMapping(this.root);
  398.          this.root.updatePreferredSize(0);
  399.          this.visibleNodes.removeAllElements();
  400.          if (((AbstractLayoutCache)this).isRootVisible()) {
  401.             this.visibleNodes.addElement(this.root);
  402.          }
  403.  
  404.          if (!this.root.isExpanded()) {
  405.             this.root.expand();
  406.          } else {
  407.             Enumeration var2 = this.root.children();
  408.  
  409.             while(var2.hasMoreElements()) {
  410.                this.visibleNodes.addElement(var2.nextElement());
  411.             }
  412.  
  413.             if (!((AbstractLayoutCache)this).isFixedRowHeight()) {
  414.                this.updateYLocationsFrom(0);
  415.             }
  416.          }
  417.       } else {
  418.          this.visibleNodes.removeAllElements();
  419.          this.root = null;
  420.       }
  421.  
  422.       if (super.treeSelectionModel != null) {
  423.          super.treeSelectionModel.clearSelection();
  424.       }
  425.  
  426.       this.visibleNodesChanged();
  427.    }
  428.  
  429.    private TreeStateNode createNodeAt(TreeStateNode var1, int var2) {
  430.       Object var4 = super.treeModel.getChild(var1.getValue(), var2);
  431.       TreeStateNode var5 = this.createNodeForValue(var4);
  432.       ((DefaultMutableTreeNode)var1).insert(var5, var2);
  433.       var5.updatePreferredSize(-1);
  434.       boolean var3 = var1 == this.root;
  435.       if (var5 != null && var1.isExpanded() && (var1.getRow() != -1 || var3)) {
  436.          int var6;
  437.          if (var2 == 0) {
  438.             if (var3 && !((AbstractLayoutCache)this).isRootVisible()) {
  439.                var6 = 0;
  440.             } else {
  441.                var6 = var1.getRow() + 1;
  442.             }
  443.          } else if (var2 == ((DefaultMutableTreeNode)var1).getChildCount()) {
  444.             var6 = var1.getLastVisibleNode().getRow() + 1;
  445.          } else {
  446.             TreeStateNode var7 = (TreeStateNode)((DefaultMutableTreeNode)var1).getChildAt(var2 - 1);
  447.             var6 = var7.getLastVisibleNode().getRow() + 1;
  448.          }
  449.  
  450.          this.visibleNodes.insertElementAt(var5, var6);
  451.       }
  452.  
  453.       return var5;
  454.    }
  455.  
  456.    private TreeStateNode getNodeForPath(TreePath var1, boolean var2, boolean var3) {
  457.       if (var1 != null) {
  458.          TreeStateNode var4 = this.getMapping(var1);
  459.          if (var4 != null) {
  460.             if (var2 && !var4.isVisible()) {
  461.                return null;
  462.             } else {
  463.                return var4;
  464.             }
  465.          } else {
  466.             Stack var5;
  467.             if (this.tempStacks.size() == 0) {
  468.                var5 = new Stack();
  469.             } else {
  470.                var5 = (Stack)this.tempStacks.pop();
  471.             }
  472.  
  473.             try {
  474.                var5.push(var1);
  475.                var1 = var1.getParentPath();
  476.  
  477.                for(Object var13 = null; var1 != null; var1 = var1.getParentPath()) {
  478.                   var4 = this.getMapping(var1);
  479.                   if (var4 != null) {
  480.                      while(var4 != null && ((Vector)var5).size() > 0) {
  481.                         var1 = (TreePath)var5.pop();
  482.                         var4.getLoadedChildren(var3);
  483.                         int var6 = super.treeModel.getIndexOfChild(((DefaultMutableTreeNode)var4).getUserObject(), var1.getLastPathComponent());
  484.                         if (var6 != -1 && var6 < ((DefaultMutableTreeNode)var4).getChildCount() && (!var2 || var4.isVisible())) {
  485.                            var4 = (TreeStateNode)((DefaultMutableTreeNode)var4).getChildAt(var6);
  486.                         } else {
  487.                            var4 = null;
  488.                         }
  489.                      }
  490.  
  491.                      TreeStateNode var15 = var4;
  492.                      return var15;
  493.                   }
  494.  
  495.                   var5.push(var1);
  496.                }
  497.  
  498.                return null;
  499.             } finally {
  500.                ((Vector)var5).removeAllElements();
  501.                this.tempStacks.push(var5);
  502.             }
  503.          }
  504.       } else {
  505.          return null;
  506.       }
  507.    }
  508.  
  509.    private void updateYLocationsFrom(int var1) {
  510.       if (var1 >= 0 && var1 < this.getRowCount()) {
  511.          TreeStateNode var5 = this.getNode(var1);
  512.          int var4 = var5.getYOrigin() + var5.getPreferredHeight();
  513.          int var2 = var1 + 1;
  514.  
  515.          for(int var3 = this.visibleNodes.size(); var2 < var3; ++var2) {
  516.             var5 = (TreeStateNode)this.visibleNodes.elementAt(var2);
  517.             var5.setYOrigin(var4);
  518.             var4 += var5.getPreferredHeight();
  519.          }
  520.       }
  521.  
  522.    }
  523.  
  524.    private void updateNodeSizes(boolean var1) {
  525.       this.updateNodeSizes = false;
  526.       int var3 = 0;
  527.       int var2 = 0;
  528.  
  529.       for(int var4 = this.visibleNodes.size(); var3 < var4; ++var3) {
  530.          TreeStateNode var5 = (TreeStateNode)this.visibleNodes.elementAt(var3);
  531.          var5.setYOrigin(var2);
  532.          if (var1 || !var5.hasValidSize()) {
  533.             var5.updatePreferredSize(var3);
  534.          }
  535.  
  536.          var2 += var5.getPreferredHeight();
  537.       }
  538.  
  539.    }
  540.  
  541.    private int getRowContainingYLocation(int var1) {
  542.       if (((AbstractLayoutCache)this).isFixedRowHeight()) {
  543.          return this.getRowCount() == 0 ? -1 : Math.max(0, Math.min(this.getRowCount() - 1, var1 / ((AbstractLayoutCache)this).getRowHeight()));
  544.       } else {
  545.          int var2;
  546.          if ((var2 = this.getRowCount()) <= 0) {
  547.             return -1;
  548.          } else {
  549.             int var5 = 0;
  550.             int var4 = 0;
  551.  
  552.             while(var5 < var2) {
  553.                var4 = (var2 - var5) / 2 + var5;
  554.                TreeStateNode var7 = (TreeStateNode)this.visibleNodes.elementAt(var4);
  555.                int var6 = var7.getYOrigin();
  556.                int var3 = var6 + var7.getPreferredHeight();
  557.                if (var1 < var6) {
  558.                   var2 = var4 - 1;
  559.                } else {
  560.                   if (var1 < var3) {
  561.                      break;
  562.                   }
  563.  
  564.                   var5 = var4 + 1;
  565.                }
  566.             }
  567.  
  568.             if (var5 == var2) {
  569.                var4 = var5;
  570.                if (var5 >= this.getRowCount()) {
  571.                   var4 = this.getRowCount() - 1;
  572.                }
  573.             }
  574.  
  575.             return var4;
  576.          }
  577.       }
  578.    }
  579.  
  580.    private void ensurePathIsExpanded(TreePath var1, boolean var2) {
  581.       if (var1 != null) {
  582.          if (super.treeModel.isLeaf(var1.getLastPathComponent())) {
  583.             var1 = var1.getParentPath();
  584.             var2 = true;
  585.          }
  586.  
  587.          if (var1 != null) {
  588.             TreeStateNode var3 = this.getNodeForPath(var1, false, true);
  589.             if (var3 != null) {
  590.                var3.makeVisible();
  591.                if (var2) {
  592.                   var3.expand();
  593.                }
  594.             }
  595.          }
  596.       }
  597.  
  598.    }
  599.  
  600.    private TreeStateNode getNode(int var1) {
  601.       return (TreeStateNode)this.visibleNodes.elementAt(var1);
  602.    }
  603.  
  604.    private int getMaxNodeWidth() {
  605.       int var1 = 0;
  606.  
  607.       for(int var3 = this.getRowCount() - 1; var3 >= 0; --var3) {
  608.          TreeStateNode var4 = this.getNode(var3);
  609.          int var2 = var4.getPreferredWidth() + var4.getXOrigin();
  610.          if (var2 > var1) {
  611.             var1 = var2;
  612.          }
  613.       }
  614.  
  615.       return var1;
  616.    }
  617.  
  618.    private TreeStateNode createNodeForValue(Object var1) {
  619.       return new TreeStateNode(this, var1);
  620.    }
  621.  
  622.    // $FF: synthetic method
  623.    static void access$000(VariableHeightLayoutCache var0, TreeStateNode var1) {
  624.       var0.addMapping(var1);
  625.    }
  626.  
  627.    // $FF: synthetic method
  628.    static Vector access$100(VariableHeightLayoutCache var0) {
  629.       return var0.visibleNodes;
  630.    }
  631.  
  632.    // $FF: synthetic method
  633.    static TreeStateNode access$200(VariableHeightLayoutCache var0) {
  634.       return var0.root;
  635.    }
  636.  
  637.    // $FF: synthetic method
  638.    static void access$300(VariableHeightLayoutCache var0, TreeStateNode var1) {
  639.       var0.removeMapping(var1);
  640.    }
  641.  
  642.    // $FF: synthetic method
  643.    static Rectangle access$400(VariableHeightLayoutCache var0) {
  644.       return var0.boundsBuffer;
  645.    }
  646.  
  647.    // $FF: synthetic method
  648.    static boolean access$502(VariableHeightLayoutCache var0, boolean var1) {
  649.       return var0.updateNodeSizes = var1;
  650.    }
  651.  
  652.    // $FF: synthetic method
  653.    static TreeStateNode access$600(VariableHeightLayoutCache var0, Object var1) {
  654.       return var0.createNodeForValue(var1);
  655.    }
  656.  
  657.    // $FF: synthetic method
  658.    static boolean access$500(VariableHeightLayoutCache var0) {
  659.       return var0.updateNodeSizes;
  660.    }
  661.  
  662.    // $FF: synthetic method
  663.    static void access$700(VariableHeightLayoutCache var0) {
  664.       var0.visibleNodesChanged();
  665.    }
  666. }
  667.