// mozXPath [http://km0ti0n.blunted.co.uk/mozxpath/] km0ti0n@gmail.com
// Code licensed under Creative Commons Attribution-ShareAlike License 
// http://creativecommons.org/licenses/by-sa/2.5/
if( document.implementation.hasFeature("XPath", "3.0") ){
	if( typeof XMLDocument == "undefined" ){ XMLDocument = Document; }
  XMLDocument.prototype.selectNodes = function(cXPathString, xNode){
    if( !xNode ) { xNode = this; } 
		var oNSResolver = this.createNSResolver(this.documentElement);
		var aItems = this.evaluate(cXPathString, xNode, oNSResolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
		var aResult = [];
		for( var i = 0; i < aItems.snapshotLength; i++){aResult[i] =  aItems.snapshotItem(i);	}
		return aResult;
	}
	XMLDocument.prototype.selectSingleNode = function(cXPathString, xNode){
		if( !xNode ) { xNode = this; } 
		var xItems = this.selectNodes(cXPathString, xNode);
		if( xItems.length > 0 ){return xItems[0];	}
		else{return null;	}
	}
	Element.prototype.selectNodes = function(cXPathString){
		if(this.ownerDocument.selectNodes){	return this.ownerDocument.selectNodes(cXPathString, this);}
		else{throw "For XML Elements Only";}
	}
	Element.prototype.selectSingleNode = function(cXPathString){	
		if(this.ownerDocument.selectSingleNode){return this.ownerDocument.selectSingleNode(cXPathString, this);	}
		else{throw "For XML Elements Only";}
	}
}

//-------------------------------------------------------------------
// Trim functions
//   Returns string with whitespace trimmed
//-------------------------------------------------------------------
function LTrim(str){
	if (str==null){return null;}
	for(var i=0;str.charAt(i)==" ";i++);
	return str.substring(i,str.length);
	}
function RTrim(str){
	if (str==null){return null;}
	for(var i=str.length-1;str.charAt(i)==" ";i--);
	return str.substring(0,i+1);
	}
function Trim(str){return LTrim(RTrim(str));}
function LTrimAll(str) {
	if (str==null){return str;}
	for (var i=0; str.charAt(i)==" " || str.charAt(i)=="\n" || str.charAt(i)=="\t"; i++);
	return str.substring(i,str.length);
	}
function RTrimAll(str) {
	if (str==null){return str;}
	for (var i=str.length-1; str.charAt(i)==" " || str.charAt(i)=="\n" || str.charAt(i)=="\t"; i--);
	return str.substring(0,i+1);
	}
function TrimAll(str) {
	return LTrimAll(RTrimAll(str));
	}
//-------------------------------------------------------------------
// isNull(value)
//   Returns true if value is null
//-------------------------------------------------------------------
function isNull(val){return(val==null);}

//-------------------------------------------------------------------
// isBlank(value)
//   Returns true if value only contains spaces
//-------------------------------------------------------------------
function isBlank(val){
	if(val==null){return true;}
	for(var i=0;i<val.length;i++) {
		if ((val.charAt(i)!=' ') && (val.charAt(i)!="\t") && (val.charAt(i)!="\n") && (val.charAt(i)!="\r")){return false;}
		}
	return true;
	}

//-------------------------------------------------------------------
// isInteger(value)
//   Returns true if value contains all digits
//-------------------------------------------------------------------
function isInteger(val){
	if (isBlank(val)){return false;}
	for(var i=0;i<val.length;i++){
		if(!isDigit(val.charAt(i))){return false;}
		}
	return true;
	}

//-------------------------------------------------------------------
// isNumeric(value)
//   Returns true if value contains a positive float value
//-------------------------------------------------------------------
function isNumeric(val){return(parseFloat(val,10)==(val*1));}

//-------------------------------------------------------------------
// isArray(obj)
// Returns true if the object is an array, else false
//-------------------------------------------------------------------
function isArray(obj){return(typeof(obj.length)=="undefined")?false:true;}

//-------------------------------------------------------------------
// isDigit(value)
//   Returns true if value is a 1-character digit
//-------------------------------------------------------------------
function isDigit(num) {
	if (num.length>1){return false;}
	var string="1234567890";
	if (string.indexOf(num)!=-1){return true;}
	return false;
	}



var ITEM_METHOD_INSERT = "INSERT";
var ITEM_METHOD_UPDATE = "UPDATE";
var ITEM_METHOD_DELETE = "DELETE";

function MSG_RequiredFieldEval(strColumnAlias, strColumnUI){
	alert("El campo \"" + strColumnUI + "\" es obligatorio.\nDebe introducir un valor.");
	//eval(strColumnAlias+".focus()");
	return false;
}

function MSG_RequiredField(objColumnAlias, strColumnUI){
	alert("El campo \"" + strColumnUI + "\" es obligatorio.\nDebe introducir un valor.");
	//objColumnAlias.focus();
	return false;
}

function MSG_WrongField(objColumnAlias, strColumnUI, strType){
	alert("El campo \"" + strColumnUI + "\" no es correcto.\nDebe introducir un valor de tipo " + strType);
	//objColumnAlias.focus();
	return false;
}

function MSG_WrongFormat(objColumnAlias, strColumnUI, strFormat){
	alert("El campo \"" + strColumnUI + "\" no es correcto.\nDebe introducir un valor con formato " + strFormat);
	//objColumnAlias.focus();
	return false;
}

function MSG_Alert(objColumnAlias, strAlert){
	alert(strAlert);
	//objColumnAlias.focus();
	return false;
}

function ValidateDate(objColumnAlias){
	TestDate = /\d\d\/\d\d\/\d\d\d\d/;
	if (TestDate.test(objColumnAlias)) return true;
	else return false;
}

//La siguiente función se encuentra replicada en Portal/Index.ascx con el nombre 'sendXmlRequest'
function sendXml(strURL,strXmlRequest, strMethod){
	//strXmlRequest = strXmlRequest.replace(/&/g, "__AMP__");
	var xmlhttp = new ActiveXObject("Msxml2.XMLHTTP");
	xmlhttp.Open("POST", strURL + strMethod, false);
	xmlhttp.setRequestHeader ("Content-Type", "application/x-www-form-urlencoded");
	//xmlhttp.setRequestHeader ("Content-Type", "text/html; charset=utf-8");
	xmlhttp.setRequestHeader ("Content-Length", strXmlRequest.length);
	xmlhttp.Send(strXmlRequest);
	return xmlhttp.responseXML;
}

function ServerCall(sURL, sMethod, sNameSpace)
{
	// Initialize the prototype
	if (typeof(_bSCPrototypeCalled) == 'undefined') _SC__Prototype();

	// public propeties
	this.URL = sURL;
	this.Method = sMethod;
	this.NameSpace = sNameSpace;

	this._SoapMsg = "";
	this.Parameters = new Array();
	this.CallReturn = _CallReturn;
}

function _CallReturn(){
	this.hasError = false;
	this.ErrorNumber = 0;
	this.ErrorDescription = "";
	this.returnValue = null;
}

function _SC__Prototype()
{

	//public methods
	ServerCall.prototype.AddParameter = _SC_AddParameter;
	ServerCall.prototype.Send = _SC_Send;
	ServerCall.prototype._ShowInternalError = _SC__ShowInternalError;
	ServerCall.prototype._IsError = _SC__IsError;
	
	_bSCPrototypeCalled = 1;
	
	//---------------------------------------------------------------------------------------
	//	Method: _SC_AddField
	//			Este metodo se usa para añadir parametros a la llamada a SOAP
	//---------------------------------------------------------------------------------------
	function _SC_AddParameter(Parameter)
	{
		this.Parameters.length += 1;
		this.Parameters[(this.Parameters.length - 1)] = Parameter;
	}

	//---------------------------------------------------------------------------------------
	//	Method: _SC_Send
	//			Este metodo se usa para realizar la llamada al servidor
	//---------------------------------------------------------------------------------------
	function GetXMLHTTP()
	{
		var http_request = false;

		if (window.XMLHttpRequest) {
			http_request = new XMLHttpRequest(); 
			if (http_request.overrideMimeType) {
                		http_request.overrideMimeType('text/xml');
                        }

		} else if (window.ActiveXObject) {
			http_request = new ActiveXObject("Microsoft.XMLHTTP"); 
		} 

		return http_request;
	}
	
	function _SC_Send()
	{
		this._SoapMsg = "";
		this._SoapMsg += "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
		this._SoapMsg += "<soap:Envelope xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">";
		this._SoapMsg += "  <soap:Body>";
		this._SoapMsg += "    <" + this.Method + " xmlns=\"" + this.NameSpace + "\">";

		for (i=0; i<this.Parameters.length; i++)
		{
			//this._SoapMsg += "      <" + this.Parameters[i].name + "><![CDATA[" + this.Parameters[i].value + "]]></" + this.Parameters[i].name + ">";
			this._SoapMsg += "      " + xml_crearElemento(this.Parameters[i].name,this.Parameters[i].value);
		}

		this._SoapMsg += "    </" + this.Method + ">";
		this._SoapMsg += "  </soap:Body>";
		this._SoapMsg += "</soap:Envelope>";
		
		//http = new ActiveXObject("Microsoft.XMLHTTP");

		http = GetXMLHTTP();
		http.open("POST", this.URL, false);
		http.setRequestHeader("Content-Type","text/xml; charset=utf-8");
		http.setRequestHeader("Content-Length",this._SoapMsg.length);
		http.setRequestHeader("SOAPAction",this.NameSpace + this.Method);
		http.send(this._SoapMsg);

		if ((http.status != 200) || (http.readyState != 4))
		{
			var faultCode = http.responseXML.selectSingleNode("//soap:Fault/faultcode").text
			var faultString = http.responseXML.selectSingleNode("//soap:Fault/faultstring").text
			var Detail = http.responseXML.selectSingleNode("//soap:Fault/detail").text
			this.CallReturn.hasError=true;
			this.CallReturn.ErrorDescription = "FaultCode: " + faultCode + "\n" + "FaultString: " + faultString + "\n" + "Detail: " + Detail;
		}
		else 
		{
			this.CallReturn.hasError=false;
			//this.CallReturn.returnValue=http.responseText;
			
			//var objReturn = http.responseXML.documentElement.selectSingleNode("//" + this.Method + "Result/RETURN").childNodes(0);
			var objReturn;

			if (http.responseXML.selectSingleNode("//" + this.Method + "Result/ERROR/MESSAGE") != null)
			{
				this.hasError = true;
				this.CallReturn.hasError = true;
				this.CallReturn.returnValue = http.responseXML.selectSingleNode("//" + this.Method + "Result/ERROR/MESSAGE").text;
				return;
			}else if(http.responseXML.selectSingleNode("//" + this.Method + "Result/RETURN/ERROR/MESSAGE") != null)
			{
				this.hasError = true;
				this.CallReturn.hasError = true;
				this.CallReturn.returnValue = http.responseXML.selectSingleNode("//" + this.Method + "Result/RETURN/ERROR/MESSAGE").text;
				return;
			}

			if (window.ActiveXObject)
			{
				objReturn = http.responseXML.selectSingleNode("//" + this.Method + "Result/RETURN").childNodes(0);
			}
			else
			{
				objReturn = http.responseXML.getElementsByTagName("RETURN")[0].firstChild;
			}

			if (objReturn != null)
			{
				if (window.ActiveXObject)
				{
					this.CallReturn.returnValue=objReturn.xml;
				}
				else
				{
					this.CallReturn.returnValue=objReturn.data;
				}
			}
			else
			{
				this.CallReturn.returnValue="";
			}
		}
		
		return this.CallReturn;
	}
	
	//---------------------------------------------------------------------------------------
	//	Method: _SC__ShowInternalError
	//---------------------------------------------------------------------------------------
	function _SC__ShowInternalError()
	{
		
	}

	//---------------------------------------------------------------------------------------
	//	Method: _SC_IsError
	//			Determina si se ha devuelto un error
	//---------------------------------------------------------------------------------------
	function _SC__IsError(docXML, WebServiceMethod)
	{
		if (docXML.responseXML.selectSingleNode("//" + WebServiceMethod + "Result/ERROR") != null) 
		{
			this.CallReturn.hasError=true;
			if (docXML.responseXML.selectNodes("//" + WebServiceMethod + "Result/ERROR/DESCRIPTION").length != 0)
				this.CallReturn.ErrorDescription = docXML.responseXML.selectSingleNode("//" + WebServiceMethod + "Result/ERROR/DESCRIPTION").text;
			else if (docXML.responseXML.selectNodes("//" + WebServiceMethod + "Result/ERROR/MESSAGE").length != 0)
				this.CallReturn.ErrorDescription = docXML.responseXML.selectSingleNode("//" + WebServiceMethod + "Result/ERROR/MESSAGE").text;
			if (docXML.responseXML.selectNodes("//" + WebServiceMethod + "Result/ERROR/NUMBER").length != 0)
				this.CallReturn.ErrorNumber = docXML.responseXML.selectSingleNode("//" + WebServiceMethod + "Result/ERROR/NUMBER").text;
		}
		else
		{
			this.CallReturn.hasError = false;
			try
			{
				this.CallReturn.returnValue = docXML.responseXML.selectSingleNode("//" + WebServiceMethod + "Result/RETURN").childNodes(0).xml;
			}
			catch (ex)
			{
				this.CallReturn.returnValue = "";
			}
		}
	}	
	

}



function SC_Parameter(sName, sValue)
{
	this.name = sName;
	this.value = sValue;
}


function NavigateURL(strURL){
	window.navigate(strURL + "?" + g_strURLParams);
}

function DisableLeftIndex(bolDisable){
	if (bolDisable) 
	{
		if (Link_A.length>0)
		{
			for(i=0; i<Link_A.length; i++){
				Link_A[i].style.display = "none";
				Link_Span[i].style.display = "";
			}
		}
		else
		{
			Link_A.style.display = "none";
			Link_Span.style.display = "";
		}
	}
	else
	{
		if (Link_A.length>0)
		{
			for(i=0; i<Link_A.length; i++){
				Link_A[i].style.display = "";
				Link_Span[i].style.display = "none";
			}
		}
		else
		{
			Link_A.style.display = "";
			Link_Span.style.display = "none";
		}
	}
}

// Actualiza las URL's de los links de la barra de navegación de la izquierda.
function UpdateLinks(strURLParams) 
{
	var strHref = "";
	var strURL = "";
	var strParams = "";
	if (Link_A.length>0) 
	{
		for (j=0; j<Link_A.length; j++) 
		{
			strHref = Link_A[j].href;
			// URL
			strURL = strHref.split("?")[0];
			Link_A[j].href = strURL + "?" + strURLParams;
			// Parametros de la URL
			//strParams = strHref.split("?")[1];
			
			// Por el momento se presupone que se "machaca" todos los parametros de la URL
			// es decir, que solo tiene un parametro y que actualiza este único parametro.
			// En caso de tener mas de un parametro en la URL y solo desear modificar alguno 
			// de ellos es necesario implentar el cuerpo de esta función
			//strHref = strURL + "?" + strURLParams;
			//Link_A[j].href = strHref;
		}
	}
	else
	{
		strHref = Link_A.href;
		// URL
		strURL = strHref.split("?")[0];
		// Parametros de la URL
		strParams = strHref.split("?")[1];
		Link_A.href = strURL + "?" + strURLParams;
		
		// Por el momento se presupone que se "machaca" todos los parametros de la URL
		// es decir, que solo tiene un parametro y que actualiza este único parametro.
		// En caso de tener mas de un parametro en la URL y solo desear modificar alguno 
		// de ellos es necesario implentar el cuerpo de esta función
		//strHref = strURL + "?" + strURLParams;
		//Link_A.href = strHref;
	}
}


function IsResponseError(docResponseXml)
{	
	// En caso de que no contiene nada
	if (docResponseXml.xml == "") return false;
	
	// En caso de que contiene algo
	if (docResponseXml.documentElement.nodeName == "ERROR") return true;
	else return false;
}


function DeactivateTextInput(objInput)
{
	objInput.value = "";
	objInput.disabled = true;
	objInput.style.backgroundColor = "#EEEEEE";
}

function ActivateTextInput(objInput)
{
	objInput.disabled = false;
	objInput.style.backgroundColor = "";
}

function DeleteConfirm()
{
	return confirm("¿Está seguro de que desea eliminar el elemento?\nPulse 'Aceptar' para eliminar.");
}

// **********************************************************
// RdCC - 5/12/2002 
// Funciones de validación de datos
// **********************************************************
// Comprueba si el dato en un numero
function CheckNumber(Data)
{	
	if (Data != "") {
		var numberRegex = new RegExp("[0-9]");
		return Data.match(numberRegex);
	}
	else return true;
}

function CheckDate(Data)
{
	var DatosFecha = Data.split('/'); 
	var Fecha = new Date(); 
	Fecha.setFullYear(DatosFecha[2],DatosFecha[1]-1,DatosFecha[0]); 
	return (Fecha.getMonth()==DatosFecha[1]-1);
}

// Comprueba que la fecha1 es mayor o igual que la fecha2
function CompareDates(Data1,Data2)
{
	var DatosFecha1 = Data1.split('/'); 
	var Fecha1 = new Date(); 
	Fecha1.setFullYear(DatosFecha1[2],DatosFecha1[1]-1,DatosFecha1[0]); 
	
	var DatosFecha2 = Data2.split('/'); 
	var Fecha2 = new Date(); 
	Fecha2.setFullYear(DatosFecha2[2],DatosFecha2[1]-1,DatosFecha2[0]); 
	
	return (Fecha1 >= Fecha2); 
}

function AbrirPagina(strPagina) 
{ 
	var xx=screen.width-200; 
	var yy=screen.height-100; 
	var secundaria; 
	secundaria = window.open(strPagina,"","toolbar=0,location=0,directories=0,menubar=0,status=0,resizable=1,scrollbars=1,width="+xx+",height="+yy+",alwaysRaised,screenX=0,screenY=0,left=80,top=60"); 
	secundaria.focus(); 
} 
//////////////////////////////////////////////////////////////////////////// // 
//Función publica que crea un elemento en formato XML 
//////////////////////////////////////////////////////////////////////////// 
function xml_crearElemento(elementName, elemenValue) //As string 
{ 
	if (elemenValue=='') return ""; 
	else return "<" + elementName + "><![CDATA[" + elemenValue + "]]></" + elementName + ">"; 
}

// Función publica que te devuelve la fecha actual, en formato de YYYYMMDD
function GetCurrentDate(){
	var sDate = "";
	var nowDate = new Date();
	var sYear = "" + nowDate.getFullYear();
	var sMonth = "" + (nowDate.getMonth()+1);
	var sDay = "" + nowDate.getDate();
	
	if (sMonth.length == 1) {sMonth = "0" + sMonth};
	if (sDay.length == 1) {sDay = "0" + sDay};
	
	sDate = sYear + sMonth + sDay;
	return sDate;
}

// Función publica que te devuelve la hora actual, en formato de HH:mm
function GetCurrentHour(){
	var nowTime = new Date();

	return nowTime.getHours() + ":" + nowTime.getMinutes();
}

// Función publica que tarduce una hora, en formato de HH:mm a HHmm
function GetHour(sDate){
	var sNew = "";
	
	if (sDate.length != 5) return sNew;
	
	var sHour = "" + sDate.substr(0,2);
	var sMin = "" + sDate.substr(3,2);
			
	sNew += sHour + sMin;
	
	return sNew;
}

// Función pública que traduce una fecha, en formato YYYYMMDD a DD/MM/YYYY
function TranslateDate(sDate) {
	var sNew = "";
	var sYear = "" + sDate.substr(0,4);
	var sMonth = "" + sDate.substr(4,2);
	var sDay = "" + sDate.substr(6,2);
		
	sNew += "" + sDay + "/";
	sNew += "" + sMonth + "/";
	sNew += "" + sYear;
	
	return sNew;
}

// Función pública que traduce una fecha, en formato DD/MM/YYYY a YYYYMMDD
function TranslateDateToString(sDate) {
	var sNew = "";
	var sYear = "" + sDate.substr(6,4);
	var sMonth = "" + sDate.substr(3,2);
	var sDay = "" + sDate.substr(0,2);
		
	sNew += "" + sYear + sMonth + sDay;
	
	return sNew;
}

// Función pública que traduce una fecha, en formato Date a DD/MM/YYYY
function DateToUI(dt) {
	var sDate = "";
	var sYear = "" + dt.getFullYear();
	var sMonth = "" + (dt.getMonth()+1);
	var sDay = "" + dt.getDate();
	
	if (sMonth.length == 1) {sMonth = "0" + sMonth};
	if (sDay.length == 1) {sDay = "0" + sDay};
	
	sDate = sDay + "/" + sMonth + "/" + sYear;
	return sDate;
}	

//Pasa una fecha a formato dd/mm/yyyy. Se utiliza para que no de problemas guardar fechas
//del tipo d/m/aaaa, ya que siempre pasa a dd/mm/yyyy
function FormatDate(sDate)
{
	dtDate = GetDate(sDate);
	return DateToUI(dtDate);
}

// Función publica que te devuelve la hora actual, en formato HH:MM:SS
function GetCurrentTime(){
	var nowTime = new Date();

	return nowTime.getHours() + ":" + nowTime.getMinutes() + ":" + nowTime.getSeconds();
}

function GetDate(sDate) {
	var mFecha = sDate.split("/");
	
	//var nYear = eval(sDate.substr(6,4));
	//var nMonth = eval(sDate.substr(3,2))-1;
	//var nDay = eval(sDate.substr(0,2));
	var nYear = mFecha[2];
	var nMonth = mFecha[1]-1;
	var nDay = mFecha[0];
	
	var dt = new Date(nYear,nMonth,nDay);
			
	return dt;
}

// Función pública que obtiene el valor de un nodo o atributo a partir de un xmlDom
function GetNodeText(xmlDom, strName) {
    var strText="";

    strText = xmlDom.documentElement.selectSingleNode(strName).text;
    
    return strText;
}

// Función pública que modifica el valor de un nodo o atributo a partir de un xmlDom
function SetNodeText(xmlDom, strName, strValue) {
    xmlDom.documentElement.selectSingleNode(strName).text = strValue;
}

// Función pública que comprueba el error en la llamada a un webservice y lo notifica.
function CheckWSError(objResult, strFunction, strStatusMessage)
{
	if (objResult.hasError) {
		alert("[Error: " + strFunction + ", " + objResult.ErrorDescription + "] "+objResult.returnValue);
		window.status = strStatusMessage;
		return true;
	}
	else
	{
		var strReturn = new String();
		strReturn = objResult.returnValue;
		if (strReturn.indexOf("<ERROR>",0) != -1)
		{
			alert("[Error: " + strFunction + ", " + objResult.ErrorDescription + "]\n\n" + objResult.returnValue);
			window.status = strStatusMessage;
			return true;
		}
		else return false
	}		
}

function esDigito(sChr)
{
	var sCod = sChr.charCodeAt(0);
	return ((sCod > 47) && (sCod < 58));
}

function finMes(nMes)
{
	var nRes = 0;
	var nMes2 = parseInt(nMes,10);
	switch (nMes2)
	{
		case 1: nRes = 31; break;
		case 2: nRes = 29; break;
		case 3: nRes = 31; break;
		case 4: nRes = 30; break;
		case 5: nRes = 31; break;
		case 6: nRes = 30; break;
		case 7: nRes = 31; break;
		case 8: nRes = 31; break;
		case 9: nRes = 30; break;
		case 10: nRes = 31; break;
		case 11: nRes = 30; break;
		case 12: nRes = 31; break;
	}
	return nRes;
}

function ValidaDia(nDia,nMes)
{
	if (typeof nDia == "undefined") return false;	
	if (typeof nMes == "undefined") return false;	
	var bOk = false;
	bOk = bOk || ((nDia >= 1) && (nDia <= finMes(nMes)));
	
	return bOk;
}

function ValidaMes(nMes)
{
	if (typeof nMes == "undefined") return false;	
	var bOk = false;
	bOk = bOk || ((nMes >= 1) && (nMes <= 12));
	return bOk;
}

function ValidaAno(nAno)
{
	if (typeof nAno == "undefined") return false;	
	var bOk = true;
	bOk = bOk && ((nAno.length == 2) || (nAno.length == 4));
	if (bOk)
	{
		for (var i = 0; i < nAno.length; i++)
		{
			bOk = bOk && esDigito(nAno.charAt(i));
		}
	}
	return bOk;
}

function ValidaFecha(oFecha)
{
	var bOk = true;
	if (oFecha.value != "")
	{
		var arr = oFecha.split('/');	
		bOk = bOk && (ValidaAno(arr[2]));
		bOk = bOk && (ValidaMes(arr[1]));
		bOk = bOk && (ValidaDia(arr[0],arr[1]));	
	}
	return bOk;
}

//Formatea un número redondea los decimales a 2 y pone coma en lugar de .
function FormatNumber(Number)
{

	if (Number==null || Number=='') return "";
	var strNumber = "" + Number;

	var newNumber = 0.0 + parseFloat(strNumber);

	newNumber = "" + Math.round(newNumber*100)/100;
			
	var pos = newNumber.indexOf(".");

	if (pos > 0)
	{
		newNumber = newNumber.substring(0,pos) + "," + newNumber.substring(pos+1, newNumber.length);
	}
	return (newNumber);

}