<!--

/* --------------------------------------------
VARIABLES DE CONFIGURACIÓN PARA MANEJO DE DATOS
-------------------------------------------- */

var separacionFechas = "/";
var formatoFecha     = "dd/mm/aaaa";
// var separacionFechas = "-";
var numerosEnteros         = "0123456789-";
var numerosEnterosConComas = ".0123456789-";

/* ---------------------------------------------------------
FUNCIONES CON CADENAS DE TEXTO Y OTROS CAMPOS DE FORMULARIOS
--------------------------------------------------------- */

function esVacio(cadena){
    return (trim(obtenerValor(cadena))=="");
}

function esNulo(cadena){
    return esVacio (cadena);
}

function textLength(cadena){
    return obtenerValor(cadena).length;
}

function esVacioSelect(elSelect){
    return esVacio(elSelect.options[elSelect.selectedIndex].value);
}

function esNuloSelect(elSelect){
    return esVacioSelect (elSelect);
}

function esUrl (cadena) {
    laUrl = obtenerValor(cadena);
    return (laUrl.toLowerCase().substring(0,7) == 'http://' ||
            laUrl.toLowerCase().substring(0,6) == 'ftp://'  ||
            laUrl.toLowerCase().substring(0,8) == 'https://');
}

function countChars(chars, cadena){
    laCadena  = obtenerValor(cadena);
    sizeChars = chars.length;
    counter = 0;
    for (x=0; x<laCadena.length-sizeChars; x++){
        if (laCadena.substring(x,(x+sizeChars)) == chars){
            counter++;
        }
    }
    return counter;
}

function countCharsIgnoreCase(chars, cadena){
    laCadena  = obtenerValor(cadena).toLowerCase();
    return countChars(chars.toLowerCase(), laCadena);
}


/* --------------------------------------------------------
FUNCIONES DE GESTIÓN DE FORMULARIOS Y CAMPOS DE FORMULARIOS
-------------------------------------------------------- */

function gestionError(campo, mensaje) {
    alert (mensaje);
    if (campo.type!=null && campo.type!="hidden"){
        campo.focus();
        if (campo.type=="text" || campo.type=="textarea"){
            campo.select();
        }
    }
}

function setSelectedIndex(elSelect, elValor){
    // Se selecciona la posición del Select cuyo valor es igual a 'elValor'.

    if(elSelect!=null){
        for (i=0; i<elSelect.options.length; i++){
            if(elSelect[i].value == elValor){
                elSelect[i].selected = true;
                break;
            }
        }
    }
}

function rellenaSelect(elSelectDestino, listaValores, listaTextos, accion){
    // Rellena 'elSelectDestino' con los Arrays 'listaValores' y 'listaTextos'
    // y al acabar ejecuta una acción personalizada si se define.

    elSelectDestino.length = 1;
    elSelectDestino.options[0].value = "";
    elSelectDestino.options[0].text  = "Seleccione...";

    if (listaValores!=null && listaValores.length>0){
        elSelectDestino.length += listaValores.length;
        for (x=1; x<=listaValores.length; x++){
            elSelectDestino.options[x].value = listaValores[x-1];
            elSelectDestino.options[x].text  = listaTextos[x-1];
        }
    }

    if (accion!=null){
        eval(accion);
    }
}

function valorRadioSeleccionado(radioName){
    // De un grupo de 'radioButtons' devuelve el valor del elemento seleccionado
    // o devuelve 'null' si no hubiese ninguno seleccionado.

    if (radioName.length!=null){
        for (x=0; x<radioName.length; x++){
            if (radioName[x].checked){
                return radioName[x].value;
            }
        }
    } else {
        if (radioName.checked){
            return radioName.value;
        }
    }
}

function extensionesValidas(ruta, extensiones){
    // Devuelve 'true' si la 'ruta' pasada es correcta y el archivo tiene una
    // extensión que esta dentro del Array de 'extensiones'.
    // 'extensiones' es un Array de cadenas del tipo new Array("jpg","jpeg","gif");

    var laRuta      = obtenerValor(ruta);
    var laExtension = laRuta.substring(laRuta.lastIndexOf(".")+1, laRuta.length);

    var barraDir = "/";
    if (laRuta.lastIndexOf(barraDir)<0){
        barraDir = "\\";
    }

    var elNombre = laRuta.substring(laRuta.lastIndexOf(barraDir)+1, laRuta.lastIndexOf("."));

    if (!esVacio(elNombre) && !(laRuta.indexOf("/")>0 && laRuta.indexOf("\\")>0)){
        for (x=0; x<extensiones.length; x++){
            if (laExtension==extensiones[x]){
                return true;
            }
        }
    }
    return false;
}

/* ------------------
FUNCIONES CON NÚMEROS
------------------ */

function esPorcentaje(cadena){
    elPorcentaje = parseFloat(obtenerValor(cadena));
    if (esNumeroConComas(elPorcentaje) && elPorcenaje>=0 && elPorcentaje<=100){
        return true;
    }
    return false;
}

function esNumero(cadena){
    laCadena = obtenerValor(cadena);
    if (contieneCaracteresValidos(laCadena, numerosEnteros) && countChars("-",laCadena)<=1 && laCadena.toString().lastIndexOf("-")<=0){
        return true;
    }
}

function esNumeroConComas(cadena){
    laCadena = obtenerValor(cadena);
    if (contieneCaracteresValidos(laCadena, numerosEnterosConComas) && countChars("-",laCadena)<=1 && laCadena.toString().lastIndexOf("-")<=0){
        return true;
    }
}

function esNumeroDecimal(cadena){
    return esNumeroConComas(cadena);
}

function esDecimal(cadena){
    return esNumeroConComas(cadena);
}

function sumaDigitos(cadena){
    // Suma los digitos de una cadena entre sí, por ejemplo en la cadena '1024'
    // se realizará la siguiente operación: 1 + 0 + 2 + 4 = 7
    // Esta función es necesaria para calcular el CIF.

    var resultado = 0;
    laCadena = obtenerValor(cadena).toString();
    for (x=0; x<laCadena.length; x++){
        resultado += parseInt(cadena.charAt(x));
    }
    return resultado;
}

/* -----------------
FUNCIONES CON FECHAS
----------------- */

function comparaFechas(fecha1, fecha2){
    valores1 = getValoresFecha(fecha1, formatoFecha);
    elDia1   = parseInt(valores1[0]   , 10);
    elMes1   = parseInt(valores1[1]-1 , 10);
    elAnyo1  = parseInt(valores1[2]   , 10);

    valores2 = getValoresFecha(fecha2, formatoFecha);
    elDia2   = parseInt(valores2[0]   , 10);
    elMes2   = parseInt(valores2[1]-1 , 10);
    elAnyo2  = parseInt(valores2[2]   , 10);

    auxFecha1 = new Date (elAnyo1, elMes1, elDia1, 0, 0, 0, 0);
    auxFecha2 = new Date (elAnyo2, elMes2, elDia2, 0, 0, 0, 0);

    val1 = auxFecha1.getTime();
    val2 = auxFecha2.getTime();

    return (val1-val2);
}

function getValoresFecha(fecha, formato){

    laFecha = obtenerValor(fecha);

    var valores = null;
    if (countChars("/",laFecha)==2){
        valores = laFecha.split("/");
    } else if (countChars("-",laFecha)==2){
        valores = laFecha.split("-");
    } else if (countChars(" ",laFecha)==2){
        valores = laFecha.split(" ");
    } else {
        // El formato de fecha no es valido.
        // Debe ser 'dd/mm/aaaa' o 'dd-mm-aaaa' o 'dd mm aaaa'.
        return false;
    }

    if (formato=="dd/mm/aaaa"){
        elDia   = parseInt(valores[0]   , 10);
        elMes   = parseInt(valores[1]-1 , 10);
        elAnyo  = parseInt(valores[2]   , 10);
    } else if (formato=="mm/dd/aaaa"){
        elDia   = parseInt(valores[1]   , 10);
        elMes   = parseInt(valores[0]-1 , 10);
        elAnyo  = parseInt(valores[2]   , 10);
    }

    if (!esNumero(elDia) || !esNumero(elMes) || !esNumero(elAnyo)){
        // Alguno de los números tiene caracteres extraños.
        return false;
    }

    return new Array(elDia, elMes, elAnyo);
}

function chequeaFecha(cadena){

    laFecha = obtenerValor(cadena);

    valores = getValoresFecha(laFecha, formatoFecha);
    elDia   = parseInt(valores[0], 10);
    elMes   = parseInt(valores[1], 10);
    elAnyo  = parseInt(valores[2], 10);

    if ((elAnyo>=100 && elAnyo<1900) || elAnyo.toString().length<4) {
        // El año no es correcto.
        // Debe ser de dos digitos o de cuatro mayor que 1900.
        return false;
    } else if (elAnyo<100) {
        elAnyo += 2000;
    }

    auxFecha = new Date (elAnyo, elMes, elDia, 0, 0, 0, 0);
    auxFecha.setYear(elAnyo);
    auxFecha.setMonth(elMes);
    auxFecha.setDate(elDia);
    auxDia   = auxFecha.getDate();
    auxMes   = auxFecha.getMonth();
    auxAnyo  = auxFecha.getYear();

    if (elDia==auxDia && elMes==auxMes && (elAnyo==auxAnyo || elAnyo==(auxAnyo+1900)) ){
        if (cadena.type=="text"){
            cadena.value = ((elDia<10)?"0":"")     + elDia     + separacionFechas +
                           (((elMes+1)<10)?"0":"") + (elMes+1) + separacionFechas + elAnyo;
        }
        return true;
    }
    return false;
}

function esFechaCorrecta(eFecha){
    return chequeaFecha (eFecha);
}


/* ----------------------------------------------------------------
FUNCIONES PARA CONTROLAR VENTANAS Y ELEMENTOS PROPIOS DEL NAVEGADOR
---------------------------------------------------------------- */

function abrirVentana(nombre, direccion, ancho, alto, redimensionable, barrasScroll, referencia){
    var argumentos = "";
    if (ancho!=null){
        argumentos += ",width=" + ancho;
    }
    if (alto!=null){
        argumentos += ",height=" + alto;
    }
    argumentos += ",resizable="  + (redimensionable)?"yes":"no";
    argumentos += ",scrollbars=" + (barrasScroll)?"yes":"no";
    argumentos += ",status=0";

    var laVentana = window.open(direccion, nombre, argumentos);
    laVentana.focus();

    if (laVentana != null){
        if (laVentana.opener == null){
            laVentana.opener = self;
        }
    }

    if (referencia){ return laVentana; }
}

function LanzaVentana(nombre, direccion, ancho, alto, referencia){
    abrirVentana(nombre, direccion, ancho, alto, null, null, referencia);
}

function imprimirMarco(elMarco){
    // Imprime un marco de la página si se le pasa, sino imprime toda la ventana.

    if(esNavegadorMicrosoft>=5){
        if (elMarco!=null){
            elMarco.focus()
        }
        window.print();
    } else if(esNavegadorNetscape>=4){
        if (elMarco!=null){
            elMarco.print()
        } else {
            top.print();
        }
    } else {
        alert ("Acción de imprimir no soportada por su Navegador.");
    }
}

function cancelarClickDerecho(){
    if (window.Event){
        document.captureEvents(Event.MOUSEUP);
    }
    document.oncontextmenu = nocontextmenu;
    document.onmousedown = norightclick;
}

function nocontextmenu(){
   event.cancelBubble = true
   event.returnValue = false;
   return false;
}

function norightclick(e){
    if (window.Event){
        if (e.which == 2 || e.which == 3){
            return false;
        }
    } else if (event.button == 2 || event.button == 3){
        nocontextmenu()
    }
}

function esNavegadorMicrosoft(){
    // Detecta si el navegador es el Internet Explorer y devuelve su versión o 'false'.
    if (navigator.appName.indexOf("Microsoft")>=0){
        datosVersion = navigator.appVersion.split("; ");
        for (x=0; x<datosVersion.length; x++){
            if (datosVersion[x].indexOf("MSIE")>=0){
                return parseFloat(datosVersion[x].substring(5,datosVersion[x].length));
            }
        }
    }
    return false;
}

function esNavegadorNetscape(){
    // Detecta si el navegador es Netscape, o compatible, y devuelve su versión o 'false'.
    if (navigator.appName.indexOf("Netscape")>=0){
        return parseFloat(navigator.appVersion.substring(0,navigator.appVersion.indexOf("(")));
    }
    return false;
}

/* -------------------------------
FUNCIONES ESPECIFICAS CON CHECKBOX
------------------------------- */

function numChecks(elForm, elCheck){
    var f = eval("document." + elForm);
    if (f!=null){
        var c = eval("document." + elForm + "." + elCheck);
        if (c!=null){
            if (eval(c.length)){
                return c.length;
            } else {
                return 1;
            }
        } else {
            alert ("Error. La funcion 'numChecks' no encuentra el checkbox: '" + elCheck + "' Dentro del formulario: '" + elForm + "'");
            return 0;
        }
    } else {
        alert ("Error. La funcion 'numChecks' no encuentra el formulario: '" + elForm + "'");
        return 0
    }
}

function esCheckboxMultiple(f, c){
    if (numChecks(f,c)>1){
        return true;
    }
    return false;
}

function numMarcados(elForm, elCheck){
    if (numChecks(elForm, elCheck)>0){
        var c = eval("document." + elForm + "." + elCheck);
        contador = 0;
        if (esCheckboxMultiple(elForm, elCheck)){
            for (i=0; i<c.length;i++){
                if (c[i].checked){
                    contador++;
                }
            }
        } else {
            if (c.checked){
                contador++;
            }
        }
        return contador;
    }
}

function algunoMarcado(elForm, elCheck){
    return (numMarcados(elForm, elCheck)!=0);
}
function ningunoMarcado(elForm, elCheck){
    return (numMarcados(elForm, elCheck)==0);
}
function unoMarcado(elForm, elCheck){
    return (numMarcados(elForm, elCheck)==1);
}

function cambiarSeleccion(elForm, elCheck, elValor, marcar){
    var c = eval("document." + elForm + "." + elCheck);


    if (esCheckboxMultiple(elForm, elCheck)){
        for (i=0; i<c.length; i++){
            if (c[i].type=="checkbox"){
                if (elValor!=true && elValor!=false){ // Se usa para Invertir la seleccion //
                    c[i].checked = !c[i].checked;
                } else { // Se usa para marcar Todos o Ninguno //
                    c[i].checked = elValor;
                }
                if (marcar){
                    marcarLinea ("tablaLinea"+c[i].value, c[i].checked);
                }
            }
        }
    } else {
        if (c.type=="checkbox"){
            if (elValor!=true && elValor!=false){ // Se usa para Invertir la seleccion //
                c.checked = !c.checked;
            } else { // Se usa para marcar Todos o Ninguno //
                c.checked = elValor;
            }
            if (marcar){
                marcarLinea ("tablaLinea"+c.value, c.checked);
            }
        }
    }
}

function seleccionarTodos(elForm, elCheck){
    cambiarSeleccion(elForm, elCheck, true);
}
function deseleccionarTodos(elForm, elCheck){
    cambiarSeleccion(elForm, elCheck, false);
}
function desmarcarTodos(elForm, elCheck){
    cambiarSeleccion(elForm, elCheck, false);
}
function marcarTodos(elForm, elCheck){
    cambiarSeleccion(elForm, elCheck, true);
}
function invertirSeleccion(elForm, elCheck) {
    cambiarSeleccion(elForm, elCheck);
}



/* -----------------------------
FUNCIONES PARA DATOS ESPECIFICOS
----------------------------- */

function validaNIF (objeto) {
    // Valida el NIF que se le pasa. El formato puede ser 12345678A ó 12345678-A
    // si al NIF le faltan dígitos se completa con ceros. Se el puede pasar el
    // campo directamente o bien la cadena de texto a comprobar.

    var elNif = obtenerValor(objeto).toUpperCase();

    if (elNif.length<9) {
        for (w = elNif.length; w<9; w++) {
            elNif += "0";
        }
    }

    var elNumero = elNif.substring(0,8);
    if (!esNumero(elNumero)){
        return false;
    }

    var laLetra = elNif.charAt(8);
    if (elNif.length >= 10){
        laLetra = elNif.charAt(9);
    }

    var posiblesLetras = "TRWAGMYFPDXBNJZSQVHLCKET";
    if (posiblesLetras.indexOf(laLetra)<0){
        return false;
    }

    var pos = elNumero%23;
    if (posiblesLetras.charAt(pos)!=laLetra){
        return false;
    }

    if (typeof objeto == "object") {
        objeto.value = elNumero + laLetra;
    }
    return true;
}

function validaNIE(cadena){
    // Igual que validar el NIF. El formato puede ser X12345678A ó X12345678-A
    // Sólo se comprueba que la cadena empiece por 'X'.

    elNie = obtenerValor(cadena);

    if (elNie.length<9 || elNie.length>10 || elNie.charAt(0).toUpperCase()!="X"){
        return false;
    }

    if (elNie.length==9){
        return validaCIF(elNie);
    } else if (elNie.length==10){
        return validaNIF(elNie.substring(1,elNie.length));
    }
}

function validaCIF(cadena){
    // Valida el CIF que se le pasa. El formato puede ser A12345674 ó P1234567D
    // También comprueba los CIF para extranjeros, que empiezan por 'X'.

    posiblesLetras = ("ABCDEFGHKLMNPQSX");
    letrasControl = new Array ("J","A","B","C","D","E","F","G","H","I");

    elCif       = obtenerValor(cadena);
    tipoEntidad = elCif.charAt(0).toUpperCase();

    if(elCif.length!=9 || !contieneCaracteresValidos(tipoEntidad, posiblesLetras)){
        return false;
    }

    numeros = elCif.substring(1,elCif.length);

    pares     = parseInt(elCif.charAt(2)) + parseInt(elCif.charAt(4)) + parseInt(elCif.charAt(6));
    auxImpar1 = sumaDigitos((parseInt(elCif.charAt(1))*2).toString());
    auxImpar2 = sumaDigitos((parseInt(elCif.charAt(3))*2).toString());
    auxImpar3 = sumaDigitos((parseInt(elCif.charAt(5))*2).toString());
    auxImpar4 = sumaDigitos((parseInt(elCif.charAt(7))*2).toString());
    ultimoNum = elCif.charAt(8);
    impares   = auxImpar1 + auxImpar2 + auxImpar3 + auxImpar4;
    parcial   = (pares + impares).toString();

    elControl = 10 - parseInt(parcial.substring(parcial.length-1, parcial.length));

    if (tipoEntidad=="X" || tipoEntidad=="P"){
        if (letrasControl[elControl] == ultimoNum.toUpperCase()){
            return true;
        }
    } else {
        if (elControl == parseInt(ultimoNum)){
            return true;
        }
    }
    return false;

}

function validaCualquierDoc(cadena){
    documento = obtenerValor(cadena);
    if (validaNIF(documento) || validaNIE(documento) || validaCIF(documento)){
        return true;
    }
    return false;
}

/* ------------------------------------------------------------------------------
FUNCIONES DE AMBITO GENERAL (También se les hacen llamadas desde otras funciones)
------------------------------------------------------------------------------ */

function obtenerValor(objeto){
    // Si es un objeto devuelve su valor, si es una cadena la devuelve sin tocarla.

    if (typeof objeto == "object" && (objeto.type=="text" || objeto.type=="textarea" || objeto.type=="file" || objeto.type=="radio" || objeto.type=="checkbox") || objeto.type=="password"){
        return objeto.value;
    } else if (typeof objeto == "object" && (objeto.type=="select")){
        return objeto.options[objeto.selectedIndex].value;
    } else if (typeof objeto == "string" || typeof objeto == "number"){
        return objeto;
    } else {
        alert ("Error en la función obtenerValor, no se puede obtener valor de '" + objeto.type + "'.\n" +
               "Sólo se puede obtener el valor de campos de texto y cadenas.");
    }
}

function contieneCaracteresValidos(cadena, caracteresValidos){
    // Devuelve 'true' si la 'cadena' esta compuesta integramente por 'caracteresValidos'.

    var laCadena = obtenerValor(cadena);
    for (var i=0; i<laCadena.length; i++){
        if (caracteresValidos.indexOf(laCadena.charAt(i))<0){
            return false;
        }
    }
    return true;
}

function trim(cadena) {
    // Elimina los espacios delanteros y traseros de la cadena. También elimina
    // espacios consecutivos y los reemplaza con un espacio. Se le puede pasar
    // una cadena o bien un objeto que contenga una cadena.

    var result = obtenerValor(cadena);

    if (result.length>0){
        var ch = result.substring(0, 1);

        while (ch == " ") {
            result = result.substring(1, result.length);
            ch = result.substring(0, 1);
        }
        ch = result.substring(result.length-1, result.length);

        while (ch == " ") {
            result = result.substring(0, result.length-1);
            ch = result.substring(result.length-1, result.length);
        }

        while (result.indexOf(" ") != -1) {
            result = result.substring(0, result.indexOf(" ")) + result.substring(result.indexOf(" ")+1, result.length);
        }
    }

    return result;
}

// COMPROBACION DIGITO DE CONTROL PARA NUMEROS DE CUENTAS BANCARIAS //

var pesos = new Array(1,2,4,8,5,10,9,7,3,6);
function comprobarDigitoControl(ent,off,dgc,num){
	if (ent.length!=4  || off.length!=4  || dgc.length!=2  || num.length!=10){ return false; }
	if (!esNumero(ent) || !esNumero(off) || !esNumero(dgc) || !esNumero(num)){ return false; }
	dc1 = calcularDigito(ent+""+off);
	dc2 = calcularDigito(num);
	if ((dc1+""+dc2)==dgc){ return true; }
	return false;
}
function calcularDigito(numero){
	dc = 0;
	for (x=numero.length-1; x>=0; x--){
		peso = pesos[x+(pesos.length-numero.length)];
		nm   = numero.charAt(x);
		dc  += (peso*nm);
	}
	return (11-(dc%11));
}




// NUEVAS //

function obtenerDiv(nombreDiv){
    if (document.All){ // Es Internet Explorer
        return eval(nombreDiv);
    } else { // Es Firefox
        return document.getElementById(nombreDiv);
    }
}

function in_array(aguja, pajar){
    for (x=0; x>pajar.length; x++){
        if (pajar[x]==aguja){ return true; }
    }
    return false;
}

function alertAndFocus(msj, obj){
    alert (msj); obj.focus()
}

/*
OBJETOS PARA COMPROBAR CAMPOS DE FORMA ELEGANTE
*/
function requeridos(){}
requeridos.prototype.campos = new Array();
requeridos.prototype.length = 0;
requeridos.prototype.comprobar = function(nombreCampo){
    this.campos[this.campos.length] = nombreCampo;
    eval ("this." + nombreCampo + " = new campoRequerido();");
    cr = eval ("this." + nombreCampo);
    cr.seLlama(nombreCampo);
    this.length++;

}

function campoRequerido (){}
campoRequerido.prototype.d = "";
campoRequerido.prototype.seLlama = function(desc){
    this.d = desc;
}
campoRequerido.prototype.p = "";
campoRequerido.prototype.debeSer = function(prop){
    if (this.p==""){ this.p = new Array() }
    this.p[this.p.length] = prop;
}

var campo = new requeridos();
var camposRequeridos = new Array();
/*
FIN DE OBJETOS PARA COMPROBAR CAMPOS
*/


function comprobarCampos(f){

    if (campo.length>0){ // Si se usa el "asistente" se hace esto //
    camposRequeridos = new Array();
    for (x=0; x<campo.length; x++){
        nombreCampo = campo.campos[x];
        elCampo = eval("campo." + nombreCampo);
        camposRequeridos[x] = elCampo.d + "|" + nombreCampo;
	    for (xx=0; xx<elCampo.p.length; xx++){
	    camposRequeridos[x] += "|" + elCampo.p[xx];
	    }
	}
    }

    for (h=0; h<f.elements.length; h++){


        elElemento     = f.elements[h];
        tipoElemento   = elElemento.type;
        nombreElemento = elElemento.name;
        valorElemento  = elElemento.value;

        for (y=0; y<camposRequeridos.length; y++){

            campoRequerido   = camposRequeridos[y].split("|");
            descripcionCampo = campoRequerido[0];
            nombreRequerido  = campoRequerido[1];


            if (nombreRequerido==nombreElemento){

                for (z=2; z<campoRequerido.length; z++){

                    toDo = campoRequerido[z];

                    if (toDo=="noVacio"){
                        if (esVacio(valorElemento)){
                            alertAndFocus("El campo '" + descripcionCampo + "' no tiene valor.", elElemento);
                            return false;
                        }
                    }

                    if (toDo=="numEntero"){
                        if (!esVacio(valorElemento) && !esNumero(valorElemento)){
                            alertAndFocus("El campo '" + descripcionCampo + "' debe de ser un número entero (sin comas).", elElemento);
                            return false;
                        }
                    }

                    if (toDo=="numDecimal"){
                        if (!esVacio(valorElemento) && !esNumeroConComas(valorElemento)){
                            alertAndFocus("El campo '" + descripcionCampo + "' debe de ser un número.", elElemento);
                            return false;
                        }
                    }

                    if (toDo=="numPositivo"){
                        if ((!esVacio(valorElemento) && !esNumeroConComas(valorElemento)) || valorElemento.indexOf("-")==0){
                            alertAndFocus("El campo '" + descripcionCampo + "' debe de ser un número positivo.", elElemento);
                            return false;
                        }
                    }

                    if (toDo=="esFecha" || toDo=="fecha"){
                        if (!esVacio(valorElemento) && !chequeaFecha(valorElemento)){
                            alertAndFocus("La fecha introducida en el campo '" + descripcionCampo + "' no es correcta.\nCompruebe el formato, debe ser " + formatoFecha + ".", elElemento);
                            return false;
                        }
                    }
                    
                    if (toDo.indexOf("numCuenta:")==0){
                    	camposCuenta = toDo.split(":");
                    	entidad = eval ("f." + camposCuenta[1] + ".value");
                    	oficina = eval ("f." + camposCuenta[2] + ".value");
                    	digitoC = eval ("f." + camposCuenta[3] + ".value");
                    	numeroC = eval ("f." + camposCuenta[4] + ".value");
                    	
                    	if (!comprobarDigitoControl(entidad,oficina,digitoC,numeroC)){
                    	    alertAndFocus("El número de cuenta introducido no es correcto. \nCompruebe el número de cuenta.", elElemento);
                    	    return false;
                    	}
                    	
                    }

                    if (toDo.indexOf("<")>0){
                        if (!esVacio(valorElemento)){
                            params = toDo.split("<");
                            if (toDo.indexOf("<=")>0){ params = toDo.split("<="); }
                            param  = params[0];
                            value  = params[1];
                            if (isNaN(value)){
                                obj   = eval("f." + params[1]);
                                if (obj!=null){
                                    value = obtenerValor(obj);
                                }
                            }
                            if (param=="num"){
                                value = parseInt(value);
                                if (valorElemento>value && toDo.indexOf("<=")>0){
                                    alertAndFocus("El número del campo '" + descripcionCampo + "' debe ser menor o igual que " + value + ".", elElemento);
                                    return false;
                                } else if (valorElemento>=value && toDo.indexOf("<=")<0){
                                    alertAndFocus("El número del campo '" + descripcionCampo + "' debe ser menor que " + value + ".", elElemento);
                                    return false;
                                }
                            }
                            if (param=="len"){
                                value = parseInt(value);
                                if (valorElemento.length>value && toDo.indexOf("<=")>0){
                                    alertAndFocus("La longitud del campo '" + descripcionCampo + "' debe ser menor o igual que " + value + ".", elElemento);
                                    return false;
                                } else if (valorElemento.length>=value && toDo.indexOf("<=")<0){
                                    alertAndFocus("La longitud del campo '" + descripcionCampo + "' debe ser menor que " + value + ".", elElemento);
                                    return false;
                                }
                            }
                            if (param=="date" || param=="fecha"){
                                if (esVacio(value)){
                                    alertAndFocus("La fecha del campo '" + descripcionCampo + "' no se puede comparar porque la otra fecha está vacia.", elElemento);
                                    return false;
                                } else if (comparaFechas(valorElemento,value)>0 && toDo.indexOf("<=")>0){
                                    alertAndFocus("La fecha del campo '" + descripcionCampo + "' no puede ser posterior a la otra fecha.", elElemento);
                                    return false;
                                } else if (comparaFechas(valorElemento,value)>=0 && toDo.indexOf("<=")<0){
                                    alertAndFocus("La fecha del campo '" + descripcionCampo + "' no puede ser posterior ni igual a la otra fecha.", elElemento);
                                    return false;
                                }
                            }
                        }
                    }

                    if (toDo.indexOf(">")>0){
                        if (!esVacio(valorElemento)){
                            params = toDo.split(">");
                            if (toDo.indexOf(">=")>0){ params = toDo.split(">="); }
                            param  = params[0];
                            value  = params[1];
                            if (isNaN(value)){
                                obj   = eval("f." + params[1]);
                                if (obj!=null){
                                    value = obtenerValor(obj);
                                }
                            }
                            if (param=="num"){
                                value = parseInt(value);
                                if (valorElemento<value && toDo.indexOf(">=")>0){
                                    alertAndFocus("El número del campo '" + descripcionCampo + "' debe ser mayor o igual que " + value + ".", elElemento);
                                    return false;
                                } else if (valorElemento<=value && toDo.indexOf(">=")<0){
                                    alertAndFocus("El número del campo '" + descripcionCampo + "' debe ser mayor que " + value + ".", elElemento);
                                    return false;
                                }
                            }
                            if (param=="len"){
                                value = parseInt(value);
                                if (valorElemento.length<value && toDo.indexOf(">=")>0){
                                    alertAndFocus("La longitud del campo '" + descripcionCampo + "' debe ser mayor o igual que " + value + ".", elElemento);
                                    return false;
                                } else if (valorElemento.length<=value && toDo.indexOf(">=")<0){
                                    alertAndFocus("La longitud del campo '" + descripcionCampo + "' debe ser mayor que " + value + ".", elElemento);
                                    return false;
                                }
                            }
                            if (param=="date" || param=="fecha"){
                                if (esVacio(value)){
                                    alertAndFocus("La fecha del campo '" + descripcionCampo + "' no se puede comparar porque la otra fecha está vacia.", elElemento);
                                    return false;
                                } else if (comparaFechas(valorElemento,value)<0 && toDo.indexOf(">=")>0){
                                    alertAndFocus("La fecha del campo '" + descripcionCampo + "' no puede ser anterior a la otra fecha.", elElemento);
                                    return false;
                                } else if (comparaFechas(valorElemento,value)<=0 && toDo.indexOf(">=")<0){
                                    alertAndFocus("La fecha del campo '" + descripcionCampo + "' no puede ser anterior ni igual a la otra fecha.", elElemento);
                                    return false;
                                }
                            }
                        }
                    }

                    if (toDo.indexOf("!=")>0){
                        if (!esVacio(valorElemento)){
                            params = toDo.split("!=");
                            param  = params[0];
                            value  = params[1];
                            if (isNaN(value)){
                                obj   = eval("f." + params[1]);
                                if (obj!=null){
                                    value = obtenerValor(obj);
                                }
                            }
                            if (param=="num" && valorElemento==parseInt(value)){
                                alertAndFocus("El número del campo '" + descripcionCampo + "' no debe ser igual que " + value + ".", elElemento);
                                return false;
                            }
                            if (param=="len" && valorElemento.length==parseInt(value)){
                                alertAndFocus("La longitud del campo '" + descripcionCampo + "' no debe igual que " + value + ".", elElemento);
                                return false;
                            }
                            if (param=="date" || param=="fecha"){
                                if (esVacio(value)){
                                    alertAndFocus("La fecha del campo '" + descripcionCampo + "' no se puede comparar porque la otra fecha está vacia.", elElemento);
                                    return false;
                                } else if (comparaFechas(valorElemento,value)==0){
                                    alertAndFocus("La fecha del campo '" + descripcionCampo + "' no puede ser igual a la otra fecha.", elElemento);
                                    return false;
                                }
                            }
                        }
                    }

                    if (toDo.indexOf("==")>0){
                        if (!esVacio(valorElemento)){
                            params = toDo.split("==");
                            param  = params[0];
                            value  = params[1];
                            if (isNaN(value)){
                                obj   = eval("f." + params[1]);
                                if (obj!=null){
                                    value = obtenerValor(obj);
                                }
                            }
                            if (param=="str" && valorElemento!=value){
                                alertAndFocus("El campo '" + descripcionCampo + "' debe ser igual que el otro.", elElemento);
                                return false;
                            }
                            if (param=="num" && valorElemento!=parseInt(value)){
                                alertAndFocus("El número del campo '" + descripcionCampo + "' debe ser igual que " + value + ".", elElemento);
                                return false;
                            }
                            if (param=="len" && valorElemento.length!=parseInt(value)){
                                alertAndFocus("La longitud del campo '" + descripcionCampo + "' debe igual que " + value + ".", elElemento);
                                return false;
                            }
                            if (param=="date" || param=="fecha"){
                                if (esVacio(value)){
                                    alertAndFocus("La fecha del campo '" + descripcionCampo + "' no se puede comparar porque la otra fecha está vacia.", elElemento);
                                    return false;
                                } else if (comparaFechas(valorElemento,value)!=0){
                                    alertAndFocus("La fecha del campo '" + descripcionCampo + "' tiene que ser igual a la otra fecha.", elElemento);
                                    return false;
                                }
                            }
                        }
                    }


                }

            }

        }

    }

    return true;

}

//-->