Announcement

**shortpasta** · 1 Sep 2012, 11:06

New test cases, same results...

Here is a new test case: it is like the previous one, but the Load button only loads Root A.
When you expand Root A, then it loads its children.

1. Click Load Root A, which loads ONLY Root A
2. Expand Root A, which loads the children because childArray is empty
3. Click Remove Root A
4. Click Load Root A, which loads ONLY Root A
The tree shows Root A, and ALSO its children, confirming that tree.remove () is not working.

And here is a similar test case:
1. Click Load Root A, which loads ONLY Root A
2. Expand Root A, which loads the children. onFolderOpenend (), childArray is empty
3. Close Root A
4. Click Remove Root A
5. Click Load Root A, which loads ONLY Root A
6. Expand Root A, which does NOT load children because childArray is of size 2
This confirms that tree.remove () is not removing its children.

The final and possibly most interesting issue here is this test case:
1. Click Load Root A, which loads ONLY Root A, and Root A shows the icon to allow expanding it
2. Expand Root A, which loads the children. onFolderOpenend (), childArray is empty
3. Click Remove Root A Recursive (this is the method that deletes all children recursively)
4. Click Load Root A, which loads ONLY Root A, except that this time it does NOT show the icon to allow expanding it

If anybody has any ideas, shoot and I will gladly try them.

Code:

import com.smartgwt.client.widgets.tree.TreeGrid;
import com.smartgwt.client.widgets.tree.Tree;
import com.smartgwt.client.widgets.tree.TreeGridField;
import com.smartgwt.client.widgets.tree.TreeNode;
import com.smartgwt.client.widgets.tree.events.FolderOpenedHandler;
import com.smartgwt.client.widgets.tree.events.FolderOpenedEvent;
import com.smartgwt.client.widgets.layout.VLayout;
import com.smartgwt.client.widgets.events.ClickHandler;
import com.smartgwt.client.widgets.events.ClickEvent;
import com.smartgwt.client.widgets.IButton;
import com.smartgwt.client.types.SortDirection;
import com.smartgwt.client.types.TreeModelType;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;

public class TestTreeRemove implements EntryPoint {
  

  /**
   * The EntryPoint interface
   * See http://forums.smartclient.com/showthread.php?t=23429
   */
  public void onModuleLoad () {

    // configure Tree
    final Tree tree = new Tree ();
    tree.setModelType (TreeModelType.PARENT);
    tree.setNameProperty ("name");
    tree.setIdField ("nodeId");
    tree.setParentIdField ("parentNodeId");
    tree.setShowRoot (true);

    // configure root TreeNode
    final TreeNode rootTreeNode = new TreeNode ("root");
    rootTreeNode.setAttribute (tree.getIdField (), 1);
    
    tree.setRoot (rootTreeNode);

    // configure TreeGrid
    final TreeGridField nameField = new TreeGridField ("name", "Name", 200);
    final TreeGrid treeGrid = new TreeGrid ();
    treeGrid.setWidth (300);
    treeGrid.setHeight (200);
    treeGrid.setSortFoldersBeforeLeaves (true);
    treeGrid.setSortDirection (SortDirection.ASCENDING);
    treeGrid.setFields (nameField);
    treeGrid.setData (tree);
    
    // handle expansion
    final TreeNode rootATreeNode = new TreeNode ();
    treeGrid.addFolderOpenedHandler (new FolderOpenedHandler () {
      public void onFolderOpened (final FolderOpenedEvent event) {

        // check children
        final TreeNode treeNode = event.getNode ();
        final TreeNode[] childArray = tree.getChildren (treeNode);
        final String childArrayDescription = childArray != null ?
          String.valueOf (childArray.length) + " elements" :
          "null";
        GWT.log ("onFolderOpened (). name: " + treeNode.getAttribute ("name") + ", " + childArrayDescription);
        
        // add children
        if (childArray == null || childArray.length == 0) {
          
          GWT.log ("onFolderOpened (). loading children because childArray is " + (childArray == null ? "null" : "empty"));
          final TreeNode childA = new TreeNode ();
          childA.setAttribute (tree.getIdField (), 3);
          childA.setAttribute (tree.getParentIdField (), 2);
          childA.setAttribute ("name", "Root A - Child A");
          tree.add (childA, rootATreeNode);
    
          final TreeNode childB = new TreeNode ();
          childB.setAttribute (tree.getIdField (), 4);
          childB.setAttribute (tree.getParentIdField (), 2);
          childB.setAttribute ("name", "Root A - Child B");
          tree.add (childB, rootATreeNode);
        }
      }
    });
    
    // Root A
    //   Root A - Child A
    //   Root A - Child B
    final IButton loadButton = new IButton ();
    loadButton.setTitle ("Load Root A");
    loadButton.addClickHandler (new ClickHandler () {
      public void onClick (final ClickEvent event) {

        rootATreeNode.setAttribute (tree.getIdField (), 2);
        rootATreeNode.setAttribute (tree.getParentIdField (), 1);
        rootATreeNode.setAttribute ("name", "Root A");
        rootATreeNode.setIsFolder (true);
        tree.add (rootATreeNode, rootTreeNode);
      }
    });

    // button to delete the root
    final IButton removeRootAButton = new IButton ();
    removeRootAButton.setTitle ("Remove Root A");
    removeRootAButton.addClickHandler (new ClickHandler () {
      public void onClick (final ClickEvent event) {

        tree.remove (rootATreeNode);
      }
    });
    
    // button to delete the root
    final IButton removeRootARecursiveButton = new IButton ();
    removeRootARecursiveButton.setTitle ("Remove Root A Recursive");
    removeRootARecursiveButton.addClickHandler (new ClickHandler () {
      public void onClick (final ClickEvent event) {

        removeTreeNodeExceptForRootTreeNode (tree, rootTreeNode);
      }
    });

    // button to dump the tree
    final IButton dumpTreeButton = new IButton ();
    dumpTreeButton.setTitle ("Dump Tree");
    dumpTreeButton.addClickHandler (new ClickHandler () {
      public void onClick (final ClickEvent event) {

        final TreeNode treeNode = tree.getRoot ();
        final String prefix = " ";
        dumpTreeNode (tree, treeNode, prefix);
      }
    });

    // layout
    final VLayout layout = new VLayout ();
    layout.addMember (treeGrid);
    layout.addMember (loadButton);
    layout.addMember (removeRootAButton);
    layout.addMember (removeRootARecursiveButton);
    layout.addMember (dumpTreeButton);
    layout.show ();
  }

  /**
   * Dumps the given TreeNode
   * @param tree
   * @param treeNode
   * @param prefix
   */
  private void dumpTreeNode (
    final Tree tree,
    final TreeNode treeNode,
    final String prefix) {

    // log
    GWT.log (
      prefix +
      "id: " + treeNode.getAttributeAsInt (tree.getIdField ()) +
      "parentId: " + treeNode.getAttributeAsInt (tree.getParentIdField ()) +
      "");
    
    // dump children
    final TreeNode[] childTreeNodeArray = tree.getChildren (treeNode);
    if (childTreeNodeArray != null) {
      for (final TreeNode childTreeNode : childTreeNodeArray) {
        dumpTreeNode (tree, childTreeNode, prefix + prefix);
      }
    }
  }
  
  /**
   * Removes the given TreeNode and all its children
   * @param tree
   * @param treeNode
   */
  private void removeTreeNodeExceptForRootTreeNode (
    final Tree tree,
    final TreeNode treeNode) {
    
    // remove children first
    final TreeNode[] childTreeNodeArray = tree.getChildren (treeNode);
    if (childTreeNodeArray != null) {
      for (final TreeNode childTreeNode : childTreeNodeArray) {
        removeTreeNodeExceptForRootTreeNode (tree, childTreeNode);
      }
    }
    
    // finally remove this node, unless it is the root
    if (treeNode.getAttributeAsInt (tree.getIdField ()) != 1) {
      tree.remove (treeNode);
    }
    else {
      GWT.log ("removeTreeNodeRecursive (): not deleting rootTreeNode");
    }
  }
}

Attached Files

**shortpasta** · 5 Sep 2012, 15:15

I added an additional validation check by calling tree.hasChildren (treeNode) before adding children to it.

After invoking tree.remove (treeNode); on "Root A", I added the following calls in onFolderOpened ():

Code:

final TreeNode[] childArray = tree.getChildren (treeNode);
final Boolean hasChildren = tree.hasChildren (treeNode);

In this test case I do this:
1. Add Root A
2. Expand Root A which adds 2 child nodes. At this point, the above invocations indicate that Root A has 0 children.
3. Remove Root A (by either method)
4. Add Root A
5. Expand Root A to add 2 child nodes, but before it gets to add them, both of the above invocations indicate that Root A has 2 children...

Am I doing this right?
If anybody is removing treeNodes from a Tree, can you tell me how you are doing it?
Any advice to help figure this out?

**blong** · 18 Dec 2012, 10:50

Ever get feedback on this?

Has anyone reached out to you with info on this? I'm starting to wonder if I can trust SmartGWT's TreeGrid, etc.

**Isomorphic** · 18 Dec 2012, 11:08

This wasn't reproducible when we looked at it. Are you reproducing it with any current builds?

**shortpasta** · 18 Dec 2012, 12:45

I just retested this with:
SmartGWT 3.1p-2012-11-23
SmartClient Version: v8.3p_2012-11-23/LGPL Development Only (built 2012-11-23)
GWT 2.5.0
FF 6.0.2

And I am getting the expected result.

With several previous builds including SmartGWT 3.0p-2012-04-26 and 3.0p-2012-08-31:
1. Click Load Root A, which loads ONLY Root A
2. Expand Root A, which loads the children. onFolderOpenend (), childArray is empty
3. Close Root A
4. Click Remove Root A
5. Click Load Root A, which loads ONLY Root A
6. Expand Root A, which does NOT load children because childArray is of size 2, which confirms that tree.remove () is not removing its children.

With 3.1p-2012-11-23 step #6 does load the children because childArray is now of size 0. So this seems to work as expected to me.

Announcement

Tree.remove () does not remove children

Comment

Comment

Comment

Comment

Comment