/*
|----------------------------------------------------------------------------------------------------|
|           Função: fctFormataMascara()                                                              |
|        Descrição: Formata o Campo de acordo com a máscara especificada.                            |
|  ================================================================================================  |
|       Parâmetros: mascara  = String que possui a máscara de formatação do campo.                   |
|                   oCampo   = Campo que será formatado de acordo com a máscara.                     |
|                   oEvent   = Objeto event, necessário para funcionar Cross-Browser.                |
|           Evento: onkeydown                                                                        |
|  Tipo de Retorno: boolean                                                                          |
|  ================================================================================================  |
|           Criado: 26/07/2006 | Por: Mauro Willian                                                  |
|       Modificado: __/__/____ | Por:                                                                |
|----------------------------------------------------------------------------------------------------|
*/
function fctFormataMascara(mascara, oCampo, oEvent)
{
    var tecla_codigo;
    var tecla_char;
    var caracter;
    var valor = oCampo.value;
    var valor_aux;
    var valor_tamanho = 0;
    var colocar_separador = false;
    
    if (oEvent.keyCode)
        tecla_codigo = oEvent.keyCode;
    else if (oEvent.which)
        tecla_codigo = oEvent.which;
    
    tecla_char = String.fromCharCode(tecla_codigo);
    
    //Permite algumas teclas
    if (tecla_codigo == 8 || tecla_codigo == 9 || (tecla_codigo == 35 && oEvent.shiftKey) || (tecla_codigo == 36 && oEvent.shiftKey) || (tecla_codigo == 37 && oEvent.shiftKey) || (tecla_codigo == 39 && tecla_char != "'") || (tecla_codigo == 46 && tecla_char != '.'))
        return true;
    
    if (!OnlyNumbers(oEvent))
        return false;
    
    valor_aux = valor + tecla_char;
    
    if (valor == "")
        valor = tecla_char;
    
    caracter = mascara.substr(valor_aux.length-1, 1);
    
    valor_tamanho = valor_aux.length;
    switch (caracter)
    {
        case '.':
        case '/':
        case ',':
        case '-':
        case ':':
        case '_':
        case '(':
        case ')':
            valor_tamanho = valor_tamanho - 1;
            colocar_separador = true;
            break;
    }
    
    oCampo.value = '';
    for (var i = 0; i < valor_tamanho; i++)
    {
        oCampo.value += valor_aux.charAt(i);
    }
    
    if (colocar_separador)
    {
        oCampo.value += caracter;
        oCampo.value += valor_aux.charAt(valor_aux.length-1);
    }
    
    return false;
}

/*
|----------------------------------------------------------------------------------------------------|
|           Função: fctVerificaData()                                                                |
|        Descrição: Verifica se a data digitada está entre 01/01/1753 e 31/12/9999.                  |
|  ================================================================================================  |
|       Parâmetros: oCampo = Campo que contém a data digitada.                                       |
|           Evento: onkeydown                                                                        |
|  Tipo de Retorno: boolean                                                                          |
|  ================================================================================================  |
|           Criado: 28/07/2006 | Por: Mauro Willian                                                  |
|       Modificado: __/__/____ | Por:                                                                |
|----------------------------------------------------------------------------------------------------|
*/
function fctVerificaData(oCampo)
{
    var oRegExp = /^(0[1-9]|[12][0-9]|[3][12])\/(0[1-9]|1[012])\/([12][0-9]{3})?$/;
    
    if (!oRegExp.test(oCampo.value) && oCampo.value != '')
    {
        //alert('Data inválida!');
        oCampo.style.border = '2px solid #F00';
        oCampo.focus();
        oCampo.select();
        return;
    }
}

/*
|----------------------------------------------------------------------------------------------------|
|           Função: fctVerificaTempo()                                                               |
|        Descrição: Verifica se o valor digitado é uma hora ou um minuto válido.                     |
|  ================================================================================================  |
|       Parâmetros: tipo   = Tipo de verificação (H ou M).                                           |
|                   oCampo = Campo que contém a hora/minuto.                                         |
|                   oEvent = Objeto event, necessário para funcionar Cross-Browser                   |
|           Evento: onkeydown                                                                        |
|  Tipo de Retorno: boolean                                                                          |
|  ================================================================================================  |
|           Criado: 28/07/2006 | Por: Mauro Willian                                                  |
|       Modificado: __/__/____ | Por:                                                                |
|----------------------------------------------------------------------------------------------------|
*/
function fctVerificaTempo(tipo, oCampo, oEvent)
{
    var oRegExp;
    
    if (tipo.toUpperCase() == 'H') //00...23
        oRegExp = /([01][0-9]|2[0-3])/;
    else if (tipo.toUpperCase() == 'M') //00...59
        oRegExp = /[0-5][0-9]/;
    else //00...23:00...59
        oRegExp = /([01][0-9]|2[0-3]):[0-5][0-9]/;
    
    if (!oRegExp.test(oCampo.value) && oCampo.value != '')
    {
        if (tipo.toUpperCase() == 'H')
            alert('Hora inválida!');
        else if (tipo.toUpperCase() == 'M')
            alert('Minuto inválido!');
        else
            alert('Horário inválido!');
        oCampo.focus();
        oCampo.select();
        return;
    }
}

/*
|----------------------------------------------------------------------------------------------------|
|           Função: OnlyNumbers()                                                                    |
|        Descrição: Permite somente números entre 0 e 9.                                             |
|  ================================================================================================  |
|       Parâmetros: oEvent = Objeto event, necessário para funcionar Cross-Browser                   |
|           Evento: onkeypress                                                                       |
|  Tipo de Retorno: void                                                                             |
|  ================================================================================================  |
|           Criado: ??/??/???? | Por: ?????????????                                                  |
|       Modificado: __/__/____ | Por:                                                                |
|----------------------------------------------------------------------------------------------------|
*/
function OnlyNumbers(oEvent)
{
    var oRegExp = /[0-9]/;
    var tecla_codigo;
    var tecla_char;
    
    if (oEvent.keyCode)
        tecla_codigo = oEvent.keyCode;
    else if (oEvent.which)
        tecla_codigo = oEvent.which;
    
    tecla_char = String.fromCharCode(tecla_codigo);
    
    //Permite algumas teclas
    if (tecla_codigo == 8 || tecla_codigo == 9 || (tecla_codigo == 35 && oEvent.shiftKey) || (tecla_codigo == 36 && oEvent.shiftKey) || (tecla_codigo == 37 && (oEvent.shiftKey || tecla_char != '%')) || (tecla_codigo == 39 && tecla_char != "'") || (tecla_codigo == 46 && tecla_char != '.'))
        return true;
    //Se for número
    else if (!oRegExp.test(tecla_char))
        return false;
    //Se não for número
    else
        return true;
}

/*
|----------------------------------------------------------------------------------------------------|
|           Função: fctAutoTab()                                                                     |
|        Descrição: Altera o foco do cursor para o campo anterior ou posterior ao atual              |
|  ================================================================================================  |
|       Parâmetros: oEvent   = Objeto event, necessário para funcionar Cross-Browser                 |
|                   oElement = Objeto do elemento (campo) atual (this).                              |
|                   oForm    = Objeto do formulário.                                                 |
|           Evento: onkeyup                                                                          |
|  Tipo de Retorno: void                                                                             |
|  ================================================================================================  |
|           Criado: 16/03/2006 | Por: Mauro Willian                                                  |
|       Modificado: __/__/____ | Por:                                                                |
|----------------------------------------------------------------------------------------------------|
*/
function fctAutoTab(oEvent, oElement, oForm)
{
    //Variáveis da função
    var keyNumber = null;
    var inteIndice = null;
    var inteNovoCampo = 0;
    
    if (window.event)
        keyNumber = oEvent.keyCode;
    else if(oEvent.which)
        keyNumber = oEvent.which;
    
    //Recupero o indice do campo atual
    for (var i = 0; i < oForm.length; i++)
    {
        if (oForm.elements[i].type != null)
        {
            if (oForm.elements[i].name.toUpperCase() == oElement.name.toUpperCase())
            {
                inteIndice = i;
                break;
            }
        }
    }
    
    if (inteIndice == null)
        return;
    
    //Se o usuário digitou a seta para cima mudamos o foco do cursor para o campo anterior
    if (keyNumber == 38)
    {
        if (inteIndice > 0)
            inteNovoCampo = inteIndice - 1;
    }
    //Se o usuário digitou a seta para baixo, ou a tecla Enter, ou se a quantidade de caracteres digitado for igual ao maxlength do campo mudamos o foco do cursor para o próximo campo
    else if ((keyNumber == 40) || (keyNumber == 13) || (oElement.value.length == oElement.maxLength))
    {
        inteNovoCampo = inteIndice + 1;
        if (inteIndice >= oForm.length)
            inteNovoCampo = 0;
    }
    else
    {
        inteNovoCampo = inteIndice;
    }
    
    //Altera o foco do cursor para o campo correto
    if (inteNovoCampo != inteIndice)
    {
        if (!oForm.elements[inteNovoCampo].disabled)
        {
            if ((oForm.elements[inteNovoCampo].type == 'text') || (oForm.elements[inteNovoCampo].type == 'password') || (oForm.elements[inteNovoCampo].type == 'textarea'))
                oForm.elements[inteNovoCampo].select();
            oForm.elements[inteNovoCampo].focus();
        }
    }
}

/*
|----------------------------------------------------------------------------------------------------|
|           Função: textCounter()                                                                    |
|        Descrição: Conta a quantidade de caracteres do campo e limita de acordo com a quantidade.   |
|  ================================================================================================  |
|       Parâmetros: oCampo           = Objeto do campo que será contado.                             |
|                   oCampoContador   = Objeto do campo que mostrará a quantidade que ainda restam.   |
|                   inteLimiteMaximo = Limite máximo de caracteres permitidos.                       |
|           Evento: onkeypress                                                                       |
|  Tipo de Retorno: void                                                                             |
|  ================================================================================================  |
|           Criado: ??/??/???? | Por: ?????????????                                                  |
|       Modificado: __/__/____ | Por:                                                                |
|----------------------------------------------------------------------------------------------------|
*/
function textCounter(oCampo, oCampoContador, inteLimiteMaximo) {
    if (oCampo.value.length > inteLimiteMaximo)
        oCampo.value = oCampo.value.substring(0, inteLimiteMaximo);
    else if(oCampoContador != '')
        oCampoContador.value = inteLimiteMaximo - oCampo.value.length;
}

/*
|----------------------------------------------------------------------------------------------------|
|           Função: VerificaCPF()                                                                    |
|        Descrição: Verifica se o CPF está no formato válido, e se os números são válidos.           |
|                   Aceita os formatos 123.456.789-09 ou 12345678909                                 |
|  ================================================================================================  |
|       Parâmetros: cpf = String que contém o CPF que será validado.                                 |
|           Evento: nenhum                                                                           |
|  Tipo de Retorno: bool                                                                             |
|  ================================================================================================  |
|           Criado: 11/08/2006 | Por: Mauro Willian                                                  |
|       Modificado: __/__/____ | Por:                                                                |
|----------------------------------------------------------------------------------------------------|
*/
function VerificaCPF(cpf)
{
    var oRegExp = /\d{3}\.?\d{3}\.?\d{3}\-?\d{2}/;
    var soma1 = 0;
    var soma2 = 0;
    var resto;
    
    //Verifica se o CPF está em um formato válido
    if (oRegExp.test(cpf))
    {
        //Retira os pontos (.) e o traço (-)
        cpf = cpf.replace(/\.|-/gi, "");
        
        //Somando os 9 primeiros dígitos
        for (var i = 0; i < 9; i++)
        {
            soma1 += parseInt(cpf.charAt(i), 10) * (10 - i);
            soma2 += parseInt(cpf.charAt(i), 10) * (11 - i);
        }
        soma2 += parseInt(cpf.charAt(9), 10) * 2;
        
        resto = 11 - (soma1 % 11);
        
        if (resto == 10 || resto == 11)
            resto = 0;
        
        if (resto != parseInt(cpf.charAt(9)))
		    return false;
        
        resto = 11 - (soma2 % 11);
        
        if (resto == 10 || resto == 11)
            resto = 0;
        
        if (resto != parseInt(cpf.charAt(10)))
		    return false;
    }
    else
    {
        return false;
    }
    return true;
}

/*
|----------------------------------------------------------------------------------------------------|
|           Função: VerificaCNPJ()                                                                 |
|        Descrição: Verifica se o CNPJ está no formato válido, e se os números são válidos.          |
|                   Aceita os formatos 02.998.301/0001-81 ou 02998301000181                          |
|  ================================================================================================  |
|       Parâmetros: cnpj = String que contém o CNPJ que será validado.                               |
|           Evento: nenhum                                                                           |
|  Tipo de Retorno: bool                                                                             |
|  ================================================================================================  |
|           Criado: 11/08/2006 | Por: Mauro Willian                                                  |
|       Modificado: __/__/____ | Por:                                                                |
|----------------------------------------------------------------------------------------------------|
*/
function VerificaCNPJ(cnpj)
{
    var oRegExp = /\d{2}\.?\d{3}\.?\d{3}\/?\d{4}\-?\d{2}/;
    var soma1 = 0;
    var soma2 = 0;
    var resto;
    var digito;
    var digito1;
    var digito2;
    var digito_tmp = "";
    
    //Verifica se o CNPJ está em um formato válido
    if (oRegExp.test(cnpj))
    {
        //Retira os pontos (.), as barra (/) e o traço (-)
        cnpj = cnpj.replace(/\.|\/|\-/gi, "");
        digito_tmp = cnpj.substring(cnpj.length-2, cnpj.length);
        
        //Calculando o 1º dígito verificador
        soma1 += parseInt(cnpj.charAt(0), 10) * 5;
        soma1 += parseInt(cnpj.charAt(1), 10) * 4;
        soma1 += parseInt(cnpj.charAt(2), 10) * 3;
        soma1 += parseInt(cnpj.charAt(3), 10) * 2;
        soma1 += parseInt(cnpj.charAt(4), 10) * 9;
        soma1 += parseInt(cnpj.charAt(5), 10) * 8;
        soma1 += parseInt(cnpj.charAt(6), 10) * 7;
        soma1 += parseInt(cnpj.charAt(7), 10) * 6;
        soma1 += parseInt(cnpj.charAt(8), 10) * 5;
        soma1 += parseInt(cnpj.charAt(9), 10) * 4;
        soma1 += parseInt(cnpj.charAt(10), 10) * 3;
        soma1 += parseInt(cnpj.charAt(11), 10) * 2;
        
        resto = soma1 % 11;
        digito1 = (resto < 2) ? 0 : 11 - resto;
        
        //Calculando o 2º dígito verificador
        soma2 += parseInt(cnpj.charAt(0), 10) * 6;
        soma2 += parseInt(cnpj.charAt(1), 10) * 5;
        soma2 += parseInt(cnpj.charAt(2), 10) * 4;
        soma2 += parseInt(cnpj.charAt(3), 10) * 3;
        soma2 += parseInt(cnpj.charAt(4), 10) * 2;
        soma2 += parseInt(cnpj.charAt(5), 10) * 9;
        soma2 += parseInt(cnpj.charAt(6), 10) * 8;
        soma2 += parseInt(cnpj.charAt(7), 10) * 7;
        soma2 += parseInt(cnpj.charAt(8), 10) * 6;
        soma2 += parseInt(cnpj.charAt(9), 10) * 5;
        soma2 += parseInt(cnpj.charAt(10), 10) * 4;
        soma2 += parseInt(cnpj.charAt(11), 10) * 3;
        soma2 += parseInt(digito1, 10) * 2;
        
        resto = soma2 % 11;
        digito2 = (resto < 2) ? 0 : 11 - resto;
        
        //Calculando o dígito verificador
        digito = (digito1 * 10) + digito2;
        
        //Verificando se os dígitos são diferentes aos digitados.
        if (digito != digito_tmp)
            return false;
    }
    else
    {
        return false;
    }
    return true;
}

/*
|----------------------------------------------------------------------------------------------------|
|           Função: LimparOptions()                                                                  |
|        Descrição: Limpa os options do select                                                       |
|  ================================================================================================  |
|       Parâmetros: select_id = Id do objeto select que será limpo.                                  |
|           Evento: nenhum                                                                           |
|  Tipo de Retorno: bool                                                                             |
|  ================================================================================================  |
|           Criado: 30/08/2006 | Por: Flávio Henrique                                                |
|       Modificado: __/__/____ | Por:                                                                |
|----------------------------------------------------------------------------------------------------|
*/
function LimparOptions(select_id){
    var oSelect = document.getElementById(select_id);
    if(oSelect != null){
        while(oSelect.childNodes.length != 0)
            oSelect.removeChild(oSelect.firstChild);
    }
}