/***

    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;
		
   }