//=============================================================================
// PROJETO:...: FAMILY CARE
//-----------------------------------------------------------------------------
// MODULO.....: validateform.js
//              Rotinas para validacao de campos de formularios WEB.
//-----------------------------------------------------------------------------
// AUTOR......: Joao Luiz Piza de Souza Rodrigues
// VERSAO.....: 01.01
// DATA.......: Junho de 2001
//-----------------------------------------------------------------------------
// COMENTARIO.: Este modulo possui funcoes reaproveitaveis para a validacao de
//              campos preenchidos pelo usuario num formulario WEB. Estas fun-
//              coes executam no lado do cliente (browser), liberando o servi-
//              dor.
//-----------------------------------------------------------------------------
// REVISOES:
//------+-------+------------+-------------------------------------------------
// 01.00 | JLPSR | 10/06/2001 | Versao inicial
//=============================================================================

//-----------------------------------------------------------------------------
// Notas que se aplicam as expressoes regulares (RegExps) declaradas abaixo:
//
// 1) Queremos coincidir as cadeias de caracteres exatamente. Em outras pala-
//    vras, queremos um retorno verdadeiro se a cadeia sendo testada coincidir
//    com a expressao regular sem outros caracteres nao coincidentes no inicio
//    nem no final da cadeia. Porisso, comecamos cada RegExp com o caracter es-
//    pecial ^ (que designa o inicio dos dados) e terminamos com o caracter es-
//    pecial $ (que indica o final da cadeia).
// 2) Nos comentarios abaixo, usamos as seguintes abreviacoes:
//    BOI = Beginning Of Input (Inicio da cadeia de caracteres)
//    EOI = End Of Input (Final da cadeia de caracteres)
// 3) Ignore a primeira e a ultima barra inclinada (/).E 'apenas um delimitador
//    para a expressao regular.
// 4) Para maiores explicacoes sobre caracteres especiais componentes de uma
//    expressao regular, tais como ^ $ \s + [] \d * ! ? \ . consulte:
//
//    http://developer.netscape.com/library/documentation/communicator/jsguide/regexp.htm
//-----------------------------------------------------------------------------

// BOI, seguido por um ou mais caracteres brancos, seguidos por EOI.
var reWhitespace = /^\s+$/
//var reWhitespace = new RegExp( "^\\s+$", "ig" );

// BOI, seguido por um ou mais digitos, seguido por EOI.
// var reInteger = /^\d+$/
var reInteger = /(^\d{1,3}(\.\d{3})*$)|(^\d+$)/

// BOI, seguido por um + ou um - opcional, seguido por um ou mais digitos, 
// seguido por EOI.
var reSignedInteger = /^(\+|-)?\d+$/
//var reSignedInteger = new RegExp( "^\\d+$", "ig" );

// BOI, seguido por um + ou um - opcional, seguido por um destes dois padroes:
// a) um ou mais digitos, seguidos por ., seguidos por zero ou mais digitos
// b) zero ou mais digitos, seguidos por ., seguido por um ou mais digitos
// ... seguido por EOI.
var reSignedFloat = /^(((\+|-)?\d+(\.\d*)?)|((\+|-)?(\d*\.)?\d+))$/
//var reSignedFloat = new RegExp( "^((\\d+(\\.\\d*)?)|((\\d*\\.)?\\d+))$", "ig" );

// BOI, seguido de um ou dois digitos, seguido de :, seguido de dois digitos,
// seguido, opcionalmente, pelo conjunto de : mais dois digitos, seguidos pela
// abreviatura AM ou PM, seguido por EOI.
var reTime = /^(\d{1,2}):(\d{2})(:(\d{2}))?(\s?(AM|am|PM|pm))?$/
//var reTime = new RegExp( "^(\\d{1,2}):(\\d{2})(:(\\d{2}))?(\\s?(AM|am|PM|pm))?$" );

// BOI, seguido por um ou dois digitos, seguido por uma / ou um -, seguido por
// mais dois digitos, seguido, novamente por / ou -, seguido por quatro digitos
// seguido por EOI.
var reDate = /^(\d{1,2})(\/|-)(\d{1,2})\2(\d{4})$/
//var reDate = new RegExp( "^(\\d{1,2})(\\/|-)(\\d{1,2})\\2(\\d{4})$" );

// A variavel global defaultEmptyOK define o valor de retorno default para
// varias funcoes 'as quais se pode passar uma cadeia vazia. Se nada for es-
// pecificado em contrario, elas retornarao o conteudo de defaultEmptyOK.
//
// defaultEmptyOK e' falso, o que significa que, por default, estas funcoes
// farao uma validacao "estrita". A funcao IsInteger, por exemplo, somente re-
// tornara' true se lhe for passada uma cadeia contendo um numero inteiro; se
// receber uma cadeia vazia, ela retornara' false.
//
// Pode-se alterar globalmente este comportamento padrao (para todas as funcoes
// que usam defaultEmptyOK) trocando o valor desta variavel.
//
// Muitas destas funcoes possuem um argumento opcional emptyOK que permite so-
// brepor este comportamento padrao durante a chamada de uma funcao.
//
// Esta funcionalidade e' util porque e' possivel dizer "se o usuario puser
// qualquer coisa neste campo, esta coisa deve ser um inteiro (ou um numero de
// telefone, ou uma cadeia alfanumerica, etc.), mas ele tambem pode deixar o
// campo vazio". Este e' o caso de campos opcionais, mas que devem conter um
// certo tipo de conteudo, se preenchidos.
var defaultEmptyOK = false;

// Abreviaturas validas para os estados brasileiros e o distrito federal.
var BRStateCodes = "AC|AL|AP|AM|BA|CE|DF|ES|GO|MA|MT|MS|MG|PA|PB|PR|PE|PI|RJ|RN|RS|RO|RR|SC|SP|SE|TO|"
var BRStateCodeDelimiter = "|";

var strError;

//-----------------------------------------------------------------------------
// FUNCAO..............: changeColor
//-----------------------------------------------------------------------------
// DESCRICAO...........: Muda o estilo da borda, a cor da borda e a cor de fun-
//                       do de um dado campo de texto.
// PARAMETROS (ENTRADA): field - Referencia valida para um campo de texto.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Nada.
//-----------------------------------------------------------------------------
function changeColor( field )
{
    field.style.borderColor     = "red";
    field.style.borderStyle     = "solid";
    field.style.backgroundColor = "yellow";
}

//-----------------------------------------------------------------------------
// FUNCAO..............: restoreColor
//-----------------------------------------------------------------------------
// DESCRICAO...........: Restaura para branco a cor de fundo de um dado campo
//                       de texto quando ele recebe o foco.
// PARAMETROS (ENTRADA): Nenhum.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Nada.
//-----------------------------------------------------------------------------
function restoreColor( field )
{
    field.style.borderColor     = "";
    field.style.borderStyle     = "inset";
    field.style.backgroundColor = "white";
}

//-----------------------------------------------------------------------------
// FUNCAO..............: stripCharsInBag
//-----------------------------------------------------------------------------
// DESCRICAO...........: Retira todos os caracteres presentes na cadeia de cara-
//                       cteres bag da cadeia s.
// PARAMETROS (ENTRADA): s   - Cadeia da qual se quer filtrar caracteres.
//                       bag - Cadeia que contem os caracteres que se quer ex-
//                             cluir.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Cadeia s filtrada dos caracteres em bag.
//-----------------------------------------------------------------------------
function stripCharsInBag( s, bag )
{
    var i;
    var returnString = "";


    // Obtem cada caracter da cadeia pesquisada; se o caracter nao esta' na
    // cadeia bag, adiciona-o 'a cadeia returnString.
    for ( i = 0; i < s.length; i++ ) {   
        var c = s.charAt( i );
        if (bag.indexOf( c ) == -1) returnString += c;
    }
    return returnString;
}

//-----------------------------------------------------------------------------
// FUNCAO..............: isStateCode( field[, BOOLEAN emptyOK] )
//-----------------------------------------------------------------------------
// DESCRICAO...........: Verifica se a cadeia de caracteres fornecida como pa-
//                       rametro contem um codigo (abreviatura) valido para um
//                       estado brasileiro.
// PARAMETROS (ENTRADA): field   - Referencia valida para um campo de texto.
//                       emptyOK - Veja comentarios no inicio deste arquivo.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Retorna true se a cadeia esta' contem uma abreviatura
//                       valida.
//-----------------------------------------------------------------------------
function isStateCode( field )
{
    var retCode;
    var s = Trim( field.value.toUpperCase( ) );

    if ( isEmpty( s ) ) {
        if ( isStateCode.arguments.length == 1 ) {
            if ( defaultEmptyOK == false ) {
                strError = "- Unidade da Federacao em branco";
                changeColor( field );
            }
            return defaultEmptyOK;
        } else {
            if ( isStateCode.arguments[ 1 ] == false ) {
                strError = "- Unidade da Federacao em branco";
                changeColor( field );
            }
            return ( isStateCode.arguments[ 1 ] == true );
        }
    }
    retCode = ( ( BRStateCodes.indexOf( s ) != -1 ) && ( s.indexOf( BRStateCodeDelimiter ) == -1 ) );
	if ( retCode == false ) {
        strError = "- Unidade da Federacao invalida";
        changeColor( field );
    } else {
        field.value = s;
    }
	return( retCode );
}

//-----------------------------------------------------------------------------
// FUNCAO..............: isEmpty
//-----------------------------------------------------------------------------
// DESCRICAO...........: Verifica se a cadeia de caracteres fornecida como pa-
//                       rametro esta' vazia ou em branco.
// PARAMETROS (ENTRADA): s - Cadeia de caracteres (string) a verificar
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Retorna true se a cadeia esta' vazia ou contem apenas
//                       caracteres brancos (espaco, tab, etc.).
//-----------------------------------------------------------------------------
function isEmpty( s )
{
    return( ( s == null ) || ( s.length == 0 ) || reWhitespace.test( s ) );
}

//-----------------------------------------------------------------------------
// FUNCAO..............: isTime
//-----------------------------------------------------------------------------
// DESCRICAO...........: Verifica se a cadeia de caracteres fornecida como pa-
//                       rametro e' uma hora valida no formato HH:MM:SS AM/PM.
//                       Os segundos e AM/PM sao opcionais.
// PARAMETROS (ENTRADA): field - Referencia valida para um campo de entrada de
//                               texto a validar.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Retorna true se for uma hora valida.
//-----------------------------------------------------------------------------
function isTime( field )
{
    var fieldVal   = Trim( field.value );
    var matchArray = fieldVal.match( reTime );
    
    if ( matchArray == null ) {
        strError="- Formato invalido para hora.\nUse os formatos HH:MM ou HH:MM:SS";
        return false;
    }
    hour   = matchArray[ 1 ];
    minute = matchArray[ 3 ];
    second = matchArray[ 4 ];

    if ( second == "" ) second = null;

    if ( hour < 0  || hour > 23 ){
        strError = "- As horas devem estar entre 1 e 23.";
        return false;
    }
    if ( minute < 0 || minute > 59 ) {
        strError = "- Os minutos devem estar entre 0 e 59.";
        return false;
    }
    if ( second != null && ( second < 0 || second > 59 ) ) {
        strError = "- Os segundos devem estar entre 0 e 59.";
        return false;
    }
    if ( second == null ) fieldVal += ":00";

    strError = "- Hora valida.";
    return true;
}

//-----------------------------------------------------------------------------
// FUNCAO..............: isInteger( TEXTFIELD field[, BOOLEAN emptyOK] )
//-----------------------------------------------------------------------------
// DESCRICAO...........: Verifica se a cadeia de caracteres fornecida como pa-
//                       rametro e' composta por um numero inteiro sem sinal.
// PARAMETROS (ENTRADA): field - Referencia valida para um campo de entrada de
//                               texto a validar.
//                       emptyOK - Veja comentarios no inicio deste arquivo.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Retorna true se for um numero inteiro, sem sinal
//
//      EXEMPLOS DE CHAMADAS:     RESULTADO:
//      isInteger( "5" )          true 
//      isInteger( "" )           defaultEmptyOK
//      isInteger( "-5" )         true
//      isInteger( "+5" )         true
//      isInteger( "", false )    false
//      isInteger( "", true )     true
//-----------------------------------------------------------------------------
function isInteger( field )
{
    var n1, n2;
    var s = Trim( field.value );

    if ( isEmpty( s ) ) {
        if ( isInteger.arguments.length == 1 ) {
            if ( defaultEmptyOK == false ) {
                strError = "- Numero em branco";
                changeColor( field );
            }
            return defaultEmptyOK;
        } else {
            if ( isInteger.arguments[ 1 ] == false ) {
                strError = "- Numero em branco";
                changeColor( field );
            }
            return ( isInteger.arguments[ 1 ] == true );
        }
    } else {
        if ( reInteger.test( s ) == false ) {
            strError = "- Numero deve ser inteiro, sem sinal";
            changeColor( field );
			return( false );
        } else {
            s = stripCharsInBag( s, "." );
            field.value = s;
            if ( field.maxvalue != "" ) {
                n1 = s * 1;
                n2 = field.maxvalue * 1;
                if ( n1 > n2 ) {
                    strError = "- Numero superior a " + field.maxvalue;
                    changeColor( field );
                    return false;
                }
            }
            if ( field.minvalue != "" ) {
                n1 = s * 1;
                n2 = field.minvalue * 1;
                if ( n1 < n2 ) {
                    strError = "- Numero inferior a " + field.minvalue;
                    changeColor( field );
                    return false;
                }
            }
            return( true );
        }
    }
}

//-----------------------------------------------------------------------------
// FUNCAO..............: isSignedInteger( STRING s [, BOOLEAN emptyOK] )
//-----------------------------------------------------------------------------
// DESCRICAO...........: Verifica se a cadeia de caracteres fornecida como pa-
//                       rametro e' composta por numeros; permite-se que o pri-
//                       meiro caracter seja + ou -. Nao permite ponto flutuan-
//                       te, notacao exponencial, etc.
// PARAMETROS (ENTRADA): s       - Cadeia de caracteres (string) a verificar
//                       emptyOK - Veja comentarios no inicio deste arquivo.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Retorna true se for um numero inteiro.
//
//      EXEMPLOS DE CHAMADAS:           RESULTADO:
//      isSignedInteger( "5" )          true 
//      isSignedInteger( "" )           defaultEmptyOK
//      isSignedInteger( "-5" )         true
//      isSignedInteger( "+5" )         true
//      isSignedInteger( "", false )    false
//      isSignedInteger( "", true )     true
//-----------------------------------------------------------------------------
function isSignedInteger( s )
{
    if ( isEmpty( s ) ) 
        if ( isSignedInteger.arguments.length == 1 ) return defaultEmptyOK;
        else return( isSignedInteger.arguments[ 1 ] == true );
    else {
        return reSignedInteger.test( s );
    }
}

//-----------------------------------------------------------------------------
// FUNCAO..............: isSignedFloat( STRING s [, BOOLEAN emptyOK] )
//-----------------------------------------------------------------------------
// DESCRICAO...........: Verifica se a cadeia de caracteres fornecida como pa-
//                       rametro representa um numero de ponto flutuante (real)
//                       com ou sem sinal. Permite-se que o primeiro caracter
//                       seja + ou -. Nao aceita notacao exponencial.
//                       Tambem retorna true para inteiros sem sinal. Para dis-
//                       tinguir entre inteiros e numeros de ponto flutuante,
//                       chame primeiro isSignedInteger, depois isSignedFloat.
// PARAMETROS (ENTRADA): s       - Cadeia de caracteres (string) a verificar
//                       emptyOK - Veja comentarios no inicio deste arquivo.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Retorna true se for um numero real.
//-----------------------------------------------------------------------------
function isSignedFloat( s )
{
    if ( isEmpty( s ) ) 
        if ( isSignedFloat.arguments.length == 1 ) return defaultEmptyOK;
        else return ( isSignedFloat.arguments[ 1 ] == true );
    else {
        return reSignedFloat.test( s );
    }
}

//-----------------------------------------------------------------------------
// FUNCAO..............: isNumeric
//-----------------------------------------------------------------------------
// DESCRICAO...........: Verifica se a cadeia de caracteres fornecida como pa-
//                       rametro representa um numero de ponto flutuante (real)
//                       ou interio, com ou sem sinal. Permite-se que o primei-
//                       ro caracter seja + ou -. Nao aceita notacao exponen-
//                       cial.
// PARAMETROS (ENTRADA): s       - Cadeia de caracteres (string) a verificar
//                       emptyOK - Veja comentarios no inicio deste arquivo.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Retorna true se for um numero inteiro.
//-----------------------------------------------------------------------------
function IsNumeric( s )
{
    return isSignedInteger( s ) || isSignedFloat( s );
}

//-----------------------------------------------------------------------------
// FUNCAO..............: isDate( TEXTFIELD field[, BOOLEAN emptyOK] )
//-----------------------------------------------------------------------------
// DESCRICAO...........: Verifica se a cadeia de caracteres fornecida como pa-
//                       rametro representa uma data valida.
// PARAMETROS (ENTRADA): field - Referencia valida para um campo de entrada de
//                               texto a validar.
//                       emptyOK - Veja comentarios no inicio deste arquivo.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Retorna true se for uma data.
//-----------------------------------------------------------------------------
function isDate( field )
{
    var dateStr = Trim( field.value );
    var matchArray = dateStr.match( reDate );
    
    if ( isEmpty( dateStr ) ) {
        if ( isDate.arguments.length == 1 ) {
            if ( defaultEmptyOK == false ) {
                strError = "- Data em branco";
                changeColor( field );
            }
            return defaultEmptyOK;
        } else {
            if ( isDate.arguments[ 1 ] == false ) {
                strError = "- Data da Federacao em branco";
                changeColor( field );
            }
            return ( isDate.arguments[ 1 ] == true );
        }
    }
    day   = matchArray[ 1 ];
    month = matchArray[ 3 ];
    year  = matchArray[ 4 ];
    
    if ( ( month < 1 || month > 12 ) ||
         ( day < 1 || day > 31 )     ||
         ( ( month == 4 || month == 6 || month == 9 || month == 11 ) && day == 31 ) ) {
        strError = "- A data fornecida nao e valida";
        changeColor( field );
        return false;
    }
    if ( month == 2 ) {
        var isleap = ( year % 4 == 0 && ( year % 100 != 0 || year % 400 == 0 ) );
        if ( day > 29 || ( day==29 && !isleap ) ) {
            strError = "- A data fornecida nao e valida";
            changeColor( field );
            return false;
        }
    }
    field.value = day + "/" + month + "/" + year;
    return true;
}

//-----------------------------------------------------------------------------
// FUNCAO..............: isEmail( TEXTFIELD field[, BOOLEAN emptyOK] )
//-----------------------------------------------------------------------------
// DESCRICAO...........: Verifica se a cadeia de caracteres fornecida como pa-
//                       rametro contem uma expressao que pode ser considerada
//                       um endereco de e-mail valido.
// PARAMETROS (ENTRADA): field - Referencia valida para um campo de entrada de
//                               texto a validar.
//                       emptyOK - Veja comentarios no inicio deste arquivo.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Retorna true se for uma expressao de e-mail valida.
//-----------------------------------------------------------------------------
function isEmail( field )
{
    var s = Trim( field.value );
	
	
    if ( isEmpty( s ) ) {
        if ( isEmail.arguments.length == 1 ) {
            if ( defaultEmptyOK == false ) {
                strError = "- E-mail em branco";
                changeColor( field );
            }
            return defaultEmptyOK;
        } else {
            if ( isEmail.arguments[ 1 ] == false ) {
                strError = "- E-mail em branco";
                changeColor( field );
            }
            return ( isEmail.arguments[ 1 ] == true );
        }
    }
    var supported = 0;
	var retCode;
    if ( window.RegExp ) {
        var tempStr = "a";
        var tempReg = new RegExp( tempStr );
        if ( tempReg.test( tempStr ) ) supported = 1;
    }
    if ( !supported )
        retCode = ( s.indexOf( "." ) > 2 ) && ( s.indexOf( "@" ) > 0 );
    else {
        var r1 = new RegExp( "(@.*@)|(\\.\\.)|(@\\.)|(^\\.)" );
        var r2 = new RegExp( "^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$" );
        retCode = ( !r1.test( s ) && r2.test( s ) );
    }
    if ( retCode == false ) {
        strError = "- E-mail invalido";
        changeColor( field );
    }
	return( retCode );
}

//-----------------------------------------------------------------------------
// FUNCAO..............: Left
//-----------------------------------------------------------------------------
// DESCRICAO...........: Reproduz a funcao Left da linguagem VB/VBScript. Re-
//                       torna uma cadeia contendo um numero especificado de
//                       caracteres a contar do lado esquerdo da cadeia forne-
//                       cida.
// PARAMETROS (ENTRADA): String - Cadeia de caracteres da qual a porcao mais 'a
//                                esquerda e' retornada. Se a cadeia contiver
//                                null, retorna false.
//                       Length - Expressao numerica indicando quantos caracte-
//                                res retornar. Se 0, retorna uma cadeia de
//                                comprimento zero (""). Se maior ou igual ao
//                                numero de caracteres da cadeia original, re-
//                                torna toda a cadeia original.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Veja acima.
//-----------------------------------------------------------------------------
function Left( String, Length )
{
    if ( String == null ) return( false );

    return String.substr( 0, Length );
}

//-----------------------------------------------------------------------------
// FUNCAO..............: Len
//-----------------------------------------------------------------------------
// DESCRICAO...........: Reproduz a funcao Len da linguagem VB/VBScript. Infor-
//                       ma o numero de caracteres de uma cadeia fornecida como
//                       parametro (ou o numero de caracteres necessario para
//                       armazenar uma variavel.
// PARAMETROS (ENTRADA): String - Qualquer expressao que represente uma cadeia
//                                de caracteres (string) valida. Se contiver
//                                null, retorna false.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Veja acima.
//-----------------------------------------------------------------------------
function Len( string )
{
    if ( string == null ) return( false );

    return String( string ).length;
}

//-----------------------------------------------------------------------------
// FUNCAO..............: Right
//-----------------------------------------------------------------------------
// DESCRICAO...........: Reproduz a funcao Right da linguagem VB/VBScript. Re-
//                       torna uma cadeia contendo um numero especificado de
//                       caracteres a contar do lado direito da cadeia forne-
//                       cida.
// PARAMETROS (ENTRADA): String - Cadeia de caracteres da qual a porcao mais 'a
//                                direita e' retornada. Se a cadeia contiver
//                                null, retorna false.
//                       Length - Expressao numerica indicando quantos caracte-
//                                res retornar. Se 0, retorna uma cadeia de
//                                comprimento zero (""). Se maior ou igual ao
//                                numero de caracteres da cadeia original, re-
//                                torna toda a cadeia original.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Veja acima.
//-----------------------------------------------------------------------------
function Right( String, Length )
{
    if ( String == null ) return( false );

    var dest = '';
    for ( var i = ( String.length - 1 ); i >= 0; i-- )
        dest = dest + String.charAt( i );

    String = dest;
    String = String.substr(0, Length);
    dest = '';

    for ( var i = ( String.length - 1 ); i >= 0; i-- )
        dest = dest + String.charAt( i );

    return dest;
}

//-----------------------------------------------------------------------------
// FUNCAO..............: Space
//-----------------------------------------------------------------------------
// DESCRICAO...........: Reproduz a funcao Space da linguagem VB/VBScript. Re-
//                       torna uma cadeia contendo um numero especificado de
//                       espacos.
// PARAMETROS (ENTRADA): Number - Numero de espacos que devem compor a cadeia
//                                retornada.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Veja acima.
//-----------------------------------------------------------------------------
function Space( Number )
{
    var temp = '';

    if ( Number < 1 ) return '';

    for ( var i = 0; i < Number; i++ )
        temp = temp + ' ';

    return temp;
}

//-----------------------------------------------------------------------------
// FUNCAO..............: InStr
//-----------------------------------------------------------------------------
// DESCRICAO...........: Reproduz a funcao InStr da linguagem VB/VBScript. In-
//                       forma a posicao da primeira ocorrencia de uma cadeia
//                       de caracteres (String1) dentro de uma outra (String2).
//                       Se String1 for null, retorna false.
// PARAMETROS (ENTRADA): String1 - Cadeia procurada.
//                       String2 - Cadeia onde se procura.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Veja acima.
//-----------------------------------------------------------------------------
function InStr( String1, String2 )
{
    var a = 0;

    if ( String1 == null || String2 == null )
        return( false );

    String1 = String1.toLowerCase( );
    String2 = String2.toLowerCase( );

    a = String1.indexOf( String2 );
    if ( a == -1 ) return 0;
    else           return a + 1;
}

//-----------------------------------------------------------------------------
// FUNCAO..............: LTrim
//-----------------------------------------------------------------------------
// DESCRICAO...........: Reproduz a funcao LTrim da linguagem VB/VBScript. Re-
//                       torna uma cadeia de caracteres contendo uma copia da
//                       cadeia fornecida como parametro sem os espacos que es-
//                       ta eventualmente contenha em seu inicio.
// PARAMETROS (ENTRADA): String - Cadeia de caracteres valida. Se contiver null
//                                retorna false.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Veja acima.
//-----------------------------------------------------------------------------
function LTrim( String )
{
    var i = 0;
    var j = String.length - 1;

    if ( String == null ) return( false );

    for ( i = 0; i < String.length; i++ ) {
        if ( String.substr( i, 1 ) != ' ' && String.substr( i, 1 ) != '\t' )
            break;
    }
    if ( i <= j ) return( String.substr( i, ( j + 1 ) - i ) );
    else          return( '' );
}

//-----------------------------------------------------------------------------
// FUNCAO..............: RTrim
//-----------------------------------------------------------------------------
// DESCRICAO...........: Reproduz a funcao RTrim da linguagem VB/VBScript. Re-
//                       torna uma cadeia de caracteres contendo uma copia da
//                       cadeia fornecida como parametro sem os espacos que es-
//                       ta eventualmente contenha em seu final.
// PARAMETROS (ENTRADA): String - Cadeia de caracteres valida. Se contiver null
//                                retorna false.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Veja acima.
//-----------------------------------------------------------------------------
function RTrim( String )
{
    var i = 0;
    var j = String.length - 1;

    if ( String == null ) return( false );

    for( j = String.length - 1; j >= 0; j-- ) {
        if ( String.substr( j, 1 ) != ' ' && String.substr( j, 1 ) != '\t' )
        break;
    }
    if ( i <= j ) return( String.substr( i, ( j + 1 ) - i ) );
    else          return( '' );
 }

//-----------------------------------------------------------------------------
// FUNCAO..............: Trim
//-----------------------------------------------------------------------------
// DESCRICAO...........: Reproduz a funcao Trim da linguagem VB/VBScript. Re-
//                       torna uma cadeia de caracteres contendo uma copia da
//                       cadeia fornecida como parametro sem os espacos que es-
//                       ta eventualmente contenha em seu inicio e/ou final.
// PARAMETROS (ENTRADA): String - Cadeia de caracteres valida. Se contiver null
//                                retorna false.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Veja acima.
//-----------------------------------------------------------------------------
function Trim( String )
{
    if ( String == null ) return ( false );

    return RTrim( LTrim( String ) );
}

//-----------------------------------------------------------------------------
// FUNCAO..............: IntDivide
//-----------------------------------------------------------------------------
// DESCRICAO...........: Em JavaScript, a divisao de dois valores inteiros leva
//                       a um resultado de ponto flutuante (ao contrario do que
//                       acontece em VBScript, Java, C, C++...). Esta funcao
//                       executa uma divisao inteira.
// PARAMETROS (ENTRADA): String - Cadeia de caracteres a validar.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Retorna o quociente inteiro da divisao do numerador
//                       pelo denominador.
//-----------------------------------------------------------------------------
function IntDivide( numerator, denominator )
{
    // Para encontrar o quociente inteiro, primeiro diminui o numerador do va-
    // lor do resto; depois, divide.
    var remainder = numerator % denominator;
    var quotient = ( numerator - remainder ) / denominator;

    // Outra solucao possivel, converter o quociente para um inteiro por trun-
    // camento. Observe que a funcao floor nao serve para quocientes negativos.
    /*
    if ( quotient >= 0 )
        quotient = Math.floor( quotient );
    else 
        quotient = Math.ceil( quotient );
    */
    return( quotient );
}

//-----------------------------------------------------------------------------
// FUNCAO..............: isCPF( TEXTFIELD field[, BOOLEAN emptyOK] )
//-----------------------------------------------------------------------------
// DESCRICAO...........: Verifica se a cadeia de caracteres fornecida como pa-
//                       rametro contem um CPF valido.
// PARAMETROS (ENTRADA): field - Referencia valida para um campo de entrada de
//                               texto a validar.
//                       emptyOK - Veja comentarios no inicio deste arquivo.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Retorna true se for CPF valido; senao, retorna false.
//-----------------------------------------------------------------------------
function isCPF( field )
{
    var String, sCPF, soma, result1, result2, ch, i, j;
    var Number = new Array( 11 );

    String = Trim( field.value );
    if ( isEmpty( String ) ) {
        if ( isCPF.arguments.length == 1 ) {
            if ( defaultEmptyOK == false ) {
                strError = "- CPF em branco";
                changeColor( field );
            }
            return defaultEmptyOK;
        } else {
            if ( isCPF.arguments[ 1 ] == false ) {
                strError = "- CPF em branco";
                changeColor( field );
            }
            return ( isCPF.arguments[ 1 ] == true );
        }
    }
    // Retira todos os caracteres que nao sejam 0-9
    sCPF = '';
    for ( i = 0, j = 0; i < String.length; i++ ) {
        ch = String.charCodeAt( i );
        if ( ch >= 48 && ch <= 57 ) {
            sCPF = sCPF + String.charAt( i );
            if ( j < 11 ) Number[ j++ ] = ch - 48;
        }
    }
    if ( sCPF.length != 11 ) {
        strError = "- CPF tem obrigatoriamente 11 digitos";
    } else if ( sCPF == "00000000000" || sCPF == "88888888888" ) {
        strError = "- CPF invalido";
    } else {
        soma = 10 * Number[0] + 9 * Number[1] + 8 * Number[2] + 7 * Number[3] + 6 * Number[4] + 5 * Number[5] + 4 * Number[6] + 3 * Number[7] + 2 * Number[8];
        soma = soma - ( 11 * IntDivide( soma, 11 ) );

        if ( soma == 0 || soma == 1 ) result1 = 0;
        else                          result1 = 11 - soma;

        if ( result1 == Number[9] ) {
            soma = Number[0] * 11 + Number[1] * 10 + Number[2] * 9 + Number[3] * 8 + Number[4] * 7 + Number[5] * 6 + Number[6] * 5 + Number[7] * 4 + Number[8] * 3 + Number[9] * 2;
            soma = soma - ( 11 * IntDivide( soma, 11 ) );
        
            if ( soma == 0 || soma == 1 ) result2 = 0;
            else                          result2 = 11 - soma;
        
            if ( result2 == Number[ 10 ] ) {
                strError = "- CPF valido";
                field.value = sCPF;
				return true;
            } else {
                strError = "- CPF invalido";
            }
        } else {
            strError = "- CPF invalido";
        }
    }
    changeColor( field );
    return false;
}

//-----------------------------------------------------------------------------
// FUNCAO..............: isCNPJ( TEXTFIELD field[, BOOLEAN emptyOK] )
//-----------------------------------------------------------------------------
// DESCRICAO...........: Verifica se a cadeia de caracteres fornecida como pa-
//                       rametro contem um CNPJ valido.
// PARAMETROS (ENTRADA): field - Referencia valida para um campo de entrada de
//                               texto a validar.
//                       emptyOK - Veja comentarios no inicio deste arquivo.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Retorna true se for CNPJ valido; senao, retorna false.
//-----------------------------------------------------------------------------
function isCNPJ( field )
{
    var String, sCPF, soma, result1, result2, ch, i, j;
    var Number = new Array( 11 );

    String = Trim( field.value );
    if ( isEmpty( String ) ) {
        if ( isCNPJ.arguments.length == 1 ) {
            if ( defaultEmptyOK == false ) {
                strError = "- CNPJ em branco";
                changeColor( field );
            }
            return defaultEmptyOK;
        } else {
            if ( isCNPJ.arguments[ 1 ] == false ) {
                strError = "- CNPJ em branco";
                changeColor( field );
            }
            return ( isCNPJ.arguments[ 1 ] == true );
        }
    }
    // Retira todos os caracteres que nao sejam 0-9
    sCNPJ = '';
    for ( i = 0, j = 0; i < String.length; i++ ) {
        ch = String.charCodeAt( i );
        if ( ch >= 48 && ch <= 57 ) {
            sCNPJ = sCNPJ + String.charAt( i );
            if ( j < 14 ) Number[ j++ ] = ch - 48;
        }
    }
    if ( sCNPJ.length != 14 ) {
        strError = "- CNPJ tem obrigatoriamente 14 digitos";
    } else if ( sCNPJ == "00000000000000" ) {
        strError = "- CNPJ invalido";
    } else {
        soma = Number[0] * 5 + Number[1] * 4 + Number[2] * 3 + Number[3] * 2 + Number[4] * 9 + Number[5] * 8 + Number[6] * 7 + Number[7] * 6 + Number[8] * 5 + Number[9] * 4 + Number[10] * 3 + Number[11] * 2;
        soma = soma - ( 11 * IntDivide( soma, 11 ) );
        
        if ( soma == 0 || soma == 1 ) result1 = 0;
        else                          result1 = 11 - soma;
        
        if ( result1 == Number[ 12 ] ) {
            soma = Number[0] * 6 + Number[1] * 5 + Number[2] * 4 + Number[3] * 3 + Number[4] * 2 + Number[5] * 9 + Number[6] * 8 + Number[7] * 7 + Number[8] * 6 + Number[9] * 5 + Number[10] * 4 + Number[11] * 3 + Number[12] * 2;
            soma = soma - ( 11 * IntDivide( soma, 11 ) );
            
            if ( soma == 0 || soma == 1 ) result2 = 0
            else                          result2 = 11 - soma;
            
            if ( result2 == Number[ 13 ] ) {
                strError = "- CNPJ valido";
                field.value = sCNPJ;
				return true;
            } else {
                strError = "- CNPJ invalido";
            }
        } else {
            strError = "- CNPJ invalido";
        }
    }
    changeColor( field );
    return false;
}

//-----------------------------------------------------------------------------
// FUNCAO..............: isMoney( TEXTFIELD field[, BOOLEAN emptyOK] )
//-----------------------------------------------------------------------------
// DESCRICAO...........: Verifica se a cadeia de caracteres fornecida como pa-
//                       rametro representa um valor monetario.
// PARAMETROS (ENTRADA): field - Referencia valida para um campo de entrada de
//                               texto a validar.
//                       emptyOK - Veja comentarios no inicio deste arquivo.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Retorna true se for um valor monetario, sem sinal.
//-----------------------------------------------------------------------------
function isMoney( field )
{
    var commaPos;
    // BOI, seguido por um destes dois padroes:
    // a) um ou mais digitos, seguido por ",", seguido por zero ou mais digitos.
    // b) zero ou mais digitos, seguido por "," seguido por um ou mais digitos.
    // ... seguido por EOI.
    var reMoney = /^((\d+(,\d*)?)|((\d*,)?\d+))$/
	var s = Trim( field.value );

    if ( isEmpty( s ) ) {
        if ( isMoney.arguments.length == 1 ) {
            if ( defaultEmptyOK == false ) {
                strError = "- Valor monetario em branco";
                changeColor( field );
            }
            return defaultEmptyOK;
        } else {
            if ( isMoney.arguments[ 1 ] == false ) {
                strError = "- Valor monetario em branco";
                changeColor( field );
            }
            return ( isMoney.arguments[ 1 ] == true );
        }
    }
    // Retira eventuais pontos separadores de milhares, cifroes, etc., deixan-
    // do, espera-se, apenas numeros e uma virgula.
	s = stripCharsInBag( s, ".rR$ \t\n\r\f\v");

	if ( reMoney.test( s ) ) {
        commaPos = s.indexOf( "," );
        if ( commaPos == -1 ) {
            s = s + ",00";
            commaPos = s.indexOf( "," );
        } else if ( commaPos == 0 ) {
            s = "0" + s;
            commaPos = s.indexOf( "," );
        }
        if ( commaPos == s.length - 1 ) s = s + "00";
        else if ( commaPos == s.length - 2 ) s = s + "0";
        else if ( commaPos < s.length - 2 ) s = s.substr( 0, commaPos + 3 );
        field.value = s;
        return true;
    } else {
        strError = "- Valor monetario invalido";
        changeColor( field );
        return false;
    }
}

//-----------------------------------------------------------------------------
// FUNCAO..............: isCep( TEXTFIELD field[, BOOLEAN emptyOK] )
//-----------------------------------------------------------------------------
// DESCRICAO...........: Verifica se a cadeia de caracteres fornecida como pa-
//                       rametro representa um Codigo de Enderecamento Postal.
// PARAMETROS (ENTRADA): field - Referencia valida para um campo de entrada de
//                               texto a validar.
//                       emptyOK - Veja comentarios no inicio deste arquivo.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Retorna true se for (parecer) um CEP.
//-----------------------------------------------------------------------------
function isCEP( field )
{
//    var reCEP = /^\d{5}(-|.|\s)?\d{3}$/
    var reCEP = /^\d{4,5}(-|.|\s){1}\d{3}$/
    var s = Trim( field.value );

    if ( isEmpty( s ) ) {
        if ( isCEP.arguments.length == 1 ) {
            if ( defaultEmptyOK == false ) {
                strError = "- CEP em branco";
                changeColor( field );
            }
            return defaultEmptyOK;
        } else {
            if ( isCEP.arguments[ 1 ] == false ) {
                strError = "- CEP em branco";
                changeColor( field );
            }
            return ( isCEP.arguments[ 1 ] == true );
        }
    }
    if ( reCEP.test( s ) ) {
        // Retira eventuais separadores, deixando, espera-se, apenas numeros
        s = stripCharsInBag( s, ".- \t\n\r\f\v");
        field.value = s;
        return true;
    } else {
        strError = "- CEP invalido";
        changeColor( field );
        return false;
    }
}

//-----------------------------------------------------------------------------
// FUNCAO..............: checkCep( TEXTFIELD field)
//-----------------------------------------------------------------------------
// DESCRICAO...........: Funcao auxiliar que, chamada a tratar o evento OnKeyUp,
//                       vai verificando se a cadeia de caracteres recebida ate'
//                       entao representa um Codigo de Enderecamento Postal.
//                       Quando o conteudo do campo de entrada de dados parecer
//                       um CEP, a funcao submete ao servidor o formulario que
//                       contem o campo.
// PARAMETROS (ENTRADA): field - Referencia valida para um campo de entrada de
//                               texto a validar.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Nada.
//-----------------------------------------------------------------------------
function checkCep( field )
{
    if ( isCEP( field ) ) {
        document.forms(0).action = document.forms(0).action + "?cep=" + field.value;
        document.forms(0).submit( );
    }
}

//-----------------------------------------------------------------------------
// FUNCAO..............: isNoBlank( TEXTFIELD field)
//-----------------------------------------------------------------------------
// DESCRICAO...........: Verifica se a cadeia de caracteres fornecida como pa-
//                       rametro e' nao-vazia.
// PARAMETROS (ENTRADA): field - Referencia valida para um campo de entrada de
//                               texto a validar.
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Nada.
//-----------------------------------------------------------------------------
function isNoBlank( field )
{
    var s = field.value;

    if ( isEmpty( s ) ) {
        strError = "- Campo em branco";
        changeColor( field );
        return false;
    } else                return true;
}

//-----------------------------------------------------------------------------
// FUNCAO..............: validateField
//-----------------------------------------------------------------------------
// DESCRICAO...........: Valida, conforme um criterio especificado, um campo de
//                       formulario WEB preenchido pelo usuario.
// PARAMETROS (ENTRADA): field     - Referencia valida para um campo de entra-
//                                   da de textos de um formulario, contendo os
//                                   seguintes atributos:
//                                   value    - Cadeia de caracteres (campo) a
//                                              validar.
//                                   validate - Indica se precisamos usar uma
//                                              expressao regular ou se vamos
//                                              usar uma forma pre'-definida de
//                                              validacao. E' possivel passar
//                                              em validate os seguintes valo-
//                                              res:
//                                              "regexp"  - Se usamos uma expre-
//                                                          ssao regular, deve-
//                                                          mos usar um padrao
//                                                          associado fornecido
//                                                          no atributo pattern.
//                                              "email"   - Assegura que o ende-
//                                                          reco de e-mail nao
//                                                          contem caracteres
//                                                          ilegais e esta' num
//                                                          formato valido.
//                                              "date"    - Assegura que e' uma
//                                                          data valida.
//                                              "noblank" - Assegura que o cam-
//                                                          po contem ao menos
//                                                          um caracter.
//                                              "numeric" - Assegura que o cam-
//                                                          po contem um valor
//                                                          numerico.
//                                              "cgc" ou
//                                              "cnpj"    - Assegura que e' um
//                                                          numero valido para
//                                                          o CNPJ.
//                                              "cpf" ou
//                                              "cnpf"    - Assegura que e' um
//                                                          numero valido para
//                                                          o CNPF.
//                                   pattern  - Se a forma de validacao for
//                                              "regexp", deve conter uma ex-
//                                              pressao regular ou um dos se-
//                                              guintes valores pre'-definidos:
//                                              "phone_1" - Numero no padrao
//                                                          xxx-xxxx-xxxx
//                                              "phone_2" - Numero no padrao
//                                                         (xxx)xxxx-xxxx
//                                              "cep_1"   - Numero no padrao
//                                                          xxxxxxxx
//                                              "cep_2"   - Numero no padrao
//                                                          xxxxx-xxx
// PARAMETROS (SAIDA)..: Nenhum.
// RETORNA.............: Veja acima.
//-----------------------------------------------------------------------------
function validateField( field )
{
    var validateField, sValue, sValidate, sPattern;


    validateField = false;
    if ( field.validate == null ) return validateField;

	sValidate = Trim( field.validate );    // Remove os espacos anteriores e posteriores.
	sValidate = sValidate.toLowerCase( );

    switch ( sValidate ) {
        case "none":
            validateField = true;
            break;

        case "noblank":
        case "mnoblank":                        // Verifica se o valor e' nao-vazio (opcional - brancos OK)
            validateField = isNoBlank( field );
            break;

        case "ocep":                           // Verifica se e' um CPF valido (opcional)
            validateField = isCEP( field, true );
            break;

        case "mcep":                           // Verifica se e' um CPF valido (mandatorio)
            validateField = isCEP( field );
            break;

        case "ocpf":
        case "ocnpf":                          // Verifica se e' um CPF valido (opcional)
            validateField = isCPF( field, true );
            break;
        
        case "mcpf":
        case "mcnpf":                          // Verifica se e' um CPF valido (mandatorio)
            validateField = isCPF( field );
            break;
        
        case "ocgc":
        case "ocnpj":                           // Verifica se e' um CGC valido (opcional)
            validateField = isCNPJ( field, true );
            break;
            
        case "mcgc":
        case "mcnpj":                           // Verifica se e' um CGC valido (mandatorio)
            validateField = isCNPJ( field );
            break;
            
        case "ostate":                          // Verifica se e' a abreviatura de um estado da federacao (opcional)
            validateField = isStateCode( field, true );
            break;
            
        case "mstate":                          // Verifica se e' a abreviatura de um estado da federacao (mandatorio)
            validateField = isStateCode( field );
            break;

        case "omoney":                          // Verifica se e' um valor monetario (opcional)
            validateField = isMoney( field, true );
            break;

        case "mmoney":                          // Verifica se e' um valor monetario (mandatorio)
            validateField = isMoney( field );
            break;

        case "oemail":                          // Verifica se e' um endereco de e-mail valido (opcional)
            validateField = isEmail( field, true );
            break;

        case "memail":                          // Verifica se e' um endereco de e-mail valido (mandatorio)
            validateField = isEmail( field );
            break;

        case "odate":                           // Verifica se e' uma data valida (opcional)
            validateField = isDate( field, true );
            break;

        case "mdate":                            // Verifica se e' uma data valida (mandatorio)
            validateField = isDate( field );
            break;            

        case "ointeger":                        // Verifica se o valor e' inteiro sem sinal (opcional)
            validateField = isInteger( field, true );
            break;

        case "minteger":                        // Verifica se o valor e' inteiro sem sinal (mandatorio)
            validateField = isInteger( field );
            break;

        case "time":
            validateField = isTime( field );
            break;

        case "noblank":                         // Verifica se o campo esta preenchido
            validateField = !isEmpty( Trim( field.value ) );
            if ( validateField == false )
                strError = "- Campo nao pode ser deixado em branco"
            break;

        case "numeric":                         // Verifica se o valor e' numerico
            validateField = IsNumeric( field );
            break;
        
        case "regexp":                          // Verifica se confere com expressao regular.
            // Se o atributo "validate" e' igual a "regexp", e' necessario que
            // haja um correspondente atributo "pattern" que tanto pode se re-
            // ferir a uma expressao regular pre'-determinada, quanto ser uma
            // expressao regular em si.
            sPattern = Trim( field.pattern );
			sPattern = sPattern.toLowerCase( );
			switch ( sPattern ) {   // Tipos de padrao ou um padrao do usuario.
                case "phone_1":
                    sPattern = "\\d{2,3}-\\d{2,4}-\\d{4}$";
                    strError     = "- O numero do telefone deve estar no formato: xxx-xxx-xxxx";
                    break;
                case "phone_2":
                    sPattern = "\\(\\d{2,3}\\)\\d{2,4}-\\d{4}$";
                    strError     = "- O numero do telefone deve estar no formato: (xxx)xxx-xxxx";
                    break;
                default:
                    strError     = "- O campo nao combina com o padrao '" + sPattern + "'";
                    break;
            }
			sValue = Trim( field.value );
            if ( sValue.search( sPattern ) == -1 ) validateField = false;
            else                                   validateField = true;
            break;
    }
    return validateField;
}

//-----------------------------------------------------------------------------
// FUNCAO..............: validateForm( formID )
//-----------------------------------------------------------------------------
// DESCRICAO...........: 
// PARAMETROS (ENTRADA): 
// PARAMETROS (SAIDA)..: 
// RETORNA.............: 
//-----------------------------------------------------------------------------
function validateForm( formID )
{
    var numberElements, sError;
    var idArray = new Array( document.all[formID].length );

    strError = "";
    sError   = "";

    for ( var x = 0; x < document.all[formID].length; x++ ) {
        // Varre todo o formulario `a procura de campos "text" ou "hidden".
        if ( document.all[formID].elements[x].type == "text" || document.all[formID].elements[x].type == "hidden" ) {
            var thisItem = document.all[formID].elements[x];
            if ( thisItem.validate == null ) continue;
            
            // Verifica se e' necessario proceder a uma validacao.
            if ( thisItem.validate.toLowerCase( ) != "none" ) {
                if ( validateField( thisItem ) == false ) {
                    // Se a funcao nao retornar true, adiciona o id deste campo
                    // ao array de campos com problema.
                    idArray[x] = thisItem.id;
                    sError     = sError + Space( 5 ) + strError + "\n";
                }
            }
        }
    }
    if ( sError != "" ) {
        for ( var x = 0; x < idArray.length; x++ ) {
//            if ( idArray[x] != null ) {
//                // Troca a cor de fundo dos campos de texto que contem erros.
//                eval( "document.all." + idArray[x] + ".style.backgroundColor=\"yellow\"" );
//                eval( "document.all." + idArray[x] + ".style.borderColor=\"red\"" );
//                eval( "document.all." + idArray[x] + ".style.borderStyle=\"solid\"" );
//            }
        }
        sError = "Os seguintes erros foram encontrados:\n\n" + sError;
        alert( sError );
    } else {
        document.all[formID].submit( );
    }
}