/*
linha para incluir arquivo nas telas
  <link  type="text/css" rel="stylesheet" href="padrao.css">
  <script type="text/javascript"           src="basic.js"></script>
*/

// ************ ROTINAS PARA ENVIAR DADOS MODO AJAX ************
// variavel a ser utilizada para retorno do ajax


var ajax = false;

function chChamar(pLocal)
{
    document.form.action = pLocal;
    document.form.submit();
}
        
function montaLinhaPost(pform)
{
    var form = document.forms[pform];
    var el = form.length;
    var linha = "";
    for (var i = 0; i < el; i++)
    {
        nome  = form.elements[i].name;
        valor = escape(form.elements[i].value);
        linha += nome + "=" + valor;
        if (i < (el - 1))
        {
            linha += "&";
        }
    }
    return linha;
}


function enviaDadosAjax(sArqAjax, sNmFormParaPost, fFuncao)
{
    if (window.XMLHttpRequest)
    {
        ajax = new XMLHttpRequest();
    }
    else if (window.ActiveXObject)
    {
        ajax = new ActiveXObject("Microsoft.XMLHTTP");
    }

    ajax.onreadystatechange = fFuncao;
    ajax.open("POST", sArqAjax, true);
    ajax.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
    ajax.send(montaLinhaPost(sNmFormParaPost));
}

var ajax2 = null;
function enviaDadosAjaxParaRetorno(sArqAjax, sNmFormParaPost, objRetorno)
{
    if (window.XMLHttpRequest)
    {
        ajax2 = new XMLHttpRequest();
    }
    else if (window.ActiveXObject)
    {
        ajax2 = new ActiveXObject("Microsoft.XMLHTTP");
    }

    ajax2.onreadystatechange = new Function('retornoAjax("'+objRetorno+'");');
    ajax2.open("POST", sArqAjax, false);
    ajax2.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
    ajax2.send(montaLinhaPost(sNmFormParaPost));
}

function enviaDadosAjaxParaRetornoAsin(sArqAjax, sNmFormParaPost, objRetorno)
{
    if (window.XMLHttpRequest)
    {
        ajax2 = new XMLHttpRequest();
    }
    else if (window.ActiveXObject)
    {
        ajax2 = new ActiveXObject("Microsoft.XMLHTTP");
    }

    ajax2.onreadystatechange = new Function('retornoAjax("'+objRetorno+'");');
    ajax2.open("POST", sArqAjax, true);
    ajax2.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
    ajax2.send(montaLinhaPost(sNmFormParaPost));
}

function retornoAjax(objRet)
{
    var texto = '';
    var obj = getCampo(objRet);
    if (ajax2.readyState == 4)
    {
        texto = ajax2.responseText;
        texto=texto.replace(/\+/g," ");
        texto=unescape(texto);
    }
    else
    {
        texto = 'Carregando...';
    }
    if (obj != null)
    {
        obj.innerHTML = texto;
    }
}

function TAjax(pArqAjax, pNmFormParaPost)
{
    var ajax;
    var sArqAjax = '';
    var sNmFormParaPost = '';
    var objRetorno = '';
    var bExibeCarregando = true;
    var bModo = true;
    this.sArqAjax = pArqAjax;
    this.sNmFormParaPost = pNmFormParaPost;

    this.retornaParaObj = envDadosParaRetorno;

    function envDadosParaRetorno(pObjeto)
    {
        objRetorno = getCampo(pObjeto);
        ajax = null;
        if (window.XMLHttpRequest)
        {
            ajax = new XMLHttpRequest();
        }
        else if (window.ActiveXObject)
        {
            ajax = new ActiveXObject("Microsoft.XMLHTTP");
        }
        if (ajax !=null)
        {
            ajax.onreadystatechange = retAjax;
            ajax.open("POST", this.sArqAjax, this.bModo);
            ajax.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
            ajax.send(montaLinhaPost(this.sNmFormParaPost));
        }
        else
        {
            alert('Seu navegador nao suportar XMLHTTP.');
        }
    }

    function retAjax()
    {
        var texto = '';
        var obj = objRetorno;
        if (ajax.readyState == 4)
        {
            texto = ajax.responseText;
            texto=texto.replace(/\+/g," ");
            texto=unescape(texto);
        }
        else
        {
            if (this.bExibeCarregando)
            {
                texto = 'Carregando...';
            }
            else
            {
                texto = '';
            }
        }

        if (obj != null)
        {
            if (obj.getAttributeNode('value') != null)
            {
                obj.value = texto;
            }
            else
            {
                obj.innerHTML = texto;
            }
        }
    }
} // fim do objeto TAjax.

//-------------------------------

// ************ ROTINAS PARA VALIDAR DATAS ************
// rotina para validar digito de um campo para receber as datas
//   s� sera aceito digitos numericos e / como separador
// sintaxe: onKeyPress='return (validaDigData(event));'
function validaDigData(e)
{
    var keynum = '';
    if(window.event) // IE
    {
        keynum = e.keyCode;
    }
    else if(e.which) // Netscape/Firefox/Opera
    {
        keynum = e.which;
    }

    var s = String.fromCharCode(keynum);
    if ((s<"0" || s>"9") && s != "/" && ( (keynum != 13) && (keynum != 8) && (keynum != 1) && (keynum != 2) && (keynum != 9) ) )
    {
        alert("Digite somente numeros e / como separador ");
        return false;
    }
}
// rotina para formatar a data no padrao
function formataData(pData)
{
    var sVar = new String(pData);
    if (sVar.search("/") < 0)
    {
        sVar = sVar.substr(0, 2)+'/'+sVar.substr(2, 2)+'/'+sVar.substr(4, 4);
    }
    return sVar;
}
// Rotina para validar a data digita
//  a data deve ser informada no seguinte formato: dd/mm/yyyy
// sintaxe: onBlur = 'validaData(this);'
function validaData(obj)
{
    var erro = "-1";
    var sVal = new String(obj.value);
    var bValido = false;

    if  (sVal.length > 0)
    {
        sVal = formataData(sVal);
        obj.value = sVal;
        var sSpl = sVal.split("/");

        var dia, mes, ano;

        dia = sSpl[0];
        mes = sSpl[1];
        ano = sSpl[2];

        if ((sVal.length < 6) ||
            (dia.length <  1) || (dia.length > 2) ||
            (mes.length <  1) || (mes.length > 2) ||
            (ano.length != 4)
            )
            {
            erro = "Data invalida ";
        }
        else
        {
            if ( ano < 1900)
            {
                erro = "Ano invalido. Deve ser maior que 1900";
            }
            else
            {
                if (mes < 1 || mes > 12)

                {
                    erro = "Mês invalido. Deve estar entre 1 e 12";
                }
                else
                {
                    d = new Date();
                    d.setFullYear(eval(ano), eval(mes), 1);
                    d.setDate(d.getDate()-1);
                    var ultDia = d.getDate();

                    if (dia < 1 || dia > ultDia)
                    {
                        erro = "Dia invalido. Deve estar entre 1 e "+ultDia;
                    }
                    else
                    {
                        if (mes == 2)

                        {
                            if (dia < 1 || dia > ultDia)

                            {
                                erro = "Dia invalido. Deve estar entre 1 e "+ultDia+" para o mês de fevereiro.";
                            }
                        }
                    }
                }
            }
        }

        if ((erro != "-1") && (obj.value != ""))
        {
            obj.value = "";
            alert (erro);
            obj.focus();
            bValido = false;
        }
        else
        {
            bValido = true;
        }
    }
    else
    {
        bValido = true;
    }

    return bValido;
}

function validaPeriodo(dt1, dt2)
{
    var spl1 = new String(dt1.value);
    var spl2 = new String(dt2.value);
    spl1 = spl1.split("/");
    spl2 = spl2.split("/");
    var num1, num2;

    num1 = spl1[2]+spl1[1]+spl1[0];
    num2 = spl2[2]+spl2[1]+spl2[0];

    if (eval(num1) > eval(num2))
    {
        alert('Periodo de datas invalido');
        dt2.focus();
    }
}
// sintaxe: onBlur='verificaDataAtual(this);'
function verificaDataAtual(pData)
{
    var sVal = new String(pData.value);
    var bErro = false;

    if  (sVal.length > 0)
    {
        sVal = formataData(sVal);
        pData.value = sVal;
        var sSpl = sVal.split("/");
        var dData = new Date();
        var dia, mes, ano;
        dia = sSpl[0];
        mes = sSpl[1];
        ano = sSpl[2];
        var dDtDig = new Date();
        dDtDig.setFullYear(eval(ano), eval(mes)-1, dia);
        if (dDtDig > dData)
        {
            bErro = true;
        }
    }
    if (bErro)
    {
        alert('Data informada maior que a data atual.\nVerifique!!!');
        pData.focus();
    }
}

function verificarData(pDataVerif, pHoraVerif,
    pbComDataAtual, pOperador,
    pDataMin, pHoraMin, pDataMax, pHoraMax)
{
    var DtVerif = new Date();
    var DtMin = new Date();
    var DtMax = new Date();
    var aHrVerif = '';
    var aHrMin = '';
    var aHrMax = '';
    var aVar = '';
    var dData = new Date();

    if (pDataVerif.length > 0)
    {
        aVar = formataData(pDataVerif).split("/");
        DtVerif.setFullYear(eval(aVar[2]), eval(aVar[1])-1, eval(aVar[0]));
    }
    if (pDataMin.length > 0)
    {
        aVar = formataData(pDataMin).split("/");
        DtMin.setFullYear(eval(aVar[2]), eval(aVar[1])-1, eval(aVar[0]));
    }
    if (pDataMax.length > 0)
    {
        aVar = formataData(pDataMax).split("/");
        DtMax.setFullYear(eval(aVar[2]), eval(aVar[1])-1, eval(aVar[0]));
    }

    if (pHoraVerif.length > 0)
    {
        aHrVerif = pHoraVerif.split(":");
    }
    if (pHoraMin.length > 0)
    {
        aHrMin = pHoraMin.split(":");
    }
    if (pHoraMax.length > 0)
    {
        aHrMax = pHoraMax.split(":");
    }

    var bValidaDtAtual  = (!( (pbComDataAtual) && (pOperador != '') ) );
    var bValidaDtMinimo = (!(pDataMin.length > 0));
    var bValidaDtMaximo = (!(pDataMax.length > 0));
    var sOperador = '';

    if (!bValidaDtAtual)
    { // se for para validar com a data atual
        switch (pOperador)
        {
            case '==': sOperador = 'diferente';
                bValidaDtAtual = (DtVerif.getDate() == dData.getDate()) &&
                (DtVerif.getMonth() == dData.getMonth()) &&
                (DtVerif.getFullYear() == dData.getFullYear());
                break;
            case '!=': sOperador = 'igual';
                bValidaDtAtual = (DtVerif.getDate() != dData.getDate()) ||
                (DtVerif.getMonth() != dData.getMonth()) ||
                (DtVerif.getFullYear() != dData.getFullYear());

                break;
            case  '>': sOperador = 'menor ou igual';
                bValidaDtAtual = (DtVerif > dData);
                break;
            case '>=': sOperador = 'menor';
                bValidaDtAtual = (DtVerif >= dData);
                break;
            case  '<': sOperador = 'maior ou igual';
                bValidaDtAtual = (DtVerif < dData);
                break;
            case '<=': sOperador = 'maior';
                bValidaDtAtual = (DtVerif <= dData);
                break;
        }
    }// fim da valida��o se tiver q verificar com a data atual

    if (!bValidaDtMinimo)
    {// foi informado a data minima entao devo verificar
        bValidaDtMinimo = (DtVerif > DtMin);
        if (!bValidaDtMinimo)
        {// a data de verifica��o n�o � maior que a data m�nima informada
            bValidaDtMinimo = ( ((DtVerif.getDate() == DtMin.getDate()) && (DtVerif.getMonth() == DtMin.getMonth()) && (DtVerif.getFullYear() == DtMin.getFullYear()))
                && (pHoraVerif.length > 0) && (pHoraMin.length > 0) );
            if (bValidaDtMinimo)
            {// as datas s�o iguais e as horas foram informadas entao devo verificar a hora
                bValidaDtMinimo = ( eval(aHrVerif[0]+aHrVerif[1]) > eval(aHrMin[0]+aHrMin[1]) );
            }
        }
    } // fim da verifica��o se a data minima se foi informado.

    if (!bValidaDtMaximo)
    {// foi informado a data m�xima entao devo verificar
        bValidaDtMaximo = (DtVerif < DtMax);
        if (!bValidaDtMaximo)
        {// a data de verifica��o n�o � menor que a data m�xima
            bValidaDtMaximo = ( ((DtVerif.getDate() == DtMax.getDate())&&(DtVerif.getMonth() == DtMax.getMonth())&&(DtVerif.getFullYear() == DtMax.getFullYear()))
                && (pHoraVerif.length > 0) && (pHoraMax.length > 0) );
            if (bValidaDtMaximo)
            { // as data s�o igauis e as horas foram informadas entao verifico a hora.
                bValidaDtMaximo = ( eval(aHrVerif[0]+aHrVerif[1]) < eval(aHrMax[0]+aHrMax[1]) );
            }
        }
    } // fim da verifica��o da data m�xima se foi informado.

    var sMsgError = '';

    var sMsgHora = ((pHoraVerif.length > 0)?'/hora':'')

    if (!bValidaDtAtual)
    {
        sMsgError = 'A data '+pDataVerif+' \ufffd '+sOperador+' que a data atual.';
    }
    if (!bValidaDtMinimo)
    {
        sMsgError = 'A data'+sMsgHora+' informada é menor ou igual que a data'+sMsgHora+' mínima.';
    }
    if (!bValidaDtMaximo)
    {
        sMsgError = 'A data'+sMsgHora+' informada é maior ou igual que a data'+sMsgHora+' máximo.';
    }

    var aRetorno = new Array(2);

    aRetorno[0] = (bValidaDtAtual && bValidaDtMinimo && bValidaDtMaximo);
    aRetorno[1] = sMsgError;

    return aRetorno;
}
//-------------------------------

// ************ ROTINAS PARA VALIDAR HORAS ************
// rotina para validar digito da hora.
// sintaxe: onKeyPress='return (validaDigHora(event));'
function validaDigHora(e)
{
    var keynum = '';
    if(window.event) // IE
    {
        keynum = e.keyCode;
    }
    else if(e.which) // Netscape/Firefox/Opera
    {
        keynum = e.which;
    }

    var s = String.fromCharCode(keynum);
    if ((s<"0" || s>"9") && s != ":" && keynum != 13 && keynum != 8)
    {
        alert("Digite somente numeros e : como separador ");
        return false;
    }
}

function formataHora(pHora)
{
    var sVar = new String(pHora);
    if (sVar.search(":") < 0)
    {
        sVar = sVar.substr(0,2)+':'+sVar.substr(2,2);
    }
    return sVar;
}
// rotina para validar hora informada
// sintaxe: onBlur = validaHora(this);
function validaHora(obj)
{
    var erro = "-1";
    var sVal = new String(obj.value);

    if  (sVal.length > 0)
    {
        sVal = formataHora(sVal);
        obj.value = sVal;
        var sSpl = sVal.split(":");

        var hora, minuto;

        hora   = sSpl[0];
        minuto = sSpl[1];

        if (  (sVal.length < 5) ||
            (hora.length < 1) ||   (hora.length > 2) ||
            (minuto.length < 1) || (minuto.length > 2)
            )
            {
            erro = "Horario invalida ";
        }
        else
        {
            if ( (hora < 0) || (hora > 23) )
            {
                erro = 'Hora invalida';
            }
            if ( (minuto < 0) || (minuto > 59) )
            {
                erro = 'Minuto invalido';
            }
        }
        if ((erro != "-1") && (obj.value != ""))
        {
            obj.value = "";
            alert (erro);
            obj.focus();
        }
    }
}
//-------------------------------
// ************ ROTINAS PARA VALIDAR DIGITO NUMERICO ************
// valida digitos numericos
// sintaxe: onKeyPress='return (validaDigNumerico(event));'
function validaDigNumerico(e)
{
    var keynum = '';
    if(window.event) // IE
    {
        keynum = e.keyCode;
    }
    else if(e.which) // Netscape/Firefox/Opera
    {
        keynum = e.which;
    }

    var s = String.fromCharCode(keynum);
    if ( (s < "0" || s > "9") && ( (keynum != 13) && (keynum != 8) && (keynum != 1) && (keynum != 2) && (keynum != 9) ) )
    {
        return false;
    }

    return true;
}
//-------------------------------

//-------------------------------
// ************ ROTINAS PARA VALIDAR DIGITO NUMERICO PARA VALOR************
// valida digitos numericos
// sintaxe: onKeyPress='return (validaValor(event));'
function validaValor(e)
{
    var keynum = '';
    if(window.event) // IE
    {
        keynum = e.keyCode;
    }
    else if(e.which) // Netscape/Firefox/Opera
    {
        keynum = e.which;
    }

    var s = String.fromCharCode(keynum);
    if ( (s < "0" || s > "9") && (keynum!= 13) && (keynum != 8) &&  (keynum!=44) )
    {
        return false;
    }
}
//-------------------------------



// ************ ROTINAS PARA VALIDAR DIGITO NUMERICO ************
// valida digitos numericos
// sintaxe: onKeyPress='return (validaDigNumFloat(event));'
function validaDigNumFloat(e)
{
    var keynum = '';
    if(window.event) // IE
    {
        keynum = e.keyCode;
    }
    else if(e.which) // Netscape/Firefox/Opera
    {
        keynum = e.which;
    }

    var s = String.fromCharCode(keynum);
    if ( ((s < "0") || (s > "9")) && (s != ',') && (keynum!= 13) && (keynum != 8)   )
    {
        return false;
    }
}
//-------------------------------
// ************ ROTINAS PARA trocar Ponto por virgula ou vice e versa ************
// rotina para validar digitos de valores
// rotina que troca do parametro pValue
//    o caracter comparado no paramento pComp pelo paramentro pTroca
function trocaVirgulaPorPonto(pValue, pComp, pTroca, pTrunc)
{
    var sValue = new String(pValue);
    var iTrunc = (pTrunc == undefined?2:pTrunc);
    sValue = sValue.split("");
    sSaida = "";
    var i=0;
    var count = 0
    bAchou = false;
    //   while ((i < sValue.length) && (count < 3))
    while ((i < sValue.length) && (count <= iTrunc))
    {
        if ( (sValue[i] == pComp) && (!bAchou) )
        {
            sSaida += pTroca;
            bAchou = true;
        }
        else
        {
            if ( (sValue[i] != ' ') &&
                (sValue[i] != pComp) &&
                (sValue[i] != pTroca) )
                {
                sSaida += sValue[i];
            }
        }
        if (bAchou)
        {
            count++;
        }
        i++;
    }

    return sSaida;
}
//-------------------------------

// ************ ROTINAS PARA formatar valores monetarios 2 digitos ************
// rotina para validar digitos de valores
// sintaxe: onBlur='formatarFloat(this);'
function formatarFloat(pObj, pTrunc)
{
    if (validaCampo(pObj.name))
    {
        pObj.value =  formatarValorFloat(pObj.value, pTrunc);
    }
}

function formatarValorFloat(pValue, pTrunc)
{
    sNum = pValue;
    sNum = trocaVirgulaPorPonto(sNum, ',', '.', pTrunc);
    if ( sNum.indexOf('.') >= 0 )
    {
        sVar = sNum.split('.');
        if (sVar[0].length <= 0)
        {
            sVar[0] = '0';
        }
        switch (sVar[1].length)
        {
            case 0: sVar[1] = '00';
                break;
            case 1: sVar[1] += '0';
                break;
        }
        sNum = sVar.join('.');
    }
    else
    {
        sNum += '.00';
    }

    return trocaVirgulaPorPonto(sNum, '.', ',', pTrunc);
}
//-------------------------------

// ************ ROTINAS PARA VALORES TEXTO ************
// rotina para validar digitos de valores
// sintaxe: onKeyPress='return (validaDigTexto(event));'
function validaDigTexto(e)
{
    var keynum = '';
    if(window.event) // IE
    {
        keynum = e.keyCode;
    }
    else if(e.which) // Netscape/Firefox/Opera
    {
        keynum = e.which;
    }

    var s = String.fromCharCode(keynum);
    if ( ( (s == "'") || (s == '"') )  && ( (keynum != 13) && (keynum != 8) && (keynum != 1) && (keynum != 2) && (keynum != 9) ) )
    {
        //      alert("N�o � permitido digitar (')ap�strofo.  ");
        return false;
    }
    else
    {
        return true;
    }
}
//-------------------------------

// ************ ROTINAS PARA VALIDAR TELEFONE ************
//rotina para validar digitos de telefone.
// sintaxe: onKeyPress='return (validaDigTel(event));'
function validaDigTel(e)
{
    var keynum = '';
    if(window.event) // IE
    {
        keynum = e.keyCode;
    }
    else if(e.which) // Netscape/Firefox/Opera
    {
        keynum = e.which;
    }

    var s = String.fromCharCode(keynum);
    if ( ( (s < "0") || (s > "9")) && (keynum != 13) && (keynum != 8))
    {
        alert("Digite somente números para informar o telefone.");
        return false;
    }
}

function validaDigTelComRamal(e)
{
    var keynum = '';
    if(window.event) // IE
    {
        keynum = e.keyCode;
    }
    else if(e.which) // Netscape/Firefox/Opera
    {
        keynum = e.which;
    }

    var s = String.fromCharCode(keynum).toUpperCase();
    if ( ( (s < "0") ||(s > "9") ) && (s != ' ') && (s != 'R') && (keynum != 13) && (keynum != 8))
    {
        alert("Digite somente números para informar o telefone.");
        return false;
    }
}
//-------------------------------

// ************ ROTINAS PARA VALIDAR E-MAIL ************
// rotina de validação de E-Mail
// sintaxe: onBlur='validaEmail(this)';
function validaEmail(pObjEmail)
{
    var sVar = new String(pObjEmail.value);
    var bValido = false;
    if (sVar != '')
    {
        if (sVar.indexOf('@') > 0)
        {// tem @
            sVar = sVar.substr(sVar.indexOf('@')+1);
            if (sVar.indexOf('.') > 0 )
            {// tem '.' entao pode ter dominio
                sVar = sVar.substr(sVar.indexOf('.')+1);
                if (sVar.length > 0)
                { // email est� correto.
                    bValido = true;
                }
            }
        }
        else
        {
            bValido = false;
        }
        if (!bValido)
        {
            alert('E-Mail invalido.');
            pObjEmail.value = '';
            pObjEmail.focus();
        }
        else
        {
            sVar = pObjEmail.value;
            pObjEmail.value = sVar.toLowerCase();
        }
    }
}
//-------------------------------

// ************ ROTINAS PARA VALORES COM VIRGULA ************
// rotina para validar digitos de valores
// sintaxe: onKeyPress='return (validaDigValor(event));'
function validaDigValor(e)
{
    var keynum = '';
    if(window.event) // IE
    {
        keynum = e.keyCode;
    }
    else if(e.which) // Netscape/Firefox/Opera
    {
        keynum = e.which;
    }

    var s = String.fromCharCode(keynum);
    if ( (s < "0" || s > "9") && (s != ",") && (keynum != 13) && (keynum != 8))
    {
        alert("Digite somente n�meros e/ou separadores \",\"");
        return false;
    }
}
//-------------------------------

// ************ ROTINAS PARA VALORES TEXTO Hexadecimal************
// rotina para validar digitos de valores
// sintaxe: onKeyPress='return (validaDigTextoHexa(event));'
function validaDigTextoHexa(e)
{
    var keynum = '';
    if(window.event) // IE
    {
        keynum = e.keyCode;
    }
    else if(e.which) // Netscape/Firefox/Opera
    {
        keynum = e.which;
    }

    var s = String.fromCharCode(keynum);
    s = s.toUpperCase();
    if ( !((s == "A") || (s == "B") ||
        (s == "C") || (s == "D") ||
        (s == "E") || (s == "F") ||
        (s == "-"))  &&
    (s < "0" || s > "9") &&
        (keynum != 13) && (keynum != 8))
        {
        return false;
    }
    else
    {
        return true;
    }
}
//-------------------------------

// ************ ROTINAS PARA AJUSTAR CAMPOS MEMO ************
// rotina para trocar caracter ENTER #13 por \n

function ajustaTextoMemo(pTexto)
{
    var sTexto = new String(pTexto);
    var sReturn = new String();

    for (var i=0; i < sTexto.length; i++)
    {
        if (sTexto.charCodeAt(i) == 13)
        {
            sReturn += '\\n';
        }
        else
        {
            sReturn += sTexto.charAt(i);
        }
    }
    sReturn = sReturn;
    return sReturn;
}
//-------------------------------

// ************ ROTINAS PARA EXIBIR UM HINT FIXO ************
// no formulario deve existir uma TAG DIV com o id = dHint
// que ser� o componente que exibira o hint.
//
// colocar o evento onMouseMove chamando exibeHint(<texto html>)
// dentro do objeto que deseja exibir o hint.
// exemplo: onMouseMove="exibeHint('LINHA 1');"
//
// colocar o evento onMouseOut chamando OcultaHint()
// pode ser no objeto que est� exibindo o hint ou no grupo que esta
// o objeto que exibe o hint
//
// rotina que exibe o hint
function exibeHint(pHint)
{
    /*
   function ietruebody()
   {
      return (document.compatMode && document.compatMode!="BackCompat")?document.documentElement : document.body
   }
*/

    var oHint = getCampo('dHint');
    oHint.innerHTML = pHint;
    /*
   var offsetxpoint=-10 //Customize x offset of tooltip
   var offsetypoint=20 //Customize y offset of tooltip
   var ie=document.all
   var ns6=document.getElementById && !document.all


   var curX=(ns6)?e.pageX : event.clientX+ietruebody().scrollLeft;
   var curY=(ns6)?e.pageY : event.clientY+ietruebody().scrollTop;
//Find out how close the mouse is to the corner of the window
   var rightedge=ie&&!window.opera? ietruebody().clientWidth-event.clientX-offsetxpoint : window.innerWidth-e.clientX-offsetxpoint-20;
   var bottomedge=ie&&!window.opera? ietruebody().clientHeight-event.clientY-offsetypoint : window.innerHeight-e.clientY-offsetypoint-20;

   var leftedge=(offsetxpoint<0)? offsetxpoint*(-1) : -1000

//if the horizontal distance isn't enough to accomodate the width of the context menu
   if (rightedge<oHint.offsetWidth) {
//move the horizontal position of the menu to the left by it's width
      oHint.style.left=ie? ietruebody().scrollLeft+event.clientX-oHint.offsetWidth+"px" : window.pageXOffset+e.clientX-oHint.offsetWidth+"px";
   }
   else if (curX<leftedge)
   { oHint.style.left="5px"; }
   else //position the horizontal position of the menu where the mouse is positioned
   { oHint.style.left=curX+offsetxpoint+"px"; }

//same concept with the vertical position
   if (bottomedge<oHint.offsetHeight)
   { oHint.style.top=ie? ietruebody().scrollTop+event.clientY-oHint.offsetHeight-offsetypoint+"px" : window.pageYOffset+e.clientY-oHint.offsetHeight-offsetypoint+"px"; }
   else
   { oHint.style.top=curY+offsetypoint+"px"; }
*/

    oHint.style.zIndex = 1;
    oHint.style.visibility = 'visible';
    oHint.style.position = 'absolute';
    oHint.style.backgroundColor  = 'FFFFCE';

    oHint.style.top = 20 +window.event.clientY;
    oHint.style.left = 10 + window.event.clientX;
    oHint.style.maxWidth = '100px';
    oHint.style.overflow = 'auto';

//   window.status = 'X=' + window.event.x +' Y=' + window.event.y;

}
// rotina para ocultar o hint
function OcultaHint()
{
    var oHint = getCampo('dHint');
    oHint.innerHTML = '';
    oHint.style.zIndex = -1;
    oHint.style.visibility = 'hidden';
    oHint.style.position = 'static';
    oHint.style.backgroundColor  = 'FFF';
}

function ajustaTextoParaHint(pObjMemo)
{
    var sVar = encodeURI(pObjMemo.value);
    sVar = decodeURI(sVar.replace(/%0d%0A/gi, '<br>'));
    return sVar;
}
//-------------------------------
// ************ ROTINA PARA verificar campos nulos ************
function validaCampo(pObj)
{
    var vObj = getCampo(pObj);
    var bValido = (vObj != null);
    if (bValido)
    {
        var sVar = new String(vObj.value);
        sVar = sVar.replace(/ /gi, "");
        bValido = (sVar.length > 0);
    }
    return bValido;
}
//-------------------------------
// ************ ROTINA PARA pegar um campo do form ************

function getCampo(pNameORId)
{
    var vObj = document.getElementById(pNameORId);
    if (vObj == null)
    {
        vObj = document.getElementsByName(pNameORId);
        vObj = vObj[0];
    }
    return vObj;
}
//-------------------------------

// ************ ROTINA PARA carregar um COMBO (SELECT) atr�ves de uma vetor (array) ************
// Essa fun��o faz a carga de um objeto SELECT com um vetor qualque.
// para utilizar � necess�rio ter um vetor de que tamanho quiser.
// Paramentros:
//    pNmCboOBJ = nome do objeto SELECT
//    aArray = vetor que tem os dados a serem carregados
//    indValue = informa o indice, dentro do vetor, que cont�m o valor
//               que ser� colocado na propriedade value de cada option
//    indTexto = informa o indice, dentro do vetor, que cont�m o valor que ser� exibido no SELECT
//    indTextoIgual = pode ser um vetor ou n�o indicando o indice do vetor que ser� utilizado para
//                    fazer compara��o com o parametro pTextoIgual
//    pTextoIgual = pode ser um vetor ou n�o indicando com o texto que deseja comparar no vetor.
//    bTodos = informa se vai colcar o primeira op��o do select TODOS com value ''
//
// Sintaxe:
//
//   // definindo o array
//   var aInfoEquip = new Array( new Array('BALUN 75/120 OHMS', 'FTD', 'BALUN'),
//                               new Array('DIALER', 'MITEL', 'A01-2P'),
//                               new Array('DIALER', 'MITEL', 'A01-4P'),
//                               new Array('DIALER', 'MITEL', 'D11-4P'),
//                               new Array('GATEWAY VOIP', 'QUINTUM', 'ASG400'),
//                               new Array('GATEWAY VOIP', 'QUINTUM', 'ASM400'),
//                               new Array('GATEWAY VOIP', 'QUINTUM', 'AXG1600'));
//   // chamando a funcao
//   carregaCombo('cboMarca', aInfoEquip, 1, 1, '', '');
//       ou
//   carregaCombo('cboMarca', aInfoEquip, 1, 1, new Array(0, 2), new Array('DIALER', 'A01-4P') );
//       ou
//   carregaCombo('cboMarca', aInfoEquip, 1, 1, 0, 'GATEWAY VOIP');
function carregaCombo(pNmCboOBJ, aArray, indValue, indTexto, indTextoIgual, pTextoIgual, bTodos)
{
    function verificaSeItemJaEstaIncluso(pNmCboOBJ, pTexto)
    {
        var aOptions = getCampo(pNmCboOBJ).options;
        var bTextoNaLista = false;
        var iIndice = 0;
        while ( (iIndice < aOptions.length ) && (!bTextoNaLista) )
        {
            bTextoNaLista = (aOptions[iIndice].text.toUpperCase() == pTexto.toUpperCase());
            iIndice++;
        }
        return bTextoNaLista;
    }

    function verificaTextoIgual(aArray, iIndice, indTextoIgual, pTextoIgual)
    {
        var bTextoIgual = true;
        if ( (indTextoIgual.length != undefined) &&
            (pTextoIgual.length != undefined)       )
            {
            var indCont = 0;
            while ( (indCont < indTextoIgual.length) && (bTextoIgual) )
            {
                bTextoIgual = (aArray[iIndice][indTextoIgual[indCont]] == pTextoIgual[indCont]);
                indCont++;
            }
        }
        else
        {
            bTextoIgual = ( aArray[iIndice][indTextoIgual] == pTextoIgual );
        }
        return bTextoIgual;
    }

    var combo = getCampo(pNmCboOBJ);

    while (combo.options[0] != null)
    {
        combo.options[0] = null;
    }
    if (bTodos)
    {
        combo.options[0] = new Option('Todos', '');
    }
    for (var iIndice =0; iIndice < aArray.length; iIndice++)
    {
        if ( !verificaSeItemJaEstaIncluso(pNmCboOBJ, aArray[iIndice][indTexto]) )
        {
            if (pTextoIgual != '')
            {
                if (verificaTextoIgual(aArray, iIndice, indTextoIgual, pTextoIgual))
                {
                    combo.options[combo.options.length] = new Option(aArray[iIndice][indTexto], aArray[iIndice][indValue]);
                }
            }
            else
            {
                combo.options[combo.options.length] = new Option(aArray[iIndice][indTexto], aArray[iIndice][indValue]);
            }
        }
    }
}
//-------------------------------
// ************ ROTINA PARA pegar o valor de um objeto radio do form ************
function getRadioValue(pNameORId)
{
    var i = 0;
    var sValue = '';
    var rdb = document.getElementsByName(pNameORId);
    while ( (sValue == '') && (i <= (rdb.length -1)) )
    {
        if ( rdb[i].checked == true )
        {
            sValue = rdb[i].value;
        }
        i++;
    }

    return sValue;
}
//-------------------------------

// ************ ROTINA PARA selecionar um radio com o valor informado ************
function selecionaRadio(pNameORId, pValue)
{
    var i = 0;
    var bSelecionou = false;
    var rdb = document.getElementsByName(pNameORId);
    while ( (!bSelecionou) && (i <= (rdb.length -1)) )
    {
        if ( rdb[i].value == pValue )
        {
            rdb[i].checked = true;  bSelecionou = true;
        }
        i++;
    }

    return bSelecionou;
}
//-------------------------------
// ************ ROTINA PARA controle de habilitado ou desabilitado os radio ************
function controleStatusRadio(pNameORId, pStatus)
{
    var i = 0;
    var rdb = document.getElementsByName(pNameORId);
    for (i=0; i < rdb.length; i++)
    {
        rdb[i].disabled = !pStatus;
    }
}
//-------------------------------

// ************ ROTINA PARA validar valor numerico entre um range de valor ************
function validaRange(pNmObj, pMinimo, pMaximo)
{
    var obj = getCampo(pNmObj);
    var iValue = obj.value;
    var bValMinimo = true;
    var bValMaximo = true;
    if (iValue != '')
    {
        if (pMinimo != '')
        {
            bValMinimo = (eval(iValue) >= eval(pMinimo));
        }
        if (pMaximo != '')
        {
            bValMaximo = (eval(iValue) <= eval(pMaximo));
        }
    }
    var sMsg = '';
    if (!bValMinimo)
    {
        sMsg += 'Valor informado � menor que '+pMinimo+', o valor minimo permitido.\n';
    }
    if (!bValMaximo)
    {
        sMsg += 'Valor informa � maior que '+pMaximo+', o valor m�ximo permitido.\n';
    }

    if (sMsg != '')
    {
        alert(sMsg+'Verifique.');
        obj.value='';
        obj.focus();

    }

    return (bValMinimo && bValMaximo);
}
//-------------------------------

/*
   Objeto para controle de Acesso do usuario

Deve ser passado o valor do acesso para o objeto na cria��o
Sintaxe:
   controle= new TControleAcesso();
   controle.setAcesso(24)

para saber se o o usuario tem permiss�o a alguma opera��o basta fazer a compara��o.
Sintaxe:

   if (controle.status_INCLUIR)
   {
   ... liberado
   }
   else
   {
   ... bloqueado
   }

function TControleAcesso(pAcesso)
{
   acesso = pAcesso;
   this.status_INCLUIR = (acesso & 1);
   this.status_ALTERAR = (acesso & 2);
   this.status_EXCLUIR = (acesso & 4);
   this.status_IMPRDOC = (acesso & 8);
   this.status_IMPRESSAO = (acesso & 16);
   this.status_GERAR = (acesso & 32);
   this.status_CONSULTAR = (acesso & 64);
   this.status_CONFIDENCIAL = (acesso & 128);
}

*/

function TControleAcesso()
{
    this.acesso;
    this.status_INCLUIR;
    this.status_ALTERAR;
    this.status_EXCLUIR;
    this.status_IMPRDOC;
    this.status_IMPRESSAO;
    this.status_GERAR;
    this.status_CONSULTAR;
    this.status_CONFIDENCIAL;

    this.setAcesso = setAcesso;

    function setAcesso(pNum)
    {
        this.acesso = pNum;
        this.status_INCLUIR = (this.acesso & 1);
        this.status_ALTERAR = (this.acesso & 2);
        this.status_EXCLUIR = (this.acesso & 4);
        this.status_IMPRDOC = (this.acesso & 8);
        this.status_IMPRESSAO = (this.acesso & 16);
        this.status_GERAR = (this.acesso & 32);
        this.status_CONSULTAR = (this.acesso & 64);
        this.status_CONFIDENCIAL = (this.acesso & 128);
    }
}

function valida_CNPJ_CPF(pValue)
{
    var _dig1     = '';
    var _dig2     = '';
    var _digV1    = '';
    var _digV2    = '';
    var _doc      = '';
    var _multiAte = 0;

    function retiraMascara(cgc_cpf)
    {
        var s = '';
        for (var i=0; i < cgc_cpf.length; i++)
        {
            if ( (cgc_cpf.charAt(i) != '/') &&
                (cgc_cpf.charAt(i) != '.') &&
                (cgc_cpf.charAt(i) != '-') &&
                (cgc_cpf.charAt(i) != ' ')    )
                {
                s = cgc_cpf.charAt(i) + s;
            }
        }
        return s;
    }

    function devolveDigito(pcgc_cpf)
    {
        var total = 0;
        var x     = 2;
        var y     = 0;
        for (var i = 0; i < pcgc_cpf.length; i++)
        {
            total = total + (parseInt(pcgc_cpf.charAt(i)) * x);
            x++;
            if (x == (_multiAte+1))
            {
                x = 2;
            }
        }
        y = 11 - (total % 11);
        if (y > 9)
        {
            y = 0;
        }
        return y;
    }

    _doc = retiraMascara(pValue);

    _dig1 = _doc.substr(1,1);
    _dig2 = _doc.substr(0,1);

    if ( _doc.length > 11)
    {
        _multiAte = 9;
    }
    else {
        _multiAte = 11;
    }

    _digV1 = devolveDigito(_doc.substr(2));
    _digV2 = devolveDigito(_digV1 + _doc.substr(2));

    return ( (_dig1 == _digV1) && (_dig2 == _digV2) );
}

//formata de forma generica os campos
function formataCampo(campo, Mascara, evento)
{
    var boleanoMascara;

    var Digitato = evento.keyCode;
    exp = /\-|\.|\/|\(|\)| /g
    campoSoNumeros = campo.value.toString().replace( exp, "" );

    var posicaoCampo = 0;
    var NovoValorCampo="";
    var TamanhoMascara = campoSoNumeros.length;

    if (Digitato != 8) { // backspace
        for(i=0; i<= TamanhoMascara; i++) {
            boleanoMascara  = ((Mascara.charAt(i) == "-") || (Mascara.charAt(i) == ".")
                || (Mascara.charAt(i) == "/"))
            boleanoMascara  = boleanoMascara || ((Mascara.charAt(i) == "(")
                || (Mascara.charAt(i) == ")") || (Mascara.charAt(i) == " "))
            if (boleanoMascara) {
                NovoValorCampo += Mascara.charAt(i);
                TamanhoMascara++;
            }else {
                NovoValorCampo += campoSoNumeros.charAt(posicaoCampo);
                posicaoCampo++;
            }
        }
        campo.value = NovoValorCampo;
        return true;
    }else {
        return true;
    }
}

//valida numero inteiro com mascara
function mascaraInteiro(){
    if (event.keyCode < 48 || event.keyCode > 57){
        event.returnValue = false;
        return false;
    }
    return true;
}

//adiciona mascara ao CPF
function MascaraCPF(txtCPF)
{
    if(mascaraInteiro(txtCPF)==false)
    {
        event.returnValue = false;
    }
    return formataCampo(txtCPF, '000.000.000-00', event);
}

//adiciona mascara ao CEP
function MascaraCep(txtCep)
{
    if(mascaraInteiro(txtCep)==false)
    {
        event.returnValue = false;
    }
    return formataCampo(txtCep, '00000-000', event);
}

// adiciona mascara aos telefones
function MascaraTel(txtTel)
{
    if(mascaraInteiro(txtTel)==false)
    {
        event.returnValue = false;
    }
    return formataCampo(txtTel, '(00)0000-0000', event);
}

//adiciona mascara de cnpj
function MascaraCNPJ(txtCNPJ){
    if(mascaraInteiro(txtCNPJ)==false){
        event.returnValue = false;
    }
    return formataCampo(txtCNPJ, '00.000.000/0000-00', event);

}

//Muda cor de fundo do text para vermelho
function changeColor(pObj,newColor)
{
    pObj.style.backgroundColor = newColor;
}

function base64_encode (data) {
    var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
    var o1, o2, o3, h1, h2, h3, h4, bits, i = 0, ac = 0, enc="", tmp_arr = [];

    if (!data) {
        return data;
    }

    data = this.utf8_encode(data+'');

    do { // pack three octets into four hexets
        o1 = data.charCodeAt(i++);
        o2 = data.charCodeAt(i++);
        o3 = data.charCodeAt(i++);

        bits = o1<<16 | o2<<8 | o3;

        h1 = bits>>18 & 0x3f;
        h2 = bits>>12 & 0x3f;
        h3 = bits>>6 & 0x3f;
        h4 = bits & 0x3f;

        // use hexets to index into b64, and append result to encoded string
        tmp_arr[ac++] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4);
    } while (i < data.length);

    enc = tmp_arr.join('');

    switch (data.length % 3) {
        case 1:
            enc = enc.slice(0, -2) + '==';
        break;
        case 2:
            enc = enc.slice(0, -1) + '=';
        break;
    }
    return enc;
}

function utf8_decode ( str_data ) {
    var tmp_arr = [], i = 0, ac = 0, c1 = 0, c2 = 0, c3 = 0;

    str_data += '';

    while ( i < str_data.length ) {
        c1 = str_data.charCodeAt(i);
        if (c1 < 128) {
            tmp_arr[ac++] = String.fromCharCode(c1);
            i++;
        } else if ((c1 > 191) && (c1 < 224)) {
            c2 = str_data.charCodeAt(i+1);
            tmp_arr[ac++] = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));
            i += 2;
        } else {
            c2 = str_data.charCodeAt(i+1);
            c3 = str_data.charCodeAt(i+2);
            tmp_arr[ac++] = String.fromCharCode(((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
            i += 3;
        }
    }

    return tmp_arr.join('');
}
function utf8_encode ( argString ) {
    var utftext = "";
    var start, end;
    var stringl = 0;

    start = end = 0;
    stringl = string.length;
    for (var n = 0; n < stringl; n++) {
        var c1 = string.charCodeAt(n);
        var enc = null;

        if (c1 < 128) {
            end++;
        } else if (c1 > 127 && c1 < 2048) {
            enc = String.fromCharCode((c1 >> 6) | 192) + String.fromCharCode((c1 & 63) | 128);
        } else {
            enc = String.fromCharCode((c1 >> 12) | 224) + String.fromCharCode(((c1 >> 6) & 63) | 128) + String.fromCharCode((c1 & 63) | 128);
        }
        if (enc !== null) {
            if (end > start) {
                utftext += string.substring(start, end);
            }
            utftext += enc;
            start = end = n+1;
        }
    }

    if (end > start) {
        utftext += string.substring(start, string.length);
    }

    return utftext;
}

function base64_decode (data) {
    var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
    var o1, o2, o3, h1, h2, h3, h4, bits, i = 0, ac = 0, dec = "", tmp_arr = [];

    if (!data) {
        return data;
    }

    data += '';

    do {  // unpack four hexets into three octets using index points in b64
        h1 = b64.indexOf(data.charAt(i++));
        h2 = b64.indexOf(data.charAt(i++));
        h3 = b64.indexOf(data.charAt(i++));
        h4 = b64.indexOf(data.charAt(i++));

        bits = h1<<18 | h2<<12 | h3<<6 | h4;

        o1 = bits>>16 & 0xff;
        o2 = bits>>8 & 0xff;
        o3 = bits & 0xff;

        if (h3 == 64) {
            tmp_arr[ac++] = String.fromCharCode(o1);
        } else if (h4 == 64) {
            tmp_arr[ac++] = String.fromCharCode(o1, o2);
        } else {
            tmp_arr[ac++] = String.fromCharCode(o1, o2, o3);
        }
    } while (i < data.length);

    dec = tmp_arr.join('');
    dec = this.utf8_decode(dec);

    return dec;
}