Changeset 5119 for trunk/src/com/itmill/toolkit/tests/book/TableEditableBean.java

Timestamp:

07/28/08 13:12:15 (5 months ago)

Author:

magi@…

Message:

Updated book examples. Form example, editable Table with beans, QueryContainer? with Select.

Files:

• trunk/src/com/itmill/toolkit/tests/book/TableEditableBean.java (modified) (5 diffs)

trunk/src/com/itmill/toolkit/tests/book/TableEditableBean.java

@@ -5 +5 @@
 package com.itmill.toolkit.tests.book;
 
+import java.util.Collection;
+import java.util.Vector;
+
+import com.itmill.toolkit.data.Container;
 import com.itmill.toolkit.data.Item;
 import com.itmill.toolkit.data.Property;
 import com.itmill.toolkit.data.Property.ValueChangeEvent;
 import com.itmill.toolkit.data.util.BeanItem;
+import com.itmill.toolkit.ui.AbstractField;
 import com.itmill.toolkit.ui.BaseFieldFactory;
 import com.itmill.toolkit.ui.CheckBox;
@@ -17 +22 @@
 import com.itmill.toolkit.ui.Table;
 
+/**
+ *  Shows how to bind a bean to a table and make it editable. 
+ */
 public class TableEditableBean extends CustomComponent {
+    /**
+     * Let's have a simple example bean.
+     */
         public class MyBean {
                 boolean selected;
@@ -23 +34 @@
                 
                 public MyBean() {
-                        selected = false;
-                        text     = "Hello";
+                        this.selected = false;
+                        this.text     = "";
                 }
 
@@ -47 +58 @@
         }
         };
-        
+
+    /**
+     * Custom field factory that sets the fields as immediate for debugging
+     * purposes. This is not normally necessary, unless you want to have some
+     * interaction that requires it.
+     */
         public class MyFieldFactory extends BaseFieldFactory {
             public Field createField(Class type, Component uiContext) {
-                // Boolean field
-            if (Boolean.class.isAssignableFrom(type)) {
-                final CheckBox checkbox = new CheckBox();
-                checkbox.setSwitchMode(true);
-                checkbox.setImmediate(true);
-                return checkbox;
-            }
-            return super.createField(type, uiContext);
+                // Let the BaseFieldFactory create the fields
+                Field field = super.createField(type, uiContext);
+                
+                // ...and just set them as immediate
+                ((AbstractField)field).setImmediate(true);
+                
+            return field;
             }
         }
-        
-        public class MyTable extends Table {
-            /** Really adds an item and not just an item id. */
-            public void addItem(Item item, Object itemId) {
-                
+
+    /**
+     * This is a custom container that allows adding BeanItems inside it. The
+     * BeanItem objects must be bound to a MyBean object. The item ID is an
+     * Integer from 0 to 99.
+     * 
+     * Most of the interface methods are implemented with just dummy
+     * implementations, as they are not needed in this example.
+     */
+        public class MyContainer implements Container {
+        Item[] items;
+        int    current = 0;
+            
+            public MyContainer() {
+                items = new Item[100]; // Yeah this is just a test
             }
+
+        public boolean addContainerProperty(Object propertyId, Class type,
+                Object defaultValue) throws UnsupportedOperationException {
+            throw new UnsupportedOperationException();
+        }
+
+        public Item addItem(Object itemId) throws UnsupportedOperationException {
+            throw new UnsupportedOperationException();
+        }
+
+        public Object addItem() throws UnsupportedOperationException {
+            throw new UnsupportedOperationException();
+        }
+
+        /**
+         *  This addItem method is specific for this container and allows adding
+         *  BeanItem objects. The BeanItems must be bound to MyBean objects.   
+         */
+        public void addItem(BeanItem item) throws UnsupportedOperationException {
+            items[current++] = item;
+        }
+
+        public boolean containsId(Object itemId) {
+            if (itemId instanceof Integer) {
+                int pos = ((Integer)itemId).intValue();
+                if (pos >= 0 && pos < 100)
+                    return items[pos] != null;
+            }
+            return false;
+        }
+
+        /**
+         * The Table will call this method to get the property objects for the
+         * columns. It uses the property objects to determine the data types of
+         * the columns.
+         */
+        public Property getContainerProperty(Object itemId, Object propertyId) {
+            if (itemId instanceof Integer) {
+                int pos = ((Integer)itemId).intValue();
+                if (pos >= 0 && pos < 100) {
+                    Item item = items[pos];
+                    
+                    // The BeanItem provides the property objects for the items.
+                    return item.getItemProperty(propertyId);
+                }
+            }
+            return null;
+        }
+
+        /** Table calls this to get the column names. */
+        public Collection getContainerPropertyIds() {
+            // This container can contain only BeanItems bound to MyBeans.
+            Item item = new BeanItem(new MyBean());
+            
+            // The BeanItem knows how to get the property names from the bean.
+            return item.getItemPropertyIds();
+        }
+
+        public Item getItem(Object itemId) {
+            if (itemId instanceof Integer) {
+                int pos = ((Integer)itemId).intValue();
+                if (pos >= 0 && pos < 100)
+                    return items[pos];
+            }
+            return null;
+        }
+
+        public Collection getItemIds() {
+            Vector ids = new Vector();
+            for (int i=0; i<100; i++)
+                ids.add(Integer.valueOf(i));
+            return ids;
+        }
+
+        public Class getType(Object propertyId) {
+            return BeanItem.class;
+        }
+
+        public boolean removeAllItems() throws UnsupportedOperationException {
+            throw new UnsupportedOperationException();
+        }
+
+        public boolean removeContainerProperty(Object propertyId)
+                throws UnsupportedOperationException {
+            throw new UnsupportedOperationException();
+        }
+
+        public boolean removeItem(Object itemId)
+                throws UnsupportedOperationException {
+            throw new UnsupportedOperationException();
+        }
+
+        public int size() {
+            return current;
+        }
+            
         }
 
@@ -78 +199 @@
         table.setPageLength(8);
         
-        // Define the names and data types of columns.
-        table.addContainerProperty("selected", Boolean.class, null);
-        table.addContainerProperty("text",      String.class,  null);
+        // Use the custom container as the data source
+        MyContainer myContainer = new MyContainer();
+        table.setContainerDataSource(myContainer);
         
         // Add a few items in the table.
         for (int i=0; i<5; i++) {
+            // Create the bean
                 MyBean item = new MyBean();
+                item.setText("MyBean " + i);
+                
+                // Have an Item that is bound to the bean
                 BeanItem bitem = new BeanItem(item);
-                //table.addItem(bitem);
-                table.addItem(new Object[]{bitem,bitem}, new Integer(i));
+                
+                // Add the item directly to the container using the custom addItem()
+            // method. We could otherwise add it to the Table as well, but
+            // the Container interface of Table does not allow adding items
+                // as such, just item IDs.
+                myContainer.addItem(bitem);
         }
         
         // Use custom field factory that sets the checkboxes in immediate mode.
+        // This is just for debugging purposes and is not normally necessary.
         table.setFieldFactory(new MyFieldFactory());