Changeset 643

Timestamp:

2008-09-26 13:15:59 (5 years ago)

Author:

paul

Message:

Fix for issue #78 the CaseControl? which displays a certain child control based on the value of a selector.
Also there is a fix for issue #79 on the enabled/disabled state for controls
Controls can be be made hidden & visible
Did some documenting in Control.js

Location:

trunk/modules/kauri-forms/kauri-forms-framework/src

Files:

• assembler/kauri-forms-assembler.xml (modified) (1 diff)
• main/kauri/js/case.js (added)
• main/kauri/js/control.js (modified) (75 diffs)
• test/js/test-case.js (added)
• test/js/testPage.html (modified) (2 diffs)

trunk/modules/kauri-forms/kauri-forms-framework/src/assembler/kauri-forms-assembler.xml

@@ -25 +25 @@
         <include>collection.js</include>
         <include>composite.js</include>
+        <include>case.js</include>
 
         <include>date.js</include>

trunk/modules/kauri-forms/kauri-forms-framework/src/main/kauri/js/control.js

@@ -21 +21 @@
 
     /**
-     * ControlElements declares the constants and helper methods and instances to handle the control to HTML binding operations of
+     * @class ControlElements declares the constants and helper methods and instances to handle the control to HTML binding operations of
      * indexing and finding HTML elements bound to the controls.
      * <p>
@@ -41 +41 @@
     }
 
-
+    /**
+    * Html attribute name used for specifying an index
+    * @static
+    * @final
+    */
     ControlElements.ATTR_INDEX = "kauri-index";
+    
+    /**
+    * Html attribute name used for specifying the control id
+    * @static
+    * @final
+    */
     ControlElements.ATTR_IDREF = "kauri-idref";
+    
+    /**
+    * Html attribute name used for specifying the relation. Rev is short for reverse index
+    * @static
+    * @final
+    */
     ControlElements.ATTR_REV = "kauri-rev";
+    
+    /**
+    * Specifies that the element has a messages relation with the control
+    * @static
+    * @final
+    */
     ControlElements.REV_MESSAGES = "messages";
+    
+    /**
+    * Specifies that the element has a label relation with the control
+    * @static
+    * @final
+    */
     ControlElements.REV_LABEL = "label";
+    
+    /**
+    * Specifies that the element has an input relation with the control. If no relation is specified this is used by default
+    * @static
+    * @final
+    */
     ControlElements.REV_INPUT = "input";
+    
+    /**
+    * Specifies that the element has a mark relation with the control. 
+    * <b>TODO:</b> What does this mark thing do anyway?
+    * @static
+    * @final
+    */
     ControlElements.REV_MARK = "mark";
+    
+    /**
+    * Specifies that the element is a container for the control
+    * @static
+    * @final
+    */
     ControlElements.REV_CONTAINER = "container";
+    
+    /**
+    * Specifies that the element should be used as a layout or template for child elements
+    * @static
+    * @final
+    */
     ControlElements.REV_LAYOUT = "layout";
+    
+    /**
+    * Specifies that the element is a child item of the control
+    * @static
+    * @final
+    */
     ControlElements.REV_ITEM = "item";
+    
+    /**
+    * Specifies that the element is used for refreshing data
+    * @static
+    * @final
+    */
     ControlElements.REV_REFRESH = "refresh";
 
@@ -58 +123 @@
      * Indexes the passed 'space' of HTML elements. Indexing in this context means resolving the various relative kauri-rev
      * attributes into absolute kauri-index attributes while keeping the pre-indexed references in the passed elementsIndex.
+     * @param {HTMLElement} space Which html element should be used as the start of indexing, all the child elements of the space will be indexed
+     * @param {ControlElements} store Where the index should be stored
+     * @param {Boolean} forceReIndexing Index even if the space has already been indexed
+     * @static
      */
     ControlElements.index = function( space, store, forceReIndexing) {
@@ -104 +173 @@
      * Finds the element assigned to the identified control for a specific kauri-form-relation (functional role), and creates it if
      * not found.
-     * 
+     * @param {Control} control
+     * @param {String} relation What relation the element has with the control (input, message, ...)
+     * @param {Boolean} create Flag that indicates if an element should be created if not found
      * @final
      * @static
@@ -166 +237 @@
     /**
      * Regular expression to parse index-entries.
-     * 
+     * @type Pattern
      * @static
      * @final
@@ -174 +245 @@
     /**
      * Splits the index-expressions in index and relation parts.
-     * 
+     * @param {String} index
+     * @return An Object with an index and a relation
+     * @type Object
      * @static
      * @final
@@ -191 +264 @@
     /**
      * Builds a new array with 'meta' property to store the associated relation-elements
-     * 
+     * @return an empty array
+     * @type Array
      * @static
      * @final
@@ -204 +278 @@
 
     /**
-     * 
+     * Generates a jQuery selector based on the given relationship
+     * @param {String} relation The relationship the element has with the control
+     * @return A selector to be used by jQuery to select certain elements
+     * @type String
+     * @static
+     * @final
      */
     ControlElements.revSelector = function( relation) {
@@ -235 +314 @@
      * 
      * @return whatever the idfn or relfn functions return.
+     * @private
      */
     ControlElements.prototype._operateIndex = function( index, relation, idfn, relfn) {
@@ -259 +339 @@
      * @param {string}
      *            [relation] relation-part to clear. <code>undefined</code> will force extra parsing of the index looking for a
-     *            relation part. <code>false</code> will skip index-parsing and clear the array.
+     *            relation part. <code>false</code> will skip index-parsing and clear the array.     
      */
     ControlElements.prototype.clearElementIndex = function( index, relation) {
@@ -340 +420 @@
 
     /**
-     * Control performs the actual DOM manipulations and event passing for an actual input-control on the form. Pure UI formatting
+     * @class Control performs the actual DOM manipulations and event passing for an actual input-control on the form. Pure UI formatting
      * effects (in fact any non data-bound interaction) are not handled by these controls.
      * 
@@ -363 +443 @@
     /**
      * Initializes all aspects of the control in a well defined sequence.
-     * 
+     * @param {Object} conf Control configuration     
      * @final should not be overridden
      */
@@ -380 +460 @@
     /**
      * Initializes the 'type' from the configuration object passed in (if that didn't happen yet).
-     * 
+     * @param {Object} conf Control configuration
      * @final should not be overridden
      */
@@ -396 +476 @@
     /**
      * Creates the type from the config if that is still needed.
-     * 
+     * @param {Object} conf Control configuration
      * @final should not be overridden
      */
@@ -408 +488 @@
 
 
-    /** Holds the control-bound HTML elements per relation */
+    /**
+    * Holds the control-bound HTML elements per relation
+    * @private 
+    */
     Control.prototype._elements;
 
-    /** Holds the configuration parameters for finding/creation control bound HTML elements per relation */
+    /** 
+    * Holds the configuration parameters for finding/creation control bound HTML elements per relation
+    * @type Object 
+    */
     Control.prototype.elements = {
         messages : {
@@ -419 +505 @@
     };
 
+    /**
+    * Initializes element configurations
+    */
     Control.prototype.initElementConfigs = function() {
 
     }
 
+    /**
+    * Gets an element configuration attribute based on it's relationship with the control
+    * @param {String} relation The elements relationship with the control
+    * @param {String} attribute Attribute name
+    * @return The sought after attribute
+    * @type Object
+    * @final
+    * @private
+    */
     Control.prototype._getElementConfig = function( relation, attribute) {
 
@@ -431 +529 @@
     }
 
+    /**
+    * Gets the element selector for an element with the specified relationship
+    * @param {String} relation The elements relationship with the control
+    * @return The element selector
+    * @type String
+    */
     Control.prototype.getElementSelector = function( relation) {
 
@@ -436 +540 @@
     }
     
+    /**
+    * Gets the create statement for an element with the specified relationship
+    * @param {String} relation The elements relationship with the control
+    * @return The create statement
+    * @type String
+    */
     Control.prototype.getCreateElement = function( relation) {
 
@@ -441 +551 @@
     }
     
+    /**
+    * Sets a html element (jQuery wrapped) for a specific relationship
+    * @param {String} relation The elements relationship with the control
+    * @param {jQuery} $elm Html element, jQuery wrapped
+    */
     Control.prototype.setElement = function( relation, $elm) {
 
@@ -448 +563 @@
     }
     
+    /**
+    * Gets a html element (jQuery) for a specific relationship
+    * @param {String} relation The elements relationship with the control
+    * @return The html element
+    * @type jQuery
+    */
     Control.prototype.getElement = function( relation) {
 
@@ -537 +658 @@
     /**
      * Perform control specific HTML element-binding on containment elements
-     * 
+     * @param {Boolean} create Create the elements if they don't exist yet
      * @see #_initElements(create)
      */
@@ -546 +667 @@
     /**
      * Initialize options (lists of possible values) for the control.
+     * @param {Boolean} create Create the option elements if they don't exist yet
      */
     Control.prototype.initOptions = function(create) {
@@ -576 +698 @@
     /**
      * Perform control specific HTML updating of options
+     * @param {Array} values Option values
+     * @param {Array} labels Option labels
      */
     Control.prototype.updateOptions = function( values, labels) {
@@ -586 +710 @@
     /**
      * Perform control specific HTML element-binding.
-     * 
+     * @param {Boolean} create Creates the elements if they don't exist yet
      * @see #_initElements(create)
      */
@@ -593 +717 @@
     }
 
-
+    /**
+    * Initializes validation i.e. sets validation listeners
+    */
     Control.prototype.initValidation = function() {
 
@@ -599 +725 @@
     };
 
-    /** The input-element which change() event should trigger the update sequence. Undefinef disables update. */
+    /** 
+    * The input-element which change() event should trigger the update sequence. Undefinef disables update.
+    * @return The update element
+    * @type jQuery 
+    */
     Control.prototype.getUpdateElement = function() {
 
@@ -681 +811 @@
      * formatting and validation is to be applied.
      */
-    Control.prototype.update = function() {
-
+    Control.prototype.update = function() {            
         var userVal = this.getUserValue();
         this.updateUserValue(userVal);
@@ -702 +831 @@
     }
 
+    /**
+    * Specifies that the value state is not yet known
+    * @static
+    * @final
+    */
     Control.STATE_INIT = undefined;
+    
+    /**
+    * Specifies that the value stored in the control has been deemed valid
+    * @static
+    * @final
+    */
     Control.STATE_VALID = "valid";
+    
+    /**
+    * Specifies that the value stored in the control has been deemed invalid
+    * @static
+    * @final
+    */
     Control.STATE_INVALID = "invalid";
+    
+    /**
+    * Specifies that validation is in progress
+    * @static
+    * @final
+    */
     Control.STATE_IN_PROGRESS = "in-progress";
-
+    
+    /**
+    * Specifies that the control is hidded
+    * @static
+    * @final
+    */
+    Control.STATE_HIDDEN = "hidden";
+    
+    /**
+    * Specifies that the control is visible
+    * @static
+    * @final
+    */
+    Control.STATE_VISIBLE = "visible";
+    
+    /**
+    * Specifies that the control is enabled
+    * @static
+    * @final
+    */
+    Control.STATE_ENABLED = "enabled";
+    
+    /**
+    * Specifies that the control has been disabled
+    * @static
+    * @final
+    */
+    Control.STATE_DISABLED = "disabled";
+
+    /**
+    * The controls value state. This is used to find out if the contained value is valid or not and all states in between
+    */
     Control.prototype.valueState = Control.STATE_INIT;
+    
+    /**
+    * The controls view state, is it visible or not
+    */ 
+    Control.prototype.viewState = Control.STATE_VISIBLE;
+    
+    /**
+    * Can a control be manipulated or not, enabled/disabled.
+    */
+    Control.prototype.operationalState = Control.STATE_ENABLED;
 
     /**
      * Sets the user-value and triggers formatting and validating as would actual editing.
+     * @param {Object} userValue 
+     * @param {Boolean} noValidation Should validation be done or not
      */
     Control.prototype.updateUserValue = function( userValue, noValidation) {
@@ -724 +919 @@
     }
 
+    /**
+    * Handles errors produced by funky values
+    * @param {Error} e The error object 
+    */
     Control.prototype.handleValueError = function( e) {
 
@@ -731 +930 @@
     }
 
-    Control.prototype.isValid = function(forceValidation) {
-
+    /**
+    * Checks if the control is valid
+    * @param {Boolean} forceValidation Force the validation if the control has been changed or not
+    * @return Is the control valid or not
+    * @type Boolean
+    */
+    Control.prototype.isValid = function(forceValidation) {            
         forceValidation = forceValidation || false;
         
@@ -741 +945 @@
     }
 
+    /**
+    * Sets the controls value
+    * @param {Object} value
+    * @param {Boolean} noValidation Should validation be done after setting the value?    
+    */
     Control.prototype.setValue = function( value, noValidation) {
-
         noValidation = noValidation || false;
         
@@ -761 +969 @@
     };
 
+    /**
+    * Gets the controls value
+    * @return The value
+    * @type Object
+    */
     Control.prototype.getValue = function() {
 
@@ -766 +979 @@
     };
 
+    /**
+    * Gets the controls wirevalue. The wirevalue is the value formatted in a manner that can be communicated to other services
+    * @return the wire value
+    * @type Object
+    */
     Control.prototype.getWireValue = function() {
 
@@ -781 +999 @@
     }
 
+    /**
+    * Sets the wire value
+    * @param {Object} wireValue
+    */
     Control.prototype.setWireValue = function( wireValue) {
 
@@ -793 +1015 @@
 
     /**
+     * Sets the original value of a control
+     * @param {Object} value the original value
      * @private Not meant to be called externally, is called internally as a side effect of setWireValue.
      */
@@ -800 +1024 @@
     }
 
+    /**
+    * Checks if a control has changes
+    * @return if a controls has changes or not
+    * @type Boolean
+    */
     Control.prototype.hasChanges = function() {
 
@@ -805 +1034 @@
     }
 
+    /**
+    * Checks if the provided value equals the value currently stored in the control
+    * @param {Object} thatValue The value to check against
+    * @return equals or not
+    * @type Boolean
+    */
     Control.prototype.valueEquals = function( thatValue) {
 
@@ -813 +1048 @@
     }
 
+    /**
+    * Validates the provided value using the configured validators
+    * @param  {Object} value    
+    */
     Control.prototype.newValidation = function( value) {
-    
         if (this.getType().validators.length == 0) {
             // if there are no validators then we must assume that the control is valid
@@ -825 +1063 @@
     }
 
+    /**
+    * Gets the validation data
+    * @return
+    * @type Object
+    */    
     Control.prototype.getValidationData = function() {
         return {control: this, options: this.getOptionValues()};
     }
     
+    /**
+    * Retrieve the controls options values
+    * @return an array of values
+    * @type Array
+    */
     Control.prototype.getOptionValues = function() {
         if (this.options == undefined || this.options.getValues == undefined)
@@ -835 +1083 @@
     }
     
+    /**
+    * What to do when a validation is successful
+    */
     Control.prototype.validationSuccess = function() {
 
     }
 
+    /**
+    * Things to do before the validation begins
+    */
     Control.prototype.validationStart = function() {
 
@@ -845 +1099 @@
     }
 
+    /**
+    * Things to do when a validation is complete
+    */
     Control.prototype.validationComplete = function() {
 
@@ -863 +1120 @@
     }
 
+    /**
+    * What to do when a validation fails
+    * @param {String} message What is displayed as a validation failed message
+    */
     Control.prototype.validationFail = function( message) {
 
@@ -868 +1129 @@
     }
 
+    /**
+    * Sets a message in the controls message element, if there is any
+    * @param {String} msg Message to be displayed
+    */
     Control.prototype.setMessage = function( msg) {
-
+        
         var msgElm = this.getElement("messages");
         if (msgElm) {
@@ -884 +1149 @@
     }
 
+    /**
+    * Clears the controls message
+    */
     Control.prototype.clearMessage = function() {
-
+        
         this.setMessage("");
     }
 
-
+    /**
+    * Gives a string representation of the control
+    * @return a string representation of the control
+    * @type String
+    */
     Control.prototype.toString = function() {
 
@@ -895 +1167 @@
     };
 
-
+    /**
+    * Gets this controls absolute id. This means including all the ids of possible parent controls
+    * @return absolute id or id-path
+    * @type String
+    */
     Control.prototype.getAbsoluteId = function() {
 
@@ -908 +1184 @@
 
     // TODO support 'match-patterns' allowing to return arrays of controls on which some jqyery like each() can then execute
-
+    /**
+    * Finds a control by checking it's path. This path can be a string representation or an array of path segments.
+    * @param {Object} arg {String} path or an {Array} of path segments  
+    * @return A control
+    * @type Control
+    */
     Control.prototype.findControl = function() {
 
@@ -922 +1203 @@
     }
 
+    /**
+    * Finds a control using a string representation of a path
+    * @param {String} path 
+    * @return A control
+    * @type Control
+    */   
     Control.prototype._findControlByPath = function( path) {
 
@@ -929 +1216 @@
     }
 
+    /**
+    * Finds a control using an array of path segments
+    * @param {Array} path segments 
+    * @return A control
+    * @type Control
+    */ 
     Control.prototype._findControlBySegments = function( segments) {
 
@@ -947 +1240 @@
             return target;
     }
-
-    /**
+    
+    /**
+    * Hides all elements in the control
+    */
+    Control.prototype.hide = function () {
+        for (var rel in this._elements) {
+            this._elements[rel].hide();
+        }
+        this.viewState = Control.STATE_HIDDEN;
+    }
+    
+    /**
+    * Makes control and all elements in the control visible
+    */
+    Control.prototype.show = function () {
+        for (var rel in this._elements) {
+            this._elements[rel].show();
+        }
+        this.viewState = Control.STATE_VISIBLE;
+    }
+        
+    /**
+    * Enables the control for writing
+    */
+    Control.prototype.enable = function () {
+        for (var rel in this._elements) {
+            var el = this._elements[rel];
+            if (el.is(":disabled")) {
+                el.removeAttr("disabled");
+            }
+            el.removeClass("disabled");
+        }
+        this.operationalState = Control.STATE_ENABLED;
+    }
+    
+    /**
+    * Disables the control
+    */
+    Control.prototype.disable = function () {
+        for (var rel in this._elements) {
+            var el = this._elements[rel];
+            if (el.is(":enabled")) {
+                el.attr("disabled", "disabled");
+            }
+            el.addClass("disabled");             
+        }
+        this.operationalState = Control.STATE_DISABLED;
+    }
+
+    /*
      * GETTERS & SETTERS
      */
 
+    /**
+    * Gets the controls id
+    * @return the id
+    * @type String
+    */
     Control.prototype.getId = function() {
 
@@ -957 +1303 @@
     }
 
+    /**
+    * Get the controls form control
+    * @return a form object
+    * @type Form
+    */
     Control.prototype.getForm = function() {
 
@@ -962 +1313 @@
     }
 
+    /**
+    * Sets the controls field type
+    * @param {FieldType} type The Field type to be used for this control    
+    */
     Control.prototype.setType = function( type) {
 
@@ -967 +1322 @@
     };
 
+    /**
+    * Gets the controls field type
+    * @return the controls type
+    * @type FieldType
+    */    
     Control.prototype.getType = function() {
 
@@ -972 +1332 @@
     }
 
+    /** 
+    * Gets the controls parent
+    * @return the parent control
+    * @type Control
+    */
     Control.prototype.getParent = function() {
 
@@ -979 +1344 @@
     $.inherit(AbstractContainerControl, Control);
 
+    /**
+    * @class The base class to be used by all other container controls
+    * @extends Control
+    * @constructor
+    * @param {String} id. Control Id
+    * @param {Form} form. The form that should contain this control
+    * @param {Object} conf. The configuration    
+    */
     function AbstractContainerControl( id, form, conf) {
 
@@ -984 +1357 @@
     }
 
+    /**
+    * Creates a blank value
+    * @return a blank value
+    * @type Object
+    */ 
     AbstractContainerControl.prototype.newBlankValue = function() {
 
@@ -989 +1367 @@
     };
 
-    //** Indicates initValue was called from parent already, and should be called on children from now on.
+    /** 
+    * Indicates initValue was called from parent already, and should be called on children from now on.
+    * @type boolean
+    */
     AbstractContainerControl.prototype.childInitValue = false;
     
-    /** Holds the configuration parameters for finding/creation control bound HTML elements per relation */
+    /** 
+    * Holds the configuration parameters for finding/creation control bound HTML elements per relation
+    * @type object 
+    */
     AbstractContainerControl.prototype.elements = {};
     $.extend(AbstractContainerControl.prototype.elements, Control.prototype.elements);
@@ -1004 +1388 @@
     });
 
+    /**
+    * Gets the values from all children 
+    * @param {String} getMethodName Getter method name <ul><li>getUserValue</li><li>getWireValue</li></ul>
+    * @return an array containing the values found in the this controls child controls 
+    * @type Array
+    * @private
+    */
     AbstractContainerControl.prototype.getValueLoop = function( getMethodName) {
 
@@ -1009 +1400 @@
 
         var children = this.getChildren();
-
+        
         // loop trough all contained elements ('rows or members'), and get their value
         for ( var i in children) {
@@ -1018 +1409 @@
     }
 
+    /**
+    * Sets the values for all of this controls children
+    * @param {String} setMethodName The setters method name <ul><li>setUserValue</li><li>setWireValue</li></ul>
+    * @param {Array} value The values should be ordered in the same order as the children
+    * @private
+    */
     AbstractContainerControl.prototype.setValueLoop = function( setMethodName, value) {
 
         // ignore childUpdates
         var restore = this.updateValue;
-        this.updateValue = function(){};
+        this.updateValue = function( childControl ){};
         
         // loop trough all contained elements ('rows or members'), and set their value
@@ -1037 +1434 @@
     }
 
+    /**
+    * Gets the values of all child controls in user format
+    * @return an array of values found in the child controls. These values are in user format
+    * @type Array
+    */
     AbstractContainerControl.prototype.getUserValue = function() {
 
         return this.getValueLoop("getUserValue");
     }
-
+    
+    /**
+    * Sets the values for all of this controls children. The value is expected to be in user format    
+    * @param {Array} value The values should be ordered in the same order as the children
+    */
     AbstractContainerControl.prototype.setUserValue = function( value) {
 
@@ -1047 +1453 @@
     }
 
+    /**
+    * Gets the values from all children
+    * @return an array containing the values found in the this controls child controls 
+    * @type Array
+    * @private
+    */
     AbstractContainerControl.prototype.getValue = function() {
 
@@ -1052 +1464 @@
     }
 
+    /**
+    * Sets the values for all of this controls children    
+    * @param {Array} value The values should be ordered in the same order as the children
+    * @private
+    */
     AbstractContainerControl.prototype.setValue = function( value) {
 
@@ -1058 +1475 @@
     }
 
+    /**
+    * Gets the values from all children.    
+    * @return an array containing the values found in the this controls child controls. The values returned will be in wire format 
+    * @type Array    
+    */
     AbstractContainerControl.prototype.getWireValue = function() {
 
         return this.getValueLoop("getWireValue");
     }
-
+    /**
+    * Sets the values for all of this controls children. The value is expected to be in wire format    
+    * @param {Array} value The values should be ordered in the same order as the children    
+    */
     AbstractContainerControl.prototype.setWireValue = function( value) {
 
@@ -1068 +1493 @@
     }
 
+    /**
+    * Sets the original value of the control (This doesn't do anything)
+    * @param {Object} value    
+    */
     AbstractContainerControl.prototype.setOriginalValue = function( value) {
 
     }
 
+    /**
+    * Checks if there are any changes in the child controls
+    * @return 
+    * @type boolean
+    */
     AbstractContainerControl.prototype.hasChanges = function() {
 
@@ -1082 +1516 @@
     }
 
+    /**
+    * Always returns false
+    * @param {object} thatValue
+    */
     AbstractContainerControl.prototype.valueEquals = function( thatValue) {
 
@@ -1088 +1526 @@
 
 
+    /**
+    * Doesn't do anything
+    */
     AbstractContainerControl.prototype.clearChildValues = function() {
 
     };
 
+    /**
+    * Gets all child controls
+    * @return object containing all the children
+    * @type Object
+    */
     AbstractContainerControl.prototype.getChildren = function() {
 
@@ -1097 +1543 @@
     }
 
+    /**
+    * Gets a child by it's ID
+    * @param {String} id
+    * @return the child
+    * @type Control
+    */
     AbstractContainerControl.prototype.getChild = function( id) {
 
@@ -1102 +1554 @@
     }
 
+    /**
+    * Initializes typical container elements
+    * @param {Boolean} create If true it will create the container elements if the don't already exist
+    * @private
+    */
     AbstractContainerControl.prototype.initContainerElements = function( create) {
 
@@ -1109 +1566 @@
         }
         var layout = ControlElements.lookup(this, ControlElements.REV_LAYOUT, create);
-        if (layout) {
+        if (layout) {            
             layout.hide();
         }
@@ -1119 +1576 @@
 
     /**
+     * the item selector
      * @final
      */
@@ -1126 +1584 @@
      * Creates the HTML elements for hosting a new child-id by cloning the "layout" section into the "container" section This will
      * also register the newly created elements into the
-     * 
+     * @param {String} id Id to be used to the newly created child
+     * @return the new control elements
+     * @type jQuery
      * @final
      */
@@ -1151 +1611 @@
     }
 
+    /**
+    * Creates a new control based on type but doesn't add it to the list of children
+    * @param {String} id The id of the new child control
+    * @param {FieldType} type The childs field type
+    * @return the child control
+    * @type Control 
+    */
     AbstractContainerControl.prototype.createChildControl = function( id, type) {
 
@@ -1186 +1653 @@
         return childControl;
     }
-
+    
+    /**
+    * Places a the child control in the list of this controls children
+    * @param {String} id 
+    * @param {Control} childControl
+    */
     AbstractContainerControl.prototype.putChild = function( id, childControl) {
 
@@ -1192 +1664 @@
     }
     
+    /**
+    * Runs validation on this control and acknowledges a change in value
+    * @param {Control} childControl    
+    */
     AbstractContainerControl.prototype.updateValue = function(childControl) {
         this.newValidation(this.getValue());
@@ -1197 +1673 @@
     }
 
+    /**
+    * Checks if this control and all it's child controls are valid
+    * @param {Boolean} forceValidation Does the validation if changes have been made or not
+    */
     AbstractContainerControl.prototype.isValid = function(forceValidation) {
         var valid = this["<super.call>"]("isValid", [forceValidation]);

trunk/modules/kauri-forms/kauri-forms-framework/src/test/js/testPage.html

@@ -30 +30 @@
   <script type="text/javascript" src="../../main/kauri/js/collection.js" ></script>
   <script type="text/javascript" src="../../main/kauri/js/composite.js" ></script>
+  <script type="text/javascript" src="../../main/kauri/js/case.js" ></script>
   <script type="text/javascript" src="../../main/kauri/js/date.js" ></script>
   <script type="text/javascript" src="../../main/kauri/js/form.js" ></script>
@@ -58 +59 @@
   <script type="text/javascript" src="test-composite.js" ></script>
   <script type="text/javascript" src="test-collection.js" ></script>
+  <script type="text/javascript" src="test-case.js" ></script>
   <script type="text/javascript" src="test-form.js" ></script>
   <script type="text/javascript" src="test-date.js" ></script>
+  
+  <link rev="stylesheet" src="../../main/kauri/public/css/datepicker.css"/>
   
 </head>