Renamed tests -> uitest and tests/testbench -> uitest/src (#9299)

1 files changed, 322 insertions, 0 deletions

diff --git a/uitest/src/com/vaadin/tests/dd/DDTest2.java b/uitest/src/com/vaadin/tests/dd/DDTest2.java
new file mode 100644
index 0000000000..7757513fc1
--- /dev/null
+++ b/uitest/src/com/vaadin/tests/dd/DDTest2.java
@@ -0,0 +1,322 @@
+package com.vaadin.tests.dd;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+import com.vaadin.data.Container;
+import com.vaadin.data.Item;
+import com.vaadin.data.util.HierarchicalContainer;
+import com.vaadin.event.DataBoundTransferable;
+import com.vaadin.event.Transferable;
+import com.vaadin.event.dd.DragAndDropEvent;
+import com.vaadin.event.dd.DropHandler;
+import com.vaadin.event.dd.acceptcriteria.AcceptCriterion;
+import com.vaadin.event.dd.acceptcriteria.And;
+import com.vaadin.event.dd.acceptcriteria.Or;
+import com.vaadin.event.dd.acceptcriteria.SourceIs;
+import com.vaadin.server.Resource;
+import com.vaadin.server.ThemeResource;
+import com.vaadin.tests.components.TestBase;
+import com.vaadin.tests.util.Person;
+import com.vaadin.tests.util.PersonContainer;
+import com.vaadin.ui.AbstractSelect;
+import com.vaadin.ui.AbstractSelect.AbstractSelectTargetDetails;
+import com.vaadin.ui.AbstractSelect.AcceptItem;
+import com.vaadin.ui.HorizontalLayout;
+import com.vaadin.ui.UI;
+import com.vaadin.ui.Table;
+import com.vaadin.ui.Table.TableTransferable;
+import com.vaadin.ui.Tree;
+import com.vaadin.ui.Tree.TargetItemAllowsChildren;
+import com.vaadin.ui.Tree.TreeDragMode;
+import com.vaadin.ui.Window;
+
+public class DDTest2 extends TestBase {
+
+    java.util.Random r = new java.util.Random(1);
+
+    HorizontalLayout hl = new HorizontalLayout();
+    Tree tree1 = new Tree("Tree that accepts table rows to folders");
+    Table table = new Table("Drag rows to Tree on left or right");
+    Tree tree2 = new Tree("Accepts items, copies values");
+
+    private Tree tree3;
+
+    @Override
+    protected void setup() {
+        UI w = getLayout().getUI();
+        /* darn reindeer has no icons */
+
+        /* Make all trees (their nodes actually) draggable */
+        tree1.setDragMode(TreeDragMode.NODE);
+        tree2.setDragMode(TreeDragMode.NODE);
+
+        hl.addComponent(tree1);
+        hl.addComponent(table);
+        hl.addComponent(tree2);
+        hl.setWidth("100%");
+        hl.setSpacing(true);
+        hl.setExpandRatio(table, 1);
+        popuplateTrees();
+        table.setWidth("100%");
+        table.setPageLength(10);
+        populateTable();
+        addComponent(hl);
+
+        tree3 = new Tree(
+                "Tree with lazy loading criteria, of first server visit caches accept rules for all captions");
+        tree3.setDragMode(TreeDragMode.NODE);
+
+        tree3.addItem("Drag on me");
+        tree3.addItem("Or me");
+        /*
+         * An example of lazy initializing drop criterion with component
+         * specific api for easy rule writing.
+         * 
+         * Example is pretty stupid (accepts drop on all nodes, but by
+         * explicitly defining them here), but demonstrates lazy initialization
+         * option if rules are heavy.
+         */
+        final AcceptCriterion crit = new Tree.TreeDropCriterion() {
+
+            @Override
+            protected Set<Object> getAllowedItemIds(DragAndDropEvent dragEvent,
+                    Tree tree) {
+                return new HashSet<Object>(tree.getItemIds());
+            }
+        };
+
+        tree3.setDropHandler(new DropHandler() {
+            @Override
+            public void drop(DragAndDropEvent dropEvent) {
+                Transferable transferable = dropEvent.getTransferable();
+
+                String data = (String) transferable.getData("Text");
+                if (transferable instanceof TableTransferable) {
+                    TableTransferable tr = (TableTransferable) transferable;
+                    System.out.println("From table row" + tr.getPropertyId());
+                    Object value = tr.getSourceContainer()
+                            .getItem(tr.getItemId())
+                            .getItemProperty(tr.getPropertyId()).getValue();
+                    data = (null != value) ? value.toString() : null;
+                }
+                if (data == null) {
+                    data = "-no Text data flavor-";
+                }
+                tree3.addItem(data);
+                AbstractSelect.AbstractSelectTargetDetails dropTargetData = (AbstractSelect.AbstractSelectTargetDetails) dropEvent
+                        .getTargetDetails();
+                tree3.setParent(data, dropTargetData.getItemIdOver());
+
+            }
+
+            @Override
+            public AcceptCriterion getAcceptCriterion() {
+                return crit;
+            }
+        });
+
+        addComponent(tree3);
+
+        /*
+         * Make table rows draggable
+         */
+        table.setDragMode(Table.TableDragMode.ROW);
+
+        TargetItemAllowsChildren onNode = TargetItemAllowsChildren.get();
+        SourceIs fromTable = new SourceIs(table);
+
+        SourceIs fromTree = new SourceIs(tree1);
+        final Or fromTree1OrTable = new Or(fromTable, fromTree);
+        // Or could in the case be replaced with, keeping here as an example and
+        // test
+        @SuppressWarnings("unused")
+        SourceIs treeOrTable = new SourceIs(table, tree1);
+
+        final And and = new And(fromTree1OrTable, onNode);
+
+        DropHandler dropHandler = new DropHandler() {
+
+            @Override
+            public void drop(DragAndDropEvent event) {
+                /*
+                 * We know transferrable is from table, so it is of type
+                 * DataBoundTransferrable
+                 */
+                DataBoundTransferable tr = (DataBoundTransferable) event
+                        .getTransferable();
+                Object itemId = tr.getItemId();
+                Container sourceContainer = tr.getSourceContainer();
+                if (tr.getSourceComponent() != tree1) {
+                    // if the source is from table (not from tree1 itself),
+                    // transfer Name property and use it as an identifier in
+                    // tree1
+                    Object nameValue = sourceContainer.getItem(itemId)
+                            .getItemProperty("Name").getValue();
+                    String name = (null != nameValue) ? nameValue.toString()
+                            : null;
+
+                    tree1.addItem(name);
+                    tree1.setChildrenAllowed(name, false);
+
+                    /*
+                     * Remove the item from table
+                     */
+                    sourceContainer.removeItem(itemId);
+
+                    itemId = name;
+
+                }
+
+                /*
+                 * As we also accept only drops on folders, we know dropDetails
+                 * is from Tree and it contains itemIdOver.
+                 */
+                AbstractSelectTargetDetails details = (AbstractSelectTargetDetails) event
+                        .getTargetDetails();
+                Object idOver = details.getItemIdOver();
+                tree1.setParent(itemId, idOver);
+
+            }
+
+            @Override
+            public AcceptCriterion getAcceptCriterion() {
+                return and;
+            }
+        };
+        tree1.setDropHandler(dropHandler);
+
+        /*
+         * First step done. tree1 now accepts drags only from table and only
+         * over tree nodes aka "folders"
+         */
+
+        /*
+         * Now set the rightmost tree accept any item drag. On drop, copy from
+         * source. Also make drags from tree1 possible.
+         */
+
+        dropHandler = new DropHandler() {
+            @Override
+            public void drop(DragAndDropEvent event) {
+                AbstractSelectTargetDetails details = (AbstractSelectTargetDetails) event
+                        .getTargetDetails();
+                Transferable transferable = event.getTransferable();
+
+                if (transferable instanceof DataBoundTransferable) {
+                    DataBoundTransferable tr = (DataBoundTransferable) transferable;
+
+                    Object itemId = tree2.addItem();
+                    tree2.setParent(itemId, details.getItemIdOver());
+                    if (tr.getSourceComponent() == tree1) {
+                        // use item id from tree1 as caption
+                        tree2.setItemCaption(itemId, (String) tr.getItemId());
+                        // if comes from tree1, move subtree too
+                        copySubTree(tr.getItemId(), itemId);
+                    } else if (tr.getSourceComponent() == table) {
+                        // comes from table, override caption with name
+                        String name = (String) table.getItem(tr.getItemId())
+                                .getItemProperty("Name").getValue();
+                        tree2.setItemCaption(itemId, name);
+                    } else if (tr.getSourceComponent() == tree2) {
+                        tree2.setItemCaption(itemId,
+                                tree2.getItemCaption(tr.getItemId()));
+                    }
+                }
+            }
+
+            private void copySubTree(Object itemId, Object itemIdTo) {
+                Collection<?> children = tree1.getChildren(itemId);
+                if (children != null) {
+                    for (Object childId : children) {
+                        Object newItemId = tree2.addItem();
+                        tree2.setItemCaption(newItemId, (String) childId);
+                        tree2.setParent(newItemId, itemIdTo);
+                        copySubTree(childId, newItemId);
+                    }
+                }
+            }
+
+            @Override
+            public AcceptCriterion getAcceptCriterion() {
+                return AcceptItem.ALL;
+            }
+        };
+
+        tree2.setDropHandler(dropHandler);
+
+        /*
+         * Finally add two windows with DragDropPane. First accept anything,
+         * second has server side accept rule to allow only drops from Tree1.
+         * Check the code in implementing classes.
+         */
+        Window acceptAnyThing = new AcceptAnythingWindow();
+        Window acceptFromTree1viaServerCheck = new AcceptFromComponent(tree1);
+
+        w.addWindow(acceptAnyThing);
+        acceptAnyThing.setPositionY(450);
+        acceptAnyThing.setPositionX(150);
+        w.addWindow(acceptFromTree1viaServerCheck);
+        acceptFromTree1viaServerCheck.setPositionY(450);
+        acceptFromTree1viaServerCheck.setPositionX(450);
+
+    }
+
+    private void populateTable() {
+        table.addContainerProperty("Name", String.class, "");
+        table.addContainerProperty("Weight", Integer.class, 0);
+
+        PersonContainer testData = PersonContainer.createWithTestData();
+
+        for (int i = 0; i < 10; i++) {
+            Item addItem = table.addItem("Item" + i);
+            Person p = testData.getIdByIndex(i);
+            addItem.getItemProperty("Name").setValue(
+                    p.getFirstName() + " " + p.getLastName());
+            addItem.getItemProperty("Weight").setValue(50 + r.nextInt(60));
+        }
+
+    }
+
+    private final static ThemeResource FOLDER = new ThemeResource(
+            "../runo/icons/16/folder.png");
+    private final static ThemeResource DOC = new ThemeResource(
+            "../runo/icons/16/document.png");
+
+    private void popuplateTrees() {
+        HierarchicalContainer hc = new HierarchicalContainer();
+        hc.addContainerProperty("icon", Resource.class, DOC);
+        Item addItem = hc.addItem("Fats");
+        addItem.getItemProperty("icon").setValue(FOLDER);
+        hc.addItem("Tarja");
+        hc.setParent("Tarja", "Fats");
+        hc.setChildrenAllowed("Tarja", false);
+        addItem = hc.addItem("Thins");
+        addItem.getItemProperty("icon").setValue(FOLDER);
+        addItem = hc.addItem("Anorectic");
+        addItem.getItemProperty("icon").setValue(FOLDER);
+        hc.setParent("Anorectic", "Thins");
+        addItem = hc.addItem("Normal weighted");
+        addItem.getItemProperty("icon").setValue(FOLDER);
+
+        tree1.setContainerDataSource(hc);
+        tree1.setItemIconPropertyId("icon");
+
+        tree2.setContainerDataSource(new HierarchicalContainer());
+
+        tree2.addItem("/");
+
+    }
+
+    @Override
+    protected String getDescription() {
+        return "dd";
+    }
+
+    @Override
+    protected Integer getTicketNumber() {
+        return 119;
+    }
+
+}