/*  
calculatortoolbox.js  version 1.39.6

											Rev. date: 03-06-2010

   requires: dbcore.js
	 					 dbtoolboxes.js
						 dberrorhandler.js

*/

CalculatorToolbox = {
		jsversion: '1.39.6',
		calculatorObj: null,
		listOfTriggers: null,
		errorId: '',
		ELSEmessage:'',		
		requiredGroupsHandled:[],
		elementsArePrepared: false,
		firstESCalculationDone: false,
		sharepointEditmode: false,
		lastOnMeOperation:'',
		inputs:[],
		selects: [],
		textareas: [],
		buttons: [],
		anchors: [],
		divs: [],
		lis: [],
		spans: [],
		tables: [],
		pseudoChangeElements: [],
		changeTriggers: ' hideMeOnChange hideMeOnChecked showMeOnChecked showMeOnValue hideMeOnMultichecked hideMeOnSelected showMeOnSelected showHideMeOnMultiOr clearMeOnAnyChange calculateMeOnChange lockMeOnValueEqual lockMeOnValueNotEqual lockMeOnValueLess lockMeOnValueGreatOrEqual lockMeOnButton suggestprcamount ',
		linkAwareTriggers: ['toggleBy'],
		pseudoChangeElementIdsFromCalc: [],
		fieldsForESTransfer: [],
		linkAwareElements: [],
		togglegroups: [],
		
	
	sampleInitToolbox: function (excelMode) {
			 var self=CalculatorToolbox;
			 self.setClickListeners();
			 self.setChangeListeners();
			 self.setButtonActivation();
			 self.setKeydownListeners();
			 self.overwritePrintIcon();
			 if (excelMode) {
			 		self.activateExcel();
			 }
	},
	
		
	setJShides: function() { 
			// DisplayToolbox.hideByClass('jshide'); // Depricated 
	},
		
	prepareElementLists: function() {
			var self=CalculatorToolbox;
			self.inputs= document.getElementsByTagName('input');
			self.selects= document.getElementsByTagName('select');
			self.textareas= document.getElementsByTagName('textarea');
			self.buttons= document.getElementsByTagName('button');
			self.anchors= document.getElementsByTagName('a');
			self.divs=document.getElementsByTagName('div');
			self.lis=document.getElementsByTagName('li');
			self.spans=document.getElementsByTagName('span');
			self.tables=document.getElementsByTagName('table');
			self.elementsArePrepared=true;
			self.getSharepointEditMode();
	},
	
	getSharepointEditMode: function() {
			var self=CalculatorToolbox;
			var checkInButtonPresent = (document.getElementById('qaCheckin_anchor')) ? true:false;
			if (checkInButtonPresent) {
        	self.sharepointEditmode=true;
			}
	},
	
  setChangeListeners: function() {
		 var self=CalculatorToolbox;
		 if (!self.elementsArePrepared) {self.prepareElementLists();}
		 for (var i=0;i<self.inputs.length;i++) {
		 		if (DBcore.isInsideFieldgroup(self.inputs[i])) {
					 DBcore.addEventListener(self.inputs[i],'change',self._changeListener);
					 if (self._isChangeRelevant(self.inputs[i])) self.pseudoChangeElements.push(self.inputs[i]);
				}
		 }
		 for (var i=0;i<self.selects.length;i++) {
		 		if (DBcore.isInsideFieldgroup(self.selects[i])) {
					 DBcore.addEventListener(self.selects[i],'change',self._changeListener); 
					 if (self._isChangeRelevant(self.selects[i])) self.pseudoChangeElements.push(self.selects[i]);
				}
		 }
		 for (var i=0;i<self.textareas.length;i++) {
		 		if (DBcore.isInsideFieldgroup(self.textareas[i])) {
					 DBcore.addEventListener(self.textareas[i],'change',self._changeListener); 
					 if (self._isChangeRelevant(self.textareas[i])) self.pseudoChangeElements.push(self.textareas[i]);
				}
		 }
		 self._setPseudoChangeElements();
	},
	
	setClickListeners: function () {
		 var self=CalculatorToolbox;
		 if (!self.elementsArePrepared) {self.prepareElementLists();}
		 for (var i=0;i<self.buttons.length;i++) {
		 		if(self.buttons[i].type=='button') {
					if (DBcore.isInsideFieldgroup(self.buttons[i])) {
						 DBcore.addEventListener(self.buttons[i],'click',self._clickListener); 
					}
				}
		 }
		 for (var i=0;i<self.inputs.length;i++) {
		 		if(self.inputs[i].type=='button' || self.inputs[i].type=='radio') {
					 if (DBcore.isInsideFieldgroup(self.inputs[i])) {
					 		DBcore.addEventListener(self.inputs[i],'click',self._clickListener);
					 } 
				} else if (self.inputs[i].type=='checkbox') {
					 if (DBcore.isInsideFieldgroup(self.inputs[i])) {
					 		DBcore.addEventListener(self.inputs[i],'click',self._mousedownListener);
					 }
				}
		 }
		 for (var i=0;i<self.anchors.length;i++) {
		 		 if (DBcore.isInsideFieldgroup(self.anchors[i])) {
				 		DBcore.addEventListener(self.anchors[i],'click',self._clickListener); 
				 }
		 }
		 for (var i=0;i<self.divs.length;i++) {
		 		if (DBcore.isInsideFieldgroup(self.divs[i])) {
					 DBcore.addEventListener(self.divs[i],'click',self._clickListener); 
				}
		 }
		 self._setlinkAwareElements();
	},
	
			
	_setMouseoverListeners: function() {
			var self=CalculatorToolbox;
		  if (!self.elementsArePrepared) {self.prepareElementLists();}
		  for (var i=0;i<self.buttons.length;i++) {
		 		if(self.buttons[i].type=='button') {
					if (DBcore.isInsideFieldgroup(self.buttons[i])) {
						 DBcore.addEventListener(self.buttons[i],'mouseover',Formvalidator._mouseoverListener);
					} 
				}
		 }
	},
	
	setButtonActivation: function() {
		 var self=CalculatorToolbox;
		 if (!self.elementsArePrepared) {self.prepareElementLists();}
		 for (var i=0;i<self.buttons.length;i++) {
				if (DBcore.hasClass(self.buttons[i],'inactivebutton')) {
					 self.buttons[i]._activationenabled=true;
					 self.buttons[i]._activationstrict=false;
				} else if (DBcore.hasClass(self.buttons[i],'inactivebutton-strict')) {
				   self.buttons[i]._activationenabled=true;
					 self.buttons[i]._activationstrict=true;
				}
		 }
	},
	
	setListenerForNewButton: function(button,buttonId) {
		var self=CalculatorToolbox;
		var thebutton = (button==null) ? document.getElementById(buttonId) : button;
	  if(thebutton) {
					DBcore.addEventListener(thebutton,'click',self._clickListener); 
		}
	},
	
	setKeydownListeners: function() {
	   var self=CalculatorToolbox;
		 if (!self.elementsArePrepared) {self.prepareElementLists();}
		 for (var i=0;i<self.inputs.length;i++) {
		 		 if (self.inputs[i].type=='text' && (DBcore.hasClass(self.inputs[i],'keyCalc') || DBcore.hasTrigger(self.inputs[i],'keyEval'))) {
				 		DBcore.addEventListener(self.inputs[i],'keydown',CalculatorToolbox._keydownListener);
				 }
		 }
	},
	
	activateExcel: function() {
		 CalculatorToolbox._handleGetExcel();
	},
	
	activateInsertFromURL: function() {
	  CalculatorToolbox._handleInsertFromURL();
	},
	
	overwritePrintIcon: function() {
	  var self=CalculatorToolbox;
		if (!self.elementsArePrepared) {self.prepareElementLists();}
		var href;
		for (var i=0;i<self.anchors.length;i++) {
				hrefsearch = self.anchors[i].search;
				if (hrefsearch == '?print=true') {
					 self.anchors[i].setAttribute('onclick','window.print();');
					 self.anchors[i].setAttribute('href','#');
					 self.anchors[i].onclick=self.printDirect; //EI old mode
					 self.anchors[i].href='#'; //EI old mode
					 break;
				}
		}
	},
	
	printDirect: function() {
		window.print();
	},
	
	miscInitiations: function() {
	   var self=CalculatorToolbox;
	   self._showCopyToClipButton();
		 // <- insert new inits
	},
	
	_setlinkAwareElements: function() {
		 var self=CalculatorToolbox;
		 self.linkAwareElements=[];
		 self.togglegroups=[];
		 self.togglegroups['generic']= new Array();
		 if (!self.sharepointEditmode) {
    		 if (!self.elementsArePrepared) {self.prepareElementLists();}
    		 for (var i=0;i<self.divs.length;i++) { 
    		 		 if (self._isLinkAwareRelevant(self.divs[i])) self.linkAwareElements.push(self.divs[i]);
    		 }
    		 for (var i=0;i<self.lis.length;i++) { 
    		 		 if (self._isLinkAwareRelevant(self.lis[i])) self.linkAwareElements.push(self.lis[i]);
    		 }
    		 for (var i=0;i<self.spans.length;i++) { 
    		 		 if (self._isLinkAwareRelevant(self.spans[i])) self.linkAwareElements.push(self.spans[i]);
    		 }
		 }
	},
	
	_isLinkAwareRelevant: function(element) {
	  var self=CalculatorToolbox;
		var relevant=false;
	  var classes=element.className.split(' ');
		for (var i=0;i<classes.length;i++) {
				var classParts=classes[i].split('-');
				var classFunction=classParts[0];
				if (classFunction !='' && DBcore.findInArray(self.linkAwareTriggers,classFunction)) {
  				relevant=true;
  				break;
				}
		}
		return relevant;
	},
	
	_setPseudoChangeElements: function() {
		 var self=CalculatorToolbox;
		 if (!self.elementsArePrepared) {self.prepareElementLists();}
		 for (var i=0;i<self.divs.length;i++) { 
		 		 if (self._isChangeRelevant(self.divs[i])) self.pseudoChangeElements.push(self.divs[i]);
		 }
		 for (var i=0;i<self.lis.length;i++) { 
		 		 if (self._isChangeRelevant(self.lis[i])) self.pseudoChangeElements.push(self.lis[i]);
		 }
		 for (var i=0;i<self.spans.length;i++) { 
		 		 if (self._isChangeRelevant(self.spans[i])) self.pseudoChangeElements.push(self.spans[i]);
		 }
		 for (var i=0;i<self.pseudoChangeElementIdsFromCalc.length;i++) {
		 		 self.pseudoChangeElements.push(document.getElementById(self.pseudoChangeElementIdsFromCalc[i]));
		 }
	},
	
	_isChangeRelevant: function(target) {
		var relevant=false;
	  var classes=target.className.split(' ');
		for (var i=0;i<classes.length;i++) {
				var classParts=classes[i].split('-');
				var classFunction=classParts[0];
				if (classFunction != '' && CalculatorToolbox.changeTriggers.indexOf(''+classFunction+' ')>-1 ) {
  				relevant=true;
  				break;
				}
		}
		return relevant;
	},
	
	fieldsAreValid: function() {
			var self=CalculatorToolbox;
			var valid=true;
			var ok=true;
			self.errorId='';
			ErrorHandler.resetError();
			self.requiredGroupsHandled=[];
			var form = document.getElementsByTagName('form')[0];
			var fields = form.elements;
			for (var i=0;i<fields.length;i++) {
					if (!ok) break;
					var abortRest=false;
				  if (fields[i].tagName != 'FIELDSET' && fields[i].id && typeof fields[i].className != 'undefined' && (fields[i].type && fields[i].type!='button')) {
						var fieldId=fields[i].id;
						var classes=fields[i].className.split(' ');
						for (var j=0;j<classes.length;j++) {
						  if (ok) {
								var ClassParts=DBcore.getClassParts(classes[j]);
  							var classFunction=ClassParts.classFunction;
  							var classParams=ClassParts.classParams;
								var Handlerobject = (DBcore.findInArray(self.listOfTriggers,classFunction)) ? self.calculatorObj : self;
								switch (classFunction) {
										case 'bindExcel':
												 		 Handlerobject._handleSetExcel(fields[i],classParams);
												 		 break;
										case 'transfer':
												 		 Handlerobject._handleSetTransfer(fields[i],classParams[0]);
												 		 break;
										case 'decimal':
												 		 ok=Handlerobject._handleDecimal(fields[i],classParams,'');
														 break;
										case 'decimalpercentage':
												 		 ok=Handlerobject._handleDecimal(fields[i],classParams,'percent');
														 break;
										case 'integerGreater':
															ok=Handlerobject._handleIntegerGreater(fields[i],classParams);
															break;
										case 'integerLess':
															ok=self._handleIntegerLess(fields[i],classParams);
															break;
										case 'maxDigits':
												 		 ok=Handlerobject._handleMaxDigits(fields[i],classParams);
												 		 break;
										case 'minDigits':
												 		 ok=Handlerobject._handleMinDigits(fields[i],classParams);
												 		 break;
										case 'noLetters':
														 ok=self._handleNoLetters(fields[i]);
														 break;
										case 'notNegativeInteger':
														 ok=Handlerobject._handleNotNegativeInteger(fields[i]);
														 break;
										case 'number':
														 ok=Handlerobject._handleNumber(fields[i],classParams);
														 break;
										case 'onlyIfVisible':
														 abortRest=self._handleOnlyIfVisible(fields[i]);
														 break;
										case 'onlyIfUnlocked':
														 abortRest=self._handleOnlyIfUnlocked(fields[i]);
														 break;
										case 'positiveInteger':
														 ok=Handlerobject._handlePositiveInteger(fields[i]);
														 break;
										case 'range':
												 		 ok=Handlerobject._handleRange(fields[i],classParams);
														 break;
										case 'remove':
												 		 Handlerobject._handleRemove(fields[i],classParams);
												 		 break;
										case 'required':
														 ok=Handlerobject._handleRequired(fields[i],classParams);
														 break;
										case 'requiredIfCheckbox':
														 ok=Handlerobject._handleRequiredIfCheckbox(fields[i],classParams);
														 break;
										case 'requiredIfVisible':
														 ok=Handlerobject._handleRequiredIfVisible(fields[i]);
														 break;
										case 'requiredIfSelect':
												 		 ok=Handlerobject._handleRequiredIfSelect(fields[i],classParams);
														 break;
										case 'requiredGroup':
														 ok=Handlerobject._handleRequiredGroup(fields[i],classParams);
														 break;
										case 'trim':
														 self._handleTrim(fields[i]);
														 break;
										default: 
														 if (Handlerobject !== self && Handlerobject.dispLocalValidators) {
														 		if (Handlerobject.dispLocalValidators) {
														 			 ok=Handlerobject.dispLocalValidators(fields[i],classFunction,classParams,'calculate');
																}
														 }
														 break;
								}
								if (!ok) {
    										 valid=false;
												 if (CalculatorToolbox.errorId!='') {
      										 ErrorHandler.showErrorInline(CalculatorToolbox.errorId,fields[i].id);
  												 ErrorHandler.setErrorMark(fields[i].id);
  								 				 ErrorHandler.selectInputContent(fields[i].id);
												 }
												 break;
    					  }
								if (abortRest) break;
							}	
						}
					}
			}
			return valid;
		},
	
	_mousedownListener: function(event) {
			var self=CalculatorToolbox;
			var target=DBcore.getTarget(event);
			self.ieBlurhack(target);
	},
	
	_changeListener: function(event) {
	      var self=CalculatorToolbox;
				var ok=true;
				var abortRest=false;
				ErrorHandler.resetError();
				var field=DBcore.getTarget(event);
				var classes=field.className.split(' ');
				for (var i=0;i<classes.length;i++) {
  						  var ClassParts=DBcore.getClassParts(classes[i]);
  							var classFunction=ClassParts.classFunction;
  							var classParams=ClassParts.classParams;
								var Handlerobject = (self.listOfTriggers!=null && DBcore.findInArray(self.listOfTriggers,classFunction)) ? self.calculatorObj : self;
								switch (classFunction) {
										case 'clearfields':
														 Handlerobject._handleClearfields(field,classParams);
														 break;
										case 'decimal':
												 		 ok=Handlerobject._handleDecimal(field,classParams,'');
														 break;
										case 'decimalpercentage':
												 		 ok=Handlerobject._handleDecimal(field,classParams,'percent');
														 break;
										case 'hideElementAlways':
														 Handlerobject._handleHideAlways(field,classParams);
														 break;
										case 'hideOnChecked':
												 		 Handlerobject._handleHideOn('check',field,classParams);
														 break;
										case 'hideOnValue':
												 		 Handlerobject._handleHideOn('select',field,classParams);
														 break;
										case 'notNegativeInteger':
														 ok=self._handleNotNegativeInteger(field);
														 break;
										case 'number':
														 ok=Handlerobject._handleNumber(field,classParams);
														 break;
										case 'noLetters':
														 ok=self._handleNoLetters(field);
														 break;
										case 'onlyIfVisible':
														 abortRest=self._handleOnlyIfVisible(field);
														 break;
										case 'onlyIfUnlocked':
														 abortRest=self._handleOnlyIfUnlocked(field);
														 break;
										case 'positiveInteger':
														 ok=self._handlePositiveInteger(field);
														 break;
										case 'integerGreater':
															ok=Handlerobject._handleIntegerGreater(field,classParams);
															break;
										case 'integerLess':
															ok=Handlerobject._handleIntegerLess(field,classParams);
															break;
										case 'remove':
												 		 Handlerobject._handleRemove(field,classParams);
												 		 break;
										case 'range':
												 		 ok=Handlerobject._handleRange(field,classParams);
														 break;
										case 'resetfields':
														 Handlerobject._handleResetfields(field,classParams);
														 break;
										case 'requiredIfSelect':
												 		 Handlerobject._handleStartime(field,classParams);
														 break;
										case 'showelement':
														 Handlerobject._handleShow(field,classParams);
														 break;
										case 'showElementAlways':
														 Handlerobject._handleShowAlways(field,classParams);
														 break;
										case 'trim':
														 self._handleTrim(field);
														 break;
										default:
														if (Handlerobject !== self) {
															 	if (Handlerobject.dispLocalValidators) {
														 			 Handlerobject.dispLocalValidators(field,classFunction,classParams,'change');
																}
														 }
														 break;
								}
        				if (!ok) {
          				 ErrorHandler.showErrorInline(self.errorId,field.id);
        					 ErrorHandler.setErrorMark(field.id);
        				 break;
          			}
								if (abortRest) break;
        }
				var ButtonsToHandle=ButtonToolbox.checkForActivation(field);
    		if (ButtonsToHandle.found) {
				 		for (var j=0;j<ButtonsToHandle.targets.length;j++) {
							if(ok) {
									 ButtonToolbox.activateByRequired(ButtonsToHandle.targets[j]);
							} else {
								 ButtonToolbox.deactivateButton(ButtonsToHandle.targets[j]);
							}
						}
    	  }
				for (var j=0;j<CalculatorToolbox.pseudoChangeElements.length;j++) {
						var pcElement=CalculatorToolbox.pseudoChangeElements[j];
						  if (pcElement) {
  						classes=pcElement.className.split(' ');
  						for (var i=0;i<classes.length;i++) {
    						  var ClassParts=DBcore.getClassParts(classes[i]);
  								var classFunction=ClassParts.classFunction;
  								var classParams=ClassParts.classParams;
  								var Handlerobject = (self.listOfTriggers!=null && DBcore.findInArray(self.listOfTriggers,classFunction)) ? self.calculatorObj : self;
  								switch (classFunction) {
  											 case 'hideMeOnChange':
  											 			Handlerobject._handleHideMeOnChange(pcElement);
  											 			break;
  											 case 'hideMeOnChecked':
  											 			Handlerobject._handleHideShowMeOnChecked(pcElement,classParams,'hide');
  														break;
  											 case 'showMeOnChecked':
  											 			Handlerobject._handleHideShowMeOnChecked(pcElement,classParams,'show');
  														break;
  											 case 'showMeOnValue':
  											 			Handlerobject._handleHideShowMeOnValue(pcElement,classParams,'show');
  														break;
  											 case 'showMeOnMultichecked':
  											 			Handlerobject._handleHideShowMeOnMultichecked(pcElement,classParams,'show');
  														break;
  											 case 'hideMeOnSelected':
  											 			Handlerobject._handleHideShowMeOnSelected(pcElement,classParams,'hide');
  														break;
  											 case 'showMeOnSelected':
  											 			Handlerobject._handleHideShowMeOnSelected(pcElement,classParams,'show');
  														break;
  											 case 'showHideMeOnMultiOr':
  											 			Handlerobject._handleShowHideMeOnMultiOr(pcElement,classParams);
  														break;
  											 case 'clearMeOnAnyChange':
  											 			Handlerobject._handleClearMeOnAnyChange(pcElement);
  														break;
  											 case 'calculateMeOnChange':
  											 			Handlerobject.handleCalculateMeOnChange(pcElement,classParams);
  														break;
												 case 'lockMeOnValueEqual':
												 			Handlerobject._handleLockMeOnChange(pcElement,classParams,'eq','number');
															break;
												 case 'lockMeOnValueLess':
												 			Handlerobject._handleLockMeOnChange(pcElement,classParams,'less','number');
															break;
												 case 'lockMeOnValueGreatOrEqual':
												 			Handlerobject._handleLockMeOnChange(pcElement,classParams,'gteq','number');
															break;
												 case 'lockMeOnValueNotEqual':
												 			Handlerobject._handleLockMeOnChange(pcElement,classParams,'noteq','number');
															break;
												 case 'lockMeOnValueGreater':
												 			Handlerobject._handleLockMeOnChange(pcElement,classParams,'gt','number');
															break;
												 case 'lockMeOnButton':
												 			Handlerobject._handleLockMeOnChange(pcElement,classParams,'','check');
															break;
  											 case 'suggestprcamount':
  											 			Handlerobject._handleSuggestPercentAmount(pcElement,classParams)
  														break;
  											default:
  														if (Handlerobject !== self) {
  															 	if (Handlerobject.dispLocalValidators) {
  														 			 Handlerobject.dispLocalValidators(pcElement,classFunction,classParams,'pseudochange');
  																}
  														 }
  														 break;
  								}
  						}
						}
				}
	},
	
	
	_clickListener: function(event) {
	  		var self=CalculatorToolbox;
				var ok=true;
				var abortRest=false;
				var element=DBcore.getTarget(event);
				DBcore.stopPropagation(event);
				self.ieBlurhack(element);
				var classes=element.className.split(' ');
				for (var i=0;i<classes.length;i++) {
  						  var ClassParts=DBcore.getClassParts(classes[i]);
  							var classFunction=ClassParts.classFunction;
  							var classParams=ClassParts.classParams;
								var Handlerobject = (self.listOfTriggers!=null && DBcore.findInArray(self.listOfTriggers,classFunction)) ? self.calculatorObj : self;
  							switch (classFunction) {
										case 'infoMessage':
														self._handleInfoMessage(element,classParams);
													break;
										case 'calculate':
    												 ok=self.fieldsAreValid();
    												 if (ok) {
    														 if (Handlerobject.dispLocalValidators) {
    														 			 Handlerobject.dispLocalValidators(element,classFunction,classParams,'calculate');
    															} else {
    																   Handlerobject.handleCalculate(element);
    															}
															}
    												 break;
										case 'calculateExcel':
														 ok=self.fieldsAreValid();
														 if (ok) Handlerobject._handleExcelCalculate(element,classParams);
												 		 break;
										case 'transfer':
												 		 if (self.firstESCalculationDone) {
  												 		 self.fieldsForESTransfer=[];
  												 		 ok=self.fieldsAreValid();
  														 if (ok) Handlerobject._handleESTransfer(element,classParams);
														 }
														 break;
										case 'clearfields':
														 Handlerobject._handleClearfields(element,classParams);
														 break;
										case 'copytoclipboard':
    												 Handlerobject._handleCopyToClipboard(element,classParts);
    												 break;
										case 'deleteContainer':
												 		 Handlerobject._handleDeleteContainer(element,classParts);
														 break;
										case 'onlyIfVisible':
														 abortRest=self._handleOnlyIfVisible(element);
														 break;
										case 'onlyIfUnlocked':
														 abortRest=self._handleOnlyIfUnlocked(element);
														 break;
										case 'radioShow': 
  												   self._handleRadioShow(element,classParams);
  													 break;
										case 'radioMultiHide': 
  												   self._handleRadioMultihide(element,classParams);
  													 break;
										case 'radioHide': 
  												   self._handleRadioHide(element,classParams);
  													 break;
										case 'resetfields':
														 Handlerobject._handleResetfields(element,classParams);
														 break;
										case 'showelement':
														 Handlerobject._handleShow(element,classParams);
														 break;
										case 'hideelementonclick':
												 		 Handlerobject._handleHideElementOnClick(element);
														 break;
										default: 
														 if (Handlerobject !== self) {
															 	if (Handlerobject.dispLocalValidators) {
														 			 ok=Handlerobject.dispLocalValidators(element,classFunction,classParams,'click');
																}
														 }
														 break;
								}
								if (classFunction.slice(0,9) == 'calculate') {
									 self._setTracking(classFunction,ok);
								}
								if (abortRest) break;
				}	
				for (var j=0;j<CalculatorToolbox.linkAwareElements.length;j++) {
						var ltElement=CalculatorToolbox.linkAwareElements[j];
						  if (ltElement) {
								 classes=ltElement.className.split(' ');
								 for (var i=0;i<classes.length;i++) {
      						  var ClassParts=DBcore.getClassParts(classes[i]);
    								var classFunction=ClassParts.classFunction;
    								var classParams=ClassParts.classParams;
    								var Handlerobject = (self.listOfTriggers!=null && DBcore.findInArray(self.listOfTriggers,classFunction)) ? self.calculatorObj : self;
    								switch (classFunction) {
  								  			 case 'toggleBy':
													 			Handlerobject._handleToggleBy(ltElement,classParams,element);
																break;
													 default:
													 			if (Handlerobject !== self) {
  															 	if (Handlerobject.dispLocalValidators) {
  														 			 Handlerobject.dispLocalValidators(ltElement,classFunction,classParams,'linkAwareClick');
  																}
  														  }
  												 			break;
  									}
								}
								 
							}
				}
	},
	
	_mouseoverListener: function(event) {
			var self=Formvalidator;
			var element=DBcore.getTarget(event);
			var classes=element.className.split(' ');
					for (var i=0;i<classes.length;i++) {
  						  var ClassParts=DBcore.getClassParts(classes[i]);
  							var classFunction=ClassParts.classFunction;
  							var classParams=ClassParts.classParams;
  							switch (classFunction) {
											 case 'exitfields':
											 			self._handleExitfields(element);
														break;
											 case 'defaultbutton':
											 			self._handleExitfields(element);
														break;
								}
					}
					
	},
	
	_keydownListener: function(event) {
	  var self=CalculatorToolbox;
		var found=false;
    var charCode = (event.charCode) ? event.charCode: ((event.which) ? event.which : event.keyCode);
		var element=DBcore.getTarget(event);
		var classes=element.className.split(' ');
		if (DBcore.findInArray(classes,'keyEval-noletter')) {
			 /* Under development
			 if (charCode<32) {
			 		return true;
			 } 
			 var thechar=String.fromCharCode(charCode);
			 if ((('0123456789.,').indexOf(thechar) > -1)) {
			 	  return true;
			 } else {
			 	  return false;
			 }*/		
			 } else {
    		switch (charCode) {
    					 case 13:
    								var buttons=document.getElementsByTagName('button');
    								for (var i=0;i<buttons.length;i++) {
    										if (DBcore.hasClass(buttons[i],'calculate')) {
    											 var button=buttons[i];
    											 found=true;
    										}
    								}
    								if (found && self.calculatorObj != null) {
    									self.calculatorObj.handleCalculate(button);
    								}
    								break;
    		}
		}
	},
	
	_excelFilter: function(field,rawValue,fromExcel) {
		var self=CalculatorToolbox;
		var Handlerobject = (self.listOfTriggers!=null && DBcore.findInArray(self.listOfTriggers,classFunction)) ? self.calculatorObj : self;
	  var theValue;
		var filterDone=false;
		var classes=field.className.split(' ');
		for (var i=0;i<classes.length;i++) {
				var ClassParts=DBcore.getClassParts(classes[i]);
  			var classFunction=ClassParts.classFunction;
  			var classParams=ClassParts.classParams;
				var fixedDecimals = (classParams[1]!='') ? classParams[1]:0;
				switch (classFunction) {
					case 'decimalpercentage' :
							 if (fromExcel) {
							 		theValue=Handlerobject._handleConvertToDecimal((rawValue*100),classParams[0],fixedDecimals);
							 } else {
							 	  theValue=Handlerobject._handleConvertToPointDecimal(rawValue)/100;
							 }
							 filterDone=true;
							 break;
					case 'decimal':
							 if (fromExcel) {
							 		theValue=Handlerobject._handleConvertToDecimal(rawValue,classParams[0],fixedDecimals);
							 } else {
							 	  theValue=Handlerobject._handleConvertToPointDecimal(rawValue);
							 }
							 filterDone=true;
							 break;
					case 'number':
							 if (fromExcel) {
							 		theValue=Handlerobject._handleFormatNumberFromExcel(field,rawValue,classParams);
							 } else {
							 	 	if (rawValue.indexOf('.') !=-1 || rawValue.indexOf(',') !=-1 ) {
										 var decsign= (classParams[0]=='c') ?',':'.';
							 	  	 theValue=Handlerobject._handleConvertToPointDecimal(rawValue,decsign);
									} else {
										 theValue=StringToolbox.removeChar(rawValue,' ');				
									}
							 }
							 if (theValue=='' && !DBcore.hasTrigger(field,'setToZeroIfEmpty')) {
							 		filterDone=true;
							 } else if (theValue !='') {
							 	 	filterDone=true;
							 }
							 break;
				  case 'roundedInteger':
				 			if (fromExcel) {
								 theValue=Handlerobject._handleRoundToInteger(rawValue,classParams[0]);
							} else {
								 theValue = StringToolbox.removeAllChars(rawValue);
							}
							filterDone=true;
							break;
				  case 'setToZeroIfEmpty':
				 			if (fromExcel) {
								 if (rawValue=='0') {
			 					 		theValue='';
								 } else {
								 	  theValue=rawValue;
								 }
							} else {
								 if (field.value=='') {
								 		theValue='0';
								 } else if (theValue!='') {
								 	  theValue=rawValue;
								 }
							}
							filterDone=true;
							break;
				  default:
									theValue=rawValue;
									break;
				}
				if (filterDone) break;
		}
		return theValue;
	},
	
	ieBlurhack: function(target) {
		if (target.type=='checkbox' || target.type=='radio') {
			 target.blur();
		}
	},
	
	_handleESTransfer: function(button,classParams) {
	    var self=CalculatorToolbox;
			var webpartId=classParams[0];
			var transid = (classParams[1]) ? classParams[1]: 1;
			var field;
			for (var i=0;i<self.fieldsForESTransfer.length;i++) {
					field=self.fieldsForESTransfer[i];
					if (field._transid==transid) {
						 if (document.getElementById('trans'+i+'ID')) {
						 		document.getElementById('trans'+i+'ID').value=field.id;
								document.getElementById('trans'+i+'VAL').value=field.value;
						 }
					}
			}
			document.getElementById('EStranscount').value=i;
			var webpartSubmitfunction = 'sendForm_'+webpartId+'()';
			eval(webpartSubmitfunction);
	},
	
	transferFromES: function() {
			if (document.getElementById('EStranscount')) {
				 var targetId;
				 var targetValue;
				 var target;
				 var transcount=document.getElementById('EStranscount');
				 for (var i=0;i<transcount;i++) {
				 		 targetId=document.getElementById('trans'+i+'ID').value;
						 targetValue=document.getElementById('trans'+i+'VAL').value;
						 if (document.getElementById(targetId)) {
						 		document.getElementById(targetId).value=targetValue;
						 }
				 }
			}
	},
	
	_handleExcelCalculate: function(element,classParams) {
			CalculatorToolbox.firstESCalculationDone=true;
	    var webpartId=classParams[0];
			var webpartSubmitfunction = 'sendForm_'+webpartId+'()';
			eval(webpartSubmitfunction);
	},
	
	_handleGetExcel: function() {
		 var self=CalculatorToolbox;
		 if (!self.elementsArePrepared) {self.prepareElementLists();}
		 var resultReturned=false;
		 var numBindingFields=0;
		 var numExcelInOutFields=0;
		 var fields=[];
		 var inputelement;
		 var inputelementId;
		 var inputelementValue;
		 var excelElement;
		 for (var n=0;n<self.inputs.length;n++) {fields.push(self.inputs[n]);}
		 for (var n=0;n<self.selects.length;n++) {fields.push(self.selects[n]);}
		 for (var n=0;n<self.textareas.length;n++) {fields.push(self.textareas[n]);}
		 for (var i=0;i<fields.length;i++) {
		 		inputelement=fields[i];
				inputelementId=inputelement.id;
				if (DBcore.hasTrigger(inputelement,'bindExcel') && !DBcore.hasTrigger(inputelement,'locked')) {
					 numBindingFields++;
					 if (inputelement.type=='text' || inputelement.type=='hidden' || inputelement.type=='textarea') {
					 		if (document.getElementById('exin_'+inputelementId)) {
								 inputelementValue=document.getElementById('exin_'+inputelementId).value;
								 if (inputelementValue != '') {
								 		inputelement.value=CalculatorToolbox._excelFilter(inputelement,inputelementValue,true);
								 }
							} else if (document.getElementById('exout_'+inputelementId)) {
								 inputelementValue=document.getElementById('exout_'+inputelementId).value;
								 if (inputelementValue !='#VALUE!') {
								 		inputelement.value = CalculatorToolbox._excelFilter(inputelement,inputelementValue,true);
										if (inputelement.value!='') {
											 resultReturned=true;
										}
								 } else {
								 	  inputelement.value='';
								 }
							}  
					 } else {
					 	  excelElement=document.getElementById('exin_'+inputelementId);
							if (excelElement) {
					 	  	inputelementValue=excelElement.value;
								if (inputelementValue !=0) {
    					 		switch(inputelement.type) {
    									case 'select-one':
    											 DBcore.setSelectedValue(inputelement,inputelementValue);
    											 break;
    									case 'radio':
    											 DBcore.setRadioValue(inputelement,inputelementValue);
    											 break;
    									case 'checkbox':
    											 inputelement.checked = (inputelementValue=='TRUE') ? true: false;
    											 break;
    							}
								}
							}
					 }
				} else if (inputelementId.substring(0,5)=='exin_' || inputelementId.substring(0,6)=='exout_' ) {
					 numExcelInOutFields++;
				}
		 }
		 if (numBindingFields!=numExcelInOutFields) {
		   CalculatorToolbox.ELSEmessage +='\r -Mismatch in number of excel binding fields!';
		 }
		 if (resultReturned && document.getElementById('resultSection')) {
		 		var resultSection=document.getElementById('resultSection');
		 		DisplayToolbox.showElement(resultSection);
		 }
	},
		
	_handleRoundToInteger: function(decimalvalue,separator) {
		var res= Math.round(decimalvalue);
		res=res.toString();
		if (separator) {
			 var classParams = ['x',separator];
			 res=CalculatorToolbox._handleFormatNumberFromExcel(null,res,classParams);
		}
		return res;
	},
	
	_handleOnlyIfVisible: function(element) {
	  return (DBcore.hasHiddenParent(element) || DBcore.hasClass(element,'hide')) ? true : false;
	},
	
	_handleOnlyIfUnlocked: function(element) {
	  var locked= ((element.type=='text' && element.readonly) || element.disabled) ? true:false;
		return locked;
	},
	
	_handleSetExcel: function(field,classParams) {
		var excelInputId='exin_'+field.id;
		if (document.getElementById(excelInputId)) {
  		var excelInputfield=document.getElementById(excelInputId);
	  	var fieldValue;
			switch (field.type) {
						 case 'radio':
						 			fieldValue=DBcore.getRadioValue(field);
									break;
						 case 'select-one':
						 			fieldValue=DBcore.selectedValueOf(field);
						 			break;
						 case 'checkbox':
						 			fieldValue = (field.checked) ? 'TRUE':'FALSE' ;
									break;
						 default: 
						 			fieldValue=field.value;
									break;
			}
			var filteredValue=CalculatorToolbox._excelFilter(field,fieldValue,false);
  		excelInputfield.value=filteredValue;
			field._bindexcel=true;
		}
	},
	
	_handleSetTransfer: function(field,nr) {
			var self=CalculatorToolbox;
	    if (document.getElementById('EStranscount') && field.id && field.type!='button') {
				 var transid = (nr) ? nr : 1;
				 field._transid=transid;
				 self.fieldsForESTransfer.push(field);
			} else {
				 CalculatorToolbox.ELSEmessage='CW:Webpart problem.';
			}
	},
	
	_handleDecimal: function(field,classParams,mode) {
		var ok = true;
		var self=CalculatorToolbox;
		var decimalpoint=classParams[0];
		var decimalfix = (classParams[1]) ? parseInt(classParams[1],10):0;
		var Decimal = StringToolbox.isDecimalString(field.value,decimalpoint,decimalfix);
		if (!Decimal.isdecimal) {
			 ok=false;
			 if (Decimal.fixerror) {
			 		self.errorId='N11';
					field._specmax=decimalfix;
			 } else {
			 	  self.errorId='N7';
			 }
		} else {
			 if (Decimal.isconverted) {
			 		field.value=Decimal.decimalnumber;
			 }
			 if (field._bindexcel) {
					self._handleSetExcel(field,[]);
			 }
		}
		return ok;
	},
	
	_handleNumber: function(field,classParams) {
			var ok=true;
			var self=CalculatorToolbox;
			var number=field.value;
			var decimalpoint;
			var separator;
			var negation = (classParams[2] && classParams[2].substring(0,5)=='allownegation') ? '-':'';
			switch (classParams[0]) {
						 case 'c': 
						 			decimalpoint=',';
									break;
						 case 'p':
						 			decimalpoint='.';
									break;
						 default:
						 			decimalpoint='';
			}
			switch (classParams[1]) {
						 case 'c':
						 			separator=',';
									break;
						 case 'p':
						 			separator='.';
									break;
						 case 's':
						 			separator=' ';
									break;
						 case 'sp':
						 			separator=' .';
									break;
						 default:
						 separator='';
			}
			Numerictest = StringToolbox.isNumber(number,decimalpoint+separator,negation);
			if (!Numerictest.isnumeric) {
				 ok=false;
				 if (Numerictest.decimalerror && decimalpoint=='') {
				 		self.errorId='N8';
				 } else if (Numerictest.decimalerror) {
				 	  self.errorId='N10';
				 } else if (Numerictest.signerror) {
				 	  self.errorId='N9';
				 } else {
				 	  self.errorId='N10';
				 }
			}
			return ok;
	},
	
	_handleOnShowelement: function(container) {
	  var tag=container.tagName;
	  if (tag=='DIV' || tag=='SPAN'  || tag=='OL'  || tag=='LI'  || tag=='FIELDSET'  || tag=='P') {
			 traverse(container);
		}
    function traverse(node) { 
      if (node.nodeType == 1) {
				 if (DBcore.hasTrigger(node,'onShowelement')) {
				 		var classes=node.className.split(' ');
						for (var i=0;i<classes.length;i++) {
								var classParts=classes[i].split('-');
								if (classParts[0]=='onShowelement') {
									 classParts.shift();
									 if (classParts[0]==container.id) {
									 	 classParts.shift();
  									 var classFunction=classParts[0];
        						 classParts.shift();
        						 var classParams=classParts;
  									 var Handlerobject = (self.listOfTriggers!=null && DBcore.findInArray(CalculatorToolbox.listOfTriggers,classFunction)) ? CalculatorToolbox.calculatorObj : CalculatorToolbox;
    								 switch (classFunction) {
  									 		case 'selectme':
  													 		Handlerobject._handleSelectMe(node,classParts);
  													 		break;
  									 }
  									 break;
									}
								}
						}
				 }
			}
      if (node.childNodes != null) { 
        for (var i=0; i < node.childNodes.length; i++) { 
          traverse(node.childNodes.item(i)); 
        } 
      } 
    }
	},
	
	_handleDeleteContainer: function(button,classParts) {
				var self=CalculatorToolbox;
				var container;
				var containertype=classParts[0];
				containertype = containertype.toUpperCase();
				var element=button;
				while (element.parentNode) {
					if (element.parentNode.tagName==containertype) {
						 container=element.parentNode;
						 container.parentNode.removeChild(container);
						 break;
					} else {
  			 	   element=element.parentNode;
  			  }
				}
	},
	
	_handleRequired: function(field,classParams){
				var self=CalculatorToolbox;
				var ok=true;
				var notZero = (classParams=='notzero') ? true:false;
				var totalEmpty = (classParams=='NW') ? true:false;
				if (field.type=='select-one' && notZero && DBcore.selectedValueOf(field)==0) {
					 ok=false;
				} else if (!StringToolbox.isNotEmpty(field.value,totalEmpty)) {
					 ok=false;
				} 
				if (!ok) {
					 self.errorId='F1';
				}
				return ok;
	},
	
	_handleRequiredIfCheckbox: function(field,classParams) {
			 var self=CalculatorToolbox;
			 var ok=true;
			 var checkbox=document.getElementById(classParams[0]);
			 var required = ((checkbox.selected && classParams[1]=='selected' ) || (!checkbox.selected && classParams[1]=='notselected')) ? true : false;
			 if (required && !StringToolbox.isNotEmpty(field.value,true)) {
					 ok=false;
					 self.errorId='F1';
				}
			 return ok;
	},
	
	_handleRequiredIfVisible: function(field) {
	     var self=CalculatorToolbox;
			 var ok=true;
			 if (!StringToolbox.isNotEmpty(field.value,true) && !DBcore.hasHiddenParent(field)) {
			 		ok=false;
					self.errorId='F1';
			 }
			 return ok;
	},
	
	_handleRequiredIfSelect: function(field,classParams) {
			 var self=CalculatorToolbox;
			 var ok=true;
			 var selectbox=document.getElementById(classParams[0]);
			 var selectboxValue=DBcore.selectedValueOf(selectbox);
			 var requiredValue=classParams[1];
			 var required = (selectboxValue==requiredValue) ? true : false;
			 if (required && !StringToolbox.isNotEmpty(field.value,true)) {
					 ok=false;
					 self.errorId='F1';
				}
			 return ok;
	},
	
	_handleRequiredGroup: function(field,classParams) {
			var ok=true;
			var checkcount=0;
			var textcount=0;
			var button;
			var textfield;
			var buttonParams;
			var textfieldparams;
			var count;
			var inputs;
			var groupname=classParams[0];
			var groupMember;
	    if (groupname!='' && !DBcore.findInArray(CalculatorToolbox.requiredGroupsHandled,groupname)) {
				 CalculatorToolbox.requiredGroupsHandled.push(groupname);
				 count= (classParams[1]) ? parseInt(classParams[1],10): 0;
				 inputs=document.getElementsByTagName('input');
				 if (field.type=='checkbox') {
  				 for (var i=0;i<inputs.length;i++) {
  				 		 button=inputs[i];
  				 		 if (button.type=='checkbox' && DBcore.hasTrigger(button,'requiredGroup')) {
  						 		buttonParams = DBcore.getTriggerParams(button,'requiredGroup');
  								if (buttonParams[0]==groupname && button.checked) checkcount++;
  						 }
  				 }
  				 if (checkcount < count) {
  				 		ok=false;
  				 		Formvalidator.errorId='F8';
  						field._specmin=count;
  				 }
				 } else if (field.type=='radio') {
				 	  	if (DBcore.getRadioValue(field)=='') {
								 ok=false;
  				 			 CalculatorToolbox.errorId='F1';
							}
				 } else if (field.type=='text') {
				 	 	  for (var i=0;i<inputs.length;i++) {
									textfield=inputs[i];
									if (textfield.type=='text' && DBcore.hasTrigger(textfield,'requiredGroup')) {
										 textfieldparams=DBcore.getTriggerParams(textfield,'requiredGroup');
										 if (textfieldparams[0]==groupname && textfield.value!='')textcount++;
										 groupMember=textfield;
									}
							}
							if (textcount < count) {
								 ok=false;
								 var labeltext;
								 CalculatorToolbox.errorId='F16';// First field is rep. by @label
								 var labelspec=DBcore.getLabelFor(groupMember);
      					 if (labelspec.found) {
          					var label=labelspec.label;
          					 labeltxt=ErrorHandler._getLabeltxt(label);
        				 } else { // for sake of IE:
      							 labelspec=DBcore.getNearestLabel(field);
      							 if (labelspec.found) {
            					 label=labelspec.label;
            					 labeltxt=ErrorHandler._getLabeltxt(label);
        						 }
      					 }
								field._text1=labeltxt;
							}
				 }
			}
			return ok;
	},
	
	_handleStartime: function(field,classParams) {
			var triggervalue=classParams[0];
			var target = document.getElementById(classParams[1]);
			if (target && field.type=='select-one') {
				 var selectboxValue=DBcore.selectedValueOf(field);
				 if (selectboxValue==triggervalue) {
				 		DisplayToolbox.starcontrol(target,'visible');
				 } else {
				 	  DisplayToolbox.starcontrol(target,'hidden');
				 }
			}
	},
	
	_handleTrim: function(field) {
				if (field.value!='') {
					 field.value=DBcore.trim(field.value);
					 if (field._bindexcel) {
						 CalculatorToolbox._handleSetExcel(field,[]);
					}
				}	
	},
	
		
	_handlePositiveInteger: function(field){
				var self=CalculatorToolbox;
				var ok=true;
				if (field.value!='') {
  				if (!StringToolbox.isPositiveInteger(field.value)) {
  					 ok=false;
  					 self.errorId='F2';
  				}
				}
				return ok;
	},
	
	_handleNotNegativeInteger: function(field){
				var self=CalculatorToolbox;
				var ok=true;
				if (field.value!='') {
  				if (!StringToolbox.isNotNegativeInteger(field.value)) {
  					 ok=false;
  					 self.errorId='F3';
  				}
				}
				return ok;
	},
	
	_handleIntegerGreater: function(field,classParams) {
	   var ok=true;
		 var self=CalculatorToolbox;
		 var fieldvalue=field.value;
		 if (fieldvalue!='') {
		 		if (StringToolbox.isNumber(fieldvalue,'','-')) {
					 var minvalue = classParams[0];
					 minvalue = (minvalue.charAt(0)=='n') ? '-'+minvalue.substring(1) : minvalue;
					 if (parseInt(fieldvalue)<=parseInt(minvalue)) {
					 		field._specmin=minvalue;
					 		self.errorId='N12';
					 		ok=false;
					 }
				} else {
					 self.errorId='N8';
					 ok=false;
				}
		 }
		 return ok;
	},
	
	_handleIntegerLess: function(field,classParams) {
	   var ok=true;
		 var self=CalculatorToolbox;
		 var fieldvalue=field.value;
		 if (fieldvalue!='') {
		 		if (StringToolbox.isNumber(fieldvalue,'','')) {
					 var maxvalue = classParams[0];
					 if (parseInt(fieldvalue)>=parseInt(maxvalue)) {
					 		field._specmax=maxvalue;
					 		self.errorId='N13';
					 		ok=false;
					 }
				} else {
					 self.errorId='N8';
					 ok=false;
				}
		 }
		 return ok;
	},
	
	_handleRange: function(field,classParams) {
		 var ok=true;
		 if (field.value!='') {
    		 var self=CalculatorToolbox
    		 var parts;
    		 var testvalue;
    		 var dectype;
    		 var paramdectype='';
    		 var minval=classParams[0];
    		 var maxval=classParams[1];
				 var minvalParam=minval;
				 var maxvalParam=maxval;
    		 var valtype = (classParams[2]) ? classParams[2]:'integer';
				 var thousandtype = (classParams[3]) ? classParams[3]:'p';
    		 if (minval.indexOf('c')!=-1) {
    		 		paramdectype=',';
    				parts=minval.split('c');
    		 		minval = parts[0]+'.'+parts[1];
						minvalParam =parts[0]+','+parts[1];
    		 } else if (minval.indexOf('p')!=-1) {
    		 	 	paramdectype='.';
    				parts=minval.split('p');
    		 		minval = parts[0]+'.'+parts[1];
						minvalParam =parts[0]+'.'+parts[1];
    		 }
    		 if (maxval.indexOf('c')!=-1) {
    				parts=maxval.split('c');
    		 		maxval = parts[0]+'.'+parts[1];
						maxvalParam =parts[0]+','+parts[1];
    		 } else if (maxval.indexOf('p')!=-1) {
    				parts=maxval.split('p');
    		 		maxval = parts[0]+'.'+parts[1];
						maxvalParam =parts[0]+'.'+parts[1];
    		 }
    		 var fieldValue = StringToolbox.removeChar(field.value,' ');
				 var ValidDels={};
				 switch (thousandtype) {
				 				case 'p':
										 ValidDels=StringToolbox.validThousandDelimiters(fieldValue,'.',(valtype!='integer'));
										 fieldValue=ValidDels.altString;
										 fieldValue = StringToolbox.removeChar(fieldValue,'.');
										 break;
								case 'c':
										 fieldValue = StringToolbox.removeChar(fieldValue,',');
										 break;
				 }
    		 if (valtype=='integer') {
    		 		var integertest=StringToolbox.isNumber(fieldValue,'','');
    				if (!integertest.isnumeric) {
    					 self.errorId='N8';
    					 ok=false;
    				}
    		 } else {
    		 	  dectype = StringToolbox.getDecimalpointType(fieldValue);
    		 		if (dectype==',' && fieldValue.indexOf(',') !=-1) {
    					 fieldValue=StringToolbox.removeChar(fieldValue,'.');
    					 parts = fieldValue.split(',');
							 if (parts.length>2 || (paramdectype!='' && paramdectype!=dectype)) {
							 		self.errorId='N3';
    					 		ok=false;
							 } else {
    					 	  fieldValue=parts[0]+'.'+parts[1];
							 }
    				} else if (dectype=='.') {
    					  fieldValue=StringToolbox.removeChar(fieldValue,',');
								parts = fieldValue.split('.');
								 if (parts.length>2 || paramdectype!=dectype) {
							 		self.errorId='N3';
    					 		ok=false;
							 }
    				}
    				var numbertest=StringToolbox.isNumber(fieldValue,'.','');
    				if (!numbertest.isnumeric) {
    					 self.errorId='N3';
    					 ok=false;
    				}
    		 }
    		 if (ok) {
    				 testvalue=parseFloat(fieldValue);
    				 minval = (minval=='x') ? minval:parseFloat(minval);
    				 maxval = (maxval=='x') ? maxval:parseFloat(maxval);
    				 if (minval!='x' && testvalue<minval) {
    				 		field._specmin=minvalParam;
    					 	self.errorId='N14';
    					 	ok=false;
    				 } else if (maxval!='x' && maxval<testvalue) {
    				 	  field._specmax=maxvalParam;
    					 	self.errorId='N27';
    					 	ok=false;
    				 }
    		 }
		 }
		 return ok;
	},
	
	_handleMinDigits: function(field,classParams) {
				var self=CalculatorToolbox;
				var ok=true;
				var minimum=classParams[0];
				var Result = StringToolbox.hasMinimumDigits(field.value,minimum);
				if (!Result.overall) {
					 ok=false;
					 if (!Result.correctsize) {
					 		self.errorId='N1';
							field._specmin=minimum;
					 } else if (!Result.isnumber) {
					 	  self.errorId='N3';
					 }
				}
				return ok;
	},
	
	_handleMaxDigits: function(field,classParams) {
				var self=CalculatorToolbox;
				var ok=true;
				var maximum=classParams[0];
				var Result = StringToolbox.hasMaxDigits(field.value,maximum);
				if (!Result.overall) {
					 ok=false;
					 if (!Result.correctsize) {
					 		self.errorId='N2';
							field._specmax=maximum;
					 } else if (!Result.isnumber) {
					 	  self.errorId='N3';
					 }
				}
				return ok;
	},
	
	_handleNoLetters: function(field) {
				var self=CalculatorToolbox;
				var ok = StringToolbox.hasNoLetters(field.value,'strict');
				if (!ok) {
					 	  self.errorId='N3';
				}
				return ok;
	},
	
	_handleConvertToDecimal: function(rawValue,decimalpoint,fixedDecimals) {
	  var decimalvalue;
		var Decimal=StringToolbox.isDecimalString(rawValue,decimalpoint,fixedDecimals);
		if (!Decimal.isdecimal) { // decimal AND wanted digits
			 var decpoint = (decimalpoint== 'c') ? ',' : '.';
			 var separator = (decimalpoint=='c') ? '.':',';
			 var currentDecpoint = StringToolbox.getDecimalpointType(rawValue);
			 var currentSeparator = (currentDecpoint=='.')? ',':'.';
			 var valueStr=rawValue.toString();
			 var decimalparts = valueStr.split(currentDecpoint);
			 var integerparts = decimalparts[0].split(currentSeparator);
			 if (fixedDecimals && fixedDecimals>0) {
			 		var decparts=decimalparts[1]+'0000000000';
					var fixlimit=parseInt(fixedDecimals);
					var oneup= (decparts.charAt(fixedDecimals)>=5) ? 1: 0;
			 		decparts= decparts.substring(0,fixlimit);
					if (oneup!=0) {
						 decimalparts[1]=parseInt(decparts)+oneup;
					} else {
						 decimalparts[1]=decparts;
					}
			 }
			 decimalvalue = integerparts.join(separator)+decpoint+decimalparts[1];
		} else if (Decimal.isconverted) {
			 decimalvalue=Decimal.decimalnumber;
		} else {
			 decimalvalue=rawValue;
		}
		return decimalvalue;
	},
	
	_handleConvertToPointDecimal: function(rawValue,forcedDecPoint) {
			var decimalvalue;
			var fixedDecimals=0;
			var cleanValue=StringToolbox.removeChar(rawValue,' ');
			var decpoint = (forcedDecPoint) ? forcedDecPoint:StringToolbox.getDecimalpointType(cleanValue);
			if (decpoint ==',') {
				 cleanValue=StringToolbox.removeChar(cleanValue,'.');
				 var decimalparts = cleanValue.split(',');
				 decimalvalue=decimalparts[0]+'.';
				 decimalvalue += (decimalparts.length>1)? decimalparts[1]: '00';
			} else {
				 decimalvalue=cleanValue;
			}
			return decimalvalue;
	},
	
	_handleConvertToCommaDecimal: function(rawValue) {
			var decimalvalue;
			var fixedDecimals=0;
			var separator='';
			var Decimal=StringToolbox.isDecimalString(rawValue,'c',fixedDecimals);
			if (!Decimal.isdecimal) {
				 var decimalasstring=rawValue.toString();
				 var decimalparts = decimalasstring.split('.');
				 if (decimalparts[0].indexOf(',') != -1) {
				 		separator='.';
				 } else if (decimalparts[0].indexOf(' ') != -1) {
				 	  separator=' ';
				 }
				 var integerparts = decimalparts[0].split(',');
				 decimalvalue = integerparts.join(separator)+','+decimalparts[1];
			} else {
				 decimalvalue=rawValue;
			}
			return decimalvalue;
	},
	
	_handleFormatNumberFromExcel: function(field,rawValue,classParams) {
			var numberstring='';
			var decpoint= (classParams[0]=='p') ? '.':',';
			var separator;
			var integerpart=rawValue;
			var decimalpart='';
			switch (classParams[1]) {
						 case 'p': 
						 			separator='.';
									break;
						 case 's':
						 			separator= ' ';
									break;
						 default:
						 			separator=',';
						 			break;
			}
			if (rawValue.indexOf('.') != -1) {
				 var parts=rawValue.split('.');
				 integerpart=parts[0];
				 decimalpart=parts[1];
			}
			var cnt=0;
			for (var i=integerpart.length-1;i>=0;i--) {
					cnt++;
					if (cnt>3) {
						 numberstring = separator+numberstring;
						 cnt=1;
					}
					numberstring= integerpart.charAt(i)+numberstring;
			}
			if (decimalpart!='') {
				 numberstring = numberstring+decpoint+decimalpart;
			}
			return numberstring;
	},
	
	_handleRemove: function(field,classParams) {
				if (field.value!='') {
					 var valuestring=field.value;
					 if (classParams[0]=='leadingzeros') {
					 		field.value=StringToolbox.removeLeadingZeros(valuestring);
					 } else {
    				 var character='';
  					 for (var i=0;i<classParams.length;i++) {
    					 switch (classParams[i]) {
    					 		case 'space':
    									character=' '
    									break;
  								// <--insert other chrs here
  								default:
  										character=' '
  										break;
    					 }
  						 valuestring=StringToolbox.removeChar(valuestring,character);
  					 }
  					 field.value=valuestring;
						 if (field._bindexcel) {
						 		CalculatorToolbox._handleSetExcel(field,[]);
						 }
					 }
				}
	},
	
	_handleShow: function(field,classParams) {
				var self=CalculatorToolbox;
				var mode='on';
				var slaveField=document.getElementById(classParams[0]);
				if (field.type== 'select-one') {
					 if (DBcore.selectedValueOf(field)==slaveField) {
					 		DisplayToolbox.showElement(slaveField);
					 } else {
					 	  DisplayToolbox.hideElement(slaveField);
							mode='off';
					 }
				} else if (field.type == 'checkbox') {
					 if (field.checked) {
					 		DisplayToolbox.showElement(slaveField);
					 } else {
					 	  DisplayToolbox.hideElement(slaveField);
							mode='off';
					 }
				} else {
							DisplayToolbox.showElement(slaveField);
				}
				DBcore.removeClass(slaveField,'jshide');
				if (mode=='on') {
  				if (classParams[1]=='select' && (slaveField.tagName=='TEXTAREA' || slaveField.tagName=='INPUT' && (slaveField.type=='text' || slaveField.type=='password'))) {
    					 slaveField.focus();
    					 slaveField.select();
  	 			}
					if (mode=='on') {self._handleOnShowelement(slaveField);}
				}
	},
	
	_handleHideElementOnClick: function(target) {
				DisplayToolbox.hideElement(target);
	},
	
	_handleShowAlways: function(field,classParams) {
				var target=document.getElementById(classParams[0]);
				DisplayToolbox.showElement(target);
	},
	
	_handleHideAlways: function(field,classParams) {
				var target=document.getElementById(classParams[0]);
				DisplayToolbox.hideElement(target);
	},
	
	_handleHideMeOnChange: function(target) {
			  DisplayToolbox.hideElement(target);
	},
	
	_handleHideShowMeOnValue: function(target,classParams,mode) {
				var show = (mode=='show') ? true:false;
				if (classParams[0] && classParams[1]) {
  				var compareFieldValue=classParams[0].value;
  				var compareType=classParams[1];
					var compareValue=classParams[2];
					switch (compareType) {
								 case 'gth':
								 			if (compareFieldValue<=compareValue) {
												 show = !show;
											}
											break;
								 case 'lth':
								 			if (compareFieldValue>=compareValue) {
												 show = !show;
											}
											break;
								 default: // 'equal'
								 			if (compareFieldValue!=compareValue) {
												 show = !show;
											}
											break;
					}
					if (show) {
						 DisplayToolbox.showElement(target);
					} else {
						 DisplayToolbox.hideElement(target);
					}
				}
	},
	
	_handleHideShowMeOnChecked: function(target,classParams,mode) {
				var checkbox;
				var lastOperation='show';
				for (var i=0;i<classParams.length;i++) {
    				checkbox=document.getElementById(classParams[i]);
    				if (mode=='hide') {
    					 if (checkbox && checkbox.checked) {
							 		DisplayToolbox.hideElement(target);
									lastOperation='hide';
							 } else {
							 	 	DisplayToolbox.showElement(target);
							 }
    				} else {
    					 if (checkbox && checkbox.checked) {
							 		DisplayToolbox.showElement(target);
							 } else {
							 	  DisplayToolbox.hideElement(target);
									lastOperation='hide';
							 }
    				}
				}
				CalculatorToolbox.lastOnMeOperation=lastOperation;
	},

	_handleHideShowMeOnMultichecked: function(target,classParams,mode) { // mode='hide' not impl.
				var allchecked=true;
				var checkbox;
				for (var i=0;i<classParams.length;i++) {
  				checkbox=document.getElementById(classParams[i]);
  				if (!checkbox || !checkbox.checked) {
  					 allchecked=false;
  					 break;
  				}
				}
				if (allchecked) {
					 DisplayToolbox.showElement(target);
					 CalculatorToolbox.lastOnMeOperation='show';
				} else {
					 DisplayToolbox.hideElement(target);
					 CalculatorToolbox.lastOnMeOperation='hide';
				}
	},
	
	_handleHideShowMeOnSelected: function(target,classParams,mode) {
				var selectbox=document.getElementById(classParams[0]);
				var targetvalue=classParams[1];
				if (selectbox) {
					 var selectedvalue=DBcore.selectedValueOf(selectbox);
					 if (mode=='hide') {
					 		if (selectedvalue==targetvalue) {
  							DisplayToolbox.hideElement(target);
  							CalculatorToolbox.lastOnMeOperation='hide';
							}
					 } else {
					 	  if (selectedvalue==targetvalue) {
  							DisplayToolbox.showElement(target);
  							CalculatorToolbox.lastOnMeOperation='show';
							}
					 }
				}
	},
	
	_handleShowHideMeOnMultiOr: function(pcElement,classParams) {
			var showIt=false;
			var field;
			var testvalue;
			var value;
			var parmlength=classParams.length;
			if (parmlength%2==0) {
				 var i=0;
				 while (i<parmlength) {
				 		 field=document.getElementById(classParams[i]);
						 testvalue=classParams[i+1];
						 value = (field.type=='select-one')? DBcore.selectedValueOf(field): field.value;
						 if (value==testvalue) {
						 		showIt=true;
								break;
						 }
						 i=i+2;
				 }
			}
			if (showIt) {
				 DisplayToolbox.showElement(pcElement);
				 CalculatorToolbox.lastOnMeOperation='show';
			} else {
				 DisplayToolbox.hideElement(pcElement);
				 CalculatorToolbox.lastOnMeOperation='hide';
			}
	},
	
	_handleCopyToClipboard: function(button,classParts) {
	  var targetfield=document.getElementById(classParts[0]);
		if (targetfield !=null && ButtonToolbox.showIfClipboardData(button)) {
			 var theText=targetfield.value;
			 clipboardData.setData("Text",theText);
		}
	},
	
	_showCopyToClipButton: function() {
		var buttons = document.getElementsByTagName('button');
		for (var i=0;i<buttons.length;i++) {
				if (DBcore.hasTrigger(buttons[i],'copytoclipboard')) {
					 var active= ButtonToolbox.showIfClipboardData(buttons[i]);
				}
		}
	},
	
	_handleSelectMe: function(node,classParts) {
	   if (node.tagName=='TEXTAREA' || node.tagName=='INPUT' && (node.type=='text' || node.type=='password')) {
					 node.focus();
					 node.select();
  	 }
	},
	
	_handleClearfields: function(sourceobject,fields) {
		for (var i=0;i<fields.length;i++) {
		  document.getElementById(fields[i]).value='';
		}
	},
	
	_handleClearMeOnAnyChange: function(field) {
		switch(field.type) {
					case 'select-one':
							 field.selectedIndex=DBcore.findDefaultOption(field);
							 break;
					case 'checkbox':
							 field.value=field.defaultChecked;
							 break;
					case 'radio':
							 field.value=field.defaultChecked;
							 break;		 
					default:  // input text, textarea etc.
							 field.value=field.defaultValue;
							 break;
				}
	},
	
	_handleResetfields: function(sourceobject,fields) {
		var field=null;
		var fieldtype=null;
	  for (var i=0;i<fields.length;i++) {
				field=document.getElementById(fields[i]);
				switch(field.type) {
					case 'select-one':
							 field.selectedIndex=DBcore.findDefaultOption();
							 break;
					case 'checkbox':
							 field.value=field.defaultChecked;
							 break;
					case 'radio':
							 field.value=field.defaultChecked;
							 break;		 
					default:  // input text, textarea etc.
							 field.value=field.defaultValue;
							 break;
				}
		}
	},
	
	_handleRadioShow: function(radio,classParams) {
		if (radio.checked) {
				 var targetId=classParams[0];
				 if (radio.value==classParams[1]) {
				 		var target=document.getElementById(targetId);
				 		DisplayToolbox.showElement(target);
				 }
		}
	},
	
	_handleRadioHide: function(radio,classParams) {
		if (radio.checked) {
				 var targetId=classParams[0];
				 if (radio.value==classParams[1]) {
				 		var target=document.getElementById(targetId);
				 		DisplayToolbox.hideElement(target);
				 }
		}
	},
	
	_handleRadioMultihide: function(radio,classParams) {
		if (radio.checked) {
			 for (var i=0;i<classParams.length;i++) {
				 		var target=document.getElementById(classParams[i]);
			 		  if (target) {DisplayToolbox.hideElement(target);}
			 }
		}
	},
	
	_handleHideOn: function(mode,element,classParams) {
		var targetId;
		var tobehidden=true;
		var lock=false;
		if (element.type=='checkbox') {
			 targetId=classParams[0];
			 lock = (classParams[1]=='lock') ? true : false;
			 tobehidden = (element.checked) ? true : false;
		} else if (element.type=='select-one') {
			 targetId=classParams[1];
			 var selectedValue=DBcore.selectedValueOf(element);
			 tobehidden = (selectedValue==classParams[0]) ? true : false;
		}
		var target = document.getElementById(targetId);
  	if (target) {
    		if (tobehidden) {
    			 DisplayToolbox.hideElement(target);
    		} else if (!lock) {
    			 DisplayToolbox.showElement(target);
    		}
		}
	},
	
	_handleLockMeOnChange: function(pcElement,classParams,mode,sourceType) {
	    var lockit=false;
			var testvalue;
			if (sourceType=='number') {
    	    var sourcevalue= document.getElementById(classParams[0]).value;
					testvalue=classParams[1];
					switch (mode) { 
								 case 'less':
								 			if (sourcevalue<testvalue) {lockit=true}
											break;
								 case 'gteq':
								 			if (sourcevalue>=testvalue) {lockit=true}
											break;
								 case 'gt':
								 			if (sourcevalue>testvalue) {lockit=true}
											break;
								 case 'eq':
								 			if (sourcevalue==testvalue) {lockit=true}
											break;
								 case 'noteq':
								 			if (sourcevalue!=testvalue) {lockit=true}
											break;
					}
			} else if (sourceType=='check') {
					var sourcecheck= (document.getElementById(classParams[0]).checked=='checked') ? true:false;
					testvalue = (classParams[1]=='checked') ? true:false;
					if (sourcecheck==testvalue) {lockit=true;}
			}
			if (lockit) {
				 DisplayToolbox.lockElement(pcElement);
			}	else {
				 DisplayToolbox.unlockElement(pcElement);
			}
	},
	
	_handleSuggestPercentAmount: function(field,classParams) {
  			var percent = (classParams[2]) ? classParams[1]+'.'+classParams[2]:classParams[1];
  			percent=percent/100;
  			var targetvalue=document.getElementById(classParams[0]).value;
				targetvalue=StringToolbox.removeAllChars(targetvalue.toString());
				var minimumvalue=Math.round(percent*targetvalue);
				if (DBcore.hasTrigger(field,'number')) {
					 var params=DBcore.getTriggerParams(field,'number');
					 minimumvalue=CalculatorToolbox._handleFormatNumberFromExcel(null,minimumvalue.toString(),params);
				}
				if (field.value==0 || field.value=='') {
					 field.value=minimumvalue;
				} else if (field.value<minimumvalue) {
					 field.value=minimumvalue;
				}
	},
		
	_handleExitfields: function(element) {
	     var inputs=document.getElementsByTagName('input');
		 	 for (var i=0;i<inputs.length;i++) { 
			 		 inputs[i].blur();
			 }
	},
	
	_handleInsertFromURL: function() {
	   var self=CalculatorToolbox;
		 var fields=[];
		 var element;
		 var insertParams=[];
		 var urlParamValue;
		 var valuecomponents;
		 var urlParams = DBcore.getURLparams();
		 if (!self.elementsArePrepared) {self.prepareElementLists();}
		 for (var n=0;n<self.inputs.length;n++) {fields.push(self.inputs[n]);}
		 for (var n=0;n<self.selects.length;n++) {fields.push(self.selects[n]);}
		 for (var n=0;n<self.textareas.length;n++) {fields.push(self.textareas[n]);}
		 for (var i=0;i<fields.length;i++) {
		 		element=fields[i];
				if (DBcore.hasTrigger(element,'insertFromURL')) {
					 insertParams=DBcore.getTriggerParams(element,'insertFromURL');
					 urlParamValue=urlParams[insertParams[0]];
					 if (urlParamValue) {
    					 if (urlParamValue=='' && insertParams.length>1) {
    					 		urlParamValue=insertParams[1];
    					 }
    					 valuecomponents=urlParamValue.split('#');
    					 urlParamValue=valuecomponents[0];
    					 urlParamValue= decodeURIComponent(urlParamValue);
    					 switch(element.type) {
        									case 'select-one':
        											 DBcore.setSelectedValue(element,urlParamValue);
        											 break;
        									case 'radio':
        											 DBcore.setRadioValue(element,urlParamValue);
        											 break;
        									case 'checkbox':
        											 element.checked = (urlParamValue.toUpperCase()=='TRUE') ? true: false;
        											 break;
    											default:
    													 element.value=urlParamValue;
    													 break;
        			}
					}
				}
		 }
	},
	
	_handleToggleBy: function(ltElement,classParams,thelink) {
		var self=CalculatorToolbox;
	  var linkelementid=classParams[0];
		if (linkelementid ==thelink.id) {
    		var linkgroup = (classParams[1]) ? classParams[1]:'generic';
    		var aktiveElement=self.togglegroups[linkgroup][0];
    		if (aktiveElement) {
    			 DisplayToolbox.hideElement(aktiveElement);
    			 self.togglegroups[linkgroup][0]=null;
    		}
    		if (!aktiveElement ||(aktiveElement && aktiveElement.id!=ltElement.id)) {
    			 DisplayToolbox.showElement(ltElement);
    			 self.togglegroups[linkgroup][0]=ltElement;
    		}
		}
	},
	
	_setTracking: function(classFunction,ok) {
		var successStr = (ok)? 'true':'false';
		//if (toolEventFunction) toolEventFunction(classFunction,successStr);
	},
	
	_handleInfoMessage: function(field,classParams) {
	var id, messageType, width, height, left, top;
		(classParams[0]) ? id = classParams[0] : id = false;
		(classParams[1]) ? messageType = classParams[1] : messageType = false;
		(classParams[2]) ? width = classParams[2] : width = 100;
		(classParams[3]) ? height = classParams[3] : height = 100;
		(classParams[4]) ? left = classParams[4] : left = "center";
		(classParams[5]) ? top = classParams[5] : top = "center";	
		MessageHandler.newDiv(id, messageType, width, height, left ,top);	
		return true;
	},

	
	
	/* Formula section */
	
	LuhnMod10: function(testnumber) {
			 var verifier=-1;
			 var weight=2;
			 var testString=testnumber.toString();
			 var k=0;
			 var weightedSum=0;
			 var product=0;
			 var productStr='';
			 for (i=testString.length;i>0;i--) {
			 		 product=weight*testString.charAt(i-1);
					 if (product>9) {
					 		productStr=product.toString();
							weightedSum += (parseInt(productStr.charAt(0),10)+parseInt(productStr.charAt(1),10));
					 } else {
					 	  weightedSum += product;
					 }
					 weight= (weight==2)? 1:2;
			 }
			 var nearestUp10= 10*Math.ceil(weightedSum/10);
			 verifier = nearestUp10-weightedSum;
			 return verifier
	},
	
	MOD97: function(testnumber) {
	  var result=0;
		var rem=0;
		var goOn=true;
		var number=testnumber.toString();
		var snippet=number.substring(0,9);
		var rest=number.substring(9);
		while (goOn) {
					rem = snippet%97;
					if (rest !='') {
						 number=rem.toString()+rest.toString();
						 snippet=number.substring(0,9);
						 rest=number.substring(9);
					} else {
						 goOn=false;
					}
		}
		result=rem;
		return result;
	}
	
}