function $id(id, getByName) {
        if(typeof id == "undefined" || id == null) return null;
        if(Object.isObject(id)) {
        	if(typeof id.value != "undefined") 
	        	id.getValue = function() {
	                return this.value;
	        	}; 

        	return id;
        }
        
        var result = id;
        
        if (typeof Prototype != "undefined" && Prototype) {
                result = $(id);
        } else {
                result = document.getElementById(id);
        }
        if(!result && getByName) {
                var list = document.getElementsByName(id);
                if(list && list.length > 0) {
                        result = list[0];
                }
        }
        
        if(typeof result == "undefined" || result == null) return null;
        
        result.getValue = function() {
                return this.value;
        };
        
        return result;
}

Messages = {

	_values: {},
	
	add: function(code, message) {
		if(!code || !message) return;
		Messages._values["msg_" + code] = message;
	},
	
	get: function(code) {
		return Messages._values["msg_" + code];
	}
};

Msg = Messages;

function createHdn(container, name, value, id) {
	var hdn = document.createElement('INPUT');
	hdn.type = "hidden";
	if(name) {
		hdn.name = name;
	}
	if(value != "undefined") {
		hdn.value = value;
	}
	if(id) {
		hdn.id = id;
	}
	if(container) {
		container.appendChild(hdn);
	}
	return hdn;
}

function createSimpleTd(container, value) {
	var td = document.createElement('TD');
	td.innerHTML = value;
	if(container) {
		container.appendChild(td);
	}
	return td;
}

function createLinkTd(container, url, params, value, id) {
	var td = document.createElement('TD');
	td.appendChild(createLink(url, params, value, id));
	if(container) {
		container.appendChild(td);
	}
	return td;
}

function createLink(url, params, value, id) {
	if(!url) return;
	if(params && Object.isArray(params) && params.length > 0) {
		if(Object.isArray(params[0])) {
			for (var i = 0; i < params.length; i++) {
				url = addUrlParameter(url, params[i][0], params[i][1]);
			}
		} else {
			url = addUrlParameter(url, params[0], params[1]);
		}
	}
	var link = document.createElement('A');
	link.href = url;
	if(value) {
		link.innerHTML = value;
	}
	if(id) {
		link.id = id;
	}
	return link;
}

function createEditTd(container, value, name, id) {
	var td = document.createElement('TD');
	var input = document.createElement('INPUT');
	input.type = 'text';
	if(value) {
		input.value = value;
	}
	if(name) {
		input.name = name;
	}
	if(id) {
		input.id = id;
	}
	td.appendChild(input);
	if(container) {
		container.appendChild(td);
	}
	return td;
}

function createStandartDialog(id, _buttons) {
	Element.show(id);
	if(!_buttons) {
		_buttons = null;
	}
	var width = $id(id).style.width;
	var newDialog = new YAHOO.widget.Dialog(id, 
		{ width : width,
		  fixedcenter : true,
		  visible : false, 
		  constraintoviewport : true,
		  draggable: true,
		  buttons : _buttons
		}
	);
	
	Element.addClassName($id(id).parentNode, 'yui-skin-sam');
	Element.addClassName(id, 'main-dialog');
	newDialog.render();
	
	/*var newDialog = new Ext.BasicDialog(id, { 
        width:width,
        height:'400px',
        shadow:true,
        minWidth:300,
        minHeight:250,
        proxyDrag: true,
        visible : false 
	});
	newDialog.addKeyListener(27, newDialog.hide, newDialog);
	
	for ( var i = 0; i < _buttons.length; i++) {
		newDialog.addButton(_buttons[i].text, _buttons[i].handler, newDialog);
	}*/
	return newDialog;
}

function createDynamicSimpleDialog(id, container, dlgContent, width, height, _buttons, config) {
	var defConfig = {
		fixedcenter : true,
		visible : false, 
		constraintoviewport : false,
		draggable: true,
		buttons : _buttons,
		width: width,
		height : height
	};
	if(config) {
		for(prop in config) {
			defConfig[prop] = config[prop];
		}
	}
	var newDialog = new YAHOO.widget.Dialog(id, defConfig);
	if(dlgContent) {
		if(dlgContent.header) {
			newDialog.setHeader(dlgContent.header);
		}
		if(dlgContent.body) {
			newDialog.setBody(dlgContent.body);
		}
		if(dlgContent.footer) {
			newDialog.setFooter(dlgContent.footer);
		}
	}
	if(container) {	
		if(!$id(container)) {
			var div = document.createElement('DIV');
			div.id = container;
			document.body.appendChild(div);
		}
		Element.addClassName($id(container), 'yui-skin-sam');
		Element.show(container);
		newDialog.render(container);
	} else {
		newDialog.render();
	}
	Element.addClassName(id, 'main-dialog');
	return newDialog;
}

function showMessageDialog(name, msg, header, yesMsg, renderPlaceId) {
	handleYes = function() {this.hide();};
	var messageDialog =  
	   	new YAHOO.widget.SimpleDialog(name,  
	            { width: "300px", 
	              fixedcenter: true, 
	              visible: true, 
	              draggable: false, 
	              close: true, 
	              text: msg, 
	              icon: YAHOO.widget.SimpleDialog.ICON_HELP, 
	              constraintoviewport: true, 
	              buttons: [{ text:yesMsg, handler:handleYes}] 
	            });
	messageDialog.setHeader(header);
	messageDialog.render(renderPlaceId);
	return messageDialog;
}

Msg.add('unknownTypeOfUrl', 'Unknown type of url: ');

function loadFile(url, handler) {
	if(!url) return;
	
	append = function(fileref) {
		//document.getElementsByTagName("head")[0].appendChild(fileref);
		document.body.appendChild(fileref);
	};
	
	loadOneScript = function(url, handler) {
		var fileref = document.createElement('script');
		fileref.setAttribute("type","text/javascript");
		fileref.setAttribute("src", url);
		append(fileref);
	};
	
	loadOneCss = function(url, handler) {
		var fileref = document.createElement("link");
		fileref.setAttribute("rel", "stylesheet");
		fileref.setAttribute("type", "text/css");
		fileref.setAttribute("href", url);
		append(fileref);
	};
	
	chooseFileType = function(url, handler) {
		if(url.lastIndexOf(".js") == (url.length - ".js".length)) {
			loadOneScript(url, handler);
		} else if (url.lastIndexOf(".css") == (url.length - ".css".length)) {
			loadOneCss(url, handler);
		} else {
			alert(Msg.get('unknownTypeOfUrl') + url);
		}
	};
	
	if(Object.isArray(url)) {
		for ( var i = 0; i < url.length; i++) {
			chooseFileType(url[i], handler);
		}
	} else {
		chooseFileType(url, handler);
	}
}

function isNotEmpty(str) {
	return str && str != null && (str.strip?str.strip() != '':true) ; 
}

function isEmpty(str) {
	return !isNotEmpty(str);
}

function addUrlParameter (url, parameter, value) {
	if(!url) {
		url = '';
	}
	if(isNotEmpty(parameter) && isNotEmpty(value)) {
		if(url.indexOf('?') >= 0) {
			url += '&';
		} else {
			url += '?';
		}
		url += parameter + '=' + value;
	}
	return url;
}

function observeForChangeInputField(el, action) {
	Event.observe($id(el), 'keyup', action);
	Event.observe($id(el), 'keydown', action);
	Event.observe($id(el), 'keypress', action);
	Event.observe($id(el), 'change', action);
}

function serialize(element) {
	element = $id(element);
	if(element.nodeName == '#text') return null;
	
	if (!element.disabled && element.name && element.getValue) {
    	var value = element.getValue();
    	if(element.nodeName == 'INPUT' && element.type == 'checkbox'
			&& (element.checked == false || element.checked == "")) value = null;
      	if (value != undefined) {
        	var pair = { };
        	pair[element.name] = value;
        	return pair;
        }
    }
    return null;	
}

function serializeFrom (parent) {
	var resultAll = {};
	parent = $id(parent);
	if(parent && parent.hasChildNodes()) {
		var childs = parent.childNodes;
		for(var i=0; i<childs.length; i++) {
			var child = childs[i];
			var result = serialize(child);
			if(!result && child.hasChildNodes()) {
				result = serializeFrom(child);
			}
			if(result) {
				for(prop in result) {
					if(prop && !resultAll.prop) {
						resultAll[prop] = result[prop];
					}
				}
			}
		}
	}  
	return resultAll;
}

var serializeForm = serializeFrom;

//===================================================================================
//===================================VALIDATION======================================
//===================================================================================
Msg.add('requiredField', " is required field!");
Msg.add('validInteger', " is not valid integer!");
Msg.add('validEmail', " is not valid email!");

function validate(displayError) {
	if(displayError == undefined) displayError = true;
	var els = document.getElementsByTagName('*');
	var result = true;
	for (var i = 0; i < els.length; i++) {
		var el = els[i];
		if (Element.hasClassName(el, "v-required")) {
			result &= validateRequired(el, displayError);
		}
		if(Element.hasClassName(el, "v-int")) {
			result &= validateInteger(el, displayError);
		} else if (Element.hasClassName(el, "v-email")) {
			result &= validateEmail(el, displayError);
		}
	}
	return result;
}

function handleErrors(value, message, field) {
	//message = value + message;
	displayFieldErrors([{text: message, place: (field.id? field.id: field.name)}]);
}

function validateInteger(field) {
	var valid = true;
	var value = '';
	if ((field.type == 'hidden' ||
	    field.type == 'text' ||
      field.type == 'textarea' ||
      field.type == 'select-one' ||
      field.type == 'radio')) {

      // get field's value
      if (field.type == "select-one") {
      	var si = field.selectedIndex;
          if (si >= 0) {
          	value = field.options[si].value;
          }
      } else {
      	value = field.value;
      }

      if (value.length > 0) {
	        if (!jcv_isDecimalDigits(value)) {
	        	valid = false;
	        } else {
	        	var iValue = parseInt(value, 10);
	            if (isNaN(iValue) || !(iValue >= -2147483648 && iValue <= 2147483647)) {
		            valid = false;
	            }
	        }
      }
  }
	if(!valid && displayError) {
		handleErrors(value, Msg.get('validInteger'), field);
	}
  return valid;
}

function validateRequired(field, displayError) {
	var valid = true;

	if ((field.type == 'hidden' ||
		field.type == 'text' ||
      field.type == 'textarea' ||
      field.type == 'file' ||
      field.type == 'radio' ||
      field.type == 'checkbox' ||
      field.type == 'select-one' ||
      field.type == 'password')) {

      // get field's value
      if (field.type == "select-one") {
      	var si = field.selectedIndex;
          if (si >= 0) {
          	value = field.options[si].value;
          }
      } else if (field.type == 'radio' || field.type == 'checkbox') {
      	if (field.checked) {
      		value = field.value;
          }
      } else {
      	value = field.value;
      }

      if (trim(value).length == 0) {
          valid = false;
      }
  } else if (field.type == "select-multiple") { 
  	var numOptions = field.options.length;
      lastSelected=-1;
      for(loop=numOptions-1;loop>=0;loop--) {
      	if(field.options[loop].selected) {
      		lastSelected = loop;
              value = field.options[loop].value;
              break;
          }
      }
      if(lastSelected < 0 || trim(value).length == 0) {
      	valid=false;
      }
  } else if ((field.length > 0) && (field[0].type == 'radio' || field[0].type == 'checkbox')) {
  	isChecked=-1;
      for (loop=0;loop < field.length;loop++) {
      	if (field[loop].checked) {
      		isChecked=loop;
              break; // only one needs to be checked
          }
      }
      if (isChecked < 0) {
          valid=false;
      }
  } 
	if(!valid && displayError) {
		handleErrors(value, Msg.get('requiredField'), field);
	}
  return valid;
}

function validateEmail(field, displayError) {
	var valid = true;
	var value = '';

  if ((field.type == 'hidden' || 
  	field.type == 'text' ||
      field.type == 'textarea') &&
      (field.value.length > 0)) {
  	value = field.value;
      if (!jcv_checkEmail(value)) {
      	valid = false;
      }
  }
  if(!valid && displayError) {
		handleErrors(value, Msg.get('validEmail'), field);
	}
  return valid;
}

function jcv_checkEmail(emailStr) {
  if (emailStr.length == 0) {
      return true;
  }
  // TLD checking turned off by default
  var checkTLD=0;
  var knownDomsPat=/^(com|net|org|edu|int|mil|gov|arpa|biz|aero|name|coop|info|pro|museum)$/;
  var emailPat=/^(.+)@(.+)$/;
  var specialChars="\\(\\)><@,;:\\\\\\\"\\.\\[\\]";
  var validChars="\[^\\s" + specialChars + "\]";
  var quotedUser="(\"[^\"]*\")";
  var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/;
  var atom=validChars + '+';
  var word="(" + atom + "|" + quotedUser + ")";
  var userPat=new RegExp("^" + word + "(\\." + word + ")*$");
  var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$");
  var matchArray=emailStr.match(emailPat);
  if (matchArray==null) {
      return false;
  }
  var user=matchArray[1];
  var domain=matchArray[2];
  for (i=0; i<user.length; i++) {
      if (user.charCodeAt(i)>127) {
          return false;
      }
  }
  for (i=0; i<domain.length; i++) {
      if (domain.charCodeAt(i)>127) {
          return false;
      }
  }
  if (user.match(userPat)==null) {
      return false;
  }
  var IPArray=domain.match(ipDomainPat);
  if (IPArray!=null) {
      for (var i=1;i<=4;i++) {
          if (IPArray[i]>255) {
              return false;
          }
      }
      return true;
  }
  var atomPat=new RegExp("^" + atom + "$");
  var domArr=domain.split(".");
  var len=domArr.length;
  for (i=0;i<len;i++) {
      if (domArr[i].search(atomPat)==-1) {
          return false;
      }
  }
  if (checkTLD && domArr[domArr.length-1].length!=2 && 
      domArr[domArr.length-1].search(knownDomsPat)==-1) {
      return false;
  }
  if (len<2) {
      return false;
  }
  return true;
}

/**
* Check a value only contains valid decimal digits
* @param argvalue The value to check.
*/
function jcv_isDecimalDigits(argvalue) {
  argvalue = argvalue.toString();
  var validChars = "0123456789";

  var startFrom = 0;
  if (argvalue.charAt(0) == "-") {
      startFrom = 1;
  }

  for (var n = startFrom; n < argvalue.length; n++) {
      if (validChars.indexOf(argvalue.substring(n, n+1)) == -1) return false;
  }
  return true;
}

//Trim whitespace from left and right sides of s.
function trim(s) {
  return s.replace( /^\s*/, "" ).replace( /\s*$/, "" );
}

//----------------------- END VALIDATION --------------------------------------

function createHiddenParam(form, name, value) {
	var el = getElementByName(name);
	if(!el) {
		createHdn(form, name, value)
	} else {
		el.value = value;
	}
}

function getElementByName(name) {
	var list = document.getElementsByName(name);
	return list.length > 0? list[0]: null;
}

function getFormBySource(source) {
	var form = null;
	if (source!=undefined && source.form!=undefined) {
		form = source.form;
	} else {
		findParentForm = function(element) {
			 if (element==undefined) {
			 	return null;
			 }
			 var parent=element.parentNode;
			 while(parent!=null && parent.tagName.toLowerCase()!="form"){
			   parent=parent.parentNode;
			 }
			 return parent;
		};
		form = findParentForm(source);
	}
	return form;
}

function fillFormWithObject(container, name, object) {
	var fillLevel = function(parent) {
		if($id(parent).name) {
			var result = null;
			
			var getValueByPath = function(name, objectName, object) {
				if(result) return;
				if(name.indexOf(objectName) == 0) {
					if(name.indexOf(".") > 0 && name.indexOf(".") < name.length) {
						name = name.substring(name.indexOf(".") + 1, name.length);
						objectName = name.indexOf(".") < 0? name: name.substring(0, name.indexOf("."));
						if(object[objectName] != undefined) {
							getValueByPath(name, objectName, object[objectName]);
						}
					} else {
						result = object;
					}
				}
			};
			
			getValueByPath($id(parent).name, name, object);
			if(result != "undefined") {
				Form.Element.setValue($id(parent), result);
			}
		}
		for(var i = 0; i < $id(parent).childNodes.length; i++) {
			fillLevel($id(parent).childNodes[i]);
		}
	};
	fillLevel(container);
}

function findChild(el, childProps, recursive) {
	var recursiveF = function(el){return el.hasChildNodes();};
	if(recursive == false) recursiveF = null;
	
	return findElement(el, childProps, 
			function(el, number){return number == 0? el.childNodes[number]: el.nextSibling},
			recursiveF);
}

function findParent(el, parentProps) {
	return findElement(el, parentProps, function(el) {return el.parentNode});
}

function findPrevSibling(el, siblingProps) {
	return findElement(el, siblingProps, function(el) {return el.previousSibling});
}

function findNextSibling(el, siblingProps) {
	return findElement(el, siblingProps, function(el) {return el.nextSibling});
}

function findSibling(el, siblingProps) {
	if(el.parentNode) {
		return findChild(el.parentNode, siblingProps, false);
	}
} 

function findElement(el, targetProps, method, recursive) {
	if(!el || !targetProps) return;
	
	var i = 0;
	var next = method(el, i);
	while(next) {
		var result = true;
		//check properties
		for(prop in targetProps) {
			result = result && next[prop] == targetProps[prop];
		}
		//return found if properties matches
		if(result) return next;
		//if recursive is on check than act
		if(recursive && recursive(next)) {
			var found = findElement(next, targetProps, method, recursive);
			if(found) return found;
		}
		//get next element for iteration
		next = method(next, ++i);
	}
	return null;
}

function appendAfter(node, newNode) {
	if(!node || !newNode || !node.parentNode) return;
	if(node.nextSibling) node.parentNode.insertBefore(newNode, node.nextSibling);
	else node.parentNode.appendChild(newNode);
}

function addActionTo(action, className) {
	var targetBtn = document.getElementsByClassName(className);
	for(var i = 0; i < targetBtn.length; i++) {
		targetBtn[i].onclick = action;
	}
}

function addObserverTo(action, className) {
	var targetBtn = document.getElementsByClassName(className);
	for(var i = 0; i < targetBtn.length; i++) {
		Event.observe(targetBtn[i], 'click', action);
	}
}

FormManager = {
	
	formActionId : 'FormActionHdn',
		
	elements: [],
	
	actionMechanismApplied: false,
	
	applyActionMechanism : function(waitForLoad) {
		if(FormManager.actionMechanismApplied) return;
		if(waitForLoad) {
			Event.observe(window, 'load', function() {
				FormManager.applyActionMechanism(false);
			});
		} else {
			var actionBtns = document.getElementsByTagName('INPUT');
			for(var i = 0; i < actionBtns.length; i++) {
				if(actionBtns[i].type == 'submit' || actionBtns[i].type == 'button') {
					var clickBtnF = function(source) {
						var form = FormManager.findForm(source);
						if(form) {
							var formAction = findChild(form, {id: FormManager.formActionId}, true);
							if(!formAction) {
								formAction = createHdn(form, 'empty', '', FormManager.formActionId);
							}
							formAction.name = source.name;
							formAction.value = source.value;
						}
						return true;
					}
					if(actionBtns[i].onclick) {
						actionBtns[i].nativeClick = actionBtns[i].onclick;
						actionBtns[i].onclick = function(e) {
							clickBtnF(this);
							this.nativeClick();
						}
					} else {
						Event.observe(actionBtns[i], 'click', function(e) {
							return clickBtnF(e.element());
						});
					}
				}
			}
			FormManager.actionMechanismApplied = true;
		}
	}, 
	
	addValidator : function(el, validator) {
		if(!el || !validator) return;
		var form = FormManager.findForm(el);
		var exist = false;
		for(var i = 0; i < FormManager.elements.length; i++) {
			if(FormManager.elements[i].el == form) {
				exist = true;
				form = FormManager.elements[i];
				break;
			}
		}
		if(!exist) {
			form = new ValidationForm(form);
		}
		//form now Form Class object
		form.enableValidation();
		form.addValidator(validator);
	},
	
	addRequiredValidator: function(id, action) {
		FormManager.addValidator(id, new Validator(function() {
			if(!validateRequired($id(id), false)) 
				throw {text: Msg.get('requiredField'), place: id};
		}, action, false));
	},
	
	getForm: function(form) {
		for(var i = 0; i < FormManager.elements.length; i++) {
			if(FormManager.elements[i].el == form) {
				return FormManager.elements[i];
			}
		}
	},
	
	findForm: function(element) {
		return findParent($id(element), {nodeName: "FORM"});
	}
}

var ValidationForm = Class.create();

ValidationForm.prototype = {
		
	el: null,
	validators: [],
	processValidators: [],
	errors: [],
	validationEnabled: false,
	mainOnSubmit: null,
	mainSubmit: null,
		
	initialize: function(el) {
		if(!el) return;
		//find by parent
		if(el.nodeName != 'FORM') {
			this.el = FormManager.findForm(el);
		} else {
			this.el = $id(el);
		}
		var exist = false;
		for(var i = 0; i < FormManager.elements.length; i++) {
			if(FormManager.elements[i].el == this.el) {
				exist = true;
				break;
			}
		}
		if(!exist) {
			FormManager.elements[FormManager.elements.length] = this;
		}
	},
	
	addValidator: function(validator, enableValidation) {
		this.validators[this.validators.length] = validator;
		if(enableValidation) {
			this.enableValidation(enableValidation);
		}
	},
	
	enableValidation: function() {
		if(this.validationEnabled) return;
		
		if(!this.mainOnSubmit) this.mainOnSubmit = this.el.onsubmit;
		this.el.onsubmit = function() {return false;}
		
		var self = this;
		Event.observe(this.el, 'submit', function(e) {self.validate(self);});
		
		if(!this.mainSubmit) this.mainSubmit = this.el.submit;
		this.el.submit = function() {self.validate(self);}
		
		this.validationEnabled = true;
	},

	validate: function(self) {
		if(!self) self = this;
		
		self.errors = [];
		self.processValidators = [];
		for(var i = 0; i < self.validators.length; i++) {
			if(self.validators[i].matchAction(self._getAction())) {
				self.processValidators[self.processValidators.length] = self.validators[i];
			}
		}
		clearAllMessages();
		
		try {
			this._innerValidate(self);
		} catch (e) {alert(e);}
	},
	
	_innerValidate: function(self, error) {
		if(!self) self = this;
		if(error) {
			self.outPutError(error);
		}
		if(self.processValidators.length == 0) {
			self._submitAfterValidation();
			return;
		}
		while(self.processValidators.length > 0) {
			var validator = self.processValidators.splice(0, 1)[0];
			var callback = null;
			if(validator.isAjax()) {
				callback = function(error) {
					self._innerValidate(self, error);
				};
			}
			try {
				var result = validator.validate(callback);
				if(validator.isAjax() && result) return;
			} catch (e) {
				self.outPutError(e);
			}
		}
		if(self.processValidators.length == 0) {
			self._submitAfterValidation();
		}
	},
	
	_submitAfterValidation: function() {
		if(this.errors.length == 0) {
			if(this.mainOnSubmit) {
				this.mainOnSubmit();
			}
			this.submit();
		}
	},
	
	_getAction: function() {
		var actionSource =  this._getActionSource();
		return actionSource? (actionSource.value? actionSource.value: actionSource): null;
	},
	
	_getActionSource: function() {
		if(!this.el) return null;
		return findChild(this.el, {id: FormManager.formActionId}, true);
	},
	
	outPutError: function(error) {
		this.errors[this.errors.length] = error;
		if(Object.isString(error)) {
			displayErrorMessages(error);
		} else if (error.text) {
			displayFieldErrors(error);
		}
	},
	
	submit: function() {
		var actionSource =  this._getActionSource();
		if(actionSource && actionSource.name && actionSource.value) {
			createHdn(this.el, actionSource.name, actionSource.value);
		}
		if(!this.el) return;
		if(this.mainSubmit) {
			this.el.submit = this.mainSubmit;
		}
		this.el.submit();
	}	
};

var Validator = Class.create();

Validator.prototype = {
		
	_target : null,
	_action: null,
	_actions: [],
	_ajax : false,

	initialize: function(func, action, ajax) {
		this._target = func;
		this._action = action;
		this._ajax = ajax;
		
		if(this._action && this._action.indexOf(',') >= 0) {
			this._actions = this._action.split(',');
			for(var i = 0; i < this._actions.length; i++) {
				this._actions[i] = this._actions[i].strip();
			}
		}
	},
	
	validate: function(callback) {
		return this._target(callback);
	},
	
	matchAction: function(action) {
		if(!action) return !this._action;
		if(this._actions.length > 0) {
			for(var i = 0; i < this._actions.length; i++) {
				if(this._actions[i] == action) return true;
			}
		}
		return this._action == action;
	},
	
	isAjax: function() {
		return this._ajax;
	}
};


Msg.add('wrongCurrency', "Please input correct date by pattern ");
AdminCurrency = {
		
	enableValidation: function(source, action, forInput) {
		if(!source)return;
		source = $id(source);
		
		FormManager.addValidator(source, new Validator(function(callback) {
			if(!source.value || source.value.strip() == '') return false;
			parseCurrency(source.value, function(result) {
				var error = null;
				if(!result.validCurrency) {
					error = {text: Msg.get('wrongCurrency') + result.currencyPattern, 
						place: source.id? source.id: source.name};
				}
				if(callback) callback(error);
			}, null, forInput);
			return true;
		}, action, true));
	} 
}

var FORMAT_URL = "format.admin";

function formatDate(year, month, day, callback, vendorId) {
	if(typeof VENDORID == "undefined" || !VENDORID) {
		VENDORID = vendorId;
	}
	//starts from 0
	month = month - 1;
	AjaxActionSynchronizer.execute(new SimpleAjaxAction(FORMAT_URL, "GET"),
		null,  {
			year: year,
			month: month,
			day: day,
			vid: VENDORID
		}, callback
	);
}

function parseDate(date, callback, vendorId) {
	if(typeof VENDORID == "undefined" || !VENDORID) {
		VENDORID = vendorId;
	}
	AjaxActionSynchronizer.execute(new SimpleAjaxAction(FORMAT_URL, "GET"),
		null,  {
			date: date,
			vid: VENDORID
		}, callback
	);
}

function formatCurrency(value, callback, vendorId, forInput) {
	if(typeof VENDORID == "undefined" || !VENDORID) {
		VENDORID = vendorId;
	}
	if(typeof forInput == "undefined" || !forInput) {
		forInput = "false";
	}
	AjaxActionSynchronizer.execute(new SimpleAjaxAction(FORMAT_URL, "GET"),
		null,  {
			value: value,
			vid: VENDORID,
			currencyForInput: forInput
		}, callback
	);
}

function parseCurrency(value, callback, vendorId, forInput) {
	if(typeof VENDORID == "undefined" || !VENDORID) {
		VENDORID = vendorId;
	}
	if(typeof forInput == "undefined" || !forInput) {
		forInput = "false";
	}
	AjaxActionSynchronizer.execute(new SimpleAjaxAction(FORMAT_URL, "GET"),
		null,  {
			currencyValue: value,
			vid: VENDORID,
			currencyForInput: forInput
		}, callback
	);
}