html5forms-rails 0.1.3

data/vendor/assets/javascripts/html5forms/dev/visibleIf.js

@@ -0,0 +1,1100 @@
+/*
+ * This notice must be untouched at all times.
+ * 
+ * visibleIf.js - a cross browser form field manager that hides and shows
+ * form fields depending on the values of other form fields.
+ *
+ * Version 1.0 released Feb 21, 2009
+ * Version 2.0 (this release) released June 20, 2010.  Features new 
+ *   rules engine originally developed for HTML5Widgets.js and HTML5 custom
+ *   data- attribute support. 
+ *
+ * Written by: Zoltan Hawryluk. 
+ * 
+ * Latest release available at http://www.useragentman.com/
+ *
+ * released under the MIT License:
+ *   http://www.opensource.org/licenses/mit-license.php
+ */
+
+var visibleIf = new function(){
+    var me = this;
+    
+    var formInputCache = new Array();
+    var changedInput = null;
+    
+    var visibleIfNodes;
+    var mandatoryNodes;
+    var varRe = /\s([a-zA-Z][a-zA-Z0-9\.]*)\s/g;
+    var operatorRe = /\s*(~|!=|==|>={0,1}|<={0,1})\s*/g;
+    var leftBkRe = /\(/g;
+    var rightBkRe = /\)/g;
+    var reRe = /~ \"([^\"]*)\"/g;
+    var equalsRe = / == /g;
+    var quotedStringRe = /"[^"]*"/g;
+    var quotedStringOneOnlyRe = /"[^"]*"/;
+    var placeHolderString = '_pLaCeHoLdEr_';
+    var placeHolderRe = new RegExp(placeHolderString);
+    
+    var nodesWithEventsAttached = new Array();
+    
+    var inputsToClear;
+    
+    var req = null;
+    
+    var nameCounter = 0;
+    var CSSHelpers, StringHelpers, XMLHelpers, DOMHelpers;
+    /*
+     * Things to look into:
+     *
+     * I don't think you need the options.isPageLoad checks inside
+     * setFormElementsInside() since we are setting doClear accordingly.
+     */
+    me.init = function(reset){
+        if (EventHelpers.hasPageLoadHappened(arguments) && !reset) {
+            return;
+        }
+        
+        visibleIfNodes = CSSHelpers.getElementsByClassName(document, 'visibleIf');
+        mandatoryNodes = CSSHelpers.getElementsByClassName(document, 'mandatoryIf');
+        
+        removeDisabledNodes();
+        me.refreshPage({
+            isPageLoad: true
+        });
+        setMandatoryStates();
+        setEvents();
+        //strutsHelpers.populateDynamicFormElements();
+    }
+    
+    function removeDisabledNodes(){
+    
+        for (var i = 0; i < visibleIfNodes.length; i++) {
+            var node = visibleIfNodes[i];
+            
+            var els = getAllFormElementsIn(node)
+            
+            for (var j = 0; j < els.length; j++) {
+                var el = els[j];
+                el.disabled = false;
+                
+            }
+        }
+    }
+    
+    function refreshPageEvent(e){
+        me.refreshPage();
+    }
+    
+    me.refreshPage = function(options){
+    
+        changedInput = this;
+        
+        inputsToClear = new Array();
+        qsSb = new StringBuffer();
+        for (var i = 0; i < visibleIfNodes.length; i++) {
+            setVisibility(visibleIfNodes[i], options);
+            
+        }
+        
+        
+        if (!(options && !options.isPageLoaded)) {
+            for (i in inputsToClear) {
+                var el = inputsToClear[i];
+                if (i != 0) {
+                    qsSb.append('&');
+                }
+                qsSb.append(i).append('=');
+            }
+            
+            var qs = qsSb.toString();
+            
+            
+            if (qsSb.getLength() > 0) {
+            
+                var url = DOMHelpers.getDatasetItem(document.body, 'visibleif-deletedataurl');
+                
+                if (url) {
+                    req = XMLHelpers.getXMLHttpRequest(url, deleteRequestHandler, 'GET', qs);
+                }
+                
+            }
+            
+            
+            
+            for (var i = 0; i < mandatoryNodes.length; i++) {
+                setMandatoryStates(mandatoryNodes[i], options);
+                
+            }
+        }
+        
+		var formNodes = document.getElementsByTagName('form');
+		
+		for (var i=0; i<formNodes.length; i++) {
+			updateVisibilityProperties(formNodes[i]);
+		}
+    }
+    
+    function setMandatoryStates(e){
+        changedInput = this;
+        for (var i = 0; i < mandatoryNodes.length; i++) {
+            setMandatoryState(mandatoryNodes[i]);
+            
+        }
+        
+    }
+    
+    function getRule(node, type){
+        var r = DOMHelpers.getDatasetItem(node, type);
+        
+        if (!r) {
+            r = CSSHelpers.getElementsByClassName(node, type);
+            
+            if (r.length == 0) {
+                r = null;
+            } else {
+                r = r[0].innerHTML.trim()
+            }
+        }
+        
+        if (r) {
+            r = StringHelpers.unentify(" " + r.replace(operatorRe, ' $1 ') + " ");
+        }
+        
+        return r;
+    }
+    
+    function setEvents(){
+    
+        visibleIfNodes = CSSHelpers.getElementsByClassName(document, 'visibleIf');
+        mandatoryNodes = CSSHelpers.getElementsByClassName(document, 'mandatoryIf');
+        var nodesToIndex = [visibleIfNodes, mandatoryNodes];
+        var nameCounter = 0;
+        var forms = document.getElementsByTagName('form');
+        
+        for (var i = 0; i < forms.length; i++) {
+            EventHelpers.addEvent(forms[i], 'submit', formSubmitEvent);
+        }
+        
+        
+        
+        for (var n = 0; n < nodesToIndex.length; n++) {
+            var nodes = nodesToIndex[n];
+            for (var i = 0; i < nodes.length; i++) {
+                var node = nodes[i];
+				var parentForm = DOMHelpers.getAncestorByTagName(node, 'form');
+				
+				
+				
+                var rule;
+                var ruleType;
+                if (n == 0) {
+                    ruleType = "visibleIf-rule";
+                } else {
+                    ruleType = "mandatoryIf-rule";
+                }
+                
+                rule = getRule(node, ruleType);
+                
+                if (!rule) {
+                    throw "There is no rule for with the node with the following HTML:" + XMLHelpers.getOuterXML(node);
+                }
+                
+                
+                
+                var inputVars = getInputVars(rule);
+                
+                if (inputVars) {
+                    for (var j = 0; j < inputVars.length; j++) {
+                        var inputVar = inputVars[j];
+                        if (!nodesWithEventsAttached[parentForm.id]|| !nodesWithEventsAttached[parentForm.id][inputVar]) {
+							
+							if (!nodesWithEventsAttached[parentForm.id]) {
+								nodesWithEventsAttached[parentForm.id] = new Array();
+							}
+							
+                            nodesWithEventsAttached[parentForm.id][inputVar] = true;
+                            
+                            if (inputVars.length > 0) {
+                                                                
+                                var fieldNode = parentForm[inputVars[j]];
+                                //var fieldNode = document.getElementById(inputVars[j]);
+                                
+                                if (fieldNode != null) {
+                                    if (fieldNode.nodeName != "SELECT" && fieldNode.length) {
+                                        for (var k = 0; k < fieldNode.length; k++) {
+                                        
+                                            EventHelpers.addEvent(fieldNode[k], 'click', refreshPageEvent);
+                                            
+                                        }
+                                    } else {
+                                    
+                                        EventHelpers.addEvent(fieldNode, 'change', refreshPageEvent);
+                                    }
+                                    
+                                    if (fieldNode.type == 'text') {
+                                    
+                                        EventHelpers.addEvent(fieldNode, 'change', refreshPageEvent);
+                                    }
+                                    
+                                    if (fieldNode.type == 'checkbox') {
+                                        EventHelpers.addEvent(fieldNode, 'click', refreshPageEvent);
+                                    }
+                                }
+                                
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        
+    }
+	
+	function updateVisibilityProperties(formNode){
+		var fields = formNode.elements;
+		
+		for (var i = 0; i < fields.length; i++) {
+			var field = fields[i]
+			if (!isVisible(field) && !CSSHelpers.isMemberOfClass(field, 'visibleIf-submitIfInvisible')) {
+				CSSHelpers.addClass(field, 'visibleIf-notSubmitted');
+				field.disabled = true;
+			} else {
+				CSSHelpers.removeClass(field, 'visibleIf-notSubmitted');
+				field.disabled = false;
+			}
+		}
+	}
+	
+    function formSubmitEvent(e){
+    
+        if (CSSHelpers.isMemberOfClass(this, 'visibleIf-submitInvisibleData')) {
+            return;
+        }
+        
+        updateVisibilityProperties(this);
+    }
+    
+    function isVisible(node){
+        return node.offsetWidth != 0;
+    }
+    
+    
+    
+    function setVisibility(node, options){
+        var rule = getRule(node, 'visibleIf-rule')
+        
+        if (rule == null) {
+            throw "There is no rule for with the node with the following HTML:" + XMLHelpers.getOuterXML(node);
+        }
+        
+        var isRuleTrue = evaluateRule(DOMHelpers.getAncestorByTagName(node, 'form'), rule);
+        
+        
+        if (isRuleTrue) {
+            CSSHelpers.addClass(node, 'visibleIf-visible');
+            setFormElementsInside(node, false, options);
+        } else {
+            CSSHelpers.removeClass(node, 'visibleIf-visible');
+            
+            if (options && options.isPageLoad) {
+                setFormElementsInside(node, false, options);
+            } else {
+                setFormElementsInside(node, true, options);
+            }
+        }
+    }
+    
+    function setMandatoryState(node){
+        var rule = getRule(node, 'mandatoryIf-rule')
+        
+        if (rule == null) {
+            throw "There is no rule for with the node with the following HTML:" + XMLHelpers.getOuterXML(node);
+        }
+        
+        
+        var isRuleTrue = evaluateRule(DOMHelpers.getAncestorByTagName(node, 'form'), getRule(node, rule));
+        
+        
+        if (isRuleTrue) {
+            CSSHelpers.addClass(node, 'mandatoryIf-mandatory');
+            //setFormElementsInside(node, false);
+        } else {
+            CSSHelpers.removeClass(node, 'mandatoryIf-mandatory');
+            //setFormElementsInside(node, true);
+        }
+        
+    }
+    
+    
+    function evaluateRule(parentForm, rule){ //node, ruleNode) {
+        //var rule = getRuleString(ruleNode);
+        
+        if (rule == "") {
+            return true;
+        } else {
+        
+        
+            if (rule != null) {
+            
+                //var parentForm = DOMHelpers.getAncestorByTagName(node, 'form');
+                if (!parentForm) {
+                    throw "Error: the rule " + rule + " is not attached to a form."
+                }
+                
+                var stringToEval;
+                
+                var formElem = parentForm[rule.name];
+                
+                // first, replace all quoted strings with placeholders:
+                var diddledRule = rule.replace(quotedStringRe, placeHolderString);
+                
+                // next, grab all those quoted strings
+                var quotedVals = rule.match(quotedStringRe);
+                
+                
+                var formId = parentForm.id;
+                
+                if (!formId) {
+                    formId = 'visibleIf-form' + nameCounter;
+                    parentForm.id = formId;
+                    
+                    nameCounter++;
+                }
+                
+                
+                // now replace all variables with javascript form element values
+                stringToEval = diddledRule.replace(leftBkRe, '( ').replace(rightBkRe, ' )').replace(varRe, 'getFieldValue(document.getElementById("' +
+                formId +
+                '")["$1"]) ').replace(reRe, '.match(/$1/)');
+                
+                // now, replace placeholders back to the original strings.
+                if (quotedVals) {
+                    for (var i = 0; i < quotedVals.length; i++) {
+                        stringToEval = stringToEval.replace(placeHolderRe, quotedVals[i]);
+                    }
+                }
+                
+               
+                try {
+                    if (eval(stringToEval)) {
+                        return true;
+                    } else {
+                        return false;
+                    }
+                } 
+                catch (ex) {
+                    //alert('Bad equation: ' + stringToEval)
+                    return false;
+                }
+            }
+        }
+    }
+    
+    
+    function setFormElementsInside(node, doClear, options){
+    
+    
+    
+        if (!options) {
+            options = {};
+        }
+        
+        var formElements = getAllFormElementsIn(node);
+        
+        for (var i = 0; i < formElements.length; i++) {
+        
+        
+            var el = formElements[i];
+            
+            
+            /* Let's disable them so they aren't submitted 
+             if (!CSSHelpers.isMemberOfClass(node, 'visibleIf-ignoreDisableAttr')) {
+             
+             el.disabled = doClear ? "disabled" : "";
+             
+             if (CSSHelpers.isMemberOfClass(el, 'streetName')) {
+             jslog.debug(el.disabled);
+             }
+             }*/
+            if (el != changedInput) {
+            
+                switch (el.nodeName) {
+                    case "INPUT":
+                        switch (el.type) {
+                        
+                            case "checkbox":
+                                if (el.checked) {
+                                    if (doClear) {
+                                    
+                                        if (!CSSHelpers.isMemberOfClass(el, 'visibleIf-doNotReset')) {
+                                            // cache the value
+                                            formCache.setValue(el.name, el.value);
+                                            el.checked = false;
+                                            addToInputToClear(el);
+                                        }
+                                        
+                                    } else if (formCache.getValue(el.name) == el.value) {
+                                    //el.checked = true;
+                                    
+                                    }
+                                }
+                                break;
+                            case "radio":
+                                
+                                if (doClear) {
+                                
+                                    if (!CSSHelpers.isMemberOfClass(el, 'visibleIf-doNotReset')) {
+                                    
+                                        // cache the value
+                                        if (el.checked) {
+                                            formCache.setValue(el.name, el.value);
+                                            el.checked = false;
+                                        }
+                                        addToInputToClear(el);
+                                        
+                                    }
+                                    
+                                } else if (formCache.getValue(el.name) == el.value) {
+                                //el.checked = true;
+                                
+                                }
+                                
+                                break;
+                                
+                            case "file":
+                                
+                                // do nothing to avoid a security error.
+                                break;
+                            case "hidden":
+                                // don't do anything
+                                break;
+                            default:
+                                if (doClear) {
+                                
+                                    /*
+                             * The following code is for use with a seperate
+                             * JavaScript library, fileChanger.js.  If
+                             * it's a fileChanger widget, we need to do an Ajax call
+                             */
+                                    if (CSSHelpers.isMemberOfClass(el, 'fileList_fileDisplay')) {
+                                        CSSHelpers.removeClass(el, 'fileList_fileDisplay');
+                                        el.disabled = false;
+                                        el.name = el.name.replace("_ignore", "")
+                                        var html = XMLHelpers.getOuterXML(el).replace(/text/, 'file');
+                                        el.parentNode.innerHTML = html;
+                                        
+                                        // insert ajax call to delete file here.
+                                        url = config.getScriptedValue('visibleIf.urls.deleteFiles', {
+                                            files: StringHelpers.urlencode(el.value),
+                                            formProperty: el.name
+                                        })
+                                        req = XMLHelpers.getXMLHttpRequest(url, deleteRequestHandler);
+                                    }
+                                    
+                                    
+                                    // cache the value
+                                    formCache.setValue(el.name, el.value);
+                                    if (options.isPageLoad) {
+                                        el.value = DOMHelpers.getAttributeValue(el, 'value');
+                                        if (el.value == "null") {
+                                            el.value = "";
+                                        }
+                                    } else if (!CSSHelpers.isMemberOfClass(el, 'visibleIf-doNotReset')) {
+                                        el.value = "";
+                                        addToInputToClear(el);
+                                    }
+                                    
+                                } else {
+                                //el.value = formCache.getValue(el.name);
+                                }
+                                break;
+                        }
+                        break;
+                    case "TEXTAREA":
+                        if (doClear) {
+                            // cache the value
+                            formCache.setValue(el.name, el.value);
+                            if (options.isPageLoad) {
+                            //el.value = DOMHelpers.getAttributeValue(el, 'value');
+                            } else if (!CSSHelpers.isMemberOfClass(el, 'visibleIf-doNotReset')) {
+                                el.value = "";
+                                addToInputToClear(el);
+                            }
+                        } else {
+                        //el.value = formCache.getValue(el.name);
+                        }
+                        
+                        break;
+                    case "SELECT":
+                        if (doClear) {
+                        
+                            if (!CSSHelpers.isMemberOfClass(el, 'visibleIf-doNotReset')) {
+                                // cache the value
+                                formCache.setValue(el.name, el.selectedIndex);
+                                
+                                // TODO: should this be 0 or -1?
+                                el.selectedIndex = 0;
+                                addToInputToClear(el);
+                            }
+                            
+                            el.disabled = true;
+                            
+                        } else {
+                            //el.selectedValue =  formCache.getValue(el.name);
+                            el.disabled = false;
+                        }
+                        break;
+                        
+                        
+                }
+            }
+            
+        }
+        
+        
+        
+        
+        
+        
+        
+    }
+    
+    function addToInputToClear(el){
+        if (!inputsToClear[el.name]) {
+            inputsToClear[el.name] = el;
+        }
+    }
+    
+    function deleteRequestHandler(){
+    
+        if (!req) {
+            return;
+        }
+        
+        // only if req shows "complete"
+        if (req.readyState == ReadyState.COMPLETED) {
+            // only if "OK"
+            //DebugHelpers.log(req.getAllResponseHeaders());
+            
+            if (req.status == HttpCode.OK || req.status == HttpCode.LOCAL_OK) {
+                // whatever
+                //jslog.debug('Deleted Successfully')
+            } else {
+                throw "Something bad happened.  HTTP Status: " + req.status;
+                
+            }
+        }
+    }
+    
+    
+    function getInputVars(rule){
+        rule = rule.replace(leftBkRe, '( ').replace(rightBkRe, ' )');
+        var vars = rule.match(varRe);
+        
+        if (vars == null) {
+            return new Array();
+        }
+        
+        for (var i = 0; i < vars.length; i++) {
+            vars[i] = vars[i].trim();
+        }
+        
+        
+        return vars;
+        
+    }
+    
+    
+    function getFieldValue(formElementNode){
+        var r = "";
+        var type;
+        
+        type = formElementNode.type
+        
+        if (!type) {
+            if (formElementNode.length) 
+                type = formElementNode[0].type;
+        }
+        
+        
+        switch (type) {
+        
+            case 'text':
+            case 'hidden':
+            case 'password':
+            case 'textarea':
+            case 'select-one':
+                r = formElementNode.value;
+            case 'checkbox':
+                if (formElementNode.checked) {
+                    r = formElementNode.value;
+                }
+                break;
+            case 'radio':
+                for (var i = 0; i < formElementNode.length; i++) {
+                    if (formElementNode[i].checked) {
+                        r = formElementNode[i].value;
+                        break;
+                    }
+                }
+                
+                
+        }
+        
+        if (formElementNode.length) {
+            for (var i = 0; i < formElementNode.length; i++) {
+                if (formElementNode[i].checked) {
+                    r = formElementNode[i].value;
+                }
+            }
+            
+        }
+        
+        return r.replace('\n', '').replace('   ', '');
+    }
+    
+    function getAllFormElementsIn(node){
+        if (!node) {
+            node = document;
+        }
+        
+        var r = new Array();
+        
+        var elems = {
+            inputs: node.getElementsByTagName('input'),
+            selects: node.getElementsByTagName('select'),
+            textareas: node.getElementsByTagName('textarea')
+        };
+        
+        for (var i in elems) {
+            var elem = elems[i];
+            for (j = 0; j < elem.length; j++) {
+                r.push(elem[j]);
+            }
+        }
+        
+        return r;
+    }
+    
+    
+    /* Helper routines */
+    if (window.CSSHelpers) {
+        CSSHelpers = window.CSSHelpers;
+    } else {
+        CSSHelpers = new function(){
+            var me = this;
+            var blankRe = new RegExp('\\s');
+            
+            /**
+             * Generates a regular expression string that can be used to detect a class name
+             * in a tag's class attribute.  It is used by a few methods, so I
+             * centralized it.
+             *
+             * @param {String} className - a name of a CSS class.
+             */
+            function getClassReString(className){
+                return '\\s' + className + '\\s|^' + className + '\\s|\\s' + className + '$|' + '^' + className + '$';
+            }
+            
+            function getClassPrefixReString(className){
+                return '\\s' + className + '-[0-9a-zA-Z_]+\\s|^' + className + '[0-9a-zA-Z_]+\\s|\\s' + className + '[0-9a-zA-Z_]+$|' + '^' + className + '[0-9a-zA-Z_]+$';
+            }
+            
+            
+            
+            /**
+             * Make an HTML object be a member of a certain class.
+             *
+             * @param {Object} obj - an HTML object
+             * @param {String} className - a CSS class name.
+             */
+            me.addClass = function(obj, className){
+                if (blankRe.test(className)) {
+                    return;
+                }
+                
+                // only add class if the object is not a member of it yet.
+                if (!me.isMemberOfClass(obj, className)) {
+                    obj.className += " " + className;
+                }
+            }
+            
+            /**
+             * Make an HTML object *not* be a member of a certain class.
+             *
+             * @param {Object} obj - an HTML object
+             * @param {Object} className - a CSS class name.
+             */
+            me.removeClass = function(obj, className){
+            
+                if (blankRe.test(className)) {
+                    return;
+                }
+                
+                
+                var re = new RegExp(getClassReString(className), "g");
+                
+                var oldClassName = obj.className;
+                
+                
+                if (obj.className) {
+                    obj.className = oldClassName.replace(re, '');
+                }
+                
+                
+            }
+            
+            /**
+             * Given an HTML element, find all child nodes of a specific class.
+             *
+             * With ideas from Jonathan Snook
+             * (http://snook.ca/archives/javascript/your_favourite_1/)
+             * Since this was presented within a post on this site, it is for the
+             * public domain according to the site's copyright statement.
+             *
+             * @param {Object} obj - an HTML element.  If you want to search a whole document, set
+             * 		this to the document object.
+             * @param {String} className - the class name of the objects to return
+             * @return {Array} - the list of objects of class cls.
+             */
+            me.getElementsByClassName = function(obj, className){
+                if (obj.getElementsByClassName) {
+                    return DOMHelpers.nodeListToArray(obj.getElementsByClassName(className))
+                } else {
+                    var a = [];
+                    var re = new RegExp(getClassReString(className));
+                    var els = DOMHelpers.getAllDescendants(obj);
+                    
+                    for (var i = 0, j = els.length; i < j; i++) {
+                        if (re.test(els[i].className)) {
+                            a.push(els[i]);
+                            
+                        }
+                    }
+                    return a;
+                }
+            }
+            
+            /**
+             * Determines if an HTML object is a member of a specific class.
+             * @param {Object} obj - an HTML object.
+             * @param {Object} className - the CSS class name.
+             */
+            me.isMemberOfClass = function(obj, className){
+            
+                if (blankRe.test(className)) 
+                    return false;
+                
+                var re = new RegExp(getClassReString(className), "g");
+                
+                return (re.test(obj.className));
+            }
+        }
+    }
+    
+    if (window.DOMHelpers) {
+        DOMHelpers = window.DOMHelpers;
+    } else {
+        DOMHelpers = new function(){
+        
+            var me = this;
+            /**
+             * Given an tag, find the first ancestor tag of a given tag name.
+             *
+             * @param {Object} obj - a HTML or XML tag.
+             * @param {String} tagName - the name of the ancestor tag to find.
+             * @return {Object} - the ancestor tag, or null if not found.
+             */
+            /**
+             * Returns all children of an element. Needed if it is necessary to do
+             * the equivalent of getElementsByTagName('*') for IE5 for Windows.
+             *
+             * @param {Object} e - an HTML object.
+             */
+            me.getAllDescendants = function(obj){
+                return obj.all ? obj.all : obj.getElementsByTagName('*');
+            }
+            
+            me.getAncestorByTagName = function(obj, tagName){
+            
+                for (var node = obj.parentNode; node.nodeName.toLowerCase() != 'body'; node = node.parentNode) {
+                
+                    if (tagName.toLowerCase() == node.nodeName.toLowerCase()) {
+                        return node;
+                    }
+                    
+                }
+                return null;
+            }
+            
+            /**
+             * Given an HTML or XML object, find the an attribute by name.
+             *
+             * @param {Object} obj - a DOM object.
+             * @param {String} attrName - the name of an attribute inside the DOM object.
+             * @return {Object} - the attribute object or null if there isn't one.
+             */
+            me.getAttributeByName = function(obj, attrName){
+                var i;
+                
+                var attributes = obj.attributes;
+                for (i = 0; i < attributes.length; i++) {
+                    var attr = attributes[i]
+                    if (attr.nodeName == attrName && attr.specified) {
+                        return attr;
+                    }
+                }
+                return null;
+            }
+            
+            /**
+             * Given an HTML or XML object, find the value of an attribute.
+             *
+             * @param {Object} obj - a DOM object.
+             * @param {String} attrName - the name of an attribute inside the DOM object.
+             * @return {String} - the value of the attribute.
+             */
+            me.getAttributeValue = function(obj, attrName){
+                var attr = me.getAttributeByName(obj, attrName);
+                
+                if (attr != null) {
+                    return attr.nodeValue;
+                } else {
+                    return null;
+                }
+            }
+            
+            me.getDatasetItem = function(obj, name){
+                var r = DOMHelpers.getAttributeValue(obj, 'data-' + name);
+                
+                if (!r) {
+                    r = DOMHelpers.getAttributeValue(obj, 'data-' + name.toLowerCase())
+                }
+                return r;
+            }
+            
+            /******
+             * Converts a DOM live node list to a static/dead array.  Good when you don't
+             * want the thing you are iterating in a for loop changing as the DOM changes.
+             *
+             * @param {Object} nodeList - a node list (like one returned by document.getElementsByTagName)
+             * @return {Array} - an array of nodes.
+             *
+             *******/
+            me.nodeListToArray = function(nodeList){
+                var ary = [];
+                for (var i = 0, len = nodeList.length; i < len; i++) {
+                    ary.push(nodeList[i]);
+                }
+                return ary;
+            }
+            
+        }
+    }
+    
+    if (window.StringHelpers) {
+        StringHelpers = window.StringHelpers;
+    } else {
+        StringHelpers = new function(){
+            var me = this;
+            me.initWhitespaceRe = /^\s\s*/;
+            me.endWhitespaceRe = /\s\s*$/;
+            me.whitespaceRe = /\s/;
+            
+            me.unentify = function(s){
+            
+                return s.replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>');
+            }
+            
+            me.urlencode = function(str){
+                return escape(str).replace('+', '%2B').replace('%20', '+').replace('*', '%2A').replace('/', '%2F').replace('@', '%40');
+            }
+            
+        }
+    }
+    
+    if (window.XMLHelpers) {
+        XMLHelpers = window.XMLHelpers;
+    } else {
+        XMLHelpers = new function(){
+            var me = this;
+            
+            /**
+             * Given an XML node, return the XML inside as a string and the XML string of the node itself.
+             * Similar to Internet Explorer's outerHTML property, except it is for XML, not HTML.
+             * Created with information from http://www.codingforums.com/showthread.php?t=31489
+             * and http://www.mercurytide.co.uk/whitepapers/issues-working-with-ajax/
+             *
+             * @param {Object} node - a DOM object.
+             * @param {Object} options - a JS object containing options.  To date,
+             * 		the only one supported is "insertClosingTags", when set to
+             * 		true, converts self closing tags, like <td />, to <td></td>.
+             * @return {String} - the XML String inside the object.
+             */
+            me.getOuterXML = function(node, options){
+                var r;
+                // Internet Explorer
+                if (node.xml) {
+                    r = node.xml;
+                    
+                    // Everyone else 
+                } else if (node.outerHTML) {
+                    r = node.outerHTML;
+                } else if (window.XMLSerializer) {
+                
+                    var serializer = new XMLSerializer();
+                    var text = serializer.serializeToString(node);
+                    r = text;
+                } else {
+                    return null;
+                }
+                
+                /*
+                 * If the XML is actually HTML and you are inserting it into an HTML
+                 * document, you must use the "insertClosingTags" option, otherwise
+                 * Opera will not like you, especially if you have empty <td> tags.
+                 */
+                if (options) {
+                    if (options.insertClosingTags) {
+                        r = r.replace(selfClosingTagRe, "<$1></$1>");
+                    }
+                }
+                return r;
+            }
+            
+            /**
+             * Wrapper for XMLHttpRequest Object.  Grabbing data (XML and/or text) from a URL.
+             * Grabbing data from a URL. Input is one parameter, url. It returns a request
+             * object. Based on code from
+             * http://www.xml.com/pub/a/2005/02/09/xml-http-request.html.  IE caching problem
+             * fix from Wikipedia article http://en.wikipedia.org/wiki/XMLHttpRequest
+             *
+             * @param {String} url - the URL to retrieve
+             * @param {Function} processReqChange - the function/method to call at key events of the URL retrieval.
+             * @param {String} method - (optional) "GET" or "POST" (default "GET")
+             * @param {String} data - (optional) the CGI data to pass.  Default null.
+             * @param {boolean} isAsync - (optional) is this call asyncronous.  Default true.
+             *
+             * @return {Object} a XML request object.
+             */
+            me.getXMLHttpRequest = function(url, processReqChange) //, method, data, isAsync)
+            {
+                var argv = me.getXMLHttpRequest.arguments;
+                var argc = me.getXMLHttpRequest.arguments.length;
+                var httpMethod = (argc > 2) ? argv[2] : 'GET';
+                var data = (argc > 3) ? argv[3] : "";
+                var isAsync = (argc > 4) ? argv[4] : true;
+                
+                var req;
+                // branch for native XMLHttpRequest object
+                if (window.XMLHttpRequest) {
+                    req = new XMLHttpRequest();
+                    // branch for IE/Windows ActiveX version
+                } else if (window.ActiveXObject) {
+                    try {
+                        req = new ActiveXObject('Msxml2.XMLHTTP');
+                    } 
+                    catch (ex) {
+                        req = new ActiveXObject("Microsoft.XMLHTTP");
+                    }
+                    // the browser doesn't support XML HttpRequest. Return null;
+                } else {
+                    return null;
+                }
+                
+                if (isAsync) {
+                    req.onreadystatechange = processReqChange;
+                }
+                
+                if (httpMethod == "GET" && data != "") {
+                    url += "?" + data;
+                }
+                
+                req.open(httpMethod, url, isAsync);
+                
+                //Fixes IE Caching problem
+                req.setRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT");
+                req.send(data);
+                
+                return req;
+            }
+            
+        }
+    }
+    
+    /*
+     *  stringBuffer - ideas from
+     *  http://www.multitask.com.au/people/dion/archives/000354.html
+     */
+    function StringBuffer(){
+        var me = this;
+        
+        var buffer = [];
+        
+        
+        me.append = function(string){
+            buffer.push(string);
+            return me;
+        }
+        
+        me.appendBuffer = function(bufferToAppend){
+            buffer = buffer.concat(bufferToAppend);
+        }
+        
+        me.toString = function(){
+            return buffer.join("");
+        }
+        
+        me.getLength = function(){
+            return buffer.length;
+        }
+        
+        me.flush = function(){
+            buffer.length = 0;
+        }
+        
+    }
+    
+    /* 
+     * Adding trim method to String Object.  Ideas from
+     * http://www.faqts.com/knowledge_base/view.phtml/aid/1678/fid/1 and
+     * http://blog.stevenlevithan.com/archives/faster-trim-javascript
+     */
+    String.prototype.trim = function(){
+        var str = this;
+        
+        // The first method is faster on long strings than the second and 
+        // vice-versa.
+        if (this.length > 6000) {
+            str = this.replace(StringHelpers.initWhitespaceRe, '');
+            var i = str.length;
+            while (StringHelpers.whitespaceRe.test(str.charAt(--i))) 
+                ;
+            return str.slice(0, i + 1);
+        } else {
+            return this.replace(StringHelpers.initWhitespaceRe, '').replace(StringHelpers.endWhitespaceRe, '');
+        }
+    };
+    
+}
+
+var formCache = new function(){
+    var me = this;
+    var values = new Array();
+    
+    me.setValue = function(name, value){
+        values[name] = value;
+    }
+    
+    me.getValue = function(name){
+        if (values[name] == undefined) {
+            return "";
+        } else {
+            return values[name];
+        }
+    }
+}
+
+EventHelpers.addPageLoadEvent('visibleIf.init');
+