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