/***

    wForms 2.0
    a javascript extension to web forms. 

    Build $Tue, 20 Mar 2007 15:17:28 UTC$

    THIS FILE IS AUTOMATICALLY GENERATED.  If creating patches, please
    diff against the source tree, not this file.

    Copyright (c) 2005-2007 Cedric Savarese <cedric@veerwest.com> and contributors.
    This software is licensed under the CC-GNU LGPL <http://creativecommons.org/licenses/LGPL/2.1/>
    For more information, visit: http://www.formassembly.com/wForms 

    Build script by Troels Knak-Nielsen <troelskn@gmail.com>

***/

// wForms - a javascript extension to web forms.
// see http://www.formassembly.com/wForms
// This software is licensed under the CC-GNU LGPL <http://creativecommons.org/licenses/LGPL/2.1/>

function wHELPERS() {};

// addEvent adapated from http://ejohn.org/projects/flexible-javascript-events/
// and  Andy Smith's (http://weblogs.asp.net/asmith/archive/2003/10/06/30744.aspx)
wHELPERS.prototype.addEvent = function(obj, type, fn) {
        if(!obj) { return; }
        
        if (obj.attachEvent) {
                obj['e'+type+fn] = fn;
                obj[type+fn] = function(){obj['e'+type+fn]( window.event );}
                obj.attachEvent( 'on'+type, obj[type+fn] );
        } else if(obj.addEventListener) {                        
                obj.addEventListener( type,fn, false );
        } else {
                var originalHandler = obj["on" + type]; 
                if (originalHandler) { 
                  obj["on" + type] = function(e){originalHandler(e);fn(e);}; 
                } else { 
                  obj["on" + type] = fn; 
                } 
        }
}

wHELPERS.prototype.removeEvent = function(obj, type, fn) {
        if (obj.detachEvent) {
                if(obj[type+fn]) {
                        obj.detachEvent( 'on'+type, obj[type+fn] );
                        obj[type+fn] = null;
                }
        } else if(obj.removeEventListener)
                obj.removeEventListener( type, fn, false );
        else {
                obj["on" + type] = null;
        }
}

// Returns the event's source element 
wHELPERS.prototype.getSourceElement = function(e) {        
        if(!e) e = window.event;        
        if(e.target)
                var srcE = e.target;
        else
                var srcE = e.srcElement;
        if(!srcE) return null;
        if(srcE.nodeType == 3) srcE = srcE.parentNode; // safari weirdness                
        if(srcE.tagName.toUpperCase()=='LABEL' && e.type=='click') { 
                // when clicking a label, firefox fires the input onclick event
                // but the label remains the source of the event. In Opera and IE 
                // the source of the event is the input element. Which is the 
                // expected behavior, I suppose.                
                if(srcE.getAttribute('for')) {
                        srcE = document.getElementById(srcE.getAttribute('for'));
                }
        }
        return srcE;
}

// Cancel the default execution of an event.
wHELPERS.prototype.preventEvent = function(e) {
        if (!e) e = window.event;
        if (e.preventDefault) e.preventDefault();
        else e.returnValue = false;
        return false;
}

// Cancel the propagation of the event
wHELPERS.prototype.stopPropagation = function(e) {
        if (!e) var e = window.event;
        e.cancelBubble = true;
        if (e.stopPropagation) e.stopPropagation();
}

// Generates a random ID
wHELPERS.prototype.randomId = function () {
        var seed = (new Date()).getTime();
        seed = seed.toString().substr(6);
        for (var i=0; i<6;i++)
                seed += String.fromCharCode(48 + Math.floor((Math.random()*10)));
        return "id-" + seed;
}

// Activating an Alternate Stylesheet (thx to: http://www.howtocreate.co.uk/tutorials/index.php?tut=0&part=27)
// Use this to activate a CSS Stylesheet that shouldn't be used if javascript is turned off.
// The stylesheet rel attribute should be 'alternate stylesheet'. The title attribute MUST be set.
wHELPERS.prototype.activateStylesheet = function(sheetref) {
        if(document.getElementsByTagName) {
                var ss=document.getElementsByTagName('link');
        } else if (document.styleSheets) {
                var ss = document.styleSheets;
        }
        for(var i=0;ss[i];i++ ) {
                if(ss[i].href.indexOf(sheetref) != -1) {
                        ss[i].disabled = true;
                        ss[i].disabled = false;                        
                }
        }
}

// hasClass
wHELPERS.prototype.hasClass = function(element,className) {
        if(element && element.className) {
                if((' ' + element.className + ' ').indexOf(' ' + className +' ') != -1) {
                        return true;
                }
        }
        return false;
}
wHELPERS.prototype.hasClassPrefix = function(element,className) {
        if(element && element.className) {
                if((' ' + element.className).indexOf(' ' + className) != -1) {
                        return true;
                }
        }
        return false;
}
        wHELPERS.prototype.hasIdPrefix = function(element,idPrefix) {
                if(element && element.id) {
                        if(element.id.indexOf(idPrefix) != -1) {
                                return true;
                        }
                }
                return false;
        }


// getTop / getLeft  
// Returns pixel coordinates from the top-left window corner.
wHELPERS.prototype.getTop = function(obj) {
        var cur = 0;
        if(obj.offsetParent) {                
                while(obj.offsetParent) {
                        if((new wHELPERS()).getComputedStyle(obj,'position') == 'relative' ) {
                                // relatively postioned element
                                return cur;
                        }
                        cur+=obj.offsetTop;
                        obj = obj.offsetParent;
                }
        }
        return cur;
}
wHELPERS.prototype.getLeft = function(obj) {
        var cur = 0;
        if(obj.offsetParent) {                
                while(obj.offsetParent) {
                        if((new wHELPERS()).getComputedStyle(obj,'position') == 'relative' ) {
                                // relatively postioned element
                                return cur;
                        }
                        if((new wHELPERS()).getComputedStyle(obj,'position') == 'absolute' ) {
                                // relatively postioned element
                                return cur;
                        }
                        cur+=obj.offsetLeft;
                        obj = obj.offsetParent;
                }
        }
        return cur;
}

wHELPERS.prototype.getComputedStyle = function(element, styleName) {
        if(window.getComputedStyle) {
                return window.getComputedStyle(element,"").getPropertyValue(styleName);
        } else if(element.currentStyle) {        
                return element.currentStyle[styleName];
        }
        return false;
}
// backward compatibility
        var wHelpers = wHELPERS;   


   /* 
        * MISC FUNCTIONS 
   /* ------------------------------------------------------------------------------------------ */

// Push implementation for IE5/mac
if (!Array.prototype.push) { 
        Array.prototype.push = function() { 
                for (var i = 0; i < arguments.length; ++i) { 
                        this[this.length] = arguments[i]; 
                } 
                return this.length; 
        }; 
}


  if(wHELPERS) {
          var wFORMS = { 
          
          debugLevel     : 0, /* 0: Inactive, 1+: Debug Level */
          
          helpers        : new wHELPERS(),     
          behaviors      : {},
          onLoadComplete : new Array(),  /* stack of functions to call once all behaviors have been applied */
          processedForm  : null,
          
          onLoadHandler  : function() {
                  for(var behaviorName in  wFORMS.behaviors) {
                           wFORMS.debug('wForms/loaded behavior: ' + behaviorName);
                  }
                 
                  for (var i=0;i<document.forms.length;i++) {
                          wFORMS.debug('wForms/initialize: '+ (document.forms[i].name || document.forms[i].id) );
                          wFORMS.addBehaviors(document.forms[i]);
                  }
          },
          
          addBehaviors : function (node) {
                if(!node) return;
                
                if(!node.nodeType) {
                        // argument is not a node. probably an id string. 
                        // (typeof not used for IE5/mac compatibility)
                        node = document.getElementById(node);
                }
                if(!node || node.nodeType!=1) return;
                
                deep=(arguments.length>1)?arguments[1]:true;        

                wFORMS._addBehaviors(node, deep);                                        
          },
                  
          _addBehaviors : function (node, deep) {
                 if(node.getAttribute('rel')=='no-behavior') {
                          return false;
                 }
                 // Process element nodes only
                 if(node.nodeType == 1) { 
                          if(node.tagName == 'FORM') {
                                  wFORMS.processedForm = node;
                          }                  
                          for(var behaviorName in wFORMS.behaviors) {
                                  wFORMS.behaviors[behaviorName].evaluate(node);
                          }                        
                          if(deep) {
                                  for (var i=0, cn=node.childNodes, l=cn.length; i<l; i++) {
                                           if(cn[i].nodeType==1)
                                                 wFORMS._addBehaviors(cn[i], deep);
                                  }
                          }                          
                          if(node.tagName == 'FORM') {
                                  // run the init stack
                                  for (var i=0;i<wFORMS.onLoadComplete.length;i++) {
                                          wFORMS.onLoadComplete[i].func(wFORMS.onLoadComplete[i].form);
                                  }
                                  // empty the stack                                          
                                  if(wFORMS.onLoadComplete.length > 0) {
                                          wFORMS.onLoadComplete = new Array();
                                  }
                          }
                  }
          },
          
          hasBehavior: function(behaviorName) {
                  if(wFORMS.behaviors[behaviorName]) return true;
                  return false;
          },
          
          /* 
           * DEBUG FUNCTIONS 
           * ------------------------------------------------------------------------------------------ */
          debug : function(txt) { 
                msgLevel = arguments[1] || 10;         // 1 = least importance, X = most important
                
                if(wFORMS.debugLevel > 0 && msgLevel >= wFORMS.debugLevel) {
                        if(!wFORMS.debugOutput)
                                wFORMS.initDebug();
                        if(wFORMS.debugOutput)
                                wFORMS.debugOutput.innerHTML += "<br />" + txt;
                }
          },
          
          initDebug : function() {
                var output = document.getElementById('debugOutput');
                if(!output) {
                        output = document.createElement('div');
                        output.id = 'debugOutput';
                        output.style.position   = 'absolute';
                        output.style.right      = '10px';
                        output.style.top        = '10px';
                        output.style.zIndex     = '300';
                        output.style.fontSize   = 'x-small';
                        output.style.fontFamily = 'courier';
                        output.style.backgroundColor = '#DDD';
                        output.style.padding    = '5px';
                        if(document.body) // if page fully loaded
                                wFORMS.debugOutput = document.body.appendChild(output);
                }
                if(wFORMS.debugOutput)
                        wFORMS.debugOutput.ondblclick = function() { this.innerHTML = '' };
        }
  };
  
  wFORMS.NAME     = "wForms";
  wFORMS.VERSION  = "2.0";
  wFORMS.__repr__ = function () {
        return "[" + this.NAME + " " + this.VERSION + "]";
  };
  wFORMS.toString = function () {
        return this.__repr__();
  };
 
 
  // For backward compatibility
  wFORMS.utilities = wFORMS.helpers;
  var wf           = wFORMS; 
  wf.utilities.getSrcElement                                = wFORMS.helpers.getSourceElement;
  wf.utilities.XBrowserPreventEventDefault        = wFORMS.helpers.preventEvent;
  
  // Initializations:
  
  // Attach JS only stylesheet.
  wFORMS.helpers.activateStylesheet('wforms-jsonly.css');
  // Parse document and apply wForms behavior
  wFORMS.helpers.addEvent(window,'load',wFORMS.onLoadHandler);
  } 


// ------------------------------------------------------------------------------------------
// Field Hint / Tooltip Behavior
// ------------------------------------------------------------------------------------------
  
if(wFORMS) {

       // Component properties 
       wFORMS.idSuffix_fieldHint           = "-H";                     // a hint id is the associated field id (or name) plus this suffix
       wFORMS.className_inactiveFieldHint  = "field-hint-inactive";    // visual effect depends on CSS stylesheet
       wFORMS.className_activeFieldHint    = "field-hint";             // visual effect depends on CSS stylesheet
       
       
       wFORMS.behaviors['hint'] = {
           name: 'hint', 
           
                   // evaluate: check if the behavior applies to the given node. Adds event handlers if appropriate
             evaluate: function(node) {
               if(node.id) {
                          if(node.id.indexOf(wFORMS.idSuffix_fieldHint)>0) {                          
                            // this looks like a field-hint. See if we have a matching field.                           
                            // try first with the id, then with the name attribute.
                            var id     = node.id.replace(wFORMS.idSuffix_fieldHint, '');                            
                            var hinted = document.getElementById(id) || wFORMS.processedForm[id];
                          } 
                   if(hinted) {
                                           // is hint placed on a radio group using the name attribute?
                                           if(hinted.length > 0 && hinted[0].type=='radio') {
                                                   var hintedGroup = hinted;
                                                   l = hinted.length;
                                           } else {
                                                   var hintedGroup = new Array(hinted);
                                                   l = 1;
                                           }
                                           
                                           for(var i=0;i<l;i++) {
                                                   hinted = hintedGroup[i];

                                                   wFORMS.debug('hint/evaluate: '+ (node.id || node.name));
                                                   switch(hinted.tagName.toUpperCase()) {
                                                           case 'SELECT': 
                                                           case 'TEXTAREA':                                                   
                                                           case 'INPUT':
                                                                        wFORMS.helpers.addEvent(hinted,'focus',wFORMS.behaviors['hint'].run);
                                                                        wFORMS.helpers.addEvent(hinted,'blur' ,wFORMS.behaviors['hint'].remove);
                                                                        break;
                                                           default:
                                                                        wFORMS.helpers.addEvent(hinted,'mouseover',wFORMS.behaviors['hint'].run);
                                                                        wFORMS.helpers.addEvent(hinted,'mouseout' ,wFORMS.behaviors['hint'].remove);
                                                                        break;
                                                   }
                                                   
                                           }
                   } 
               }
           },

                   
           // run: executed when the behavior is activated
           run: function(e) {
               var element   = wFORMS.helpers.getSourceElement(e);
               var fieldHint = document.getElementById(element.id   + wFORMS.idSuffix_fieldHint);
               if(!fieldHint) // try again with the element's name attribute
                   fieldHint = document.getElementById(element.name + wFORMS.idSuffix_fieldHint);
               if(fieldHint) {
                   fieldHint.className = fieldHint.className.replace(wFORMS.className_inactiveFieldHint,
                                                                     wFORMS.className_activeFieldHint);
                                   // Field Hint Absolute Positionning
                                   fieldHint.style.top  =  (wFORMS.helpers.getTop(element)+ element.offsetHeight).toString() + "px";
                                   if(element.tagName.toUpperCase() == 'SELECT') 
                                           fieldHint.style.left =  (wFORMS.helpers.getLeft(element) + (element.offsetWidth- 8)).toString() + "px";
                                   else 
                                           fieldHint.style.left =  (wFORMS.helpers.getLeft(element)).toString() + "px"; /* + element.offsetWidth */
//                                   wFORMS.debug('hint/run: ' + (element.id || element.name) , 5);                                   
                           }
           },
                   
           // remove: executed if the behavior should not be applied anymore
           remove: function(e) {
               var element   = wFORMS.helpers.getSourceElement(e);
               var fieldHint = document.getElementById(element.id   + wFORMS.idSuffix_fieldHint);
               if(!fieldHint) // try again with the element's name attribute
                   fieldHint = document.getElementById(element.name + wFORMS.idSuffix_fieldHint);
               if(fieldHint)
                   fieldHint.className = fieldHint.className.replace(wFORMS.className_activeFieldHint,
                                                                     wFORMS.className_inactiveFieldHint);
//                           wFORMS.debug('hint/remove: ' + (element.id || element.name) , 5);                                   
           }
       }
   }
// ------------------------------------------------------------------------------------------
// Form Paging Behavior
// ------------------------------------------------------------------------------------------
  
   if(wFORMS) {
                // Component properties 
                wFORMS.className_paging                                = "wfPage";
                wFORMS.className_pagingCurrent                = "wfCurrentPage";
                wFORMS.className_pagingButtons                = "wfPageButton";
                wFORMS.className_hideSubmit                        = "wfHideSubmit";
                wFORMS.idPrefix_pageIndex                        = "wfPgIndex-";
                wFORMS.runValidationOnPageNext           = true;
                
                if(!wFORMS.arrMsg) wFORMS.arrMsg         = new Array();
                wFORMS.arrMsg[4]                                         = "Next Page";      //arrMsg[4] for backward compatibility
                wFORMS.arrMsg[5]                                         = "Previous Page";        //arrMsg[5] for backward compatibility


                wFORMS.behaviors['paging'] = {

                        idSuffix_buttonsPlaceholder: "-buttons",
                        className_pageNextButton: wFORMS.className_pagingButtons + " wfPageNextButton",
                        className_pagePreviousButton: wFORMS.className_pagingButtons + " wfPagePreviousButton",                        
                        behaviorInUse : false,
                        allowNestedPages: false,
                        onPageChange : null, /* Function to run when the page is changed */

                        // ------------------------------------------------------------------------------------------
                        // evaluate: check if the behavior applies to the given node. Adds event handlers if appropriate
                        // ------------------------------------------------------------------------------------------
                        evaluate: function(node) {
                                if (wFORMS.helpers.hasClass(node,wFORMS.className_paging)) {
                                        
                                        if(!wFORMS.behaviors['paging'].allowNestedPages && wFORMS.behaviors['paging'].getPageElement(node)) {
                                                // found a parent node that is also a page element. 
                                                // remove paging class so that the content is not hidden.
                                                node.className = node.className.replace(wFORMS.className_paging,"");
                                                return;
                                        }
                                                
                                        wFORMS.behaviors['paging'].behaviorInUse = true;
                                        
                                        var currentPageIndex = wFORMS.behaviors['paging'].getPageIndex(node);
                                        if(currentPageIndex > 1) {
                                                // add previous page button        
                                                var placeholder = this.getButtonPlaceholder(node);
                                                var button = placeholder.insertBefore(this.createPreviousPageButton(),placeholder.firstChild);                                                
                                                wFORMS.helpers.addEvent(button,'click',wFORMS.behaviors['paging'].pagingPrevious);                                                
                                        } else {
                                                // set current page class
                                                node.className += ' ' + wFORMS.className_pagingCurrent;
                                                
                                                // get the corresponding form element
                                                var form = wFORMS.behaviors['paging'].getFormElement(node);        
                                                                                                                                                                                                        
                                                // prevent submission of form with enter key.
                                                wFORMS.helpers.addEvent(form,'submit', function(e) { var element = wFORMS.helpers.getSourceElement(e);
                                                                                                                                                         if(element.type && element.type.toLowerCase()=='text') 
                                                                                                                                                                return wFORMS.preventEvent(e); } );
                                                wFORMS.preventSubmissionOnEnter = true; // for input validation behavior
                                                
                                        }
                                        if(document.getElementById(wFORMS.idPrefix_pageIndex+(currentPageIndex+1).toString())) {
                                                // add next page button        
                                                var placeholder = this.getButtonPlaceholder(node);
                                                var button = placeholder.appendChild(this.createNextPageButton());
                                                wFORMS.helpers.addEvent(button,'click',wFORMS.behaviors['paging'].pagingNext);        
                                                // hide submit button until the last page of the form is reached (do it once on the 1st page)
                                                if(currentPageIndex==1) {                                                        
                                                        wFORMS.behaviors['paging'].hideSubmitButton(form);
                                                }                                                
                                        }
                                }
                          
                        },
                        getButtonPlaceholder: function(page) {
                                var p = document.getElementById(page.id+this.idSuffix_buttonsPlaceholder);
                                if(!p) {
                                        var buttonPlaceholder = document.createElement("div");         
                                        buttonPlaceholder = page.appendChild(buttonPlaceholder);        
                                        buttonPlaceholder.className = 'actions';
                                        buttonPlaceholder.id = page.id+this.idSuffix_buttonsPlaceholder;
                                        return buttonPlaceholder;
                                }                                
                                return p; 
                        },
                        createNextPageButton: function() {                                                
                                var button = document.createElement("input"); 
                                button.setAttribute('value',wFORMS.arrMsg[4]);        
                                button.setAttribute('type',"button");        
                                button.className = this.className_pageNextButton;
                                return button;
                        },
                        createPreviousPageButton: function() {
                                // add previous page button                        
                                var button = document.createElement("input"); 
                                button.setAttribute('value',wFORMS.arrMsg[5]);        
                                button.setAttribute('type',"button");        
                                button.className = this.className_pagePreviousButton;
                                return button;
                        },
                                                
                        // ------------------------------------------------------------------------------------------
                        // pagingNext
                        // ------------------------------------------------------------------------------------------
                        pagingNext: function(e) {
                                var element  = wFORMS.helpers.getSourceElement(e);
                                if(!element) element = e
                                
                                var pageElement     = wFORMS.behaviors['paging'].getPageElement(element);
                                var pageIndex       = wFORMS.behaviors['paging'].getPageIndex(pageElement) + 1;
                                var nextPageElement = document.getElementById(wFORMS.idPrefix_pageIndex+pageIndex.toString());
                                
                                if(nextPageElement) {
                                        if(!wFORMS.hasBehavior('validation') ||
                                           (wFORMS.hasBehavior('validation') && !wFORMS.runValidationOnPageNext) || 
                                           (wFORMS.hasBehavior('validation') &&  wFORMS.runValidationOnPageNext && wFORMS.functionName_formValidation(e, true))) {
                                                
                                                pageElement.className      = pageElement.className.replace(new RegExp(wFORMS.className_pagingCurrent,"g"),"");
                                                nextPageElement.className += ' ' + wFORMS.className_pagingCurrent;

                                                // show submit button if the last page of the form is reached
                                                if(wFORMS.behaviors['paging'].isLastPage(pageIndex)) {
                                                        var form = wFORMS.behaviors['paging'].getFormElement(nextPageElement);
                                                        wFORMS.behaviors['paging'].showSubmitButton(form);
                                                }
                                                // trigger onPageChange event                                                
                                                if(wFORMS.behaviors['paging'].onPageChange) {
                                                        wFORMS.behaviors['paging'].onPageChange(nextPageElement);
                                                }
                                                window.scroll(0,0);
                                        }                                        
                                }
                        },
                        
                        // ------------------------------------------------------------------------------------------
                        // pagingPrevious
                        // ------------------------------------------------------------------------------------------                                
                        pagingPrevious: function(e) {
                                var element  = wFORMS.helpers.getSourceElement(e);
                                if(!element) element = e
 
                                var pageElement         = wFORMS.behaviors['paging'].getPageElement(element);
                                var pageIndex           = wFORMS.behaviors['paging'].getPageIndex(pageElement) - 1;
                                var previousPageElement = document.getElementById(wFORMS.idPrefix_pageIndex+pageIndex.toString());

                                if(previousPageElement) {
                                        pageElement.className          = pageElement.className.replace(new RegExp(wFORMS.className_pagingCurrent,"g"),"");
                                        previousPageElement.className += ' ' + wFORMS.className_pagingCurrent;                                                                                
                                                                                                                        
                                        // hide submit button 
                                        var form = wFORMS.behaviors['paging'].getFormElement(previousPageElement);                                        
                                        wFORMS.behaviors['paging'].hideSubmitButton(form);
                                        
                                        // trigger onPageChange event
                                        if(wFORMS.behaviors['paging'].onPageChange) {
                                                wFORMS.behaviors['paging'].onPageChange(previousPageElement);
                                        }
                                        window.scroll(0,0);
                                }
                        },
                        // ------------------------------------------------------------------------------------------
                        // show/hide submit button
                        // ------------------------------------------------------------------------------------------                                                                
                        showSubmitButton: function(form) {
                                var buttons = form.getElementsByTagName('input');
                                for (var i=0;i<buttons.length;i++) {
                                        if(buttons[i].type && buttons[i].type.toLowerCase() == 'submit') {
                                                buttons[i].className = buttons[i].className.replace(wFORMS.className_hideSubmit,"");
                                        }
                                }
                        },
                        hideSubmitButton: function(form) {
                                var buttons = form.getElementsByTagName('input');
                                for (var i=0;i<buttons.length;i++) {
                                        if(buttons[i].type && buttons[i].type.toLowerCase() == 'submit' 
                                       && !wFORMS.helpers.hasClass(buttons[i],wFORMS.className_hideSubmit) ) {
                                                buttons[i].className += ' ' + wFORMS.className_hideSubmit; 
                                        }
                                }
                        },
                        
                        // ------------------------------------------------------------------------------------------
                        // isLastPage
                        // ------------------------------------------------------------------------------------------                                        
                        isLastPage: function(pageIndex) {
                                if(isNaN(pageIndex)) {
                                        pageIndex = parseInt(pageIndex.replace(/[\D]*/,""));
                                }
                                pageIndex++;
                                var furtherPageElement = document.getElementById(wFORMS.idPrefix_pageIndex+pageIndex.toString());                        
                                if(!furtherPageElement) 
                                        return true;
                                return false;
                        },
                        // ------------------------------------------------------------------------------------------
                        // gotoPage
                        // ------------------------------------------------------------------------------------------                                
                        gotoPage: function(pageIndex) { 
                                
                                if(isNaN(pageIndex)) {
                                        var pageElement = document.getElementById(pageIndex);                                        
                                } else {
                                        var pageElement = document.getElementById(wFORMS.idPrefix_pageIndex+pageIndex.toString());
                                }                                
                                if(!pageElement) return false;
                                
                                // get the corresponding form element
                                var form = wFORMS.behaviors['paging'].getFormElement(pageElement);
                                
                                // hide current page
                                var allElements = form.getElementsByTagName("*");
                                for(var i=0; i< allElements.length; i++) {
                                        var n =  allElements[i];                                        
                                        if(wFORMS.helpers.hasClass(allElements[i],wFORMS.className_pagingCurrent)) {                                                
                                                n.className = n.className.replace(new RegExp(wFORMS.className_pagingCurrent,"g"),"");        
                                                break;
                                        }
                                }
                                //show/hide submit button as necessary
                                
                                if(wFORMS.behaviors['paging'].isLastPage(pageIndex)) 
                                        wFORMS.behaviors['paging'].showSubmitButton(form);
                                else { 
                                        wFORMS.behaviors['paging'].hideSubmitButton(form);
                                }
                                // Show the page
                                pageElement.className += ' ' + wFORMS.className_pagingCurrent;
                                
                                // trigger onPageChange event
                                if(wFORMS.behaviors['paging'].onPageChange) {
                                        wFORMS.behaviors['paging'].onPageChange(pageElement);
                                }
                        },
                        // ------------------------------------------------------------------------------------------
                        // getFormElement
                        // ------------------------------------------------------------------------------------------                                                        
                        getFormElement: function(element) {
                                var form = element.parentNode;
                                while(form && form.tagName != "FORM")
                                        form = form.parentNode;
                                return form;
                        },
                        // ------------------------------------------------------------------------------------------
                        // getPageElement
                        // ------------------------------------------------------------------------------------------                                                        
                        getPageElement: function(element) {
                                var n = element.parentNode;
                                while(n && n.tagName != "FORM" && (!n.className || !wFORMS.helpers.hasClass(n,wFORMS.className_paging)))
                                        n = n.parentNode;
                                if(n && wFORMS.helpers.hasClass(n,wFORMS.className_paging))
                                        return n;
                                else
                                        return null;
                        },
                        // ------------------------------------------------------------------------------------------
                        // getPageIndex
                        // ------------------------------------------------------------------------------------------                                                                        
                        getPageIndex: function(element) {
                                if(element && element.id) 
                                        return parseInt(element.id.replace(/[\D]*/,""));
                                else
                                        return null;
                        }
       } // End wFORMS.behaviors['paging']
   }
   
   
   
// ------------------------------------------------------------------------------------------
// Repeat Behavior
// ------------------------------------------------------------------------------------------
      
   if(wFORMS) {
                // Component properties 
                wFORMS.className_repeat                         = "repeat";
                wFORMS.className_delete                         = "removeable";
                wFORMS.className_duplicateLink                 = "duplicateLink";
                wFORMS.className_removeLink                 = "removeLink";
                wFORMS.className_preserveRadioName  = "preserveRadioName";                
                wFORMS.idSuffix_repeatCounter                = "-RC";
                wFORMS.idSuffix_duplicateLink                = "-wfDL";                                                                         
                wFORMS.preserveRadioName                        = false;                                                                         // if true, Repeat behavior will preserve name attributes for radio input. 
                wFORMS.limitSwitchScope                                = true;                                                                                  // if true, Repeat behavior will limit the scope of nested switches.
                
                if(!wFORMS.arrMsg) wFORMS.arrMsg         = new Array();
                wFORMS.arrMsg[0]                                         = "Add another response";                                          // repeat link
                wFORMS.arrMsg[1]                                         = "Will duplicate this question or section." // title attribute on the repeat link 
                wFORMS.arrMsg[2]                                         = "Remove";                                                                  // remove link
                wFORMS.arrMsg[3]                                         = "Will remove this question or section."          // title attribute on the remove link
                
                wFORMS.behaviors['repeat'] = {
                        
                        onRepeat: null, /* Function to run after the element is repeated */
                        onRemove: null,         /* Function to run after the element is removed  */
                        allowRepeat: null, /* Function for fine control on repeatable section */
                        
                           // ------------------------------------------------------------------------------------------
                           // evaluate: check if the behavior applies to the given node. Adds event handlers if appropriate
                           // ------------------------------------------------------------------------------------------
                        evaluate: function(node) {
                                
                                // Repeatable element
                                if(wFORMS.helpers.hasClass(node, wFORMS.className_repeat)) {
                                        //wFORMS.debug('evaluate/repeat: '+ node.id,3);
                                   
                                         if(!node.id) 
                                                node.id = wFORMS.helpers.randomId();
                                                
                                        // Check if we have a 'repeat' link
                                        var repeatLink = document.getElementById(node.id + wFORMS.idSuffix_duplicateLink);
                                        if(!repeatLink) {                                
                                                // create the repeat link
                                                repeatLink = wFORMS.behaviors['repeat'].createRepeatLink(node.id);
                                                                                                
                                                // find where to insert the link
                                                if(node.tagName.toUpperCase()=="TR") {
                                                        // find the last TD
                                                        var n = node.lastChild;        
                                                        while(n && n.nodeType != 1)  
                                                                n = n.previousSibling;
                                                        if(n && n.nodeType == 1) 
                                                                n.appendChild(repeatLink);
                                                        // Else Couldn't find the TD. Table row malformed ?
                                                } else
                                                        node.appendChild(repeatLink);
                                        }
                                        // Add hidden counter field if necessary
                                        var counterField = document.getElementById(node.id + wFORMS.idSuffix_repeatCounter);
                                        if(!counterField) {
                                                // IE Specific :-(
                                                if(document.all && !window.opera) { 
                                                        // see http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/name_2.asp
                                                        var counterFieldId = node.id + wFORMS.idSuffix_repeatCounter;
                                                        if(navigator.appVersion.indexOf("MSIE") != -1 && navigator.appVersion.indexOf("Windows") == -1) // IE5 Mac
                                                                counterField   = document.createElement("INPUT NAME=\"" + counterFieldId + "\"");
                                                        else
                                                                counterField   = document.createElement("<INPUT NAME=\"" + counterFieldId + "\"></INPUT>");                                         
                                                        counterField.type  ='hidden';
                                                        counterField.id    = counterFieldId; 
                                                        counterField.value = "1";
                                                }
                                                else {
                                                        counterField = document.createElement("INPUT"); 
                                                        counterField.setAttribute('type','hidden'); // hidden
                                                        counterField.setAttribute('value','1');
                                                        counterField.setAttribute('name', node.id + wFORMS.idSuffix_repeatCounter);
                                                        counterField.setAttribute('id', node.id + wFORMS.idSuffix_repeatCounter); 
                                                }
                                                
                                                // get the form element                                                
                                                var form = node.parentNode;
                                                while(form && form.tagName.toUpperCase() != "FORM")
                                                        form = form.parentNode;
                                                
                                                form.appendChild(counterField);
                                        }
                                        
                                        // Add event handler                        
                                        wFORMS.helpers.addEvent(repeatLink,'click',wFORMS.behaviors['repeat'].duplicateFieldGroup);                        
                                }        
                                   // ------------------------------------------------------------------------------------------
                                // Removeable element
                                if(wFORMS.helpers.hasClass(node, wFORMS.className_delete)) {
                                        var removeLink = wFORMS.behaviors['repeat'].createRemoveLink();
                                        // find where to insert the link
                                        if(node.tagName.toUpperCase()=="TR") {
                                                // find the last TD
                                                var n = node.lastChild;        
                                                while(n && n.nodeType != 1)  
                                                        n = n.previousSibling;
                                                if(n && n.nodeType == 1) 
                                                        n.appendChild(removeLink);
                                                // Else Couldn't find the TD. Table row malformed ?
                                        } else
                                                node.appendChild(removeLink);
                                }        
                   },
                        createRepeatLink: function(id) {
                                var repeatLink = document.createElement("a"); 
                                var spanNode = document.createElement("span");  // could be used for CSS image replacement 
                                var textNode = document.createTextNode(wFORMS.arrMsg[0]);
                                repeatLink.id = id + wFORMS.idSuffix_duplicateLink;        
                                repeatLink.setAttribute('href',"#");        
                                repeatLink.className = wFORMS.className_duplicateLink;                        
                                repeatLink.setAttribute('title', wFORMS.arrMsg[1]);        
                                spanNode.appendChild(textNode); 
                                repeatLink.appendChild(spanNode); 
                                return repeatLink;
                        },
                        createRemoveLink: function() {
                                var removeLink = document.createElement("a");
                                var spanNode   = document.createElement("span");  // could be used for CSS image replacement 
                                var textNode   = document.createTextNode(wFORMS.arrMsg[2]);
                                removeLink.setAttribute('href',"#");        
                                removeLink.className = wFORMS.className_removeLink;
                                removeLink.setAttribute('title',wFORMS.arrMsg[3]);        
                                spanNode.appendChild(textNode); 
                                removeLink.appendChild(spanNode);
                                wFORMS.helpers.addEvent(removeLink,'click',wFORMS.behaviors['repeat'].removeFieldGroup);
                                return removeLink;
                        },
                           duplicateFieldGroup: function(e) {
                                                           
                                var element  = wFORMS.helpers.getSourceElement(e);
                                if(!element) element = e
                                
                                // override of the wFORMS.preserveRadioName property using a class on the repeat link.
                                var preserveRadioName = wFORMS.helpers.hasClass(element,wFORMS.className_preserveRadioName) ? true : wFORMS.preserveRadioName;
                                //wFORMS.debug('preserveRadioName='+preserveRadioName);
                                
                                // Get Element to duplicate.                                
                                while (element && !wFORMS.helpers.hasClass(element,wFORMS.className_duplicateLink)) {
                                        element = element.parentNode;
                                }        
                                var idOfRepeatedSection = element.id.replace(wFORMS.idSuffix_duplicateLink,"");
                                var element = document.getElementById(idOfRepeatedSection); 
                                
                                
                                if (element) {
                                        var wBehavior = wFORMS.behaviors['repeat']; // shortcut
                                        
                                        // Check if we have a custom function that prevents the repeat
                                        if(wBehavior.allowRepeat) {                                                
                                                if(!wBehavior.allowRepeat(element)) return false;
                                        }
                                        
                                        // Extract row counter information
                                        counterField = document.getElementById(element.id + wFORMS.idSuffix_repeatCounter);
                                        if(!counterField) return; // should not happen.
                                        var rowCount = parseInt(counterField.value) + 1;
                                        // Prepare id suffix
                                        var suffix = "-" + rowCount.toString()
                                        // duplicate node tree 
                                        var dupTree = wBehavior.replicateTree(element, null, suffix, preserveRadioName);  //  sourceNode.cloneNode(true); 
                                        // find insert point in DOM tree (after existing repeated element)
                                        var insertNode = element.nextSibling;
                                        
                                        while(insertNode && 
                                                 (insertNode.nodeType==3 ||       // skip text-node that can be generated server-side when populating a previously repeated group 
                                                  wFORMS.helpers.hasClass(insertNode,wFORMS.className_delete))) {                                                
                                                insertNode = insertNode.nextSibling;
                                        }
                                        element.parentNode.insertBefore(dupTree,insertNode);         // Buggy rendering in IE5/Mac
                                        // if(navigator.appVersion.indexOf("MSIE") != -1 && navigator.appVersion.indexOf("Windows") == -1)                        
                                        //
                                        
                                        // the copy is not duplicable, it's removeable
                                        dupTree.className = element.className.replace(wFORMS.className_repeat,wFORMS.className_delete);
                                        // Save new row count                         
                                        document.getElementById(element.id + wFORMS.idSuffix_repeatCounter).value = rowCount;
                                        // re-add wFORMS behaviors
                                        wFORMS.addBehaviors(dupTree);
                                        
                                        if(wBehavior.onRepeat)
                                                wBehavior.onRepeat(element,dupTree);
                                }                                
                                
                                return wFORMS.helpers.preventEvent(e);
                        },
                        
                           removeFieldGroup: function(e) { 
                                var element  = wFORMS.helpers.getSourceElement(e);
                                if(!element) element = e
                                // Get Element to remove.
                                var element = element.parentNode;
                                while (element && !wFORMS.helpers.hasClass(element,wFORMS.className_delete)) {
                                        element = element.parentNode;
                                }        
                                element.parentNode.removeChild(element);
                                if(wFORMS.behaviors['repeat'].onRemove)
                                                wFORMS.behaviors['repeat'].onRemove(element);
                                return wFORMS.helpers.preventEvent(e);
                        },        
                        
                        removeRepeatCountSuffix: function(str) {
                                return str.replace(/-\d+$/,'');
                        },
        
                        replicateTree: function(element,parentElement, idSuffix, preserveRadioName) {
                                
                                // Duplicating TEXT-NODE (do not copy value of textareas)
                                if(element.nodeType==3) { 
                                        if(element.parentNode.tagName.toUpperCase() != 'TEXTAREA')
                                                var newElement = document.createTextNode(element.data); 
                                } 
                                // Duplicating ELEMENT-NODE
                                else if(element.nodeType==1) { 
                                        
                                        // Do not copy repeat/remove links
                                        if(wFORMS.helpers.hasClass(element,wFORMS.className_duplicateLink) ||
                                           wFORMS.helpers.hasClass(element,wFORMS.className_removeLink))                                                         
                                                return null; 
                                        // Exclude duplicated elements of a nested repeat group
                                        if(wFORMS.helpers.hasClass(element,wFORMS.className_delete)) 
                                                return null; 
                                        // Adjust row suffix id if we find a nested repeat group 
                                        if(wFORMS.helpers.hasClass(element,wFORMS.className_repeat) && parentElement!=null)
                                                idSuffix = idSuffix.replace('-','__');
                                        
                                        if(!document.all || window.opera) { 
                                                // Common Branch
                                                var newElement = document.createElement(element.tagName); 
                                        } else {
                                                // IE Branch 
                                                // see http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/name_2.asp                                                
                                                var tagHtml = element.tagName;
                                                
                                                if(element.name)                                         
                                                        if (element.tagName.toUpperCase() == "INPUT" && 
                                                                element.type.toLowerCase()    == "radio" && preserveRadioName)
                                                                tagHtml += " NAME='" + element.name + "' ";
                                                        else
                                                                tagHtml += " NAME='" + wFORMS.behaviors['repeat'].removeRepeatCountSuffix(element.name) + idSuffix + "' ";
                                                if(element.type) {
                                                        tagHtml += " TYPE='" + element.type + "' ";
                                                }
                                                if(element.selected) 
                                                        tagHtml += " SELECTED='SELECTED' ";
                                                if(element.checked)
                                                        tagHtml += " CHECKED='CHECKED' ";
        
                                                if(navigator.appVersion.indexOf("MSIE") != -1 && navigator.appVersion.indexOf("Windows") == -1) // IE5 Mac
                                                        var newElement = document.createElement(tagHtml);
                                                else
                                                        var newElement = document.createElement("<" + tagHtml + "></"+ element.tagName + ">"); 
                                                try { newElement.type = element.type; } catch(e) {}; // nail it down for IE5 ?, breaks in IE6
                                                
                                        }
                                 
                                        // duplicate attributes                                                                                
                                        for(var i=0; i< element.attributes.length; i++) {
                                                var attribute = element.attributes[i];
                                                
                                                // Get attribute value. 
                                                if(        attribute.specified || // in IE, the attributes array contains all attributes in the DTD
                                                        attribute.nodeName.toLowerCase() == 'value' ) { // attr.specified buggy in IE?  
                                                        // Add the row suffix if necessary.
                                                        if(        attribute.nodeName.toLowerCase() == "id" || 
                                                                attribute.nodeName.toLowerCase() == "name" ||
                                                                attribute.nodeName.toLowerCase() == "for") {
                                                                                                                        
                                                                if(wFORMS.hasBehavior('hint') && 
                                                                   attribute.nodeValue.indexOf(wFORMS.idSuffix_fieldHint) != -1)  {
                                                                        //leave the field hint suffix at the end of the id.
                                                                        var value = attribute.nodeValue;
                                                                        value= wFORMS.behaviors['repeat'].removeRepeatCountSuffix(value.substr(0,value.indexOf(wFORMS.idSuffix_fieldHint))) + idSuffix + wFORMS.idSuffix_fieldHint;
                                                                }
                                                                else {
                                                                        if(element.tagName.toUpperCase()=="INPUT" && 
                                                                           element.getAttribute('type',false).toLowerCase()=="radio" &&
                                                                           attribute.nodeName.toLowerCase() == "name" && 
                                                                           preserveRadioName) {
                                                                                var value = attribute.nodeValue;                                                
                                                                        }
                                                                        else {
                                                                                // var value = wFORMS.behaviors['repeat'].removeRepeatCountSuffix(attribute.nodeValue) + idSuffix;
                                                                                var value = attribute.nodeValue + idSuffix;
                                                                        }
                                                                }
                                                        } else {
                                                                // Do not copy the value attribute for text/password/file input
                                                                if(attribute.nodeName.toLowerCase() == "value" &&
                                                                   element.tagName.toUpperCase()=='INPUT'      &&  
                                                                  (element.type.toLowerCase() == 'text'     || 
                                                                   element.type.toLowerCase() == 'password' || 
                                                                   element.type.toLowerCase() == 'hidden' ||
                                                                   element.type.toLowerCase() == 'file')) 
                                                                        var value='';   
                                                                // Do not copy the switch behavior's 'event handled' flag, stored in the rel attribute
                                                                else if(attribute.nodeName.toLowerCase() == "rel" && 
                                                                                attribute.nodeValue.indexOf('wfHandled') != -1) {
                                                                        var value = attribute.nodeValue.replace('wfHandled','');
                                                                } else 
                                                                        var value = attribute.nodeValue;
                                                        }
                                                        // Create attribute and assign value
                                                        switch(attribute.nodeName.toLowerCase()) {
                                                                case "class":
                                                                        newElement.className = value; 
                                                                        break;
                                                                case "style": // inline style attribute (fix for IE)
                                                                        if(element.style && element.style.cssText) 
                                                                                newElement.style.cssText = element.style.cssText; 
                                                                        break;                                                                
                                                                case "onclick": // inline event handler (fix for IE)
                                                                        newElement.onclick     = element.onclick;                                                        
                                                                        break;                                                        
                                                                case "onchange":                                                        
                                                                        newElement.onchange    = element.onchange;                                                        
                                                                        break;                                                        
                                                                case "onsubmit":
                                                                        newElement.onsubmit    = element.onsubmit;                                                        
                                                                        break;                                                        
                                                                case "onmouseover":                                                        
                                                                        newElement.onmouseover = element.onmouseover;                                                        
                                                                        break;                                                        
                                                                case "onmouseout":                                                        
                                                                        newElement.onmouseout  = element.onmouseout;                                                        
                                                                        break;                                                        
                                                                case "onmousedown":
                                                                        newElement.onmousedown = element.onmousedown;                                                        
                                                                        break;                                                        
                                                                case "onmouseup":
                                                                        newElement.onmouseup   = element.onmouseup;                                                        
                                                                        break;                                                        
                                                                case "ondblclick":
                                                                        newElement.ondblclick  = element.ondblclick;                                                        
                                                                        break;                                                        
                                                                case "onkeydown":
                                                                        newElement.onkeydown   = element.onkeydown;                                                        
                                                                        break;                                                        
                                                                case "onkeyup":
                                                                        newElement.onkeyup     = element.onkeyup;                                                        
                                                                        break;                                                        
                                                                case "onblur": 
                                                                        newElement.onblur      = element.onblur;                                                        
                                                                        break;                                                        
                                                                case "onfocus":
                                                                        newElement.onfocus     = element.onfocus;                                                        
                                                                        break;
                                                                default:
                                                                        newElement.setAttribute(attribute.name, value, 0);
                                                        }
                                                }
                                        }                                
                                }
                                if(parentElement && newElement) 
                                        parentElement.appendChild(newElement);
                                for(var i=0; i<element.childNodes.length;i++) {
                                        wFORMS.behaviors['repeat'].replicateTree(element.childNodes[i],newElement,idSuffix, preserveRadioName);
                                }
                                return newElement;
                        }
       } // End wFORMS.behaviors['repeat']
           

   }

// ------------------------------------------------------------------------------------------
// Switch Behavior
// ------------------------------------------------------------------------------------------

 if(wFORMS) {

                // Component properties 
                wFORMS.classNamePrefix_switch                 = "switch";
                wFORMS.className_switchIsOn         = "swtchIsOn";    // used to keep track of the switch state on buttons and links (where the checked attribute is not available)
                wFORMS.className_switchIsOff        = "swtchIsOff";
                wFORMS.classNamePrefix_offState                = "offstate";
                wFORMS.classNamePrefix_onState                = "onstate";
                wFORMS.switchScopeRootTag           = "";                   // deprecated.        
                
                wFORMS.switchTriggers               = [];                          // associative multi-dimensional array (switchname->element Ids)
                wFORMS.switchTargets                = [];                          // associative multi-dimensional array (switchname->element Ids)
                
        
                wFORMS.behaviors['switch'] = {

                   // ------------------------------------------------------------------------------------------
                   // evaluate: check if the behavior applies to the given node. Adds event handlers if appropriate
                   // ------------------------------------------------------------------------------------------
                   evaluate: function(node) {
                
                            // Handle Switch Triggers
                                // add event handles and populate the wFORMS.switchTriggers 
                                // associative array (switchname->element Ids)
                                // ------------------------------------------------------------------------------------------                                
                                if (wFORMS.helpers.hasClassPrefix(node, wFORMS.classNamePrefix_switch)) {

                                        if(!node.id) node.id = wFORMS.helpers.randomId();
                                        
                                        if(!wFORMS.processedForm || !wFORMS.processedForm.id)
                                                var formId = "undefined";
                                        else
                                                var formId = wFORMS.processedForm.id;
                                        
                                        // Go through each class (one element can have more than one switch trigger).
                                        var switchNames = wFORMS.behaviors['switch'].getSwitchNames(node);
                                        for(var i=0; i < switchNames.length; i++) {
                                                if(!wFORMS.switchTriggers[formId])
                                                        wFORMS.switchTriggers[formId] = new Array();
                                                if(!wFORMS.switchTriggers[formId][switchNames[i]]) 
                                                        wFORMS.switchTriggers[formId][switchNames[i]] = new Array();
                                                if(!wFORMS.switchTriggers[formId][switchNames[i]][node.id]) {
                                                        wFORMS.switchTriggers[formId][switchNames[i]].push(node.id);
                                                }
                                        }

                                        switch(node.tagName.toUpperCase()) {
                                                        
                                                case "OPTION":
                                                        // get the SELECT element
                                                        var selectNode = node.parentNode;
                                                        while(selectNode && selectNode.tagName.toUpperCase() != 'SELECT') {
                                                                var selectNode = selectNode.parentNode;
                                                        }
                                                        if(!selectNode) { alert('Error: invalid markup in SELECT field ?'); return false;  } // invalid markup
                                                        if(!selectNode.id) selectNode.id = wFORMS.helpers.randomId();

                                                        // Make sure we have only one event handler for the select.
                                                        if(!selectNode.getAttribute('rel') || selectNode.getAttribute('rel').indexOf('wfHandled')==-1) {
                                                                //wFORMS.debug('switch/add event: '+ selectNode.className + ' ' + selectNode.tagName);
                                                                selectNode.setAttribute('rel', (selectNode.getAttribute('rel')||"") + ' wfHandled');
                                                                wFORMS.helpers.addEvent(selectNode, 'change', wFORMS.behaviors['switch'].run);
                                                        }                                                        
                                                        break;

                                                case "INPUT":                                                        
                                                        if(node.type && node.type.toLowerCase() == 'radio') {
                                                                // Add the onclick event on radio inputs of the same group
                                                                var formElement = node.form;        
                                                                for (var j=0; j<formElement[node.name].length; j++) {
                                                                        var radioNode = formElement[node.name][j];
                                                                        // prevents conflicts with elements with an id = name of radio group
                                                                        if(radioNode.type.toLowerCase() == 'radio') {
                                                                                // Make sure we have only one event handler for this radio input.
                                                                                if(!radioNode.getAttribute('rel') || radioNode.getAttribute('rel').indexOf('wfHandled')==-1) {                                                                
                                                                                        wFORMS.helpers.addEvent(radioNode, 'click', wFORMS.behaviors['switch'].run);
                                                                                        // flag the node 
                                                                                        radioNode.setAttribute('rel', (radioNode.getAttribute('rel')||"") + ' wfHandled');
                                                                                } 
                                                                        }
                                                                }
                                                        } else {
                                                                wFORMS.helpers.addEvent(node, 'click', wFORMS.behaviors['switch'].run);
                                                        }
                                                        break;
                                                
                                                default:                
                                                        wFORMS.helpers.addEvent(node, 'click', wFORMS.behaviors['switch'].run);
                                                        break;
                                        }
                                }
                                
                                // Push targets in the wFORMS.switchTargets array 
                                // (associative array with switchname -> element ids)
                                // ------------------------------------------------------------------------------------------
                                if (wFORMS.helpers.hasClassPrefix(node, wFORMS.classNamePrefix_offState) ||
                                    wFORMS.helpers.hasClassPrefix(node, wFORMS.classNamePrefix_onState)) {
                                        
                                        if(!node.id) node.id = wFORMS.helpers.randomId();

                                        if(!wFORMS.processedForm || !wFORMS.processedForm.id)
                                                var formId = "undefined";
                                        else
                                                var formId = wFORMS.processedForm.id;
                                        
                                        // Go through each class (one element can be the target of more than one switch).
                                        var switchNames = wFORMS.behaviors['switch'].getSwitchNames(node);
                                        
                                        for(var i=0; i < switchNames.length; i++) {
                                                if(!wFORMS.switchTargets[formId])
                                                        wFORMS.switchTargets[formId] = new Array();
                                                if(!wFORMS.switchTargets[formId][switchNames[i]]) 
                                                        wFORMS.switchTargets[formId][switchNames[i]] = new Array();
                                                if(!wFORMS.switchTargets[formId][switchNames[i]][node.id]) 
                                                        wFORMS.switchTargets[formId][switchNames[i]].push(node.id);
                                                //wFORMS.debug('switch/evaluate: [target] '+ switchNames[i],3);
                                        }                                                                                
                                }
                                
                                if(node.tagName && node.tagName.toUpperCase()=='FORM') {
                                        // function to be called when all behaviors have been applied
                                        wFORMS.onLoadComplete.push({form:node, func: wFORMS.behaviors['switch'].init}); 
                                        // clear existing triggers/targets for that form.
                                        wFORMS.behaviors['switch'].clear(node.id);
                                }
           },
                   
                   // ------------------------------------------------------------------------------------------
           // init: executed once evaluate has been applied to all elements
                   // ------------------------------------------------------------------------------------------           
                   init: function(form) {
                  
                              if(!form || !form.id)
                                              var formId = "undefined";
                           else
                                           var formId = form.id; 
                           // go through all switch triggers and activate those who are already ON                                                    
                           for(var switchName in wFORMS.switchTriggers[formId]) {
                                        // go through all triggers for the current switch
                                        for(var i=0; i< wFORMS.switchTriggers[formId][switchName].length; i++) {                                                
                                                   var element = document.getElementById(wFORMS.switchTriggers[formId][switchName][i]);                                                                                                   
                                                   if(wFORMS.behaviors['switch'].isTriggerOn(element,switchName)) {
                                                        // if it's a select option, get the select element
                                                        if(element.tagName.toUpperCase()=='OPTION') {
                                                                var element = element.parentNode;
                                                                while(element && element.tagName.toUpperCase() != 'SELECT') {
                                                                        var element = element.parentNode;
                                                                }
                                                        }
                                                        // run the trigger
                                                        wFORMS.behaviors['switch'].run(element);
                                                }
                                   }
                           }
                   },
                   
                   // ------------------------------------------------------------------------------------------
           // run: executed when the behavior is activated
                   // ------------------------------------------------------------------------------------------           
           run: function(e) {
                var element   = wFORMS.helpers.getSourceElement(e);
                                if(!element) element = e;
                            //wFORMS.debug('switch/run: ' + element.id , 5);        
                                
                                if(element.form)
                                        var form = element.form;
                                else {
                                        var form = element.parentNode;
                                        while(form && form.tagName != "FORM")
                                                form = form.parentNode;
                                }        
                                if(!form || !form.id) {
                                        // switch not within a form tag
                                        var formId = "undefined";
                                } else
                                        var formId = form.id;
                                
                                var switches_ON  = new Array();
                                var switches_OFF = new Array();
                                
                                // Get list of triggered switches (some ON, some OFF)
                                switch(element.tagName.toUpperCase()) {
                                        case 'SELECT':
                                                for(var i=0;i<element.options.length;i++) {
                                                        if(i==element.selectedIndex) {        
                                                                switches_ON  = switches_ON.concat(wFORMS.behaviors['switch'].getSwitchNames(element.options[i]));
                                                        } else {
                                                                switches_OFF = switches_OFF.concat(wFORMS.behaviors['switch'].getSwitchNames(element.options[i]));
                                                        }
                                                }

                                                break;
                                        case 'INPUT':
                                                if(element.type.toLowerCase() == 'radio') {
                                                        // Go through the radio group.
                                                        
                                                        for(var i=0;i <element.form[element.name].length;i++) { 
                                                                var radioElement = element.form[element.name][i];
                                                                if(radioElement.checked) {
                                                                        switches_ON  = switches_ON.concat(wFORMS.behaviors['switch'].getSwitchNames(radioElement));
                                                                } else {
                                                                        //wFORMS.debug(wFORMS.behaviors['switch'].getSwitchNames(radioElement).length,1);
                                                                        switches_OFF = switches_OFF.concat(wFORMS.behaviors['switch'].getSwitchNames(radioElement));
                                                                }
                                                        }
                                                } else {
                                                        if(element.checked || wFORMS.helpers.hasClass(element, wFORMS.className_switchIsOn)) {
                                                                switches_ON  = switches_ON.concat(wFORMS.behaviors['switch'].getSwitchNames(element));
                                                        } else {
                                                                switches_OFF = switches_OFF.concat(wFORMS.behaviors['switch'].getSwitchNames(element));
                                                        }                                                        
                                                }
                                                break;
                                        default:
                                                break;
                                }
                                
                                // Turn off switches first
                                for(var i=0; i < switches_OFF.length; i++) {
                                        // Go through all targets of the switch 
                                        var elements = wFORMS.behaviors['switch'].getElementsBySwitchName(switches_OFF[i], formId);
                                        for(var j=0;j<elements.length;j++) {
                                                                                                                                                                                                        
                                                // only turn off a target if all its triggers are off
                                                var triggers = wFORMS.switchTriggers[formId][switches_OFF[i]];                                                                                                
                                                var doSwitch = true;
                                                        
                                                for (var k=0; k < triggers.length; k++) {
                                                        var trigger = document.getElementById(triggers[k]);
                                                        if(wFORMS.behaviors['switch'].isTriggerOn(trigger, switches_OFF[i])) {
                                                                // An element with the REPEAT behavior limits the scope of switches 
                                                                // targets outside of the scope of the switch are not affected. 
                                                                if(wFORMS.behaviors['switch'].isWithinSwitchScope(trigger, elements[j])) {
                                                                        // one of the trigger is still ON. no switch off
                                                                        doSwitch = false;
                                                                }
                                                        }                                                        
                                                }
                                                if(doSwitch) {
                                                        wFORMS.behaviors['switch'].switchState(elements[j], wFORMS.classNamePrefix_onState, wFORMS.classNamePrefix_offState);
                                                }
                                        }
                                }
                                // Turn on
                                for(var i=0; i < switches_ON.length; i++) {
                                        var elements = wFORMS.behaviors['switch'].getElementsBySwitchName(switches_ON[i], formId);
                                        for(var j=0;j<elements.length;j++) {
                                                // An element with the REPEAT behavior limits the scope of switches 
                                                // targets outside of the scope of the switch are not affected. 
                                                if(wFORMS.behaviors['switch'].isWithinSwitchScope(element, elements[j])) {

                                                        wFORMS.behaviors['switch'].switchState(elements[j], wFORMS.classNamePrefix_offState, wFORMS.classNamePrefix_onState);
                                                        //wFORMS.debug('switch/run: [turn on ' + switches_ON[i] + '] ' + elements[j].id , 3);        
                                                }
                                        }
                                }
           },

                   // ------------------------------------------------------------------------------------------
           // clear: executed if the behavior should not be applied anymore
                   // ------------------------------------------------------------------------------------------
                   clear: function(form) {
                     // @TODO: go through wFORMS.switchTriggers to remove events.
                     if(form) {
                             wFORMS.switchTriggers[form] = [];                
                             wFORMS.switchTargets[form] = [];
                     } else {
                             wFORMS.switchTriggers = [];        
                             wFORMS.switchTargets = [];
                     }
           },
                   
                   
                   // ------------------------------------------------------------------------------------------
                   // Get the list of switches 
                   // Note: potential conflict if an element is both a switch and a target.
                   getSwitchNames: function(element) {
                                var switchNames = new Array();
                                var classNames  = element.className.split(' ');
                                for(var i=0; i < classNames.length; i++) {
                                        // Note: Might be worth keeping a prefix on switchName to prevent collision with reserved names                                                
                                        if(classNames[i].indexOf(wFORMS.classNamePrefix_switch) == 0) {
                                                switchNames.push(classNames[i].substr(wFORMS.classNamePrefix_switch.length+1));
                                        }
                                        if(classNames[i].indexOf(wFORMS.classNamePrefix_onState) == 0) {
                                                switchNames.push(classNames[i].substr(wFORMS.classNamePrefix_onState.length+1));
                                        }
                                        else if(classNames[i].indexOf(wFORMS.classNamePrefix_offState) == 0) {
                                                switchNames.push(classNames[i].substr(wFORMS.classNamePrefix_offState.length+1));
                                        }
                                }
                                return switchNames;
                        },
                        
                   // ------------------------------------------------------------------------------------------
                        switchState: function(element, oldStateClass, newStateClass) {                
                                if(!element || element.nodeType != 1) return;
                                if(element.className) {                  
                                        element.className = element.className.replace(oldStateClass, newStateClass);
                                }                
                                // For  elements that don't have a native state variable (like checked, or selectedIndex)
                                if(wFORMS.helpers.hasClass(element, wFORMS.className_switchIsOff)) {
                                        element.className = element.className.replace(wFORMS.className_switchIsOff, wFORMS.className_switchIsOn);
                                } else if(wFORMS.helpers.hasClass(element, wFORMS.className_switchIsOn)) {
                                        element.className = element.className.replace(wFORMS.className_switchIsOn, wFORMS.className_switchIsOff);
                                }
                        },
                        
                        // ------------------------------------------------------------------------------------------
                        getElementsBySwitchName: function(switchName, formId) {
                                var elements = new Array();
                                if(wFORMS.switchTargets[formId][switchName]) {
                                        for (var i=0; i<wFORMS.switchTargets[formId][switchName].length; i++) {
                                                var element = document.getElementById(wFORMS.switchTargets[formId][switchName][i]);
                                                if(element)
                                                        elements.push(element);
                                        }
                                }
                                return elements;
                        },
                        
                        // ------------------------------------------------------------------------------------------
                        isTriggerOn: function(element, triggerName) {
                                if(!element) return false;
                                if(element.tagName.toUpperCase()=='OPTION') {
                                        var selectElement = element.parentNode;
                                        while(selectElement && selectElement.tagName.toUpperCase() != 'SELECT') {
                                                var selectElement = selectElement.parentNode;
                                        }
                                        if(!selectElement) return false; // invalid markup                                        
                                        if(selectElement.selectedIndex==-1) return false; // nothing selected
                                        // TODO: handle multiple-select
                                        if(wFORMS.helpers.hasClass(selectElement.options[selectElement.selectedIndex],
                                                                                           wFORMS.classNamePrefix_switch + '-' + triggerName)) {
                                                return true;
                                        }
                                } else {
                                        if(element.checked || wFORMS.helpers.hasClass(element, wFORMS.className_switchIsOn)) 
                                                return true;
                                }
                                return false;
                        },
                        
                        // isWithinSwitchScope: An element with the REPEAT behavior limits the scope of switches 
                        // targets outside of the scope of the switch are not affected. 
                        // ------------------------------------------------------------------------------------------                        
                        isWithinSwitchScope: function(trigger, target) {
                                
                                if(wFORMS.hasBehavior('repeat') && wFORMS.limitSwitchScope == true) { 
                                        // check if the trigger is in a repeatable/removeable element
                                        var scope = trigger;
                                
                                        while(scope && scope.tagName && scope.tagName.toUpperCase() != 'FORM' && 
                                                  !wFORMS.helpers.hasClass(scope, wFORMS.className_repeat) &&
                                              !wFORMS.helpers.hasClass(scope, wFORMS.className_delete) ) {
                                                scope = scope.parentNode;
                                        }
                                        if(wFORMS.helpers.hasClass(scope, wFORMS.className_repeat) || 
                                           wFORMS.helpers.hasClass(scope, wFORMS.className_delete)) {
                                                // yes, the trigger is nested in a repeat/remove element
                                                
                                                // check if the target is in the same element.
                                                var scope2 = target;
                                                while(scope2 && scope2.tagName && scope2.tagName.toUpperCase() != 'FORM' && 
                                                          !wFORMS.helpers.hasClass(scope2, wFORMS.className_repeat) &&
                                                          !wFORMS.helpers.hasClass(scope2, wFORMS.className_delete) ) {
                                                        scope2 = scope2.parentNode;
                                                }
                                                if(scope == scope2) {
                                                        return true;  // target & trigger are in the same repeat/remove element                
                                                } else {
                                                        return false; // target not in the same repeat/remove element,                                        
                                                }
                                        } else {
                                                return true;          // trigger is not nested in a repeat/remove element, scope unaffected
                                        }
                                } else 
                                        return true;
                        }
       } // END wFORMS.behaviors['switch'] object

             
   }
// ------------------------------------------------------------------------------------------
// Form Validation Behavior
// ------------------------------------------------------------------------------------------
  
   if(wFORMS) {
                // Component properties 
                // wFORMS.functionName_formValidation  is defined at the bottom of this file
                // Those should be moved inside wFORMS.behaviors['validation']. Stays here for now for backward compatibility
               wFORMS.preventSubmissionOnEnter                   = true;                         // prevents submission when pressing the 'enter' key. Set to true if pagination behavior is used.
                   wFORMS.showAlertOnError                                   = true;                         // sets to false to not show the alert when a validation error occurs.
                wFORMS.className_required                                  = "required";
                wFORMS.className_validationError_msg         = "errMsg";                 
                wFORMS.className_validationError_fld        = "errFld";  
                wFORMS.classNamePrefix_validation                 = "validate";        
                wFORMS.idSuffix_fieldError                                = "-E";

                wFORMS.behaviors['validation'] = {
                        
                        // Error messages. This may be overwritten in a separate js file for localization or customization purposes.                        
                        errMsg_required         : "This field is required. ",
                        errMsg_alpha                 : "The text must use alphabetic characters only (a-z, A-Z). Numbers are not allowed.",
                        errMsg_email                 : "This does not appear to be a valid email address.",
                        errMsg_integer                 : "Please enter an integer.",
                        errMsg_float                 : "Please enter a number (ex. 1.9).",
                        errMsg_password         : "Unsafe password. Your password should be between 4 and 12 characters long and use a combinaison of upper-case and lower-case letters.",
                        errMsg_alphanum         : "Please use alpha-numeric characters only [a-z 0-9].",
                        errMsg_date                 : "This does not appear to be a valid date.",
                        errMsg_notification : "%% error(s) detected. Your form has not been submitted yet.\nPlease check the information you provided.",  // %% will be replaced by the actual number of errors.
                        errMsg_custom                : "Please enter a valid value.",
                        
                        // Class Names
                        className_allRequired : "allrequired",
                        
                        // first page w/ error in a multi-page form
                        jumpToErrorOnPage : null,
                        currentPageIndex  : -1,
                        
                        // do not submit fields turned off by switch behavior
                        submitSwitchedOffFields : false,
                        switchedOffFields : [],
                        
                   // ------------------------------------------------------------------------------------------
                   // evaluate: check if the behavior applies to the given node. Adds event handlers if appropriate
                   // ------------------------------------------------------------------------------------------
                        evaluate: function(node) {
                       if(node.tagName=="FORM") {
                                           // functionName_formValidation can be a reference to a function, or a string with the name of the function.
                                           // avoid using typeof
                                           if(wFORMS.functionName_formValidation.toString()==wFORMS.functionName_formValidation) {
                                                   // this is a string, not a function
                                                wFORMS.functionName_formValidation = eval(wFORMS.functionName_formValidation);
                                           }
                           wFORMS.helpers.addEvent(node,'submit',wFORMS.functionName_formValidation);
                       }
                       // Add onkeydown handler on text inputs to prevent form submission when the enter key is pressed
                                if(wFORMS.preventSubmissionOnEnter) { 
                                        if(node.tagName=='INPUT') {                                        
                                                if(!node.type || node.type.toLowerCase()=='text' ||
                                                                 node.type.toLowerCase()=='password' ||
                                                                 node.type.toLowerCase()=='file') {
                                                        wFORMS.helpers.addEvent(node,'keydown', function(e){
                                                                var evt = (e) ? e : window.event;
                                                                if(evt.keyCode==13) {
                                                                        return wFORMS.helpers.preventEvent(evt);
                                                                }
                                                        });
                                                }
                                        }
                                }
               
           },
                   // ------------------------------------------------------------------------------------------
           // init: executed once evaluate has been applied to all elements
                   // ------------------------------------------------------------------------------------------           
                   init: function() {
                   },
                   
                   // ------------------------------------------------------------------------------------------
           // run: executed when the behavior is activated
                   // ------------------------------------------------------------------------------------------                              
           run: function(e) {
                                var element  = wFORMS.helpers.getSourceElement(e);
                                if(!element) element = e;
                                //wFORMS.debug('validation/run: ' + element.id , 5);        
                                
                                var currentPageOnly = arguments.length>1 ? arguments[1]:false;
                                // arguments[1] : (wFORMS.hasBehavior('paging') && wFORMS.behaviors['paging'].behaviorInUse);

                                wFORMS.behaviors['validation'].switchedOffFields = [];
                                wFORMS.behaviors['validation'].jumpToErrorOnPage = null;
                                
                                // make sure we have the form element
                                while (element && element.tagName != 'FORM') {
                                        element = element.parentNode;
                                }                
                                
                                var nbErrors = wFORMS.behaviors['validation'].validateElement(element, currentPageOnly, true);
                                
                                // save the value in a property if someone else needs it.
                                wFORMS.behaviors['validation'].errorCount = nbErrors;
                                
                                if (nbErrors > 0) {                                        
                                        if(wFORMS.behaviors['validation'].jumpToErrorOnPage) {                                        
                                                wFORMS.behaviors['paging'].gotoPage(wFORMS.behaviors['validation'].jumpToErrorOnPage);
                                        }
                                        if(wFORMS.showAlertOnError){ wFORMS.behaviors['validation'].showAlert(nbErrors); }
                                        return wFORMS.helpers.preventEvent(e); 
                                }

                                // Remove switched-off content if any
                                // Note: in multi-page behavior the validation is run on "page next" without submitting the form.
                                //       In this situation (currentPageOnly==true) switched-off conditionals should not be removed. 
                                if(!wFORMS.behaviors['validation'].submitSwitchedOffFields && !currentPageOnly) {
                                        for(var i=0; i < wFORMS.behaviors['validation'].switchedOffFields.length; i++) {
                                                var element = wFORMS.behaviors['validation'].switchedOffFields[i];
                                                while(element.childNodes[0]) 
                                                        element.removeChild(element.childNodes[0]);
                                        }
                                }                                
                                return true;
                        },
                   
                        // ------------------------------------------------------------------------------------------
                        // remove: executed if the behavior should not be applied anymore
                        // ------------------------------------------------------------------------------------------
                        remove: function() {
                        },
                   
                   
                        // ------------------------------------------------------------------------------------------
                        // validation functions
                        // ------------------------------------------------------------------------------------------
                        validateElement: function(element /*, currentPageOnly, deep */) {

                                if(!element) return;

                                var deep = arguments.length>2 ? arguments[2] : true;
                                
                                // used in multi-page forms
                                var currentPageOnly = arguments[1] ? arguments[1] : false;                                
                                
                                var wBehavior = wFORMS.behaviors['validation'];                // shortcut
                                
                                // do not validate elements that are in a OFF-Switch
                                // Note: what happens if an element is the target of 2+ switches, some ON and some OFF ?
                                if(wFORMS.hasBehavior('switch') && wFORMS.helpers.hasClassPrefix(element,wFORMS.classNamePrefix_offState)) {
                                        if(!wBehavior.submitSwitchedOffFields) {
                                                wBehavior.switchedOffFields.push(element);
                                        }
                                        return 0;
                                }
                                // do not validate elements that are not in the current page (Paging Behavior)
                                if(wFORMS.hasBehavior('paging') && wFORMS.helpers.hasClass(element,wFORMS.className_paging)) {
                                        if(!wFORMS.helpers.hasClass(element,wFORMS.className_pagingCurrent) && currentPageOnly)
                                                return 0;
                                        wBehavior.currentPageIndex = wFORMS.behaviors['paging'].getPageIndex(element);
                                }
                                
                                var nbErrors = 0;
                                
                                // check if required
                                if(!wBehavior.checkRequired(element)) {
                                        wBehavior.showError(element, wBehavior.errMsg_required);
                                        nbErrors++;
                                        //wFORMS.debug('validation/error: [required]' + element.id + '('+nbErrors+')' , 5);
                                } else {
                                
                                        // input format validation
                                        if (wFORMS.helpers.hasClassPrefix(element,wFORMS.classNamePrefix_validation)) {
                
                                                var arrClasses = element.className.split(" ");
                                                for (j=0;j<arrClasses.length;j++) {
                                                        switch(arrClasses[j]) {
                                                                case "validate-alpha":
                                                                        if(!wBehavior.isAlpha(element.value)) {
                                                                                wBehavior.showError(element, wBehavior.errMsg_alpha);
                                                                                nbErrors++;
                                                                        }
                                                                        break;
                                                                case "validate-alphanum":
                                                                        if(!wBehavior.isAlphaNum(element.value)) {
                                                                                wBehavior.showError(element, wBehavior.errMsg_alphanum);
                                                                                nbErrors++;
                                                                        }
                                                                        break;
                                                                case "validate-date":
                                                                        if(!wBehavior.isDate(element.value)) {
                                                                                wBehavior.showError(element, wBehavior.errMsg_date);
                                                                                nbErrors++;
                                                                        }
                                                                        break;
                                                                case "validate-time":
                                                                        /* NOT IMPLEMENTED */
                                                                        break;
                                                                case "validate-email":
                                                                        if(!wBehavior.isEmail(element.value)) {
                                                                                wBehavior.showError(element, wBehavior.errMsg_email);
                                                                                nbErrors++;
                                                                        }
                                                                        break;
                                                                case "validate-integer":
                                                                        if(!wBehavior.isInteger(element.value)) {
                                                                                wBehavior.showError(element, wBehavior.errMsg_integer);
                                                                                nbErrors++;
                                                                        }                                        
                                                                        break;
                                                                case "validate-float":
                                                                        if(!wBehavior.isFloat(element.value)) {
                                                                                wBehavior.showError(element,wBehavior.errMsg_float);
                                                                                nbErrors++;
                                                                        }
                                                                        break;
                                                                case "validate-strongpassword": // NOT IMPLEMENTED
                                                                        if(!wBehavior.isPassword(element.value)) {
                                                                                wBehavior.showError(element, wBehavior.errMsg_password);
                                                                                nbErrors++;
                                                                        }
                                                                        break;
                                                                case "validate-custom": 
                                                                        var pattern = new RegExp("\/([^\/]*)\/([gi]*)");
                                                                        var matches = element.className.match(pattern);
                                                                        if(matches[0]) {                                                                                
                                                                                var validationPattern = new RegExp(matches[1],matches[2]);
                                                                                if(!element.value.match(validationPattern)) {
                                                                                        wBehavior.showError(element, wBehavior.errMsg_custom);
                                                                                        nbErrors++;                                                                                        
                                                                                }
                                                                        }                                                                                                                        
                                                                        break;                                                                        
                                                        } // end switch
                                                } // end for
                                        }
                                } // end validation check
                                
                                // remove previous error flags if any.
                                if(nbErrors==0) {
                                        wBehavior.removeErrorMessage(element);
                                } else {
                                        // flag the first page with an error (if multi-page form)
                                        if(wBehavior.currentPageIndex>0 && !wBehavior.jumpToErrorOnPage) {
                                                wBehavior.jumpToErrorOnPage = wBehavior.currentPageIndex;
                                        }
                                }
                                        
                                // recursive loop                                        
                                if(deep) {
                                        for(var i=0; i < element.childNodes.length; i++) {
                                                if(element.childNodes[i].nodeType==1) { // Element Nodes only
                                                        nbErrors += wBehavior.validateElement(element.childNodes[i], currentPageOnly, deep);
                                                }
                                        }
                                }
                                
                                return nbErrors;
                        },
                        
                        // ------------------------------------------------------------------------------------------
                        checkRequired: function(element) {
                                var wBehavior = wFORMS.behaviors['validation'];                // shortcut                                

                                if(wFORMS.helpers.hasClass(element,wFORMS.className_required)) {
                                        switch(element.tagName.toUpperCase()) {
                                                case "INPUT":
                                                        var inputType = element.getAttribute("type");
                                                        if(!inputType) inputType = 'text'; // handles lame markup
                                                        switch(inputType.toLowerCase()) {
                                                                case "checkbox":
                                                                        return element.checked; 
                                                                        break;
                                                                case "radio":
                                                                        return element.checked; 
                                                                        break;
                                                                default:
                                                                        return !wBehavior.isEmpty(element.value);
                                                        }
                                                        break;
                                                case "SELECT":                                                        
                                                        if(element.selectedIndex==-1) {
                                                                // multiple select with no selection
                                                                return false;
                                                        } else                                                                                                 
                                                                return !wBehavior.isEmpty(element.options[element.selectedIndex].value);
                                                        break;
                                                case "TEXTAREA":
                                                        return !wBehavior.isEmpty(element.value);
                                                        break;
                                                default:
                                                        return wBehavior.checkOneRequired(element);
                                                        break;
                                        }         
                                } else if(wFORMS.helpers.hasClass(element,wBehavior.className_allRequired)) {
                                        return wBehavior.checkAllRequired(element);
                                }
                                return true;
                        },
                        checkOneRequired: function(element) {        
                                if(element.nodeType != 1) return false;
                                var tagName = element.tagName.toUpperCase();
                                var wBehavior = wFORMS.behaviors['validation'];
                                
                                if(tagName == "INPUT" || tagName == "SELECT" || tagName == "TEXTAREA" ) {
                                        var value = wBehavior.getFieldValue(element);        
                                        if(!wBehavior.isEmpty(value)) {                                        
                                                return true;
                                        }                        
                                }
                                for(var i=0; i<element.childNodes.length;i++) {
                                        if(wBehavior.checkOneRequired(element.childNodes[i])) return true;
                                }
                                return false;
                        },
                        checkAllRequired: function(element)        {
                                
                                if(element.nodeType != 1) return true;
                                var tagName = element.tagName.toUpperCase();
                                var wBehavior = wFORMS.behaviors['validation'];

                                if(tagName == "INPUT" || tagName == "SELECT" || tagName == "TEXTAREA" ) {
                                        var value = wBehavior.getFieldValue(element);        
                                        if(wBehavior.isEmpty(value)) {                                        
                                                return false;
                                        }                        
                                }
                                for(var i=0; i<element.childNodes.length;i++) {
                                        if(!wBehavior.checkAllRequired(element.childNodes[i])) return false;
                                }
                                return true;
                        },
                        getFieldValue: function(element) {
                                var value = null;
                                if(element && element.tagName) {
                                        if(element.tagName.toUpperCase() == "INPUT") {
                                                var inputType = element.getAttribute("type");
                                                if(!inputType) inputType = 'text'; // handles lame markup
                                        
                                                switch(inputType.toLowerCase()) {
                                                        case "checkbox": 
                                                                value = element.checked?element.value:null; 
                                                                break;
                                                        case "radio":                                                                
                                                                var radioGroup = element.form[element.name];                                                         
                                                                for (var i = 0; i< radioGroup.length; i++) {
                                                                    if (radioGroup[i].checked) {
                                                                            if(!value) value = new Array();
                                                                                value[value.length] = radioGroup[i].value;
                                                                    }
                                                                }                                                                 
                                                                break;
                                                        default:
                                                                value = element.value;
                                                }
                                        } else if(element.tagName.toUpperCase() == "SELECT") {        
                                                if(element.selectedIndex!=-1)                                                                                                                                
                                                        value = element.options[element.selectedIndex].value                                                
                                                else
                                                        value = null; // multiple select with no selection
                                        } else if(element.tagName.toUpperCase() == "TEXTAREA") {
                                                value = element.value;
                                        }
                                }
                                return value;
                        },
                        // ------------------------------------------------------------------------------------------
                        isEmpty: function(s) {                                
                                var regexpWhitespace = /^\s+$/;
                                return  ((s == null) || (s.length == 0) || regexpWhitespace.test(s));
                        },
                        isAlpha: function(s) {
                                var regexpAlphabetic = /^[a-zA-Z\s]+$/; // Add ' and - ?
                                return wFORMS.behaviors['validation'].isEmpty(s) || regexpAlphabetic.test(s);
                        },
                        isAlphaNum: function(s) {
                                var validChars = /^[\w\s]+$/;
                                return wFORMS.behaviors['validation'].isEmpty(s) || validChars.test(s);
                        },
                        isDate: function(s) {
                                var testDate = new Date(s);
                                return wFORMS.behaviors['validation'].isEmpty(s) || !isNaN(testDate);
                        },
                        isEmail: function(s) {
                                var regexpEmail = /\w{1,}[@][\w\-]{1,}([.]([\w\-]{1,})){1,3}$/;
                                return wFORMS.behaviors['validation'].isEmpty(s) || regexpEmail.test(s);
                        },
                        isInteger: function(s) {
                                var regexp = /^[+]?\d+$/;
                                return wFORMS.behaviors['validation'].isEmpty(s) || regexp.test(s);
                        },
                        isFloat: function(s) {                
                                return wFORMS.behaviors['validation'].isEmpty(s) || !isNaN(parseFloat(s));
                        },
                        // NOT IMPLEMENTED
                        isPassword: function(s) {
                                // Matches strong password : at least 1 upper case letter, one lower case letter. 4 characters minimum. 12 max.
                                //var regexp = /^(?=.*[a-z])(?=.*[A-Z])(?!.*\s).{4,12}$/;  // <= breaks in IE5/Mac
                                return wFORMS.behaviors['validation'].isEmpty(s);
                        },
                        
                        // ------------------------------------------------------------------------------------------                
                        // Error Alert Functions
                        // ------------------------------------------------------------------------------------------                
                        showError: function (element,errorMsg) {                
                                // remove existing error message if any.
                                wFORMS.behaviors['validation'].removeErrorMessage(element);
                                
                                if (!element.id) element.id = wFORMS.helpers.randomId(); // we'll need an id here.                
                                // Add error flag to the field
                                element.className += " " + wFORMS.className_validationError_fld;
                                // Prepare error message
                                var msgNode = document.createTextNode(" " + errorMsg);
                                // Find error message placeholder.
                                var fe = document.getElementById(element.id +  wFORMS.idSuffix_fieldError);
                                if(!fe) { // create placeholder.
                                        fe = document.createElement("div"); 
                                        fe.setAttribute('id', element.id +  wFORMS.idSuffix_fieldError);                        
                                        // attach the error message after the field label if possible
                                        var fl = document.getElementById(element.id +  wFORMS.idSuffix_fieldLabel);
                                        if(fl)
                                                fl.parentNode.insertBefore(fe,fl.nextSibling);
                                        else
                                                // otherwise, attach it after the field tag.
                                                element.parentNode.insertBefore(fe,element.nextSibling);
                                }
                                // Finish the error message.
                                fe.appendChild(msgNode);          
                                fe.className += " " + wFORMS.className_validationError_msg;
                        },
                        
                        showAlert: function (nbTotalErrors) {
                           alert(wFORMS.behaviors['validation'].errMsg_notification.replace('%%',nbTotalErrors));
                        },
                        
                        removeErrorMessage: function(element) {
                                if(wFORMS.helpers.hasClass(element,wFORMS.className_validationError_fld)) {
                                        var rErrClass     = new RegExp(wFORMS.className_validationError_fld,"gi");
                                        element.className = element.className.replace(rErrClass,"");
                                        var errorMessage  = document.getElementById(element.id + wFORMS.idSuffix_fieldError);
                                        if(errorMessage)  {                                
                                                errorMessage.innerHTML=""; 
                                        }
                                }
                        }
                                        
       } // End wFORMS.behaviors['validation']
           
                wFORMS.functionName_formValidation = wFORMS.behaviors['validation'].run;


                // ----------------------------------------------------------------------
                // wForms 1.0 backward compatibility
                // ----------------------------------------------------------------------
                wFORMS.formValidation = wFORMS.behaviors['validation'].run;
                
                // Error messages. 
                wFORMS.arrErrorMsg = new Array(); 
                wFORMS.arrErrorMsg[0] = wFORMS.behaviors['validation'].errMsg_required;        
                wFORMS.arrErrorMsg[1] = wFORMS.behaviors['validation'].errMsg_alpha;                         
                wFORMS.arrErrorMsg[2] = wFORMS.behaviors['validation'].errMsg_email;                
                wFORMS.arrErrorMsg[3] = wFORMS.behaviors['validation'].errMsg_integer;                
                wFORMS.arrErrorMsg[4] = wFORMS.behaviors['validation'].errMsg_float;
                wFORMS.arrErrorMsg[5] = wFORMS.behaviors['validation'].errMsg_password;
                wFORMS.arrErrorMsg[6] = wFORMS.behaviors['validation'].errMsg_alphanum;
                wFORMS.arrErrorMsg[7] = wFORMS.behaviors['validation'].errMsg_date;
                wFORMS.arrErrorMsg[8] = wFORMS.behaviors['validation'].errMsg_notification;
                
   }