//Soporte para validadores en NetScape
//Carlos Christian Molina Vega
//Grupo CMA - Agosto 2004
//

var validatorsArray = new Array();
var validatorsSummaryArray = new Array();
var validatorsTypes = new Array();
var validatorsControls = new Array();
var validatorsDisplay = new Array();
var validatorsData = new Array();
var validatorsText = new Array();
var validatorsResult = new Array(); //Mantiene el resultado de los validators para el summary
var NSValidationDisabled = false;
//Agrega el control al arreglo de sumary
//=======================
function AddToSummaryArray(sumid)
{

	validatorsSummaryArray[validatorsSummaryArray.length] = document.getElementById(sumid);
}
//Agrega el control al arreglo de validadores.
//=======================
function AddToArray(id, valType, controlToValidate, valDisplay, valData, valtext)
{
	validatorsArray[validatorsArray.length] = document.getElementById(id);
	validatorsTypes[validatorsTypes.length] = valType;
	validatorsControls[validatorsControls.length] = document.getElementById(controlToValidate); 
	validatorsDisplay[validatorsDisplay.length] = valDisplay; 
	validatorsData[validatorsData.length] = valData;
	validatorsResult[validatorsResult.length] = false;
	validatorsText[validatorsText.length] = valtext;
}
//Ejecuta el proceso de validacion
//=======================
function DoValidateSummary()
{
	for (b=0; b < validatorsSummaryArray.length; b++)
	{
		var summary = validatorsSummaryArray[b]; //Cada summary
		var text = '';
		for (a=0; a <validatorsArray.length; a++)
		{
			if (validatorsResult[a] == false)
			{
				text = text + '- ' + validatorsText[a] + '<BR>';
			}		
		}

		summary.innerHTML = text;
	}
}
//Verifica si la validacion esta deshabilitada.
//=======================
function IsValidationDisabled()
{
	if ( typeof(NSValidationDisabled) == "undefined")
	{
		return false;
	}
	else
	{
		if (NSValidationDisabled)
		{
			NSValidationDisabled = false;
			return true;
		}
		else
			return false;
	}
	
}
//Valida esta pagina.
//=======================
function ValidateThisPage()
{
	
	if (IsValidationDisabled())
	{
	
		return true;
	}
	else
	{
	
		var ret = true;
		var ret2 = true;
		var a;
		
		for (a=0; a <validatorsArray.length; a++)
		{
			ret = DoValidate(validatorsArray[a],validatorsTypes [a] , validatorsControls [a],validatorsDisplay [a], validatorsData[a]);
			validatorsResult[a] = ret; //Guarda el resultado de cada validator para el summary
			if (ret == false)
				ret2 = false;
		}
		
		if (validatorsSummaryArray.length > 0)
		{
			//Si hay summary
			DoValidateSummary();
		}

		return ret2;
	}
}
//======================
function DoValidateOnChange(id, valType, controlToValidate, valDisplay, valData)
{
	return DoValidate(document.getElementById(id),valType,document.getElementById(controlToValidate),valDisplay,valData);
}
//Determina si el control esta activo
//======================
function ControlActive(cnt)
{
	if (cnt != null)
	{
		try{
			return !cnt.disabled;
		}
		catch(e)
		{
			return true;
		}
	}
	else
		return false;
}
//Realiza la funcion de validacion
//======================
function DoValidate(validobj, valtype, controlToValidate, valdisp, valData)
{
//	if (ControlActive (controlToValidate))
//	{
		switch(valtype)
		{
			case 'REQUIRED':
				return validateRequired(validobj, controlToValidate, valdisp);
				break;			
			case 'REGULAR':
				return validateRegular(validobj, controlToValidate, valdisp, valData);
				break;
			case 'CUSTOM':
				return validateCustom(validobj, controlToValidate, valdisp, valData);
				break;
			case 'COMPARE':
				return validateCompare(validobj, controlToValidate, valdisp, valData);
				break;
			case 'RANGE':
				return validateRange(validobj, controlToValidate, valdisp, valData);
				break;
		}
		return false;
//	}
//	else
//		return true;
}
//Muestra un mensaje de error
//=======================
function ShowErrorMessage(show, obj, ishidden)
{
	if (show)
	{
		if (ishidden)
			obj.style.visibility = "";
		else
			obj.style.display = "";
	}
	else
	{
		if (ishidden)
			obj.style.visibility = "hidden";
		else
			obj.style.display = "none";
	}
}
//Valida rangos
//=======================
function validateRange(obj, cnt, valdisp, valData)
{
	var ret = doRange(cnt, valData);
	ShowErrorMessage(!ret, obj, valdisp == 'Static');
	return ret; 
}
//=======================
function ValidateRangeNS(value, min, max)
{
	return (value >= min) && (value <= max);
}
//=======================
function doRange(cnt, valData)
{
	var IsValid = false;
	var value = ValidatorGetValue(cnt);
	eval(valData);
	return IsValid;
}
//Realiza la validacion del RequiredFieldValidator.
//=======================
function validateCompare(obj, cnt, valdisp, valData)
{
	var ret = doCompare(cnt, valData);
	ShowErrorMessage(!ret, obj, valdisp == 'Static');
	return ret; 
}
//=======================
function doCompare(cnt, valData)
{
	var obj = document.getElementById(valData);
	if (obj != null)
		return (ValidatorGetValue(cnt) == obj.value);
	else
	{
	    var evalString = "ValidatorGetValue(cnt)" + valData;
		return eval(evalString);
    }
}
//Para el validator custom
//=======================
function validateCustom(obj, cnt, valdisp, valData)
{
	var ret = DoCustom(cnt, valData, obj);
	ShowErrorMessage(!ret, obj, valdisp == 'Static');
	return ret; 
}
//=======================
function DoCustom(controlToValidate, functionname, validator)
{
	var IsValid = false;
	var texto = "IsValid = " + functionname + "(controlToValidate, validator, 'NS');";
	eval(texto);	
	return IsValid;
}
//Para validar una expresion regular.
//=======================
function validateRegular(obj, cnt, valdisp, valData)
{
	var ret = IsRegularValid(cnt,valData);
	ShowErrorMessage(!ret, obj, valdisp == 'Static');
	return ret; 
}
//=======================
function validateRequired(obj, cnt, valdisp)
{
	var ret = trim(ValidatorGetValue(cnt)).length > 0;
	ShowErrorMessage(!ret, obj, valdisp == 'Static');
	return ret; 
}
//=======================
function IsRegularValid(controlToValidate, regularexpe )
{
    var value = controlToValidate.value;
        
    if (value.length == 0)
        return true;        
    var rx = new RegExp(regularexpe);
    var matches = rx.exec(value);
    
    return (matches != null && value == matches[0]);
}
//=======================

function trim(s) {
    var m = s.match(/^\s*(\S+(\s+\S+)*)\s*$/);
    return (m == null) ? "" : m[1];
}
//=======================
function ValidatorGetValue(control)
{
    if (typeof(control.value) == "string") {
        return control.value;
    }
    if (typeof(control.tagName) == "undefined" && typeof(control.length) == "number") {
        var j;
        for (j=0; j < control.length; j++) {
            var inner = control[j];
            if (typeof(inner.value) == "string" && (inner.type != "radio" || inner.status == true)) {
                return inner.value;
            }
        }
    }
    else {
        return ValidatorGetValueRecursive(control);
    }
    return "";
}
//=======================
function ValidatorGetValueRecursive(control)
{
    if (typeof(control.value) == "string" && (control.type != "radio" || control.checked == true)) {
        return control.value;
    }
    var i, val;
    for (i = 0; i<control.childNodes.length; i++) {
        val = ValidatorGetValueRecursive(control.childNodes[i]);
        if (val != "") return val;
    }
    return "";
}