// modo de usar: 
//<input name="numero" id="numero" onKeyUp="javascript:somente_numero(this);" value="" size=15>
function somente_numero(campo){
    var digits="0123456789"
    var campo_temp
    for (var i=0;i<campo.value.length;i++){
      campo_temp=campo.value.substring(i,i+1)    
      if (digits.indexOf(campo_temp)==-1){
            campo.value = campo.value.substring(0,i);
            break;
       }
    }
}

//função para validação de formulários
function validaForm(camposVal, titulo, posicao) {
  var valida = new w3FormValidation(camposVal,titulo,posicao);
  var resultado = valida.start();
	if ( resultado )  return true;
	else return false;
}
//função q muda o estilo dos objetos tornando visíveis ou invisíves
function mostraObj(idobj,on){
  var Obj = document.getElementById(idobj);	
  if(on) Obj.className = "on";
  else Obj.className = "off";  
}

/*******************************************/
/* essa função usa a de baixo para facilitar a formatação de cpf e cnpj */
function maskCpfCnpj(obj){  
  tam = obj.value.length+1;
    
  if(tam <=15){
     mascara(obj,cpf);
  }
  else mascara(obj,cnpj);
  //alert(tam);
}

/****************************************************
coloca mácara nos campos
como usar:
    onkeypress="mascara(this,telefone)"
    onkeypress="mascara(this,cpf)"
    onkeypress="mascara(this,cnpj)"
    onkeypress="mascara(this,data)"	
/*******************************************************/
function mascara(o,f){
    v_obj=o
    v_fun=f
    setTimeout("execmascara()",1)
}

function execmascara(){
    v_obj.value=v_fun(v_obj.value)
}

function leech(v){
    v=v.replace(/o/gi,"0")
    v=v.replace(/i/gi,"1")
    v=v.replace(/z/gi,"2")
    v=v.replace(/e/gi,"3")
    v=v.replace(/a/gi,"4")
    v=v.replace(/s/gi,"5")
    v=v.replace(/t/gi,"7")
    return v
}

function soNumeros(v){
    return v.replace(/\D/g,"")
}

function maskData(v){
    v=v.replace(/\D/g,"")                 //Remove tudo o que não é dígito
    v=v.replace(/^(\d\d)(\d)/g,"$1/$2") //Coloca parênteses em volta dos dois primeiros dígitos
    v=v.replace(/(\d{2})(\d)/,"$1/$2")    //Coloca hífen entre o quarto e o quinto dígitos
    return v
}

function maskHora(v){
    v=v.replace(/\D/g,"")                 //Remove tudo o que não é dígito
    v=v.replace(/^(\d\d)(\d)/g,"$1:$2") //Coloca parênteses em volta dos dois primeiros dígitos
    //v=v.replace(/(\d{2})(\d)/,"$1/$2")    //Coloca hífen entre o quarto e o quinto dígitos
    return v
}

function telefone(v){
    v=v.replace(/\D/g,"")                 //Remove tudo o que não é dígito
    v=v.replace(/^(\d\d)(\d)/g,"($1) $2") //Coloca parênteses em volta dos dois primeiros dígitos
    v=v.replace(/(\d{4})(\d)/,"$1-$2")    //Coloca hífen entre o quarto e o quinto dígitos
    return v
}

function cpf(v){
    v=v.replace(/\D/g,"")                    //Remove tudo o que não é dígito
    v=v.replace(/(\d{3})(\d)/,"$1.$2")       //Coloca um ponto entre o terceiro e o quarto dígitos
    v=v.replace(/(\d{3})(\d)/,"$1.$2")       //Coloca um ponto entre o terceiro e o quarto dígitos
                                             //de novo (para o segundo bloco de números)
    v=v.replace(/(\d{3})(\d{1,2})$/,"$1-$2") //Coloca um hífen entre o terceiro e o quarto dígitos
    return v
}

function cep(v){
    v=v.replace(/D/g,"")                //Remove tudo o que não é dígito
    v=v.replace(/^(\d{2})(\d{3})(\d)/,"$1.$2-$3") //Esse é tão fácil que não merece explicações
    return v
}

function cnpj(v){
    v=v.replace(/\D/g,"")                           //Remove tudo o que não é dígito
    v=v.replace(/^(\d{2})(\d)/,"$1.$2")             //Coloca ponto entre o segundo e o terceiro dígitos
    v=v.replace(/^(\d{2})\.(\d{3})(\d)/,"$1.$2.$3") //Coloca ponto entre o quinto e o sexto dígitos
    v=v.replace(/\.(\d{3})(\d)/,".$1/$2")           //Coloca uma barra entre o oitavo e o nono dígitos
    v=v.replace(/(\d{4})(\d)/,"$1-$2")              //Coloca um hífen depois do bloco de quatro dígitos
    return v
}
/****************************************************/
function Limpar(valor, validos) { 
// retira caracteres invalidos da string 
var result = ""; 
var aux; 
for (var i=0; i < valor.length; i++) { 
aux = validos.indexOf(valor.substring(i, i+1)); 
if (aux>=0) { 
result += aux; 
} 
} 
return result; 
} 

/********* função para validar CPF ***********************/
function checa_CPF(val){
	CPF = document.getElementById(val).value;
	CPF = Limpar(CPF,'0123456789');
	
	if (CPF.length != 11 || CPF == "00000000000" || CPF == "11111111111" ||
		CPF == "22222222222" ||	CPF == "33333333333" || CPF == "44444444444" ||
		CPF == "55555555555" || CPF == "66666666666" || CPF == "77777777777" ||
		CPF == "88888888888" || CPF == "99999999999")
		return false;
	soma = 0;
	for (i=0; i < 9; i ++)
		soma += parseInt(CPF.charAt(i)) * (10 - i);
	resto = 11 - (soma % 11);
	if (resto == 10 || resto == 11)
		resto = 0;
	if (resto != parseInt(CPF.charAt(9)))
		return false; 
	soma = 0;
	for (i = 0; i < 10; i ++)
		soma += parseInt(CPF.charAt(i)) * (11 - i);
	resto = 11 - (soma % 11);
        resto = parseInt(resto);
	if (resto == 10 || resto == 11)
		resto = 0;
	if (resto != parseInt(CPF.charAt(10)))
		return false; 
	return true;
}

function checa_CNPJ(val) {  
   
  var cnpj = Limpar(document.getElementById(val).value,'0123456789');  
  var numeros, digitos, soma, i, resultado, pos, tamanho, digitos_iguais;  
   
  digitos_iguais = 1;  

  for (var i=0; i < cnpj.length - 1; i++)  
   
  if (cnpj.charAt(i) != cnpj.charAt(i + 1)) {  
     
  digitos_iguais = 0;  
  break;  
  }  
     
  if (!digitos_iguais) {  
     
  tamanho = cnpj.length - 2  
  numeros = cnpj.substring(0,tamanho);  
  digitos = cnpj.substring(tamanho);  
  soma = 0;  
  pos = tamanho - 7;  
     
  for (var i=tamanho; i >= 1; i--) {  
     
  soma += numeros.charAt(tamanho - i) * pos--;  
  if (pos < 2) {  
     
  pos = 9;  
  }  
  }  
     
  resultado = soma % 11 < 2 ? 0 : 11 - soma % 11;  
     
  if (resultado != digitos.charAt(0)) {  
     
  return false;  
  }  
     
  tamanho = tamanho + 1;  
  numeros = cnpj.substring(0,tamanho);  
  soma = 0;  
  pos = tamanho - 7;  
     
  for (i = tamanho; i >= 1; i--) {  
     
  soma += numeros.charAt(tamanho - i) * pos--;  
  if (pos < 2) {  
     
  pos = 9;  
  }  
  }  
     
  resultado = soma % 11 < 2 ? 0 : 11 - soma % 11;  
     
  if (resultado != digitos.charAt(1)) {  
     
  return false;  
  }  
     
  return true;  
  }  
     
  else  
  return false;  
    
}  

/*************************************************************/
function Limpar(valor, validos) { 
// retira caracteres invalidos da string 
var result = ""; 
var aux; 
for (var i=0; i < valor.length; i++) { 
aux = validos.indexOf(valor.substring(i, i+1)); 
if (aux>=0) { 
result += aux; 
} 
} 
return result; 
} 

//Formata número tipo moeda usando o evento onKeyDown 
// modo de usar: onKeydown="Formata(this,20,event,2)"
function Formata(campo,tammax,teclapres,decimal) { 
var tecla = teclapres.keyCode; 
vr = Limpar(campo.value,"0123456789"); 
tam = vr.length; 
dec=decimal 

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

if (tecla == 8 ) 
{ tam = tam - 1 ; } 

if ( tecla == 8 || tecla >= 48 && tecla <= 57 || tecla >= 96 && tecla <= 105 ) 
{ 

if ( tam <= dec ) 
{ campo.value = vr ; } 

if ( (tam > dec) && (tam <= 5) ){ 
campo.value = vr.substr( 0, tam - 2 ) + "," + vr.substr( tam - dec, tam ) ; } 
if ( (tam >= 6) && (tam <= 8) ){ 
campo.value = vr.substr( 0, tam - 5 ) + "." + vr.substr( tam - 5, 3 ) + "," + vr.substr( tam - dec, tam ) ; 
} 
if ( (tam >= 9) && (tam <= 11) ){ 
campo.value = vr.substr( 0, tam - 8 ) + "." + vr.substr( tam - 8, 3 ) + "." + vr.substr( tam - 5, 3 ) + "," + vr.substr( tam - dec, tam ) ; } 
if ( (tam >= 12) && (tam <= 14) ){ 
campo.value = vr.substr( 0, tam - 11 ) + "." + vr.substr( tam - 11, 3 ) + "." + vr.substr( tam - 8, 3 ) + "." + vr.substr( tam - 5, 3 ) + "," + vr.substr( tam - dec, tam ) ; } 
if ( (tam >= 15) && (tam <= 17) ){ 
campo.value = vr.substr( 0, tam - 14 ) + "." + vr.substr( tam - 14, 3 ) + "." + vr.substr( tam - 11, 3 ) + "." + vr.substr( tam - 8, 3 ) + "." + vr.substr( tam - 5, 3 ) + "," + vr.substr( tam - 2, tam ) ;} 
} 

} 

/*
	w3FormValidation (2.3) - 02/02/2007
	Por Leandro Vieira Pinho - http://leandro.w3invent.com.br
	
	Para informações de uso deste add-on visite:
	http://leandro.w3invent.com.br/addons/w3FormValidation/

	Parâmetros que podem ser utilizados para ATIVAR ou DESATIVAR recursos deste add-on
	var valida = new w3FormValidation(param1,param2,param3,param4,param5);
	param1 {Array}    = Campos a serem validados.
	param2 {string}   = Título do box das mensagens de erro. Padrão: Observações!
	param3 {integer}  = Distância que o box terá em relação ao topo da página. Padrão: 0
	param4 {boolean}  = Coloque false para não utilizar o "overlay" sobre o body. Padrão: true
	param5 {boolean}  = Coloque false para o box não acompanhar a rolagem da página. Padrão: true

	O código HTML gerado para exibir o box com as mensagens é o seguinte:
	
	<div id="w3ShowMsgToUser">
		<h3>Observações!</h3>
		<ol>
			<li>Mensagem</li>
			<li>...</li>
		</ol>
		<input id="w3ShowMsgToUserBtnOk" value="Ok" type="button">
	</div>
	
	Você pode estilizá-lo através das CSS e deixá-lo como desejar.
	
	Funções de terceiros utlizadas neste add-on
	
	Função: getPageSize Autor: PPK
	Função: getScrollingPosition Autor: James Edwards/Cameron Adams
	
	Tipos de validação inspirado no JS Validation de Beenjamin Keen (.com)

*/

/**
 *
 * @param {array} arrInfoVal informações sobre os campos a serem validados; tipo de validação
 * @param {string} strTitleMsgToUser título que será utilizado no box da mensagem
 * @param {int} intPageTopDistance valor que será concedido a propriedade top do box da mensagem
 * @param {boolean} boolEncobrirBody se usará um overlay sobre o body (TRUE) ou não
 * @param {boolean} boolFixMsgToUserInViewPort se o box irá acompanhar (TRUE) ou não o scrolling da página
 *
 */
function w3FormValidation(arrInfoVal,strTitleMsgToUser,intPageTopDistance,boolEncobrirBody,boolFixMsgToUserInViewPort) {
	// arrInfoVal informações sobre os campos a serem validados; tipo de validação
	this.arrInfoVal = arrInfoVal;
	
	// Mensagem que será utilizada com o título da box da mensagem - H3
	if ( typeof strTitleMsgToUser == "undefined" ) {
		this.strTitleMsgToUser = 'Observações!';
	} else {
		this.strTitleMsgToUser = strTitleMsgToUser;
	}
	
	// Se nenhum valor for informado para o parâmetro pageTopDistance, definimos-o como 0
	if ( typeof intPageTopDistance == "undefined" ) {
		intPageTopDistance = 0;
	}
	this.top = intPageTopDistance;
	
	// Se nada for definido para o parâmetro boolEncobrirBody o valor padrão será TRUE
	if ( typeof boolEncobrirBody == "undefined" ) {
		this.boolEncobrirBody = true;
	}
	
	// Pegamos um Array com a localização do usuário na página, assim exibiremos o box da Mensagem no mesmo local em que ele está :)
	var arrAtualScrollingPosition = this.getScrollingPosition();
	// Pegamos apenas a localização do eixo Y, ou seja, a distância do local até o topo da página
	this.atualScrollingPositionY = arrAtualScrollingPosition[1];
	
	// Se nada for definido para o parâmetro boolFixMsgToUserInViewPort o valor padrão será TRUE
	if ( typeof boolFixMsgToUserInViewPort == "undefined" ) {
		boolFixMsgToUserInViewPort = true;	
	}
	if ( boolFixMsgToUserInViewPort ) {
		// Adicionamos a função fixMsgToUserInViewPort para o box da mensagem acompanhar o scrolling do usuário pela página
		addEvent(window, 'scroll', this.fixMsgToUserInViewPort, false, [this.top]);
	}
};

/**
 * Função que fixa o box da mensagem no viewport do browser
 *
 * @param {array} paraTopDistance valor que será concedido ao style.top
 */
w3FormValidation.prototype.fixMsgToUserInViewPort = function(paramTopDistance) {
	// Pegamos um Array com a localização do usuário na página, assim exibiremos o box da Mensagem no mesmo local em que ele está :)
	var arrCorrenteScrollingPosition = w3FormValidation.prototype.getScrollingPosition();
	// Pegamos apenas a localização do eixo Y, ou seja, a distância do local até o topo da página
	var correnteScrollingPositionY = arrCorrenteScrollingPosition[1];
	// Somente se o objeto - o box da mensagem - estiver na página
	if ( $('w3ShowMsgToUser') ) {
		$('w3ShowMsgToUser').style.top = correnteScrollingPositionY + parseInt(paramTopDistance,'') + 'px';
	}
};

/**
 * Chama a função que validará os dados informados. Retorna TRUE se os dados forem válidos ou FALSE caso contrário.
 */
w3FormValidation.prototype.start = function() {
	// Atribui à varíavel VALIDA o resultado da validação TRUE/FALSE
	var valida = this.validation(this.arrInfoVal);
	// valor de retorno - TRUE/FALSE
	return valida;
};

w3FormValidation.prototype.validation = function(arrParams) {
	// Array que conterá as mensagens a serem exibidas ao usuário
	var arrMsgToUser = [];
	// Array que conterá o atributo ID dos campos informados
	var arrFields = [];
	// Booleano sobre o resultado da validação
	var boolResultVal = true;

	// Loop entre o Array - arrParams - passado como param da função
	for ( i = 0; i < arrParams.length; i++ ) {
	
		// O parâmetro é recebido da seguinte forma: tipo-de-validação,id-do-campo,mensagem
		var arrFieldVal = arrParams[i].split(',');
		var if_typeVal = true;
		// Variáveis utilizados pelo tipo de validação condicional
		var strCondition, arrCondition, strFieldToCheck, strValueToCheck, strFieldToCheckValue;
		// Verificamos se o primeiro item do Array contém a condição if, mais precisamente: if:
		while ( arrFieldVal[0].match("^if:") ) {
			// Pegamos a condição informada e Retiramos a partícula if:
			strCondition = arrFieldVal[0].replace("if:",""); 
			// Verificamos se o tipo de campo será um radio button
			// Para os radion buttons não é informado o ID do campo como os outros, mas sim o atributo NAME
			// Precisamos também do ID do formulário em que o radio group se encontra
			// Então, esta regra será informada assim: 'if:frmID:radioButtonName=valor,req,id do campo requerido,mensagem'
			if ( strCondition.match(":") ) {
				var arrFieldInfo = strCondition.split(":");
				var strFormID = arrFieldInfo[0];
				arrCondition = arrFieldInfo[1].split("=");
				strFieldToCheck = arrCondition[0];
				strValueToCheck = arrCondition[1];
				for ( var r = 0; r < $(strFormID)[strFieldToCheck].length; r++) {
					if ( $(strFormID)[strFieldToCheck][r].checked ) {
						strFieldToCheckValue = $(strFormID)[strFieldToCheck][r].value;
					}
				}
			} else {
				// Separamos o campo e o valor
				arrCondition = strCondition.split("=");
				strFieldToCheck = arrCondition[0];
				strValueToCheck = arrCondition[1];
				// pegamos o valor do campo informado (para compará-lo ao valor informado)
				strFieldToCheckValue = $(strFieldToCheck).value;
			}
			if ( strFieldToCheckValue != strValueToCheck ) {
				if_typeVal = false;
				break;
			} else {
				arrFieldVal.shift();
			}
		} // Fim do while match:^if
		
		if ( !if_typeVal ) {
			continue;
		}

		// tipo de validação para o campo
		var typeVal   = arrFieldVal[0]; 
		// id do campo a ser validado
		var field     = arrFieldVal[1]; 
		// mensagem a ser exibida ao usuário
		var msgToUser = '';
		// Se for uma validação do tipo: igual (dois campos com o mesmo valor)
		// igual,campo-1,campo-2,mensagem
		if ( arrFieldVal.length == 4 ) { 
			// id do segundo campo a ser validado
			var field2 = arrFieldVal[2];
			// mensagem a ser exibida ao usuário
			// Neste caso - tipo: igual - a mensagem é o 4º índice do Array
			msgToUser = arrFieldVal[3];
		} else {
			// mensagem a ser exibida ao usuário
			// Neste caso - para todos - a mensagem é o 2º índice do Array
			msgToUser = arrFieldVal[2]; 
		}

		// Verificamos se há algum tipo de validação especial
		// Validações especiais: length,range,...
		if ( typeVal.match("^length=") ) {
			var strLength_typeVal = typeVal;
			typeVal = "length";
		}
		if ( typeVal.match("^range=") ) {
			var strRange_typeVal = typeVal;
			typeVal = "range";
		}

		// Verifica o tipo de validação e a realiza
		switch(typeVal) {
			// Valida os campos requeridos
			case 'req' :
				// Validação específica para os radion button
				// Por que as coisas às vezes é tão chata?
				// Para os radion buttons não é informado o ID do campo como os outros mas sim o atributo NAME
				// Precisamos também do ID do formulário em que o radio group se encontra
				// Então, esta regra será informada assim: 'req,formID:radioName,mensagem'
				// Foi a melhor solução até o momento
				if ( field.match(":") ) {
					var arrFieldInfo = field.split(":");
					var strFormID = arrFieldInfo[0];
					var strRadioName = arrFieldInfo[1];
					if ( typeof($(strFormID)[strRadioName].type) == "undefined" ) {
						var boolRadioChecked = false;
						for ( var r = 0; r < $(strFormID)[strRadioName].length; r++) {
							if ( $(strFormID)[strRadioName][r].checked ) {
								boolRadioChecked = true;
							}
						}
						if ( !boolRadioChecked ) {
							arrMsgToUser.push(msgToUser);
							boolResultVal = false;
						}
					}
				// Validação para os demais campos
				} else {
					// Remove a classe de erro. Se o campo tiver errado depois ela é inserida de novo.
					removeClass($(field),'w3FieldError');
					if ( !$(field).value ) {
						arrMsgToUser.push(msgToUser);
						arrFields.push($(field));
						boolResultVal = false;
					}
				}
			break;
			// Valida os campos de e-mail
			case 'email' :
				// Remove a classe de erro. Se o carro tiver errado depois ela é inserida de novo.
				removeClass($(field),'w3FieldError');
				if ( !this.isEmail($(field).value) ) {
					arrMsgToUser.push(msgToUser);
					arrFields.push($(field));
					boolResultVal = false;
				}
			break;
			// Valida os campos de URL
			case 'url' :
				// Remove a classe de erro. Se o carro tiver errado depois ela é inserida de novo.
				removeClass($(field),'w3FieldError');
				if ( !this.isURL($(field).value) ) {
					arrMsgToUser.push(msgToUser);
					arrFields.push($(field));
					boolResultVal = false;
				}
			break;
			// O valor de dois campos devem ser iguais
			case 'same' :
				// Remove a classe de erro. Se o carro tiver errado depois ela é inserida de novo.
				removeClass($(field),'w3FieldError');
				if ( $(field).value != $(field2).value ) {
					arrMsgToUser.push(msgToUser);
					arrFields.push($(field));
					boolResultVal = false;
				}
			break;
			// O campo não pode ficar vazio e aceitará somente digítos [0-9]
			// Não pode ficar vazio por que vazio não é um dígito :)
			case 'digits' :
				removeClass($(field),'w3FieldError');
				if ( !$(field).value || $(field).value.match(/\D/) ) {
					arrMsgToUser.push(msgToUser);
					arrFields.push($(field));
					boolResultVal = false;
				}
			break;
			// O valor total de caracteres contidos no campo precisará ser igual ao valor informado
			// ou poderá estar entre dois valores (x-y)
			case 'length' :
				removeClass($(field),'w3FieldError');
				var strLength = strLength_typeVal.replace("length=","");
				var arrLengthOrRange = strLength.match(/[^_]+/);
				var arrLength = arrLengthOrRange[0].split("-");
				// Se for especificado dois valores, verificamos se o total de caracteres está ente esses dois valors informados.
				if ( arrLength.length == 2 ) {
					if ( ( $(field).value.length < arrLength[0] ) || ( $(field).value.length > arrLength[1] ) ) {
						arrMsgToUser.push(msgToUser);
						arrFields.push($(field));
						boolResultVal = false;
					}
				// Se for especificado um valor, verificamos se o total de caracteres é igual ao valor informado
				} else {
					if ( $(field).value.length != arrLength ) {
						arrMsgToUser.push(msgToUser);
						arrFields.push($(field));
						boolResultVal = false;
					}
				}
			break;
			case 'range' :
				// O campo precisa conter apenas dígitos [0-9]. Uma vez que será um range entre um número X e Y
				// O valor do campo não poderá ser menor que primeiro número (X) e nem maior do que o segundo (Y)
				removeClass($(field),'w3FieldError');
				var strRange = strRange_typeVal.replace("range=","");
				var arrRange = strRange.split("-");
				if ( ( $(field).value.match(/\D/) ) || ( $(field).value <  Number(arrRange[0]) ) || ( $(field).value > Number(arrRange[1]) ) ) {
					arrMsgToUser.push(msgToUser);
					arrFields.push($(field));
					boolResultVal = false;		
				}
			break;
			default :
				alert('O tipo de validação desejado não é suportado ou desconhecido pelo w3FormValidation.\n\n-------------------------\nTipo de validação: ' + typeVal + '\n-------------------------\n\nConsulte a documentação do programa para maiores detalhes em:\n\nhttp://leandro.w3invent.com.br.');
				return false;
		} // fim do switch(typeVal);

	} // fim do loop for

	// Retorna TRUE se a validação foi bem sucedida
	if ( boolResultVal ) {
		return true;
	} else {
		
		// Os campos que não foram validados receberão a classe w3FieldError
		for ( var x = 0; x < arrFields.length; x++ ) {
			addClass(arrFields[x],'w3FieldError');
		}
		
		// Exibimos as mensagens sobre os erros de cada validação
		this.showMsgToUser(arrMsgToUser);
		
		// Retorna FALSE false para o bloquear o formulário
		return false;
	}

}; // Validation

/**
 * -------------------------------------------------------------------------------------------------------------------------- 
 * Funções de validação 
 * -------------------------------------------------------------------------------------------------------------------------- 
 */

/**
 * Verifica se o e-mail é valido
 * @param {string} strEmail
 */
w3FormValidation.prototype.isEmail = function(strEmail) {
	return strEmail.search(/(\w[\w\.\-\+]+)@(.+)\.(\w+)$/) == 0;	
};

/**
 * Verifica se a URL é valida
 * @param {string} strURL
 */
w3FormValidation.prototype.isURL = function(strURL) {
	return strURL.search(/http(s)?:\/\/(www.)?([\w.]+)(\.\w{2,4})+$/) == 0;
};

/**
 * -------------------------------------------------------------------------------------------------------------------------- 
 * Fim das Funções de validação 
 * -------------------------------------------------------------------------------------------------------------------------- 
 */

/**
 * Exibe todas as mensagens que deverão ser exibidas, gerando o seguinte código HTML
 * <div id="w3ShowMsgToUser">
 *	<h3>Observações!</h3>
 *	<ol>
 *		<li>Mensagem</li>
 *	</ol>
 *	<input id="w3ShowMsgToUserBtnOk" value="Ok" type="button">
 * </div>
 * @param {Array} arrMsgToUserParam
 */
w3FormValidation.prototype.showMsgToUser = function(arrMsgToUserParam) {

	// Caso já tenha o "box" com as mensagens, removemos.
	this.closeMsgToUser('noFade');

	// Correção do bug que exibe as tags select sobre o overlay no body
	var arrTagSelect = $tags("select");
	for ( var i = 0; i < arrTagSelect.length; i++ ) {
		arrTagSelect[i].style.visibility = "hidden";
	}
	
	if ( this.boolEncobrirBody ) {
		this.encobrirBody();	
	}
	
	// Array de tags LI com a mensagem de erro como seu conteúdo
	
	var arrTagsLi = Array();
	for ( i = 0; i < arrMsgToUserParam.length; i++ ) {
		arrTagsLi.push($new('li',arrMsgToUserParam[i]));
	}	
	// Inserimos o HTML desejado na página
	$append($new('div','id=w3ShowMsgToUser',[$new('h3',this.strTitleMsgToUser),$new('ol',arrTagsLi),$new('form',$new('input',["type=button","value=Ok","id=w3ShowMsgToUserBtnOk"],""))]));
	// Inicia o w3FadingOpacity para o box da mensagem
	var fadeBox = new w3FadingOpacity('w3ShowMsgToUser',0,100,100);
	fadeBox.start();
	// Fixa o box da mensagem exatamente onde o usuário estiver na página
	// Uma vez que o valor foi pego quando ele clicou no botão (chamou esta classe)
	$('w3ShowMsgToUser').style.top = this.atualScrollingPositionY + this.top + 'px';
	// Ao clicar no botão de Ok chama a função this.closeMsgToUser para remover o "box"
	addEvent($('w3ShowMsgToUserBtnOk'),'click',this.closeMsgToUser, false);
	// Focus no botão de OK	
	$('w3ShowMsgToUserBtnOk').focus();
};

w3FormValidation.prototype.encobrirBody = function() {
	var sizesPage = getPageSize();
	$append($new("div","id=w3BodyOverlay",''));
	//$('w3BodyOverlay').style.width = arrayPageSize[0] + 'px';
	$('w3BodyOverlay').style.height = arrayPageSize[1] + 'px';
	var fadeOverlay = new w3FadingOpacity('w3BodyOverlay',0,80,100);
	fadeOverlay.start();

};

/**
 * Remove as mensagens exibidas ao usuário e o código HTML gerado
 * @param {}
 */
w3FormValidation.prototype.closeMsgToUser = function(strFade) {

	if ( strFade != 'noFade' ) {
		var fadeBox = new w3FadingOpacity('w3ShowMsgToUser',100,0,100,removerBoxes);
		fadeBox.start();
	}
	function removerBoxes() {
		$remove($('w3ShowMsgToUser'));
		$remove($('w3BodyOverlay'));

		// Correção do bug que exibe as tags select sobre o overlay no body
		var arrTagSelect = $tags("select");
		for ( var i = 0; i < arrTagSelect.length; i++ ) {
			arrTagSelect[i].style.visibility = "visible";
		}

	}
};
/**
 * Retorna a localização do formulário na página
 * @return {array} scrollLeft,scrollTop
 * @author The JavaScript Anthology 101 Essential Tips, Tricks & Hacks
 */
w3FormValidation.prototype.getScrollingPosition = function() {
	// Variável que será retornada com os valores
	var position = [0, 0];
	// pageYOffset is used by Firefox and other Mozilla browsers, Safari, Konqueror, and Opera
	if (typeof window.pageYOffset != 'undefined') {
		position = [window.pageXOffset, window.pageYOffset];
	}
	// documentElement.scrollTop is used by IE 6 in standards-compliant mode
	else if (typeof document.documentElement.scrollTop != 'undefined' && document.documentElement.scrollTop > 0) {
		position = [document.documentElement.scrollLeft, document.documentElement.scrollTop];
	}
	// body.scrollTop is used by IE 5, and IE 6 in “Quirks” mode.
	else if (typeof document.body.scrollTop != 'undefined') {
		position = [document.body.scrollLeft, document.body.scrollTop];
	}
	return position;
	/**
	 * Notes
	 * More recent Mozilla browsers (such as Firefox) also support documentElement.scrollTop and body.scrollTop, 
	 * by the same render-ing mode rules as IE 6. Safari and Konqueror support body.scrollTop in either mode. 
	 * Opera supports all three properties in any mode!
	 */
};

//
// getPageSize()
// Returns array with page width, height and window width, height
// Core code from - quirksmode.org
// Edit for Firefox by pHaez
//
function getPageSize(){
	
	var xScroll, yScroll;
	
	if (window.innerHeight && window.scrollMaxY) {	
		xScroll = document.body.scrollWidth;
		yScroll = window.innerHeight + window.scrollMaxY;
	} else if (document.body.scrollHeight > document.body.offsetHeight){ // all but Explorer Mac
		xScroll = document.body.scrollWidth;
		yScroll = document.body.scrollHeight;
	} else { // Explorer Mac...would also work in Explorer 6 Strict, Mozilla and Safari
		xScroll = document.body.offsetWidth;
		yScroll = document.body.offsetHeight;
	}
	
	var windowWidth, windowHeight;
	if (self.innerHeight) {	// all except Explorer
		windowWidth = self.innerWidth;
		windowHeight = self.innerHeight;
	} else if (document.documentElement && document.documentElement.clientHeight) { // Explorer 6 Strict Mode
		windowWidth = document.documentElement.clientWidth;
		windowHeight = document.documentElement.clientHeight;
	} else if (document.body) { // other Explorers
		windowWidth = document.body.clientWidth;
		windowHeight = document.body.clientHeight;
	}	
	
	// for small pages with total height less then height of the viewport
	if(yScroll < windowHeight){
		pageHeight = windowHeight;
	} else { 
		pageHeight = yScroll;
	}

	// for small pages with total width less then width of the viewport
	if(xScroll < windowWidth){	
		pageWidth = windowWidth;
	} else {
		pageWidth = xScroll;
	}

	arrayPageSize = new Array(pageWidth,pageHeight,windowWidth,windowHeight);

};

/**
 * -------------------------------------------------------------------------------------------------------------------------- 
 * Inclusão do add-on w3FadingOpacity 
 * -------------------------------------------------------------------------------------------------------------------------- 
 */
function w3FadingOpacity(strID, intOpacityStart, intOpacityEnd, intFadeDuration, fnAfterFaded) {
	
	this.intOffset = 10;
	this.strID = strID; // String contendo o atributo ID do objeto desejado
	this.intOpacityStart = intOpacityStart; // Valor - inteiro - inicial para o Fade
	this.intOpacityEnd = intOpacityEnd; // Valor - inteiro - final para o Fade
	this.intFadeDuration = intFadeDuration; // Valor - inteiro - para a duração do ciclo do Fade
	this.fnAfterFaded = fnAfterFaded; // Nome da função a ser chamado após a conclusão do ciclco do Fade
	this.intInterval = 0;
	
};

/**
* Aqui iniciamos todo o processo. A chamada inicial
*/
w3FadingOpacity.prototype.start = function() {
	var thisClass = this;	
	this.intInterval = setInterval(function() { thisClass.fadeCycle(); }, (this.intFadeDuration / this.intOffset));
	
};

/**
* Aqui definimos o cliclo de vida do processo de Fading
*/
w3FadingOpacity.prototype.fadeCycle = function() {
	if ( this.intOpacityEnd < this.intOpacityStart ) {
		if ( this.intOpacityStart > this.intOpacityEnd ) {
			this.intOpacityStart -= this.intOffset;
		} else {
			this.finalize();
		}
	} else {
		if ( this.intOpacityStart < this.intOpacityEnd ) {
			this.intOpacityStart += this.intOffset;
		} else {
			this.finalize();
		}
	}
	
	this.setOpacity(this.intOpacityStart / 100);
};

w3FadingOpacity.prototype.setOpacity = function(intOpacity) {
	if ( $(this.strID) ) {
		$(this.strID).style.opacity = intOpacity;
		$(this.strID).style.filter = "alpha(opacity=" + (intOpacity*100) + ")";
	}
};

w3FadingOpacity.prototype.finalize = function() {
	this.intOpacityStart = this.intOpacityEnd;
	clearInterval(this.intInterval);
	if ( this.fnAfterFaded ) {
		this.fnAfterFaded();
	}
};


/*
*	Mtzlib (0.2.6)
*	Autor: Andre Metzen (andre[at]metzen.com.br)
*	Autor: Leandro Vieira (leandro[at]w3invent.com.br)
*	26/11/2006 - 12:35
*
*	Fun?es disponiveis:
*
*	@name: $(strId[, strId2, strId3, ...]) 
*	@name: $tags(strTagName,objParentNode) 
*	@name: $before(objNew,objRefer)
*	@name: $after(objNew,objRefer)
*	@name: $replace(objNew,objOld)
*	@name: $newTN(strConteudo) 
*	@name: $new(strTagName, strParams, strConteudo)
*	@name: $append(objNode, objParentNode)
*	@name: $remove(objNode)
*	@name: getStc(evt)
*	@name: cEvt(evt)
*	@name: JSON(t)
*
*/

/*
*	@name: $(strId[, strId2, strId3, ...]) 
*	@version: 1.0
*	@author: Andre Metzen
*	@param: strId => String, Array of String
*	@return: Node Object, Array of Node Objects
*	@description: Retorna o(s) elemento(s) cujo id ?igual a "strId"
*/
function $(strId)
{
	var i, arrReturn,arrStrId;
	if(arguments.length > 1)
	{
		arrStrId = new Array();
		for(i=0; i<arguments.length; i++)
			arrStrId.push(arguments[i]);
	}
	
	if(strId instanceof Array)
	{
		arrStrId = strId;
	}
	
	if(arrStrId instanceof Array)
	{
		arrReturn = new Array();
		for(i=0; i<arrStrId.length; i++)
			arrReturn[i] = document.getElementById(arrStrId[i]);
	}
	else
	{
		arrReturn = document.getElementById(strId);
	}
	
	return arrReturn;
}

/*
*	@name: $tags(strTagName,objParentNode) 
*	@version: 1.0
*	@author: Andre Metzen
*	@param: strTagName => String
*	@param: objParentNode => Node Object(optional)
*	@return: Array of Node Objects
*	@description: Retorna todas as tags que possuam nodeName igual a "strTagName" dentro do objeto "objParentNode". 
*				  Caso "objParentNode" n? seja definido, ?usado como padr? "document"
*/
function $tags(strTagName,objParentNode)
{
	if(typeof objParentNode == "undefined")
	{
		objParentNode = document;
	}
	
	return objParentNode.getElementsByTagName(strTagName);
}

/*
*	@name: $before(objNew,objRefer)
*	@version: 1.0
*	@author: Andre Metzen
*	@param: objNew => Node Object
*	@param: objRefer => Node Object
*	@return: Node Object
*	@description: Insere o objeto "objNew" logo acima na arvore de n? do objeto "objRefer"
*/
function $before(objNew,objRefer)
{ 
	return objRefer.parentNode.insertBefore(objNew,objRefer);
}

/*
*	@name: $after(objNew,objRefer)
*	@version: 1.0
*	@author: Leandro Vieira
*	@param: objNew => Node Object
*	@param: objRefer => Node Object
*	@return: Node Object
*	@description: Insere o objeto "objNew" logo abaixo na arvore de n? do objeto "objRefer"
*/
function $after(objNew,objRefer)
{ 
	return objRefer.parentNode.insertBefore(objNew,objRefer.nextSibling);
}

/*
*	@name: $replace(objNew,objOld)
*	@version: 1.0
*	@author: Andre Metzen
*	@param: objNew => Node Object
*	@param: objOld => Node Object
*	@return: Node Object, false
*	@description: Substitue o objeto "objOld" pelo objeto "objNew"
*/
function $replace(objNew,objOld)
{
	if(objOld.parentNode)
	{
		return objOld.parentNode.replaceChild(objNew,objOld);
	}
	else
	{
		return false;
	}
}

/*
*	@name: $newTN(strConteudo) 
*	@version: 1.0
*	@author: Andre Metzen
*	@param: strConteudo => String
*	@return: Text Node Object, false
*	@description: Cria e retorna um text node com o conteudo passado em "strConteudo"
*/
function $newTN(strConteudo)
{
	if(typeof strConteudo == "string")
	{
		return document.createTextNode(strConteudo);
	}
	else
	{
		return false;
	}
}

/*
*	@name: $new(strTagName, strParams, strConteudo)
*	@version: 1.0
*	@author: Andre Metzen
*	@param: strTagName => String
*	@param: strParams => String, Array of strings; ex: "href=#" or ["href=#","target=_blank"]
*	@param: strConteudo => String, Array of objects or strings
*	@return: Node Object
*	@description: Cria um novo elemento do tipo "strTagName". O parametro "strParams" s? as propriedades que ser? aplicadas ao objeto.
*				  "strParams" pode ser uma string, caso seja apenas uma propriedade, ou um vetor, para n propriedades.
*				  O parametro "strConteudo" ?o conteudo. Pode ser passado como um vetor ou diretamente. Aceita-se como
*				  valor objetos ou string.
*/
function $new(strTagName, strParams, strConteudo)
{
	var i, newElement, arrParameters;
	if(typeof strConteudo == "undefined")
	{
		strConteudo = strParams;
		strParams = null;
	}
	
	newElement=document.createElement(strTagName);
	
	if(strParams instanceof Array)
	{
		for(i=0; i<strParams.length && (arrParameters = strParams[i].split("=")); i++)
		{	
			newElement[arrParameters[0]] = arrParameters[1];
		}
	}
	else
	{
		if(typeof strParams == "string" && ( arrParameters = strParams.split("=")) )
		{
			newElement[arrParameters[0]] = (arrParameters.length==2) ? arrParameters[1] : "";
		}
	}

	if(strConteudo instanceof Array)
	{
		for(i=0; i<strConteudo.length; i++)
		{
			(typeof(strConteudo[i]) =="string") ? $append($newTN(strConteudo[i]), newElement) : $append(strConteudo[i], newElement);
		}
	}
	else
	{
		$append(strConteudo, newElement);
	}
	
	return newElement;
}

/*
*	@name: $append(objNode, objParentNode)
*	@version: 1.0
*	@author: Andre Metzen
*	@param: objNode => Node Object, String, Array of Node Objects or Strings
*	@param: objParentNode => Node Object
*	@return: Integer
*	@description: Adiciona o "objNode" como ultimo n?filho de "objParentNode". Se "objNode" for uma string
*				  ?criada um Text Node e adicionado como ultimo n?  Caso "objParentNode" n? seja definido ?tomado
*				  como padr? "document.body"
*/
function $append(objNode, objParentNode)
{
	var i;
	if(typeof(objParentNode) == "undefined")
	{
		objParentNode = document.body;
	}
	
	if(objNode=="" || objNode == null)
	{
		return true;
	}
	if(objNode instanceof Array)
	{
		for(i=0; i<objNode.length; i++)
		{
			$append(objNode[i], objParentNode);
		}
	}
	else
	{
		if(typeof(objNode) == "string")
		{
			objParentNode.appendChild($newTN(objNode))
		}
		else
		{
			objParentNode.appendChild(objNode);
		}
	}
	
	return objParentNode.childNodes.length;
}

/*
*	@name: $remove(objNode)
*	@version: 1.0
*	@author: Andre Metzen
*	@param: objNode => Node Object
*	@return: void
*	@description: Remove o elemento "objNode"
*/
function $remove(objNode)
{
	if(objNode && objNode.parentNode)
	{
			objNode.parentNode.removeChild(objNode);
	}
}

/*
*	@name: getStc(evt)
*	@version: 1.0
*	@author: Elcio Ferreira
*	@param: evt => Event Object
*	@return: void
*	@description: Retorna o objeto no qual o evento foi realizado
*/
function getSrc(evt)
{
	if(typeof(evt) == "undefined")
	{
		evt=window.event;
	}
	
	var objSrc=evt.target?evt.target:evt.srcElement;
	
	if(objSrc.nodeType==3)
	{
		objSrc=objSrc.parentNode;
	}
	return objSrc;
}

/*
*	@name: cEvt(evt)
*	@version: 1.0
*	@author: Diego Nunes
*	@param: evt => Event Object
*	@return: false
*	@description: Cancela o efeito do evento "evt"
*/
function cEvt(evt)
{
	try 
	{ 
		evt.preventDefault();
	}
	catch(e)
	{
		event.returnValue=false;
	} 
	
	return false;
}

/*
*	@name: JSON(t)
*	@version: 1.0
*	@author: Elcio Ferreira
*	@param: t => String
*	@return: mixed
*	@description: Interpreta a string no formato JSON
*/
function JSON(t)
{
	try
	{
		return eval("["+t+"]")[0];
	}
	catch(e)
	{
		throw("Eval Error on code:\n"+t);
	}
}

function addEvent(objTarget, strEvtType, fnFunction, useCapture, arrParams)
{

	var fnNewFunction;

	if(typeof arrParams != "undefined")
	{
            /**
		 * Se for necessário passar vários argumentos em arrParams
	       */
		if ( typeof(arrParams) != 'string' ) {

			var arrParamsToFunction = []; // Iniciamos um array que conterá as mensagens de erro
					for ( var i = 0; i < arrParams.length; i++ )
			{ arrParamsToFunction.push(arrParams[i]); }

			fnNewFunction = function() { fnFunction.apply(objTarget,
				[arrParamsToFunction]); }
		} else {
			fnNewFunction = function() { fnFunction.apply(objTarget, [arrParams]); }
		}
	}
	else
	{
		fnNewFunction = fnFunction;
	}

	if (objTarget.addEventListener)
	{
		objTarget.addEventListener(strEvtType, fnNewFunction, useCapture);
		return true;
	}
	else
	{
		if (objTarget.attachEvent)
		{
			return objTarget.attachEvent('on' + strEvtType, fnNewFunction);
		}
		else
		{
			objTarget['on' + strEvtType] = fnNewFunction;
		}
	}
};

function remEvent(o, evType, fn)
{
  if (document.detachEvent) { o.detachEvent('on'+ evType, fn, true); return true; }
  if (o.removeEventListener) { o.removeEventListener(evType, fn, true); return true; }
}

function addClass(o, strClass)
{
	if(o.className.indexOf(strClass) == -1)o.className += " "+strClass;	
}

function removeClass(o, strClass)
{
	o.className = o.className.replace(strClass,"");	
}

function getPosition(e) {
    e = e || window.event;
    var cursor = {x:0, y:0};
    if (e.pageX || e.pageY) {
        cursor.x = e.pageX;
        cursor.y = e.pageY;
    } 
    else {
        cursor.x = e.clientX + 
            (document.documentElement.scrollLeft || 
            document.body.scrollLeft) - 
            document.documentElement.clientLeft;
        cursor.y = e.clientY + 
            (document.documentElement.scrollTop || 
            document.body.scrollTop) - 
            document.documentElement.clientTop;
    }
    return cursor;
}

function ajax()
{ 
	this.fila = new Array();
	this.isUrlEscaped = true;
	this.nextExecFn = false;
	this.currentRequest = false;

	///////////////////////////////////////////////////
	// Cria o objeto XMLHttpRequest
	///////////////////////////////////////////////////
	if (window.XMLHttpRequest) { this.XHR=new XMLHttpRequest(); }
  	else
	{
    	try { this.XHR=new ActiveXObject("Msxml2.XMLHTTP"); }
   		catch(e)
		{
     		try { this.XHR=new ActiveXObject("Microsoft.XMLHTTP"); }
      		catch(e) { this.XHR=false; }
		}
	}

	///////////////////////////////////////////////////
	// Fun?o que adicona uma nova requisi?o ajax a fila
	///////////////////////////////////////////////////
	
	this.addRequest = function(strUrl, fnRetorno, dados)
	{
		if(arguments.length < 1) return false;
		this.fila.push({url: strUrl, data:(typeof(dados) != "undefined") ? this.getDados(dados): null , fn: fnRetorno});
		if(this.fila.length == 1 && !this.currentRequest) this.doRequest();
	}

	///////////////////////////////////////////////////
	// Fun?o que executa a requisi?o
	///////////////////////////////////////////////////
	this.doRequest = function()
	{
		if(this.currentRequest = this.fila.pop())
		{
			var method = (this.currentRequest.data==null) ? "GET" : "POST";
			this.XHR.open(method,this.currentRequest.url+(this.currentRequest.url.indexOf("?")==-1?"?":"&")+Math.random(),true);
			this.XHR.onreadystatechange=function() { var a=this; return function () { a.doReturn.apply(a, [a.XHR]); }}.apply(this);
			if(method=="POST"){ this.XHR.setRequestHeader("Content-type","application/x-www-form-urlencoded"); this.XHR.setRequestHeader("encoding", "UTF-8"); }
			this.XHR.send(this.currentRequest.data);
		}
	}

	///////////////////////////////////////////////////
	// Fun?o que trabalha o retorno da requisi?o
	///////////////////////////////////////////////////
	
	this.doReturn = function()
	{
		if(this.XHR.readyState==4)
		{
			this.currentRequest.fn(this.XHR.responseText);
			this.currentRequest = false;
			if(this.fila.length>0)this.doRequest();
		}
	}

	///////////////////////////////////////////////////
	// Fun?o que trabalha os dados para serem enviados na requisi?o
	///////////////////////////////////////////////////

	this.getDados = function(obj)
	{
		if(obj == null) return null;
		
		if(typeof(obj) == "string")
		{
			return obj;
		}
		if(obj.nodeName.toLowerCase() = "form")
		{
			var is, ss, ts, i;
			var s = "";
			var v = new Array();
			
			is = $tags('input',obj);
			ss = $tags('select',obj);
			ts = $tags('textarea',obj);
			
			for(i=0; i<ts.length; i++)
			{
				if(!ts[i].disabled) v.push([ts[i].name,ts[i].value]);
			}
			
			for(i=0; i<is.length; i++)
			{
				if(is[i].type == "text" && !is[i].disabled) v.push([is[i].name,is[i].value]);
				if(is[i].type == "password" && !is[i].disabled) v.push([is[i].name,is[i].value]);
				if(is[i].type == "hidden" && !is[i].disabled) v.push([is[i].name,is[i].value]);
				if((is[i].type == "radio" || is[i].type == "checkbox") && is[i].checked  && !is[i].disabled) v.push([is[i].name,is[i].value]); 
			}
			
			for(i=0; i<ss.length; i++)
			{
				if(ss[i].selectedIndex == -1) v.push(ss[i].name,'');
				else v.push(new Array(ss[i].name,ss[i].options[ss[i].selectedIndex].value));
			}
			
			for(i=0; i<v.length; i++)
			{
				if(this.isUrlEscaped) s += encodeURIComponent(v[i][0])+"="+encodeURIComponent(v[i][1])+"&";
				else s += v[i][0]+"="+v[i][1]+"&";
			}
			
			return s;
		}
	}




}