From: Artur Signell Date: Fri, 19 Feb 2010 12:18:01 +0000 (+0000) Subject: Moved Expand/Collapse method references to listener class and added Tree listener... X-Git-Tag: 6.7.0.beta1~2037 X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=0912071d8c6a65be05f1fe81bb3b998fb56ce63e;p=vaadin-framework.git Moved Expand/Collapse method references to listener class and added Tree listener test case svn changeset:11401/svn branch:6.3 --- diff --git a/src/com/vaadin/ui/Tree.java b/src/com/vaadin/ui/Tree.java index 28a410fa13..7b1dad3911 100644 --- a/src/com/vaadin/ui/Tree.java +++ b/src/com/vaadin/ui/Tree.java @@ -32,6 +32,7 @@ import com.vaadin.terminal.PaintTarget; import com.vaadin.terminal.Resource; import com.vaadin.terminal.gwt.client.MouseEventDetails; import com.vaadin.terminal.gwt.client.ui.VTree; +import com.vaadin.tools.ReflectTools; /** * Tree component. A Tree can be used to select an item (or multiple items) from @@ -47,29 +48,12 @@ import com.vaadin.terminal.gwt.client.ui.VTree; public class Tree extends AbstractSelect implements Container.Hierarchical, Action.Container, ItemClickSource { - private static final Method EXPAND_METHOD; - - private static final Method COLLAPSE_METHOD; - - static { - try { - EXPAND_METHOD = ExpandListener.class.getDeclaredMethod( - "nodeExpand", new Class[] { ExpandEvent.class }); - COLLAPSE_METHOD = CollapseListener.class.getDeclaredMethod( - "nodeCollapse", new Class[] { CollapseEvent.class }); - } catch (final java.lang.NoSuchMethodException e) { - // This should never happen - throw new java.lang.RuntimeException( - "Internal error finding methods in Tree"); - } - } - /* Private members */ /** * Set of expanded nodes. */ - private final HashSet expanded = new HashSet(); + private final HashSet expanded = new HashSet(); /** * List of action handlers. @@ -743,6 +727,9 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, */ public interface ExpandListener extends Serializable { + public static final Method EXPAND_METHOD = ReflectTools.findMethod( + ExpandListener.class, "nodeExpand", ExpandEvent.class); + /** * A node has been expanded. * @@ -759,7 +746,7 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, * the Listener to be added. */ public void addListener(ExpandListener listener) { - addListener(ExpandEvent.class, listener, EXPAND_METHOD); + addListener(ExpandEvent.class, listener, ExpandListener.EXPAND_METHOD); } /** @@ -769,7 +756,8 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, * the Listener to be removed. */ public void removeListener(ExpandListener listener) { - removeListener(ExpandEvent.class, listener, EXPAND_METHOD); + removeListener(ExpandEvent.class, listener, + ExpandListener.EXPAND_METHOD); } /** @@ -828,6 +816,9 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, */ public interface CollapseListener extends Serializable { + public static final Method COLLAPSE_METHOD = ReflectTools.findMethod( + CollapseListener.class, "nodeCollapse", CollapseEvent.class); + /** * A node has been collapsed. * @@ -844,7 +835,8 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, * the Listener to be added. */ public void addListener(CollapseListener listener) { - addListener(CollapseEvent.class, listener, COLLAPSE_METHOD); + addListener(CollapseEvent.class, listener, + CollapseListener.COLLAPSE_METHOD); } /** @@ -854,7 +846,8 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, * the Listener to be removed. */ public void removeListener(CollapseListener listener) { - removeListener(CollapseEvent.class, listener, COLLAPSE_METHOD); + removeListener(CollapseEvent.class, listener, + CollapseListener.COLLAPSE_METHOD); } /** diff --git a/tests/src/com/vaadin/tests/server/component/tree/TestListeners.java b/tests/src/com/vaadin/tests/server/component/tree/TestListeners.java new file mode 100644 index 0000000000..06d0b65fba --- /dev/null +++ b/tests/src/com/vaadin/tests/server/component/tree/TestListeners.java @@ -0,0 +1,137 @@ +package com.vaadin.tests.server.component.tree; + +import java.util.ArrayList; +import java.util.List; + +import junit.framework.TestCase; + +import com.vaadin.ui.Tree; +import com.vaadin.ui.Tree.CollapseEvent; +import com.vaadin.ui.Tree.CollapseListener; +import com.vaadin.ui.Tree.ExpandEvent; +import com.vaadin.ui.Tree.ExpandListener; + +public class TestListeners extends TestCase implements ExpandListener, + CollapseListener { + private int expandCalled; + private int collapseCalled; + private Object lastExpanded; + private Object lastCollapsed; + + @Override + protected void setUp() { + expandCalled = 0; + } + + public void testExpandListener() { + Tree tree = createTree(10, 20, false); + tree.addListener((ExpandListener) this); + List rootIds = new ArrayList(tree.rootItemIds()); + + assertEquals(10, rootIds.size()); + assertEquals(10 + 10 * 20 + 10, tree.size()); + + // Expanding should send one expand event for the root item id + tree.expandItem(rootIds.get(0)); + assertEquals(1, expandCalled); + assertEquals(rootIds.get(0), lastExpanded); + + // Expand should send one event for each expanded item id. + // In this case root + child 4 + expandCalled = 0; + tree.expandItemsRecursively(rootIds.get(1)); + assertEquals(2, expandCalled); + List c = new ArrayList(tree.getChildren(rootIds.get(1))); + + assertEquals(c.get(4), lastExpanded); + + // Expanding an already expanded item should send no expand event + expandCalled = 0; + tree.expandItem(rootIds.get(0)); + assertEquals(0, expandCalled); + } + + /** + * Creates a tree with "rootItems" roots, each with "children" children, + * each with 1 child. + * + * @param rootItems + * @param children + * @param expand + * @return + */ + private Tree createTree(int rootItems, int children, boolean expand) { + Tree tree = new Tree(); + for (int i = 0; i < rootItems; i++) { + String rootId = "root " + i; + tree.addItem(rootId); + if (expand) { + tree.expandItemsRecursively(rootId); + } else { + tree.collapseItemsRecursively(rootId); + + } + for (int j = 0; j < children; j++) { + String childId = "child " + i + "/" + j; + tree.addItem(childId); + tree.setParent(childId, rootId); + tree.setChildrenAllowed(childId, false); + if (j == 4) { + tree.setChildrenAllowed(childId, true); + Object grandChildId = tree.addItem(); + tree.setParent(grandChildId, childId); + tree.setChildrenAllowed(grandChildId, false); + if (expand) { + tree.expandItemsRecursively(childId); + } else { + tree.collapseItemsRecursively(childId); + } + } + } + } + + return tree; + } + + public void testCollapseListener() { + Tree tree = createTree(7, 15, true); + tree.addListener((CollapseListener) this); + + List rootIds = new ArrayList(tree.rootItemIds()); + + assertEquals(7, rootIds.size()); + assertEquals(7 + 7 * 15 + 7, tree.size()); + + // Expanding should send one expand event for the root item id + tree.collapseItem(rootIds.get(0)); + assertEquals(1, collapseCalled); + assertEquals(rootIds.get(0), lastCollapsed); + + // Collapse sends one event for each collapsed node. + // In this case root + child 4 + collapseCalled = 0; + tree.collapseItemsRecursively(rootIds.get(1)); + assertEquals(2, collapseCalled); + List c = new ArrayList(tree.getChildren(rootIds.get(1))); + assertEquals(c.get(4), lastCollapsed); + + // Collapsing an already expanded item should send no expand event + collapseCalled = 0; + tree.collapseItem(rootIds.get(0)); + assertEquals(0, collapseCalled); + } + + @Override + public void nodeExpand(ExpandEvent event) { + lastExpanded = event.getItemId(); + expandCalled++; + + } + + @Override + public void nodeCollapse(CollapseEvent event) { + lastCollapsed = event.getItemId(); + collapseCalled++; + + } +}