Changeset 5543

Timestamp:

07/17/08 16:32:21 (3 months ago)

Author:

will

Message:

Basically working JTree, with custom Rendering, Editing and Selection behavior

Location:

branches/OmeroEditor/src

Files:

• fields/AbstractValueObject.java (added)
• fields/DateTimeValueObject.java (added)
• fields/DefaultFieldEditor.java (added)
• fields/Field.java (modified) (1 diff)
• fields/FieldPanel.java (added)
• fields/FieldValueFactory.java (added)
• fields/IField.java (added)
• fields/IFieldValue.java (added)
• fields/NoValue.java (added)
• fields/TextValueObject.java (added)
• tree/DataField.java (modified) (4 diffs)
• tree/Tree.java (modified) (2 diffs)
• treeEditingComponents (added)
• treeEditingComponents/DateTimeField.java (added)
• treeEditingComponents/EditingComponentFactory.java (added)
• treeEditingComponents/TextFieldEditor.java (added)
• treeModel/ContiguousChildSelectionModel.java (modified) (2 diffs)
• treeModel/DynamicTreeDemo.java (deleted)
• treeModel/FieldRenderer.java (modified) (4 diffs)
• treeModel/MyBasicTreeUI.java (added)
• treeModel/Tree.java (deleted)
• treeModel/TreeEditorFactory.java (modified) (2 diffs)
• treeModel/TreeUI.java (modified) (4 diffs)
• ui/FieldEditorFormFieldFactory.java (modified) (3 diffs)
• ui/FormDisplay.java (modified) (4 diffs)
• ui/components/AttributeEditorListeners.java (modified) (4 diffs)
• ui/components/AttributeTextEditor.java (modified) (3 diffs)
• ui/components/OntologyTermSelector.java (modified) (3 diffs)
• ui/formFields/FormField.java (deleted)
• ui/formFields/FormFieldCheckBox.java (modified) (2 diffs)
• ui/formFields/FormFieldContainer.java (modified) (3 diffs)
• ui/formFields/FormFieldCustom.java (modified) (3 diffs)
• ui/formFields/FormFieldDate.java (modified) (2 diffs)
• ui/formFields/FormFieldDateTime.java (modified) (3 diffs)
• ui/formFields/FormFieldDropDown.java (modified) (2 diffs)
• ui/formFields/FormFieldFixed.java (modified) (1 diff)
• ui/formFields/FormFieldImage.java (modified) (2 diffs)
• ui/formFields/FormFieldLink.java (modified) (2 diffs)
• ui/formFields/FormFieldMemo.java (modified) (2 diffs)
• ui/formFields/FormFieldNumber.java (modified) (2 diffs)
• ui/formFields/FormFieldOLS.java (modified) (1 diff)
• ui/formFields/FormFieldObservation.java (modified) (2 diffs)
• ui/formFields/FormFieldProtocol.java (modified) (2 diffs)
• ui/formFields/FormFieldTable.java (modified) (3 diffs)
• ui/formFields/FormFieldText.java (modified) (5 diffs)
• ui/formFields/FormFieldTime.java (modified) (3 diffs)
• uiComponents (added)
• uiComponents/CompSizesReg.java (added)
• uiComponents/DoubleDigitField.java (added)
• uiComponents/DoubleDigitSpinner.java (added)
• uiComponents/HrsMinsEditor.java (added)
• util/DefaultExport.java (modified) (2 diffs)

branches/OmeroEditor/src/fields/Field.java

@@ -26 +26 @@
 import java.util.HashMap;
 
+import tree.DataFieldConstants;
 
-public class Field {
+
+public class Field 
+        implements IField {
 
         HashMap<String, String> allAttributesMap;
         
+        /**
+         * The "Value" of the field. 
+         * This could be a simple string, or a mixture of dates, times etc. 
+         * It represents the experimental parameters that are stored by this
+         * field. 
+         */
+        private IFieldValue fieldValue;
+        
         public Field() {
-                this("untitled", "no value");
+                this("untitled", null, DataFieldConstants.FIXED_PROTOCOL_STEP);
         }
         
-        public Field(String name, String value) {
+        public Field(String name, String value, String fieldType) {
                 
                 allAttributesMap = new HashMap<String, String>();
                 
-                setAttribute("name", name);
-                setAttribute("value", value);
+                fieldValue = FieldValueFactory.getFieldValue(fieldType);
+                
+                setAttribute(DataFieldConstants.ELEMENT_NAME, name);
+                setAttribute(DataFieldConstants.VALUE, value);
         }
         
         public String getAttribute(String name) {
+                //System.out.println("Field getAttribute()");
+                if (fieldValue.isValueAttribute(name)) {
+                        return fieldValue.getAttribute(name);
+                }
+                
                 return allAttributesMap.get(name);
         }
         
         public void setAttribute(String name, String value) {
+                System.out.println("Field setAttribute() " + name + " = " + value);
+                if (fieldValue.isValueAttribute(name)) {
+                        fieldValue.setAttribute(name, value);
+                }
                 allAttributesMap.put(name, value);
         }
         
         public String toString() {
-                return getAttribute("name") + ": " + getAttribute("value");
+                return getAttribute(DataFieldConstants.ELEMENT_NAME) + ": " + 
+                getAttribute(DataFieldConstants.VALUE);
+        }
+
+        public boolean isAttributeTrue(String attributeName) {
+                String value = getAttribute(attributeName);
+                return DataFieldConstants.TRUE.equals(value);
+        }
+        
+        public IFieldValue getValueObject() {
+                return fieldValue;
+        }
+        
+        /**
+         * Gets the names of the attributes where this field stores its "value"s.
+         * This is used eg. (if a single value is returned)
+         * as the destination to copy the default value when defaults are loaded.
+         * Also used by EditClearFields to set all values back to null. 
+         * This method delegates to the Value object for this field.
+         *  
+         * @return      the names of the attributes that holds the "value" of this field
+         */
+        public String[] getValueAttributes() {
+                return fieldValue.getValueAttributes();
+        }
+        
+        /**
+         * This method tests to see whether the field has been filled out. 
+         * ie, Has the user entered a "valid" value into the Form. 
+         * For fields that have a single 'value', this method will return true if 
+         * that value is filled (not null). 
+         * For fields with several attributes, it depends on what is considered 'filled'.
+         * This method can be used to check that 'Obligatory Fields' have been completed 
+         * when a file is saved. 
+         * Subclasses should override this method.
+         * 
+         * @return      True if the field has been filled out by user. Required values are not null. 
+         */
+        public boolean isFieldFilled() {
+                return fieldValue.isFieldFilled();
         }
 }

branches/OmeroEditor/src/tree/DataField.java

@@ -34 +34 @@
 import javax.swing.undo.UndoableEdit;
 
+import fields.FieldPanel;
+
 import tree.edit.EditDataFieldAttribute;
 import tree.edit.EditDataFieldAttributes;
@@ -39 +41 @@
 import ui.FieldEditorFormFieldFactory;
 import ui.fieldEditors.FieldEditor;
-import ui.formFields.FormField;
 
 
@@ -72 +73 @@
 
         // the two JPanels that display the dataField, and hold optional attributes
-        FormField formField;
+        FieldPanel formField;
         FieldEditor fieldEditor;
         
@@ -296 +297 @@
                         getFormField();
                 
-                formField.setHighlighted(highlighted);
+                formField.setSelected(highlighted);
         }
         

branches/OmeroEditor/src/tree/Tree.java

@@ -47 +47 @@
 import org.w3c.dom.NodeList;
 
+import fields.FieldPanel;
+
 import tree.edit.EditAddField;
 import tree.edit.EditClearFields;
@@ -65 +67 @@
 import ui.XMLUpdateObserver;
 import ui.fieldEditors.FieldEditor;
-import ui.formFields.FormField;
 import ui.formFields.FormFieldNumber;
 import validation.XMLSchema;

branches/OmeroEditor/src/treeModel/ContiguousChildSelectionModel.java

@@ -80 +80 @@
    public void setSelectionPaths(TreePath[] pPaths) { 
            
+           //System.out.println("ContiguousChildSelectionModel   setSelectionPaths" +
+                //              "length = " + pPaths.length);
            
            if (pPaths.length > 0) {
@@ -184 +186 @@
            System.out.println("ContiguousChildSelectionModel   addSelectionPaths" +
                         "length = " + paths.length);
+           
            /*
             * Check if any new paths have different parent 
             */
            TreePath[] currentPaths = this.getSelectionPaths();
+           // if no selection, simple set the selection paths to the new paths
+           if ((currentPaths == null) || (currentPaths.length == 0)) {
+                   setSelectionPaths(paths);
+                   return;
+           }
            TreePath currentParent = currentPaths[0].getParentPath();
            

branches/OmeroEditor/src/treeModel/FieldRenderer.java

@@ -23 +23 @@
 package treeModel;
 
+//Java imports
+
 import java.awt.Component;
 
 import javax.swing.Icon;
+import javax.swing.JLabel;
 import javax.swing.JTree;
+import javax.swing.tree.DefaultMutableTreeNode;
 import javax.swing.tree.DefaultTreeCellRenderer;
-import javax.swing.tree.TreeCellRenderer;
-
-import util.ImageFactory;
-
-//Java imports
 
 //Third-party libraries
@@ -38 +37 @@
 //Application-internal dependencies
 
+import fields.FieldPanel;
+import fields.IField;
+
+
+
 /** 
+ * The Renderer for JTree, to build the "Form" of hierarchical fields.
  * 
+ * The getTreeCellRendererComponent() method returns a JPanel, which is 
+ * used to build the Non-Editable tree UI (before editing starts). 
+ * This JPanel is created by obtaining the UserObject for the node of
+ * the tree. If this is an instance of IField, it is used to create
+ * a JPanel. Otherwise it returns a JLabel. 
  *
  * @author  William Moore     
@@ -51 +61 @@
 public class FieldRenderer 
         extends DefaultTreeCellRenderer {
+        
+        public FieldRenderer() {
+                super();
+        }
 
         public Component getTreeCellRendererComponent(JTree tree, Object value,
@@ -56 +70 @@
                         boolean hasFocus) {
                 
-                        super.getTreeCellRendererComponent(
-                tree, value, selected,
-                expanded, leaf, row,
-                hasFocus);
-                        
-                        Icon bigIcon = ImageFactory.getInstance().getIcon(
-                                        ImageFactory.ALARM_ICON_64);
-                        
-                        setIcon(bigIcon);
-                        
-                        return this;
+                
+                if (value instanceof DefaultMutableTreeNode) {
+                        DefaultMutableTreeNode node = (DefaultMutableTreeNode)value;
+                        Object object = node.getUserObject();
+                        if (object instanceof IField) {
+                                IField field = (IField)object;
+                                FieldPanel fieldPanel = new FieldPanel(field, tree, node);
+                                
+                                
+                                //fieldPanel.setTree(tree);
+                                //fieldPanel.setTreeNode(node);
+                                
+                                fieldPanel.setSelected(selected);
+                                
+                                return fieldPanel;
+                        }
+                }
+                
+                System.out.println(value.getClass());
+                return new JLabel(value.toString());
         }
         
+        public Icon getLeafIcon() {
+                return null;
+        }
+        
+        public Icon getOpenIcon() {
+                return null;
+        }
+        
+        public Icon getClosedIcon() {
+                return null;
+        }
+        
+        public int getIconTextGap() {
+                return 0;
+        }
 
 }

branches/OmeroEditor/src/treeModel/TreeEditorFactory.java

@@ -28 +28 @@
 import javax.swing.tree.MutableTreeNode;
 import javax.swing.tree.TreeNode;
+
+import tree.DataFieldConstants;
 
 import fields.Field;
@@ -78 +80 @@
         public static TreeNode createDummyTree() {
                 
-                Field rootField = new Field("Title", "My Experiment");
+                Field rootField = new Field();
+                rootField.setAttribute(DataFieldConstants.ELEMENT_NAME, "Title");
                 DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode(rootField);
                 
-                DefaultMutableTreeNode p1Name = new DefaultMutableTreeNode(new Field("Protocol", "10-2-08"));
-                DefaultMutableTreeNode p2Name = new DefaultMutableTreeNode(new Field("Temperature", "37'C"));
-                DefaultMutableTreeNode c1Name = new DefaultMutableTreeNode(new Field("Cells", "HeLa"));
-                DefaultMutableTreeNode c2Name = new DefaultMutableTreeNode(new Field("DNA", "GFP-H2B"));
-                DefaultMutableTreeNode c3Name = new DefaultMutableTreeNode(new Field("Incubation time", "3 hrs"));
-                DefaultMutableTreeNode c4Name = new DefaultMutableTreeNode(new Field("On ice", "10 mins"));
+                Field field;
+                
+                DefaultMutableTreeNode p1Name = new DefaultMutableTreeNode(
+                                new Field("Protocol", "10-2-08", DataFieldConstants.TEXT_ENTRY_STEP));
+                DefaultMutableTreeNode p2Name = new DefaultMutableTreeNode(
+                                new Field("Temperature", "37'C", DataFieldConstants.TEXT_ENTRY_STEP));
+                
+                field = new Field("Date", null, DataFieldConstants.DATE_TIME_FIELD);
+                // field.setAttribute(DataFieldConstants.SECONDS, "3600");
+                //field.setAttribute(DataFieldConstants.UTC_MILLISECS, "This is a test description");
+                DefaultMutableTreeNode c1Name = new DefaultMutableTreeNode(field);
+                DefaultMutableTreeNode c2Name = new DefaultMutableTreeNode(
+                                new Field("DNA", null, DataFieldConstants.FIXED_PROTOCOL_STEP));
+                DefaultMutableTreeNode c3Name = new DefaultMutableTreeNode(
+                                new Field("Incubation time", "3 hrs", DataFieldConstants.TEXT_ENTRY_STEP));
+                DefaultMutableTreeNode c4Name = new DefaultMutableTreeNode(
+                                new Field("On ice", "10 mins", DataFieldConstants.TEXT_ENTRY_STEP));
+                
+        
         
         rootNode.add(p1Name);

branches/OmeroEditor/src/treeModel/TreeUI.java

@@ -23 +23 @@
 package treeModel;
 
+//Java imports
+
 import java.awt.BorderLayout;
 
+import javax.swing.DefaultCellEditor;
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
 import javax.swing.JTree;
-
-//Java imports
+import javax.swing.tree.DefaultTreeCellEditor;
+import javax.swing.tree.DefaultTreeCellRenderer;
+import javax.swing.tree.TreeCellEditor;
 
 //Third-party libraries
@@ -35 +39 @@
 //Application-internal dependencies
 
+import fields.DefaultFieldEditor;
+
+
 /** 
+ * This UI class displays a JTree in a scroll pane. 
  * 
  *
@@ -49 +57 @@
         extends JPanel {
         
-        private TreeModel model;
-        
         private JTree tree;
         
@@ -56 +62 @@
                 
                 super(new BorderLayout());
-                
-                this.model = model;
+
                 
                 tree = new JTree(model);
+                /*
+                 * The default UI (BasicTreeUI) is replaced with a subclass
+                 * to modify the selection and editing behavior.
+                 */
+                tree.setUI(new MyBasicTreeUI());
+                
+                /*
+                 * A custom selection model allows multiple nodes to be selected,
+                 * but ensures that they are contiguous and are all siblings.
+                 */
                 tree.setSelectionModel(new ContiguousChildSelectionModel());
+                
+                /*
+                 * Setting the row height to 0 allows each node to choose it's
+                 * own size. The JTree will call getPreferredSize() for each.
+                 */
                 tree.setRowHeight(0);
-                tree.setCellRenderer(new FieldRenderer());
+                
+                /*
+                 * A custom TreeCellRenderer (extends DefaultTreeCellRenderer)
+                 * renders nodes as JPanels.
+                 */
+                DefaultTreeCellRenderer fieldRenderer = new FieldRenderer();
+                tree.setCellRenderer(fieldRenderer);
+                
+                /*
+                 * A TreeCellEditor for editing fields.
+                 * This merely delegates to the fieldRenderer because the same 
+                 * components are used for display and editing of the tree Cells.
+                 */
+                TreeCellEditor fieldEditor = new DefaultFieldEditor(fieldRenderer);
+                /*
+                 * The DefaultTreeCellEditor (when passed a TreeCellEditor) uses this 
+                 * to switch between editing and display. 
+                 */
+            TreeCellEditor editor = new DefaultTreeCellEditor(tree, fieldRenderer, fieldEditor);
+            tree.setCellEditor(editor);
                 
                 tree.setEditable(true);
                 
+                /*
+                 * Place the JTree in a ScrollPane and add it to this panel. 
+                 */
                 JScrollPane treeScroller = new JScrollPane(tree);
-                
                 add(treeScroller, BorderLayout.CENTER);
         }
+
         
 }

branches/OmeroEditor/src/ui/FieldEditorFormFieldFactory.java

@@ -23 +23 @@
 package ui;
 
+import fields.FieldPanel;
 import tree.DataField;
 import tree.DataFieldConstants;
@@ -40 +41 @@
 import ui.fieldEditors.FieldEditorText;
 import ui.fieldEditors.FieldEditorTime;
-import ui.formFields.FormField;
 import ui.formFields.FormFieldCheckBox;
 import ui.formFields.FormFieldCustom;
@@ -143 +143 @@
         
         // FormField Factory
-        public FormField getFormField(DataField dataField) {
-                
-                FormField formField = null;
+        public FieldPanel getFormField(DataField dataField) {
+                
+                FieldPanel formField = null;
                 
                 String inputType = dataField.getInputType();

branches/OmeroEditor/src/ui/FormDisplay.java

@@ -30 +30 @@
 import javax.swing.event.ChangeListener;
 
+import fields.FieldPanel;
+
 import tree.DataFieldConstants;
 import tree.DataFieldNode;
-import ui.formFields.FormField;
 import ui.formFields.FormFieldContainer;
 
@@ -93 +94 @@
                         
                         
-                        FormField formField = (FormField)rootNode.getFormField();
+                        FieldPanel formField = (FieldPanel)rootNode.getFormField();
                         formField.setModel(model);
                         formField.refreshRootField(true);       // displays the correct buttons etc. 
@@ -111 +112 @@
                 //System.out.println("FormDisplay: buildFormTree() " + dfNode.getDataField().getName());
                 
-                boolean subStepsCollapsed = ((FormField)dfNode.getFormField()).subStepsCollapsed();
+                boolean subStepsCollapsed = ((FieldPanel)dfNode.getFormField()).subStepsCollapsed();
                 
                 if (!subStepsCollapsed) {
@@ -120 +121 @@
                 //              set visibility of the childBox wrt collapsed boolean of dataField
                 //       & sets collapse button visible if dataFieldNode has children
-                ((FormField)dfNode.getFormField()).refreshTitleCollapsed();
+                ((FieldPanel)dfNode.getFormField()).refreshTitleCollapsed();
                 
         }

branches/OmeroEditor/src/ui/components/AttributeEditorListeners.java

@@ -31 +31 @@
 import javax.swing.text.JTextComponent;
 
+import fields.IField;
+
 //Third-party libraries
 
@@ -43 +45 @@
  * Then when focus is lost, the focusListener updates the dataField
  * attribute (if textChanged), by calling 
- * setDataFieldAttribute. 
+ * setDataFieldAttribute. TextChanged is reset to false.