Uploaded image for project: 'JDK'
  1. JDK
  2. JDK-4688098

JTree.DynamicUtilTreeNode should support List and Map

    XMLWordPrintable

    Details

    • Type: Bug
    • Status: Closed
    • Priority: P4
    • Resolution: Duplicate
    • Affects Version/s: 1.4.0
    • Fix Version/s: None
    • Component/s: client-libs
    • Labels:

      Description



      Name: jl125535 Date: 05/20/2002


      FULL PRODUCT VERSION :
      java version "1.4.0-beta3"
      Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.0-beta3-b84)Java
      HotSpot(TM) Client VM (build 1.4.0-beta3-b84, mixed mode)
      Verified in 1.4.

      A DESCRIPTION OF THE PROBLEM :
      The utility class javax.swing.JTree.DynamicUtilTreeNode
      can be used to convert Vector and Hashtable objects to tree
      nodes. (See the javadoc for the constructor.)

      It could be generalized so that it supports the more generic
      Map and List interfaces. This should not interfere with the
      existing functionality since the generalization is straightforward
      (see the Source section below).


      This bug can be reproduced always.

      ---------- BEGIN SOURCE ----------
      I adapted the code and the javadocs of the JTree.java file of JDK1.4 beta3 (to
      co). I changed some occurrences of Vector and HashTable to List and Map.
      Note that i'm not proficient with the diff tool, but I included an output to
      highlight the differences below. (I intended to include the adapted JTree.java
      file, but your bug database script does not seem to accept such a long text).
      Note that the diff is meant to describe the change I want to be made, I have not
       used the adapted version.

      //////////////////////////// diff -C 2 of JTree.java /////////////////////

      *** JTree.java Tue Jan 15 00:10:25 2002
      --- /tmp/java/javax/swing/JTree.java Sat Oct 20 09:15:03 2001
      ***************
      *** 375,380 ****
             * If the object is:<ul>
             * <li>an array of <code>Object</code>s,
      ! * <li>a <code>Map</code>, or
      ! * <li>a <code>java.util.List</code>
             * </ul>then a new root node is created with each of the incoming
             * objects as children. Otherwise, a new root is created with the
      --- 375,380 ----
             * If the object is:<ul>
             * <li>an array of <code>Object</code>s,
      ! * <li>a <code>Hashtable</code>, or
      ! * <li>a <code>Vector</code>
             * </ul>then a new root node is created with each of the incoming
             * objects as children. Otherwise, a new root is created with the
      ***************
      *** 388,393 ****
                DefaultMutableTreeNode root;
        
      ! if((value instanceof Object[]) || (value instanceof Map) ||
      ! (value instanceof java.util.List)) {
                    root = new DefaultMutableTreeNode("root");
                    DynamicUtilTreeNode.createChildren(root, value);
      --- 388,393 ----
                DefaultMutableTreeNode root;
        
      ! if((value instanceof Object[]) || (value instanceof Hashtable) ||
      ! (value instanceof Vector)) {
                    root = new DefaultMutableTreeNode("root");
                    DynamicUtilTreeNode.createChildren(root, value);
      ***************
      *** 433,446 ****
            /**
             * Returns a <code>JTree</code> with each element of the specified
      ! * <code>java.util.List</code> as the
             * child of a new root node which is not displayed. By default, the
             * tree defines a leaf node as any node without children.
             *
      ! * @param value a <code>java.util.List</code>
             * @return a <code>JTree</code> with the contents of the
      ! * <code>java.util.List</code> as children of the root node
             * @see DefaultTreeModel#asksAllowsChildren
             */
      ! public JTree(java.util.List value) {
                this(createTreeModel(value));
                this.setRootVisible(false);
      --- 433,446 ----
            /**
             * Returns a <code>JTree</code> with each element of the specified
      ! * <code>Vector</code> as the
             * child of a new root node which is not displayed. By default, the
             * tree defines a leaf node as any node without children.
             *
      ! * @param value a <code>Vector</code>
             * @return a <code>JTree</code> with the contents of the
      ! * <code>Vector</code> as children of the root node
             * @see DefaultTreeModel#asksAllowsChildren
             */
      ! public JTree(Vector value) {
                this(createTreeModel(value));
                this.setRootVisible(false);
      ***************
      *** 450,454 ****
        
            /**
      ! * Returns a <code>JTree</code> created from a <code>Map</code>
             * which does not display with root.
             * Each value-half of the key/value pairs in the <code>HashTable</code>
      --- 450,454 ----
        
            /**
      ! * Returns a <code>JTree</code> created from a <code>Hashtable</code>
             * which does not display with root.
             * Each value-half of the key/value pairs in the <code>HashTable</code>
      ***************
      *** 456,465 ****
             * a leaf node as any node without children.
             *
      ! * @param value a <code>Map</code>
             * @return a <code>JTree</code> with the contents of the
      ! * <code>Map</code> as children of the root node
             * @see DefaultTreeModel#asksAllowsChildren
             */
      ! public JTree(Map value) {
                this(createTreeModel(value));
                this.setRootVisible(false);
      --- 456,465 ----
             * a leaf node as any node without children.
             *
      ! * @param value a <code>Hashtable</code>
             * @return a <code>JTree</code> with the contents of the
      ! * <code>Hashtable</code> as children of the root node
             * @see DefaultTreeModel#asksAllowsChildren
             */
      ! public JTree(Hashtable value) {
                this(createTreeModel(value));
                this.setRootVisible(false);
      ***************
      *** 3269,3288 ****
                public static void createChildren(DefaultMutableTreeNode parent,
                                                  Object children) {
      ! if(children instanceof java.util.List) {
      ! java.util.List childList = (java.util.List)children;
        
      ! for(int counter = 0, maxCounter = childList.size();
                            counter < maxCounter; counter++)
                            parent.add(new DynamicUtilTreeNode
      ! (childList.get(counter),
      ! childList.get(counter)));
                    }
      ! else if(children instanceof Map) {
      ! Map childHT = (Map)children;
      ! Iterator keys = childHT.keySet().iterator();
                        Object aKey;
        
      ! while(keys.hasNext()) {
      ! aKey = keys.next();
                            parent.add(new DynamicUtilTreeNode(aKey,
                                                               childHT.get(aKey)));
      --- 3269,3288 ----
                public static void createChildren(DefaultMutableTreeNode parent,
                                                  Object children) {
      ! if(children instanceof Vector) {
      ! Vector childVector = (Vector)children;
        
      ! for(int counter = 0, maxCounter = childVector.size();
                            counter < maxCounter; counter++)
                            parent.add(new DynamicUtilTreeNode
      ! (childVector.elementAt(counter),
      ! childVector.elementAt(counter)));
                    }
      ! else if(children instanceof Hashtable) {
      ! Hashtable childHT = (Hashtable)children;
      ! Enumeration keys = childHT.keys();
                        Object aKey;
        
      ! while(keys.hasMoreElements()) {
      ! aKey = keys.nextElement();
                            parent.add(new DynamicUtilTreeNode(aKey,
                                                               childHT.get(aKey)));
      ***************
      *** 3303,3307 ****
                 * with the specified children. For the node to allow children,
                 * the children-object must be an array of objects, a
      ! * <code>java.util.List</code>, or a <code>Map</code> -- even
                 * if empty. Otherwise, the node is not
                 * allowed to have children.
      --- 3303,3307 ----
                 * with the specified children. For the node to allow children,
                 * the children-object must be an array of objects, a
      ! * <code>Vector</code>, or a <code>Hashtable</code> -- even
                 * if empty. Otherwise, the node is not
                 * allowed to have children.
      ***************
      *** 3310,3314 ****
                 * new node
                 * @param children an array of <code>Object</code>s, a
      ! * <code>java.util.List</code>, or a <code>Map</code>
                 * used to create the child nodes; if any other
                 * object is specified, or if the value is
      --- 3310,3314 ----
                 * new node
                 * @param children an array of <code>Object</code>s, a
      ! * <code>Vector</code>, or a <code>Hashtable</code>
                 * used to create the child nodes; if any other
                 * object is specified, or if the value is
      ***************
      *** 3321,3327 ****
                    childValue = children;
                    if(children != null) {
      ! if(children instanceof java.util.List)
                            setAllowsChildren(true);
      ! else if(children instanceof Map)
                            setAllowsChildren(true);
                        else if(children instanceof Object[])
      --- 3321,3327 ----
                    childValue = children;
                    if(children != null) {
      ! if(children instanceof Vector)
                            setAllowsChildren(true);
      ! else if(children instanceof Hashtable)
                            setAllowsChildren(true);
                        else if(children instanceof Object[])
      ***************
      *** 3358,3365 ****
                /**
                 * Loads the children based on <code>childValue</code>.
      ! * If <code>childValue</code> is a <code>java.util.List
      ! </code>
                 * or array each element is added as a child,
      ! * if <code>childValue</code> is a <code>Map</code>
                 * each key/value pair is added in the order that
                 * <code>Enumeration</code> returns the keys.
      --- 3358,3364 ----
                /**
                 * Loads the children based on <code>childValue</code>.
      ! * If <code>childValue</code> is a <code>Vector</code>
                 * or array each element is added as a child,
      ! * if <code>childValue</code> is a <code>Hashtable</code>
                 * each key/value pair is added in the order that
                 * <code>Enumeration</code> returns the keys.



      ---------- END SOURCE ----------
      (Review ID: 138287)
      ======================================================================

        Attachments

          Issue Links

            Activity

              People

              Assignee:
              svioletsunw Scott Violet (Inactive)
              Reporter:
              jleesunw Jon Lee (Inactive)
              Votes:
              0 Vote for this issue
              Watchers:
              0 Start watching this issue

                Dates

                Created:
                Updated:
                Resolved:
                Imported:
                Indexed: