function fSelecionaItemCombo(combo, item) {

    for (var i=0;i<combo.options.length;i++){
        if (combo.options[i].value == item){
            combo.selectedIndex = i;
            return;
        }
    }
    combo.selectedIndex = 0;
    return;

}

function fSelecionaItemComboTxt(combotxt, combo, item) {

    var existeComboTxt = combotxt.value;
    itemValor = '-' + item;
    for (var i=0;i<combo.options.length;i++){
        if (combo.options[i].text == itemValor){
            combo.selectedIndex = i;
            if (existeComboTxt == '1') {
                // Elimina ultimo item
                if (i != combo.options.length - 1) {
                    combo.options[combo.options.length - 1] = null;
                } else {
                    return;
                }
            }
            combotxt.value = '0';
            return;
        }
    }
    if (existeComboTxt == '1') {
        // Reescreve e posiciona no ultimo
        combo.options[combo.options.length - 1].text = itemValor;
        combo.options[combo.options.length - 1].value = item;
        combo.selectedIndex = combo.options.length - 1;
                
    } else {
        // Adiciona combo txt
       combo.options[combo.options.length] = new Option(itemValor, item);
       combo.selectedIndex = combo.options.length - 1;
       combotxt.value = '1';
    }
    return;

}

setTimeout('verifBuffer()', 1000);

var buf = "-";
var tempo = 2;

function verifBuffer() {
	
	if (tempo > 0) {
		tempo--;
		if (tempo == 0) {
			buf = "-";
		}
	}
	setTimeout('verifBuffer()', 1000);
	return;

}

function comboDigitavel(obj) {

	tempo = 2;
    buf += String.fromCharCode(event.keyCode);
    buf = buf.toUpperCase();
	var tam = buf.length;
	for (x=0; x<obj.options.length; x++) {		
		tmp = obj.options[x].text;
		if (tmp.length >= tam) {
			palavra = tmp.substring(0, tam).toUpperCase();
			if (palavra == buf) {
				obj.selectedIndex = x;
				return;
			}
		}
	}
	return;

}

// Função para obter nome do selectbox
function fObtemNomeCombo(obj, cod) {
    for (x=0; x<obj.options.length; x++) {        
        if (obj.options[x].value == cod) {
            return obj.options[x].text.substring(1, obj.options[x].text.length);
        }
    }
    return '';
}

function fPrimeiro(frmDados) {
    
    if (frmDados.btPrimeiro.disabled == false) {
        if (!verifGravar(frmDados)) {
            return;
        }
        
    	regCont = frmDados.hdnRegCont.value;	
    	if (parseInt(frmDados.hdnCodigo.value) != 0) {
    		fRegistro(0, frmDados, 'f');
    	}
    }
	return;
}
		
function fUltimo(frmDados) {

    if (frmDados.btUltimo.disabled == false) {
        if (!verifGravar(frmDados)) {
            return;
        }
    
    	regCont = frmDados.hdnRegCont.value;
    	if (parseInt(frmDados.hdnCodigo.value) != regCont-1) {
    		fRegistro(regCont-1, frmDados, 'l');
    	}
    }
	return;	
}
		
function fProximo(frmDados) {

    if (frmDados.btProximo.disabled == false) {
        if (!verifGravar(frmDados)) {
            return;
        }
    
    	regCont = frmDados.hdnRegCont.value;
    	if (parseInt(frmDados.hdnCodigo.value) < regCont-1) {
    		fRegistro(parseInt(frmDados.hdnCodigo.value) + 1, frmDados, 'n');
    	}
    }
	return;
}

function fAnterior(frmDados) {
    if (frmDados.btAnterior.disabled == false) {
        if (!verifGravar(frmDados)) {
            return;
        }
    
    	regCont = frmDados.hdnRegCont.value;	
    	if (parseInt(frmDados.hdnCodigo.value) > 0) {		
    		fRegistro(parseInt(frmDados.hdnCodigo.value) - 1, frmDados, 'p');
    	}
    }
	return;
}

// Função usada para validar datas
function validaData(data) {

	var dia = '';
	var mes = '';
	var ano = '';
	proc = 1;
	for (x=0; x<data.length; x++) {	
		carac = data.substring(x, x+1);
		if (carac == "/") {
			proc++;
		}
		switch(proc) {
			case 1:
				if (carac != "/") {
					dia = dia + carac;
				}
				break;
			case 2:
				if (carac != "/") {
					mes = mes + carac;
				}
				break;
			case 3:
				if (carac != "/") {
					ano = ano + carac;
				}
				break;			
		}
	}	
	
	if ( (isNaN(dia)) || (dia < 1) || (dia > 31) ) {
		return false;
	}

	if ( (isNaN(mes)) || (mes < 1) || (mes > 12) ) {
		return false;
	}

	if ( (isNaN(ano)) || (ano < 1900) || (ano > 2030) ) {
		return false;
	}

	return isDate(ano, mes, dia);

}

// Para validar hora
function validaHora(hora) {

    var horas;
    var minutos;
    
    if (hora.length != 5) {
        return false;
    }
    
    horas = hora.substring(0, 2);
    minutos = hora.substring(3, 5);
    
    if (isNaN(horas) || isNaN(minutos)) {
        return false;
    }
    
    if (hora.substring(2, 3) != ":") {
        return false;
    }
    
    if (horas < 0 || horas > 23) {
        return false;
    }
    
    if (minutos < 0 || minutos > 59) {
        return false;
    }
    
    return true;
}

/* Variaveis globais das funcoes a seguir */

// É normal um campo ficar vazio? Não.
var defaultEmptyOK = false

// Número de dígitos do CEP
var digitsInZIPCode = 8

// Conjuntos de números e letras
var digits = "0123456789";
var lowercaseLetters = "abcdefghijklmnopqrstuvwxyz"
var uppercaseLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

// Caracteres de espaço
var whitespace = " \t\n\r";

// Caracteres de separação decimal diferem em cada língua
var decimalPointDelimiter = ","

// Caracteres não-numéricos aceitos em números de telefone
var phoneNumberDelimiters = "()- ";

// Caracteres válidos em números de telefone
var validPhoneChars = digits + phoneNumberDelimiters;

// Caracteres permitidos em números de telefone internacionais
// (aceita o sinal de + no início)
var validWorldPhoneChars = digits + phoneNumberDelimiters + "+";

// Caracteres não numéricos aceitos em CPF
var CPFDelimiters = "- ";

// Caracteres válidos em CPF
var validCPFChars = digits + CPFDelimiters;

// CPFs têm 11 dígitos
// O formato é 123.123.123-00
var digitsInCPF = 11;

// Números de telefone nacionais têm de 9 a 11 dígitos.
// O formato padrão é 011 456 7890 ou (011) 9456-7890.
var mindigitsInPhoneNumber = 8;
var maxdigitsInPhoneNumber = 11;

// Caracteres não-numéricos válidos em CEP
var ZIPCodeDelimiters = "-";

// O delimitador preferido para reformatar um CEP
var ZIPCodeDelimeter = "-"

// characters which are allowed in Social Security Numbers
var validZIPCodeChars = digits + ZIPCodeDelimiters

// CEPs têm 8 dígitos.
// O formato padrão é 12345-000.
var digitsInZIPCode = 8

// Caracteres não-numéricos aceitos em números de cartão de crédito
var creditCardDelimiters = " ."


/* Constantes Globais das funções a seguir */

// m é abreviação para "missing", ou "faltando"

var mPrefix = "Você não digitou um valor no campo "
var mSuffix = " . Este campo é requerido. Por favor, preencha-o agora."

// s é abreviação de "string", ou "cadeia de caracteres"

var sLastName = "Sobrenome"
var sFirstName = "Nome"
var sTitle = "Cargo"
var sCompanyName = "Empresa"
var sAddress = "Endereço"
var sCity = "Cidade"
var sStateCode = "Estado"
var sCountry = "País"
var sZIPCode = "CEP"
var sPhone = "Telefone"
var sFax = "Fax"
var sDateOfBirth = "Data de Nascimento"
var sExpirationDate = "Data de Validade"
var sEmail = "E-mail"
var sSSN = "CPF/CNPJ"
var sCreditCardNumber = "Número do Cartão de Crédito"
var sOtherInfo = "Outras Informações"

// i é abreviação de "inválido"

var iName = "Seu nome deve ser preenchido."
var iAddress = "Preencha este campo com o nome da rua, alameda, vila, praça ou avenida onde você mora."
var iAddressNumber = "Preencha este campo com o número da casa ou edifício onde você mora."
var iEmail = "Neste campo deve haver um endereço válido de e-mail (Exemplo: usuario@dominio.com.br)."
var iMonth = "Neste campo deve haver um número entre 1 e 12."
var iYear = "Neste campo deve haver um número de 4 digitos."
var iAno = "Neste campo deve haver um número de 2 digitos."
var iDay = "Neste campo deve haver um número entre 1 e 31."
var iDatePrefix = "O dia, mês e ano de "
var iDateSuffix = " não formam uma data válida. Exemplo: dd/mm/aaaa"
var iZIPCode = "Neste campo deve haver um número de CEP válido, com até 9 dígitos. Exemplo: 12345-0000"
var iBairro = "Preencha este campo com o bairro onde você mora."
var iCity = "Preencha este campo com a cidade onde você mora."
var iCountry = "Preencha este campo com o país onde você mora."
var iStateCode = "Preencha este campo com a sigla do estado onde você mora."
var iPhone = "Neste campo deve haver um telefone válido. Exemplo: (011) 9999-9999. Preencha-o de novo agora."
var iCPF = "Neste campo deve haver um número de CPF válido. Exemplo: 123456789-01. Preencha-o de novo agora."
var iRG = "Neste campo deve haver um número de RG válido. Exemplo: 123456789. Preencha-o de novo agora."
var iCGC = "Neste campo deve haver um número de CGC válido. Exemplo: 12345678/0001-90. Preencha-o de novo agora."
var iCreditCardPrefix = "Este não é um número válido de cartão "
var iCreditCardSuffix = ". Preencha-o de novo agora."
var iTitular = "Escreva neste campo o nome que aparece no cartão de crédito utilizado."

// p é abreviação de "prompt"

var pEntryPrompt = "Please enter a "
var pStateCode = "2 character code (like CA)."
var pZIPCode = "5 or 9 digit U.S. ZIP Code (like 94043)."
var pUSPhone = "10 digit U.S. phone number (like 415 555 1212)."
var pWorldPhone = "international phone number."
var pSSN = "9 digit U.S. social security number (like 123 45 6789)."
var pEmail = "valid email address (like foo@bar.com)."
var pCreditCard = "valid credit card number."
var pDay = "day number between 1 and 31."
var pMonth = "month number between 1 and 12."
var pYear = "2 or 4 digit year number."


// Verifica se conteudo vazio
function isEmpty(s)
{   return ((s == null) || (s.length == 0))
}

// Warning de form
function warnInvalid (theField, s)
{   theField.focus()
    theField.select()
    alert(s)
    return false
}

function warnEmpty (theField, s)
{   theField.focus()
    alert(mPrefix + s + mSuffix)
    return false
}

// Mensagem no status do browser
function prompt (s)
{   window.status = s
}

// Prompty no status
function promptEntry (s)
{   window.status = pEntryPrompt + s
}

// Dias de fevereiro
function daysInFebruary (year)
{   // Fevereiro tem 29 dias em qualquer ano divisível por 4,
    // EXCETO em anos múltiplos de 100, que não sejam divisíveis por 400.
    return (((year % 4 == 0) && ((!(year % 100 == 0)) || (year % 400 == 0))) ? 29 : 28 );
}

// Para gerar array
function makeArray(n) {
   for (var i = 1; i <= n; i++) {
      this[i] = 0
   }
   return this
}

// Define número de dias de cada mês em um certo ano.

var daysInMonth = makeArray(12);
daysInMonth[1] = 31;
daysInMonth[2] = 29;   // é preciso verificar isso.
daysInMonth[3] = 31;
daysInMonth[4] = 30;
daysInMonth[5] = 31;
daysInMonth[6] = 30;
daysInMonth[7] = 31;
daysInMonth[8] = 31;
daysInMonth[9] = 30;
daysInMonth[10] = 31;
daysInMonth[11] = 30;
daysInMonth[12] = 31;

// Define os estados brasileiros

var StateCodeDelimiter = "|";
var StateCodes = "AC|AL|AM|AP|BA|CE|DF|ES|GO|MA|MG|MG|MS|MT|PA|PB|PE|PI|PR|RN|RO|RR|RS|SC|SE|SP|TO"

// Verifica se é um numero inteiro
function isInteger (s)
{   var i;
    if (isEmpty(s))
       if (isInteger.arguments.length == 1) return defaultEmptyOK;
       else return (isInteger.arguments[1] == true);

    // Varre todos os caracteres da cadeia, um por um até encontrar um
    //   caractere não numérico.
    // Quando encontrarmos, retornamos falso; se não, retornamos verdadeiro.

    for (i = 0; i < s.length; i++)
    {
        // Verifica se o caractere corrente é um número.
        var c = s.charAt(i);
        if (!isDigit(c)) return false;
    }
    // Todos os caracteres são números.
    return true;
}

// Verifica inteiro com sinal
function isSignedInteger (s)

{   if (isEmpty(s))
       if (isSignedInteger.arguments.length == 1) return defaultEmptyOK;
       else return (isSignedInteger.arguments[1] == true);
    else {
        var startPos = 0;
        var secondArg = defaultEmptyOK;
        if (isSignedInteger.arguments.length > 1)
            secondArg = isSignedInteger.arguments[1];
        // pula o sinal + ou - no começo
        if ( (s.charAt(0) == "-") || (s.charAt(0) == "+") )
           startPos = 1;
        return (isInteger(s.substring(startPos, s.length), secondArg))
    }
}

// Verifica inteiro não negativo
function isNonnegativeInteger (s)
{   var secondArg = defaultEmptyOK;
    if (isNonnegativeInteger.arguments.length > 1)
        secondArg = isNonnegativeInteger.arguments[1];

    // A linha seguinte é um pouco "bizantina". O que ela significa:
    // a) "s" precisa ser um inteiro com sinal, E
    // b) um dos seguintes arguments tem que ser verdadeiro:
    //    i)  "s" é vazio e devemos retornar verdadeiro para cadeias vazias
    //    ii) este é um número >= 0

    return (isSignedInteger(s, secondArg)
         && ((isEmpty(s) && secondArg) || (parseInt (s) >= 0)));
}

// Verifica se inteiro positivo
function isPositiveInteger (s)
{   var secondArg = defaultEmptyOK;

    if (isPositiveInteger.arguments.length > 1)
        secondArg = isPositiveInteger.arguments[1];

    // A linha seguinte é um pouco "bizantina". O que ela significa:
    // a) "s" precisa ser um inteiro com sinal, E
    // b) um dos seguintes arguments tem que ser verdadeiro:
    //    i)  "s" é vazio e devemos retornar verdadeiro para cadeias vazias
    //    ii) este é um número >= 0

    return (isSignedInteger(s, secondArg)
         && ( (isEmpty(s) && secondArg)  || (parseInt (s) > 0) ) );
}

// Verifica ano valido
function isYear (s)
{   if (isEmpty(s))
       if (isYear.arguments.length == 1) return defaultEmptyOK;
       else return (isYear.arguments[1] == true);
    if (!isNonnegativeInteger(s)) return false;
    return (s.length == 4);
}

// Verifica se inteiro entre dois outros inteiros
function isIntegerInRange (s, a, b)
{   if (isEmpty(s))
       if (isIntegerInRange.arguments.length == 1) return defaultEmptyOK;
       else return (isIntegerInRange.arguments[1] == true);

    // Pega cadeias de não-inteiros para evitar a criação de um NaN abaixo,
    // que não funciona em JavaScript 1.0 para Windows.
    if (!isInteger(s, false)) return false;

    // Agora, explicitamente altera o tipo para inteiro através de parseInt
    //    para que o código de comparação abaixo funcione tanto
    //    em JavaScript 1.2 (que faz checagem de tipos em comparações de
    //    igualdade) e JavaScript 1.1 e anteriores (que não verificam nada).
    numero = parseInt(s, 10);
    return ((numero >= a) && (numero <= b));
}

// Verifica se é mes valido
function isMonth (s)
{   if (isEmpty(s))
       if (isMonth.arguments.length == 1) return defaultEmptyOK;
       else return (isMonth.arguments[1] == true);
    return isIntegerInRange (s, 1, 12);
}

// Verifica se dia valido
function isDay (s)
{   if (isEmpty(s))
       if (isDay.arguments.length == 1) return defaultEmptyOK;
       else return (isDay.arguments[1] == true);
    return isIntegerInRange (s, 1, 31);
}

// Usado para reformatar campos:
// ex: reformat (stripCharsNotInBag ("123 456 7890", digits),
//           "(", 3, ") ", 3, "-", 4)
function reformat (s)
{   var arg;
    var sPos = 0;
    var resultString = "";

    for (var i = 1; i < reformat.arguments.length; i++) {
       arg = reformat.arguments[i];
       if (i % 2 == 1) resultString += arg;
       else {
           resultString += s.substring(sPos, sPos + arg);
           sPos += arg;
       }
    }
    return resultString;
}

// Verifica cep
function isZIPCode (s)
{  if (isEmpty(s))
       if (isZIPCode.arguments.length == 1) return defaultEmptyOK;
       else return (isZIPCode.arguments[1] == true);
   return (isInteger(s) && (s.length == digitsInZIPCode))
}

// Verifica telefone valido
function isPhoneNumber (s)
{   if (isEmpty(s)) 
       if (isPhoneNumber.arguments.length == 1) return defaultEmptyOK;
       else return (isPhoneNumber.arguments[1] == true);
    return (isInteger(s) && s.length >= mindigitsInPhoneNumber && s.length <= maxdigitsInPhoneNumber)
}

// Verifica se campo é apenas composto de caracteres em branco
function isWhitespace (s)

{   var i;
    // Is s empty?
    if (isEmpty(s)) return true;

    // Varre a cadeia em busca de um caractere que não seja um espaço.
    // Quando encontrar, retorna falso. Senão, retorna verdadeiro.

    for (i = 0; i < s.length; i++)
    {
        // Verifica se o caractere corrente não é um espaço.
        var c = s.charAt(i);
        if (whitespace.indexOf(c) == -1) return false;
    }

    // Todos os caracteres são espaços.
    return true;
}

// Remove caracteres de uma string
function stripCharsInBag (s, bag)

{   var i;
    var returnString = "";

    // Varre a cadeia caractere por caractere.
    // Se o caractere não estiver na cadeia "bag", acrescenta-o
    //    à cadeia "returnString".

    for (i = 0; i < s.length; i++)
    {   
        // Verifica se o caractere corrente não é um espaço.
        var c = s.charAt(i);
        if (bag.indexOf(c) == -1) returnString += c;
    }
    return returnString;
}

// Remove os caracteres que não forem informados na string, mantendo apenas os informados
function stripCharsNotInBag (s, bag)
{   var i;
    var returnString = "";

    // Varre a cadeia caractere por caractere.
    // Se o caractere estiver na cadeia "bag", acrescenta-o à cadeia
    //   "returnString".

    for (i = 0; i < s.length; i++)
    {   
        // Check that current character isn't whitespace.
        var c = s.charAt(i);
        if (bag.indexOf(c) != -1) returnString += c;
    }
    return returnString;
}

// Remove espaços em branco
function stripWhitespace (s)
{   return stripCharsInBag (s, whitespace)
}

// Remove espaços em branco do inicio
function stripInitialWhitespace (s)
{   var i = 0;
    while ((i < s.length) && charInString (s.charAt(i), whitespace))
       i++;
    return s.substring (i, s.length);
}

// Verifica se é uma letra
function isLetter (c)
{   return ( ((c >= "a") && (c <= "z")) || ((c >= "A") && (c <= "Z")) )
}

// Verifica numero de 0 a 9
function isDigit (c)
{   return ((c >= "0") && (c <= "9"))
}

// Verifica se é letra ou numero
function isLetterOrDigit (c)
{   return (isLetter(c) || isDigit(c))
}

// Verifica se é estado valido
function isStateCode(s)
{   if (isEmpty(s)) 
    if (isStateCode.arguments.length == 1) return defaultEmptyOK;
    else return (isStateCode.arguments[1] == true);
 return ( (StateCodes.indexOf(s) != -1) &&
          (s.indexOf(StateCodeDelimiter) == -1) )
}

// Verifica se e-mail valido
function isEmail (s)
{   if (isEmpty(s))
       if (isEmail.arguments.length == 1) return defaultEmptyOK;
       else return (isEmail.arguments[1] == true);

    // A cadeia "s" é composta de espaços?
    //if (isWhitespace(s)) return false;

    // É preciso ter >= 1 caracteres antes da @, assim
    // começamos a procurar na posição 1
    // (i.e. segundo caractere)
    var i = 1;
    var sLength = s.length;

    // procura pela @
    while ((i < sLength) && (s.charAt(i) != "@"))
    { i++
    }

    if ((i >= sLength) || (s.charAt(i) != "@")) return false;
    else i += 2;

    // procura pelo .
    while ((i < sLength) && (s.charAt(i) != "."))
    { i++
    }

    // é preciso ter pelo menos um caractere após o .
    if ((i >= sLength - 1) || (s.charAt(i) != ".")) return false;
    else return true;
}

// Retorna se uma data é valida (ano, mes, dia)
function isDate (year, month, day)
{   
    if (! (isYear(year, false) && isMonth(month, false) && isDay(day, false))) return false;

    // Muda explicitamente o tipo para inteiro para fazer com que o código
    // funcione tanto em JavaScript 1.1 quanto em JavaScript 1.2.

    var intYear = parseInt(year);
    var intMonth = parseInt(month);
    var intDay = parseInt(day);
      
    // Pega dias inválidos, exceto em fevereiro
    if (intDay > daysInMonth[intMonth]) return false;

    // Se o mês for fevereiro, verifica o número de dias do mês no ano dado.
    if ((intMonth == 2) && (intDay > daysInFebruary(intYear))) return false;

    return true;
}

// Para reformatar CEP
function reformatZIPCode (ZIPString)
{  return (reformat (ZIPString, "", 5, "-", 3));
}

// Para checar CEP
function checkZIPCode (theField, emptyOK)
{   if (checkZIPCode.arguments.length == 1) emptyOK = defaultEmptyOK;
    if ((emptyOK == true) && (isEmpty(theField.value))) return true;
    else
    { var normalizedZIP = stripCharsInBag(theField.value, ZIPCodeDelimiters)
      if (!isZIPCode(normalizedZIP, false)) 
         return warnInvalid (theField, iZIPCode);
      else 
      {  // Se você não quiser inserir um hífen, comente a linha abaixo
         theField.value = reformatZIPCode(normalizedZIP)
         return true;
      }
    }
}

// Para checar e-mail
function checkEmail (theField, emptyOK)
{   if (checkEmail.arguments.length == 1) emptyOK = defaultEmptyOK;
    if ((emptyOK == true) && (isEmpty(theField.value))) return true;
    else if (!isEmail(theField.value, false))
       return warnInvalid (theField, iEmail);
    else return true;
}

// Para checar estado
function checkStateCode (theField, emptyOK)
{   if (checkStateCode.arguments.length == 1) emptyOK = defaultEmptyOK;
     if ((emptyOK == true) && (isEmpty(theField.value))) return true;
     else
     {  theField.value = theField.value.toUpperCase();
        if (!isStateCode(theField.value, false)) 
           return true;
        else return true;
     }
}

// Para checar ano
function checkYear (theField, emptyOK)
{   if (checkYear.arguments.length == 1) emptyOK = defaultEmptyOK;
    if ((emptyOK == true) && (isEmpty(theField.value))) return true;
    if (!isYear(theField.value, false))
       return warnInvalid (theField, iYear);
    else return true;
}

// Para checar mes
function checkMonth (theField, emptyOK)
{   if (checkMonth.arguments.length == 1) emptyOK = defaultEmptyOK;
    if ((emptyOK == true) && (isEmpty(theField.value))) return true;
    if (!isMonth(theField.value, false))
       return warnInvalid (theField, iMonth);
    else return true;
}

// Para checar dia
function checkDay (theField, emptyOK)
{   if (checkDay.arguments.length == 1) emptyOK = defaultEmptyOK;
    if ((emptyOK == true) && (isEmpty(theField.value))) return true;
    if (!isDay(theField.value, false))
       return warnInvalid (theField, iDay);
    else return true;
}

// Para checar data
function checkDate (yearField, monthField, dayField, labelString, OKtoOmitDay)
{   // A linha segunte é necessária no NN3 para evitar o erro
    //   "undefined is not a number"
    //   na comparação de igualdade abaixo
    if (checkDate.arguments.length == 4) OKtoOmitDay = false;
    if (!isYear(yearField.value)) return warnInvalid (yearField, iYear);
    if (!isMonth(monthField.value)) return warnInvalid (monthField, iMonth);
    if ( (OKtoOmitDay == true) && isEmpty(dayField.value) ) return true;
    else if (!isDay(dayField.value))
       return warnInvalid (dayField, iDay);
    if (isDate (yearField.value, monthField.value, dayField.value))
       return true;
    alert (iDatePrefix + labelString + iDateSuffix)
    return false
}

// Para reformatar telefone
function reformatPhone (Phone)
{   if (Phone.length == mindigitsInPhoneNumber)
      return (reformat (Phone, "(", 2, ") ", 2, "-", 4));
    else  {
       if (Phone.length == maxdigitsInPhoneNumber - 1)  
          return (reformat (Phone, "(", 2, ") ", 4, "-", 4));
       else if (Phone.length == maxdigitsInPhoneNumber)
          return (reformat (Phone, "", 4, "-", 3, "-", 4));
       else
          return (reformat (Phone, "(", 2, ") ", 3, "-", 4));
    }
}

// Para checar telefone
function checkPhone (theField, emptyOK)
{   if (checkPhone.arguments.length == 1) emptyOK = defaultEmptyOK;
    if ((emptyOK == true) && (isEmpty(theField.value))) return true;
    else
    {  var normalizedPhone = stripCharsInBag(theField.value, phoneNumberDelimiters)
       if (!isPhoneNumber(normalizedPhone, false)) 
          return warnInvalid (theField, iPhone);
       else 
       {  // Se você não quiser reformatar como (123) 456-789,
          // comente a linha seguinte
          theField.value = reformatPhone(normalizedPhone)
          return true;
       }
    }
}

// Valida um campo CPF
function CPFValido(CPF) {
        var digito = new Array(digitsInCPF);
        var dv = new Array(2);
        var aux = 0;
        var i = 0;

        // Se tiver menos de digitsInCPF posicoes, completa com zeros à frente
        if (CPF.length < digitsInCPF-1) {
           alert ("CPF");
           CPF = "0000000000" + CPF;
           CPF = CPF.substring(CPF.length - digitsInCPF, CPF.length);
        }

        // Separa os dígitos (12 dígitos no máximo)
        for (i=0; i<=(CPF.length-1); i++) {
           digito[i]=CPF.substring(i,i+1);
        }

        // Calcula o primeiro dígito verificador
        for (i=0; i<=8; i++) {
           aux += (digito[i] * (10-i));
        }
        if (((aux%digitsInCPF)==0) | ((aux%digitsInCPF)==1)) {
           dv[0] = 0;
        } else {
           dv[0] = digitsInCPF - (aux%digitsInCPF);
        }

        // Se o primeiro dígito não valer, pára por aqui
        if (dv[0] != digito[9]) {
           return false;
        }

        // Calcula o segundo dígito verificador
        aux = 0;
        for (i=0; i<=8; i++) {
           aux += (digito[i] * (digitsInCPF-i));
        }
        aux += dv[0] * 2;
        if (((aux%digitsInCPF)==0) | ((aux%digitsInCPF)==1)) {
           dv[1] = 0;
        } else {
           dv[1] = digitsInCPF - (aux%digitsInCPF);
        }

        // Se o segundo dígito não valer, pára por aqui
        if (dv[1] != digito[10]) {
           return false;
        }

        // Se chegou até aqui, não há por que não dizer
        // que o CPF não é válido
        return true;
}

// Checa cpf
function checkCPF (CPFfield){

   // Limpa a cadeia, tirando caracteres desnecessários
   CPFfield.value = stripCharsNotInBag (CPFfield.value, digits);

   if (CPFfield.value)
   {
   if ( (! (CPFfield.value.length >= digitsInCPF)) || (! CPFValido(CPFfield.value)) ) {
       return warnInvalid (CPFfield, iCPF);
   } else {
       // Se você não quiser reformatar como 123.123.123-00,
       // comente a linha seguinte
       CPFfield.value = reformat(CPFfield.value,"",3,".",3,".",3,"-",2);
       return true;
   }
   }
}

// Faz trim de uma string
function trim (string){
   c = string.substring (0,1)
   while (c == ' ' && string.length){
        string = string.substring (1, string.length)
        string.length = string.length - 1
        c = string.substring (0,1)
   }
   if (!string.length)
      return string
   c = string.substring (string.length-1, string.length);
   while (c == ' ' && string.length){
      string = string.substring (0, string.length-1);
      string.length = string.length - 1;
      c = string.substring (string.length-1, string.length);
    }
    return string;
}

// Obtem valor de um radio
function getRadioButtonValue (radio)
{   for (var i = 0; i < radio.length; i++)
    {   if (radio[i].checked) { break }
    }
    return radio[i].value
}

// Obtem o campo de um select
function getSelectFieldValue (fselect)
{  for (var i = 0; i < fselect.options.length; i++) {
       if (fselect.options[i].selected){
          ccName = fselect.options[i].value
          i = fselect.options.length
       }
   }
   return ccName
}

// Verifica cartão de crédito
function checkCreditCard (fselect, theField)
{   var cardType = getSelectFieldValue (fselect)
    var normalizedCCN = stripCharsInBag(theField.value, creditCardDelimiters)
    if (!isCardMatch(cardType, normalizedCCN)) 
       return warnInvalid (theField, iCreditCardPrefix + cardType + iCreditCardSuffix);
    else 
    {  theField.value = normalizedCCN
       return true
    }
}

// Para ver se número pertence a cartao de credito
function isCreditCard(st) {
  // A codificação só funciona em números de cartão com menos de 19 dígitos.
  if (st.length > 19)
    return (false);

  sum = 0; mul = 1; l = st.length;
  for (i = 0; i < l; i++) {
    digit = st.substring(l-i-1,l-i);
    tproduct = parseInt(digit ,10)*mul;
    if (tproduct >= 10)
      sum += (tproduct % 10) + 1;
    else
      sum += tproduct;
    if (mul == 1)
      mul++;
    else
      mul--;
  }

  if ((sum % 10) == 0)
    return (true);
  else
    return (false);

}

// Verifica cartao visa
function isVisa(cc)
{
  if (((cc.length == 16) || (cc.length == 13)) &&
      (cc.substring(0,1) == 4))
    return isCreditCard(cc);
  return false;
}

// Verifica cartao mastercard
function isMasterCard(cc)
{
  firstdig = cc.substring(0,1);
  seconddig = cc.substring(1,2);
  if ((cc.length == 16) && (firstdig == 5) &&
      ((seconddig >= 1) && (seconddig <= 5)))
    return isCreditCard(cc);
  return false;

}

// Verifica cartao american express
function isAmericanExpress(cc)
{
  firstdig = cc.substring(0,1);
  seconddig = cc.substring(1,2);
  if ((cc.length == 15) && (firstdig == 3) &&
      ((seconddig == 4) || (seconddig == 7)))
    return isCreditCard(cc);
  return false;

}

// Verifica cartao diners
function isDinersClub(cc)
{
  firstdig = cc.substring(0,1);
  seconddig = cc.substring(1,2);
  if ((cc.length == 14) && (firstdig == 3) &&
      ((seconddig == 0) || (seconddig == 6) || (seconddig == 8)))
    return isCreditCard(cc);
  return false;
}

// Verifica cartao discover
function isDiscover(cc)
{
  first4digs = cc.substring(0,4);
  if ((cc.length == 16) && (first4digs == "6011"))
    return isCreditCard(cc);
  return false;

}

// Verifica outros cartoes de credito
function isAnyCard(cc)
{
  if (!isCreditCard(cc))
    return false;
  if (!isMasterCard(cc) && !isVisa(cc) && !isAmericanExpress(cc) && !isDinersClub(cc) &&
      !isDiscover(cc)) {
    return false;
  }
  return true;

}

// Verifica se cartao de credito é valido
function isCardMatch (cardType, cardNumber)
{
    cardType = cardType.toUpperCase();
    var doesMatch = true;

    if ((cardType == "VISA") && (!isVisa(cardNumber)))
        doesMatch = false;
    if ((cardType == "MASTERCARD") && (!isMasterCard(cardNumber)))
        doesMatch = false;
    if ( ( (cardType == "AMERICANEXPRESS") || (cardType == "AMEX") )
                && (!isAmericanExpress(cardNumber))) doesMatch = false;
    if ((cardType == "DISCOVER") && (!isDiscover(cardNumber)))
        doesMatch = false;
    if ((cardType == "DINERS") && (!isDinersClub(cardNumber)))
        doesMatch = false;

    return doesMatch;

}

// Upper case
var handled=false;
function Upper(e,r) {
    var codTecla = e.keyCode;
    if (codTecla != 37 && codTecla != 38 && codTecla != 39 && codTecla != 40) {    
        r.value = r.value.toUpperCase();
    }
    return;
}

// Upper case no blur (mudando campo)
function UpperCase(r) {
    r.value = r.value.toUpperCase();
    return;
}

// Lower case no blur (mudando campo)
function LowerCase(r) {
    r.value = r.value.toLowerCase();
    return;
}

// Para validar numeros com apenas ponto na casa decimal
function validaNumeroSimples(numero) {

	for (x=0;x<numero.length;x++) {
		carac = numero.substring(x,x+1);
		if (!isDigit(carac)) {
			if (carac != '.') {
				return false;
			}
		}
	}
	return true;
	
}

// ###################### otsuka ##############################

function checkData(campo)
{
   if(! validaData(campo.value)) {
      retorno = iDatePrefix + campo.value + iDateSuffix;
      alert(retorno);
   }   
   return;
}

function validaDataAtual(campo)
{
   if(! validaData(campo.value)) {
      return
   }

   var dia = '';
   var mes = '';
   var ano = '';
   proc = 1;
   erro = 0;
   for (x=0; x<campo.value.length; x++) {
      carac = campo.value.substring(x, x+1);
      if (carac == "/") {
         proc++;
      }
      switch(proc)
      {
         case 1:
            if (carac != "/") { dia = dia + carac; }
            break;
         case 2:
            if (carac != "/") { mes = mes + carac; }
            break;
         case 3:
            if (carac != "/") { ano = ano + carac; }
            break;
      }
   }

   var today = new Date();

   var aat = today.getFullYear();
   var mat = today.getMonth();
   var dat = today.getDate();

   mat = mat + 1;

   if (ano > aat) { erro++; }
   else if (ano == aat)
	{  
      if (mes > mat) { erro++; }
      else if (mat == mes)
      {
         if (dia > dat) { erro++; }
      }
   }

   if (erro > 0) { alert("Data maior que atual"); campo.value=""; campo.focus();}

   return;
}

function mascaraValor(campo) {

   if (campo.value != '') {
      if (isNaN(campo.value)) {
         ret = '';
         for (x=0; x<campo.value.length; x++) {
            carac = campo.value.substring(x, x+1);
            if (!isNaN(carac)) {
               ret = ret + carac;
            }
         }
      } else {
         ret = campo.value;
      }

      z = 1;
      ret2 = '';
      while (z < ret.length + 1) {
         carac = ret.substring(ret.length - z, ret.length - z + 1);
         ret2 = carac + ret2;
         if (z == 2) {
            ret2 = ',' + ret2;
         }

         if (z > 4) {
            y = z - 2;
            if (y % 3 == 0) {
               ret2 = '.' + ret2;
            }
         }

         z++;
      }

      if (ret2.substring(0, 1) == '.' || ret2.substring(0, 1) == ',') {
         ret2 = ret2.substring(1, ret2.length);
      }

      campo.value = ret2;

   }
   return;
}

function acertaValor(campo) {
   if (campo.value.length == 1) {
      campo.value = '0,0' + campo.value;
   }
   if (campo.value.length == 2) {
      campo.value = '0,' + campo.value;
   }
   return;
}

function autoMask(field, event, sMask) {
        //var sMask = "**?##?####";
// onkeypress="return autoMask(this,event, '###.###.###/####-##');"
// onkeypress="return autoMask(this,event, 'AAAAAAAAAAA');"

        var KeyTyped = String.fromCharCode(getKeyCode(event));
        var targ = getTarget(event);
        keyCount = targ.value.length;

   if(keyCount == sMask.length)
   {
      return false;
   }
      if ((sMask.charAt(keyCount+1) != '#') && (sMask.charAt(keyCount+1) != 'A' ) )
      {
         field.value = field.value + KeyTyped + sMask.charAt(keyCount+1);
         return false;
      }

        if (sMask.charAt(keyCount) == '*')
                return true;

        if (sMask.charAt(keyCount) == KeyTyped)
        {
                return true;
        }

        if ((sMask.charAt(keyCount) == '#') && isNumeric(KeyTyped))
           return true;

        if ((sMask.charAt(keyCount) == 'A') && isAlpha(KeyTyped))
         return true;

      if ((sMask.charAt(keyCount+1) == '?') )
      {
         field.value = field.value + KeyTyped + sMask.charAt(keyCount+1);
         return true;
      }
      if (KeyTyped.charCodeAt(0) < 32) return true;
    return false;
}
 function getTarget(e) {
  // IE5
   if (e.srcElement) {
        return e.srcElement;
   }
    if (e.target) {
        return e.target;
   }
 }

  function getKeyCode(e) {
 //IE5
 if (e.srcElement) {
        return e.keyCode
 }
  // NC5
  if (e.target) {
   return e.which
  }
 }

 function isNumeric(c)
{
        var sNumbers = "01234567890";
        if (sNumbers.indexOf(c) == -1)
                return false;
        else return true;

}

function isAlpha(c)
{
        var lCode = c.charCodeAt(0);
        if (lCode >= 65 && lCode <= 122 )
          {
                return true;
         }
        else
        return false;
}

function isPunct(c)
{
        var lCode = c.charCodeAt(0);
        if (lCode >= 32 && lCode <= 47 )
          {
                return true;
         }
        else
        return false;

}

function tiraPonto(campo)
{
   ret = '';
   var alphadigit = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   if (campo.value != '') 
   {

      upcampo = campo.value.toUpperCase();
      for (x=0; x<upcampo.length; x++) 
      {
         carac = upcampo.substring(x, x+1);
         if (alphadigit.indexOf(carac) != -1)
         {
            ret = ret + carac;
         }
      }
   }

   campo.value = ret;
   return;
}



function mask_cpfcgc(formulario,campo,tammax,teclapres) {

	var tecla = teclapres.keyCode;
	if ( (teclapres.shiftKey && tecla != 9) || teclapres.ctrlKey || teclapres.altKey ) {
		return false;
	}
	
	//48 a 57 são os números do teclado alfabético (1 a 0)
	//96 a 105 são os números do teclado numérico (0 a 9)
	//8 é a tecla de BACKSPACE
	//46 é a tecla DELETE
	//9 é a tecla de TAB
	//39 e 37 são as teclas para direita e para esquerda para retirar a seleção do campo
	if ((tecla < 48 || tecla > 57) && (tecla < 96 || tecla > 105) && tecla != 8 && tecla != 9 && tecla != 46 && tecla != 37 && tecla != 39 ) {
		return false;
	}

	vr = document.forms(formulario).item(campo.name).value;
	tam_vr = vr.length;
	vr = vr.replace( "/", "" );
	vr = vr.replace( "/", "" );
	vr = vr.replace( "-", "" );
	vr = vr.replace( ".", "" );
	vr = vr.replace( ".", "" );
	vr = vr.replace( ".", "" );
	vr = vr.replace( ".", "" );
	tam = vr.length;

	if (tam < tammax && tecla != 8) {
		tam = vr.length+1;
	}

	if (tecla == 8 ) {
		tam = tam - 1;
	}
	else {
		if ( tecla != 9 && tecla != 37 && tecla != 39 ) {
			if ( tam_vr >= tammax ) {
				return false;
			}
		}
	}
}

function form_cpfcgc(formulario,campo,tammax,teclapres) {

	var tecla = teclapres.keyCode;

	if ((tecla < 48 || tecla > 57) && (tecla < 96 || tecla > 105) && tecla != 46 && tecla != 8) {
		return false;
	}

	vr = campo.value;
	vr = vr.replace( "/", "" );
	vr = vr.replace( "/", "" );
	vr = vr.replace( "-", "" );
	vr = vr.replace( ".", "" );
	vr = vr.replace( ".", "" );
	vr = vr.replace( ".", "" );
	vr = vr.replace( ".", "" );
	tam = vr.length;

	if ( tam <= 2 ) {
		document.forms(formulario).item(campo.name).value = vr;
	}
	if ( (tam > 2) && (tam <= 5) ) {
		document.forms(formulario).item(campo.name).value = vr.substr( 0, tam - 2 ) + '-' + vr.substr( tam - 2, tam );
	}
	if ( (tam >= 6) && (tam <= 8) ) {
		document.forms(formulario).item(campo.name).value = vr.substr( 0, tam - 5 ) + '.' + vr.substr( tam - 5, 3 ) + '-' + vr.substr( tam - 2, tam );
	}
	if ( (tam >= 9) && (tam <= 11) ) {
		document.forms(formulario).item(campo.name).value = vr.substr( 0, tam - 8 ) + '.' + vr.substr( tam - 8, 3 ) + '.' + vr.substr( tam - 5, 3 ) + '-' + vr.substr( tam - 2, tam );
	}
	if ( (tam == 12) ) {
		document.forms(formulario).item(campo.name).value = vr.substr( tam - 12, 3 ) + '.' + vr.substr( tam - 9, 3 ) + '/' + vr.substr( tam - 6, 4 ) + '-' + vr.substr( tam - 2, tam );
	}
	if ( (tam > 12) && (tam <= 14) ) {
		document.forms(formulario).item(campo.name).value = vr.substr( 0, tam - 12 ) + '.' + vr.substr( tam - 12, 3 ) + '.' + vr.substr( tam - 9, 3 ) + '/' + vr.substr( tam - 6, 4 ) + '-' + vr.substr( tam - 2, tam );
	}
}

//Verifica se CPF ou CGC e encaminha para a devida função de teste
function consiste_cpfcgc(Param) {
	tmp = Param;
	if (tmp.length == 11) {
		x = verifica_cpf(tmp);
		if (!x) {
			return false;
		}
	}
	else {
		if (tmp.length == 14) {
			cgc_aux = tmp.substring(0,2) + tmp.substring(2,5) + tmp.substring(5,8) + tmp.substring(8,12) + tmp.substring(12,14);
			x = verifica_cgc(cgc_aux);
			if (!x) {
				return false;
			}
		}
		else {
			return false;
		}
	}
	return true;
}

//Verifica se CPF ou CGC e encaminha para a devida função, no caso do cpf/cgc estar digitado sem mascara
function consiste_cpfcgc_sem_mascara(Param) {
	tmp = Param;
	if (tmp.length <= 11) {
		x = verifica_cpf(tmp);
		if (!x) {
			return false;
		}
	}
	else {
		x = verifica_cgc(tmp);
		if (!x) {
			return false;
		}
	}
	return true;
}

//Verifica se o número de CPF informado é válido
function verifica_cpf(sequencia) {
	if ( Procura_Str(1,sequencia,'00000000000,11111111111,22222222222,33333333333,44444444444,55555555555,66666666666,77777777777,88888888888,99999999999,00000000191,19100000000') > 0 ) {
		return false;
	}
	seq = sequencia;
	soma = 0;
	multiplicador = 2;
	for (f = seq.length - 3;f >= 0;f--) {
		soma += seq.substring(f,f + 1) * multiplicador;
		multiplicador++;
	}
	resto = soma % 11;
	if (resto == 1 || resto == 0) {
		digito = 0;
	}
	else {
		digito = 11 - resto;
	}
	if (digito != seq.substring(seq.length - 2,seq.length - 1)) {
		return false;
	}
	soma = 0;
	multiplicador = 2;
	for (f = seq.length - 2;f >= 0;f--) {
		soma += seq.substring(f,f + 1) * multiplicador;
		multiplicador++;
	}
	resto = soma % 11;
	if (resto == 1 || resto == 0) {
		digito = 0;
	}
	else {
		digito = 11 - resto;
	}
	if (digito != seq.substring(seq.length - 1,seq.length)) {
		return false;
	}
	return true;
}           	       

//Verifica se o número de CGC informado é válido
function verifica_cgc(sequencia) {
	seq = sequencia;
	soma = 0;
	multiplicador = 2;
	for (f = seq.length - 3;f >= 0;f-- ) {
		soma += seq.substring(f,f + 1) * multiplicador;
		if ( multiplicador < 9 ) {
			multiplicador++;
		}
		else {
			multiplicador = 2;
		}
	}
	resto = soma % 11;
	if (resto == 1 || resto == 0) {
		digito = 0;
	}
	else {
		digito = 11 - resto;
	}
	if (digito != seq.substring(seq.length - 2,seq.length - 1)) {
		return false;
	}
									
	soma = 0;
	multiplicador = 2;
	for (f = seq.length - 2;f >= 0;f--) {
		soma += seq.substring(f,f + 1) * multiplicador;
		if (multiplicador < 9) {
			multiplicador++;
		}
		else {
			multiplicador = 2;
		}
	}
	resto = soma % 11;
	if (resto == 1 || resto == 0) {
		digito = 0;
	}
	else {
		digito = 11 - resto;
	}
	if (digito != seq.substring(seq.length - 1,seq.length)) {
		return false;
	}
	return true;
}

function milhar(num)
{
   x = 0;

   if(num<0) {
      num = Math.abs(num);
      x = 1;
   }   if(isNaN(num)) num = "0";
      cents = Math.floor((num*100+0.5)%100);

   num = Math.floor((num*100+0.5)/100).toString();

   if(cents < 10) cents = "0" + cents;
      for (var i = 0; i < Math.floor((num.length-(1+i))/3); i++)
         num = num.substring(0,num.length-(4*i+3))+'.'
               +num.substring(num.length-(4*i+3));   ret = num + ',' + cents;   if (x == 1) ret = ' - ' + ret;return ret;
}

function numMask(campo,tam)
{
   if (campo.value != '') {
      campo.value = campo.value.replace(',','.');
      if (tam == '') { tam = campo.value.length }
      if (isNaN(campo.value)) {
         ret = '';
         for (x=0; x<tam; x++) {
            carac = campo.value.substring(x, x+1);
            if ( (!isNaN(carac)) || (carac == '-') ) {
               ret = ret + carac;
            }
         }
      } else {
         ret = campo.value.substring(0,tam);
      }

      ret = ret.replace('.',',');
      campo.value = ret;
   }
   return;
}

function contaLetra(campo,contador,maximo)
{
   eval ('cont = document.getElementById(\'' + contador + '\')');
   if (campo.value.length > maximo) { campo.value = campo.value.substring(0, maximo); }
   else { cont.innerHTML = maximo - campo.value.length; }
}

function trimString (str) {
  return str.replace(/^\s+/, '').replace(/\s+$/, '');
}

function ValidaEmail(str) {
  if (!str.value) return true; //aceita valor nulo
  str.value = trimString(str.value);
  var erEmail = /^\w+((\-\w+)|(\.\w+))*@\w+((\-\w+)|(\.\w+))+$/;

  return erEmail.test(str.value);
}

function MascaraCEP(campo, teclaPress) {
  if (window.event){
    var tecla = teclaPress.keyCode;
  } else {
    tecla = teclaPress.which;
  }
  var s = new String(campo.value);
  s = s.replace(/(\.|\(|\)|\/|\-| )+/g,'');
  tam = s.length + 1;
  if (tam > 5 && tam < 7)
    campo.value = s.substr(0,5) + '-' + s.substr(5, tam);
}

function digitos(event){
  if (window.event) {
    // IE
    key = event.keyCode;
  } 
  else if (event.which) {
    // netscape
    key = event.which;
  }
  if (key != 8 || key != 13 || key < 48 || key > 57)
    return (((key > 47) && (key < 58)) || (key == 8 ) || (key == 13));
    return true;
}

function addEngine(url, img, name, desc) 
{
   if ((typeof window.sidebar == "object") && (typeof window.sidebar.addSearchEngine == "function")) {
      window.sidebar.addSearchEngine (url, img, name, desc);
   } else {
      alert("Seu browser não é firefox.");
   }
}