Changeset 14142

Timestamp:

06/25/08 06:03:43 (5 months ago)

Author:

doughays

Message:

Fixes #4437. Creates a parsing regexp for ValidationTextBox? widgets that matches valid subsets in order to mask validation errors during data entry that are only due to partial input.

Files:

• dijit/trunk/form/ValidationTextBox.js (modified) (6 diffs)

dijit/trunk/form/ValidationTextBox.js

@@ -76 +76 @@
                 },
 
+                _isValidSubset: function(){
+                        // summary:
+                        //      Returns true if the value is either already valid or could be made valid by appending characters.
+                        return this.textbox.value.search(this._partialre) == 0;
+                },
+
                 isValid: function(/*Boolean*/ isFocused){
                         // summary: Need to over-ride with your own validation code in subclasses
@@ -96 +102 @@
                 },
 
+                _maskValidSubsetError: false,
                 validate: function(/*Boolean*/ isFocused){
                         // summary:
@@ -103 +110 @@
                         var message = "";
                         var isValid = this.isValid(isFocused);
+                        if(isValid){ this._maskValidSubsetError = true; }
+                        var isValidSubset = !isValid && isFocused && this._isValidSubset();
                         var isEmpty = this._isEmpty(this.textbox.value);
-                        this.state = (isValid || (!this._hasBeenBlurred && isEmpty)) ? "" : "Error";
+                        this.state = (isValid || (!this._hasBeenBlurred && isEmpty) || isValidSubset) ? "" : "Error";
+                        if(this.state == "Error"){ this._maskValidSubsetError = false; }
                         this._setStateClass();
                         dijit.setWaiState(this.focusNode, "invalid", isValid ? "false" : "true");
@@ -111 +121 @@
                                         message = this.getPromptMessage(true);
                                 }
-                                if(!message && this.state == "Error"){
+                                if(!message && (this.state == "Error" || (isValidSubset && !this._maskValidSubsetError))){
                                         message = this.getErrorMessage(true);
                                 }
@@ -156 +166 @@
                         var p = this.regExpGen(this.constraints);
                         this.regExp = p;
+                        var partialre = "";
+                        // parse the regexp and produce a new regexp that matches valid subsets
+                        // if the regexp is .* then there's no use in matching subsets since everything is valid
+                        if(p != ".*"){ this.regExp.replace(/\\.|\[\]|\[.*?[^\\]{1}\]|\{.*?\}|\(\?[=:!]|./g,
+                                function (re){
+                                        switch(re.charAt(0)){
+                                                case '{':
+                                                case '+':
+                                                case '?':
+                                                case '*':
+                                                case '^':
+                                                case '$':
+                                                case '|':
+                                                case '(': partialre += re; break;
+                                                case ")": partialre += "|$)"; break;
+                                                 default: partialre += "(?:"+re+"|$)"; break;
+                                        }
+                                }
+                        );}
+                        try{ // this is needed for now since the above regexp parsing needs more test verification
+                                "".search(partialre);
+                        }catch(e){ // should never be here unless the original RE is bad or the parsing is bad
+                                partialre = this.regExp;
+                                console.debug('RegExp error in ' + this.declaredClass + ': ' + this.regExp);
+                        } // should never be here unless the original RE is bad or the parsing is bad
+                        this._partialre = "^(?:" + partialre + ")$";
                 }
         }
@@ -264 +300 @@
                 },
 
+                _isDefinitelyOutOfRange: function(){
+                        // summary:
+                        //      Returns true if the value is out of range and will remain
+                        //      out of range even if the user types more characters
+                        var val = this.getValue();
+                        var isTooLittle = false;
+                        var isTooMuch = false;
+                        if("min" in this.constraints){
+                                var min = this.constraints.min;
+                                val = this.compare(val, ((typeof min == "number") && min >= 0)? 0 : min);
+                                isTooLittle = (typeof val == "number") && val < 0;
+                        }
+                        if("max" in this.constraints){
+                                var max = this.constraints.max;
+                                val = this.compare(val, ((typeof max != "number") || max > 0)? max : 0);
+                                isTooMuch = (typeof val == "number") && val > 0;
+                        }
+                        return isTooLittle || isTooMuch;
+                },
+
+                _isValidSubset: function(){
+                        return this.inherited(arguments) && !this._isDefinitelyOutOfRange();
+                },
+
                 isValid: function(/*Boolean*/ isFocused){
                         return this.inherited(arguments) &&