/*
//============================================================================================
//                                                                                                  
//     Programa.........................: lib.js
//     Objetivo.........................: Funções genéricas para uso no sistema
//     Criado por.......................: Marco Guinter Alberton                                    
//     Contato..........................: mguinter@gmail.com                                        
//     Data Criacao.....................: 11/07/2007   
//	   Alterado por.....................:
//     Data Alteracao...................:                                             
//                                                                                            
//==================================================================================================
*/


//Verifica qual o browser do visitante e armazena na variável púbica clientNavigator,   
//Caso Internet Explorer(IE) outros (Other)   
if (navigator.appName.indexOf('Microsoft') != -1){   
    clientNavigator = "IE";   
}else{   
    clientNavigator = "Other";   
}   

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Verifica_Data
///////////   Parametros: campo data, obrigatorio (1=sim, 0=nao)
///////////   Objetivo..: Testar se a data é válida
///////////   Uso.......: onblur="Verifica_Data(this,1)" do input ou chamada direta
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function Verifica_Data(data, obrigatorio){   

//Se o parâmetro obrigatório for igual à zero, significa que elepode estar vazio, caso contrário, não   
//var data = document.getElementById(data);   

    var strdata = data.value;  
    if((obrigatorio == 1) || (obrigatorio == 0 && strdata != "")){   
        //Verifica a quantidade de digitos informada esta correta.   
        if (strdata.length != 10){   
            MsgErro("Formato da data não é válido.\nFormato correto: - dd/mm/aaaa.");   
            //data.focus();   
            return false   
        }   
        //Verifica máscara da data   
        if ("/" != strdata.substr(2,1) || "/" != strdata.substr(5,1)){   
            MsgErro("Formato da data não é válido.\nFormato correto: - dd/mm/aaaa.");   
            //data.focus();   
            return false   
        }   
        dia = strdata.substr(0,2)   
        mes = strdata.substr(3,2);   
        ano = strdata.substr(6,4);   
        //Verifica o dia   
        if (isNaN(dia) || dia > 31 || dia < 1){   
            MsgErro("Formato do dia n&atilde;o &eacute; v&aacute;lido.");   
            //data.focus();   
            return false   
        }   
        if (mes == 4 || mes == 6 || mes == 9 || mes == 11){   
            if (dia == "31"){   
                MsgErro("O m&ecirc;s informado n&atilde;o possui 31 dias.");   
                //data.focus();   
                return false   
            }   
        }   
        if (mes == "02"){   
            bissexto = ano % 4;   
            if (bissexto == 0){   
                if (dia > 29){   
                    MsgErro("O m&ecirc;s informado possui somente 29 dias.");   
                    //data.focus();   
                    return false   
                }   
            }else{   
                if (dia > 28){   
                    MsgErro("O m&ecirc;s informado possui somente 28 dias.");   
                    //data.focus();   
                    return false   
                }   
            }   
        }   
    //Verifica o mês   
        if (isNaN(mes) || mes > 12 || mes < 1){   
            MsgErro("Formato do m&ecirc;s n&atilde;o &eacute; v&aacute;lido.");   
            //data.focus();   
            return false   
        }   
        //Verifica o ano   
        if (isNaN(ano)){   
            MsgErro("Formato do ano n&atilde;o &eacute; v&aacute;lido.");   
            //data.focus();   
            return false   
        }   
    }   
	return true;
}   

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Compara_Datas
///////////   Parametros: campo data inicial, campo data final
///////////   Objetivo..: Testar periodos (data final precisa ser maior que a data inicial)
///////////   Uso.......: onsubmit="Compara_Datas(document.forms[0].datainicio,document.forms[0].datafinal)");
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function Compara_Datas(data_inicial, data_final){   
    //Verifica se a data inicial é maior que a data final   
//    var data_inicial = document.getElementById(data_inicial);   
//    var data_final   = document.getElementById(data_final);   
    var str_data_inicial = data_inicial.value;   
    var str_data_final   = data_final.value;   
    var dia_inicial      = data_inicial.value.substr(0,2);   
    var dia_final        = data_final.value.substr(0,2);   
    var mes_inicial      = data_inicial.value.substr(3,2);   
    var mes_final        = data_final.value.substr(3,2);   
    var ano_inicial      = data_inicial.value.substr(6,4);   
    var ano_final        = data_final.value.substr(6,4);   
    if(ano_inicial > ano_final){   
        MsgErro("A data inicial deve ser menor que a data final.");   
        data_inicial.focus();   
        return false   
    }else{   
    if(ano_inicial == ano_final){   
    if(mes_inicial > mes_final){   
    MsgErro("A data inicial deve ser menor que a data final.");   
                data_final.focus();   
                return false   
            }else{   
                if(mes_inicial == mes_final){   
                    if(dia_inicial > dia_final){   
                        MsgErro("A data inicial deve ser menor que a data final.");   
                        data_final.focus();   
                        return false   
                    }   
                }   
            }   
        }   
    }   
	return true;
}   
  
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Verifica_Hora
///////////   Parametros: campo hora, obrigatorio (1=sim, 0=nao)
///////////   Objetivo..: Testar se a hora digitada é váida
///////////   Uso.......: onblur="Verifica_hora(this,1)" do input 
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
  
function Verifica_Hora(hora, obrigatorio){   
//Se o parâmetro obrigatório for igual à zero, significa que elepode estar vazio, caso contrário, não   
    if((obrigatorio == 1) || (obrigatorio == 0 && hora != "")){   
        if(hora.length < 5){   
            MsgErro("Formato da hora inv&aacute;lido.\nPor favor, informe a hora no formato correto: hh:mm");   
            return false   
        }   
        if(hora.substr(0,2) > 23 || isNaN(hora.substr(0,2))){   
            MsgErro("Formato da hora inv&aacute;lido.");   
            return false   
        }   
        if(hora.substr(3,2) > 59 || isNaN(hora.substr(3,2))){   
            MsgErro("Formato do minuto inv&aacute;lido.");   
            return false   
        }   
    }   
}   
  
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Verifica_Email
///////////   Parametros: campo email, obrigatorio (1=sim, 0=nao)
///////////   Objetivo..: Testar digitacao de email
///////////   Uso.......: onblur="Verifica_Email(this,1)"
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
  
function Verifica_Email(email, obrigatorio){   
//Se o parâmetro obrigatório for igual à zero, significa que elepode estar vazio, caso contrário, não   
    if((obrigatorio == 1) || (obrigatorio == 0 && email.value != "")){   
        if(!email.value.match(/([a-zA-Z0-9._-]+@[a-zA-Z0-9._-]+.[a-zA-Z0-9._-]+)/gi)){   
            MsgErro("Informe um e-mail v&aacute;lido");   
//            email.focus();   
            return false   
        }   
    }   
}   
  
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Verifica_Tamamahho
///////////   Parametros: campo, tamanho máximo
///////////   Objetivo..: Testar se os caracteres digitados estão dentro do permitido
///////////   Uso.......: onblur="Verifica_Tamanho(this, 50)"
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function Verifica_Tamanho(campo, tamanho){   
//usado para campos textarea onde não se tem o atributo maxlenght   
    var campo = document.getElementById(campo);   
    if(campo.value.length > tamanho){   
        MsgAlerta("O campo suporta no m&aacute;ximo " + tamanho + " caracteres.");   
        campo.focus();   
        return false   
    }   
}   
  
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   SoNumeros
///////////   Parametros: evento
///////////   Objetivo..: Testar se o caracter digitado é numérico
///////////   Uso.......: onkeydown="SoNumeros(event)"
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function SoNumeros(evnt){   
    var tecla;

    if (clientNavigator == "IE"){   
		tecla = evnt.keyCode;
    }else{   
		tecla = evnt.charCode;
	}
	
	if (tecla==13||tecla==9||tecla==8||tecla==46||tecla==37||tecla==39) return true; // Enter ou tab, Backspace, Del, Seta para Esquerda, Seta para Direita
	var numerico=(tecla>=96&&tecla<=105);// numeros do teclado numerico
	var numeros =(tecla>=48&&tecla<=57); // numeros do teclado normal (acima das letras)
    if (clientNavigator == "IE"){   
       if (numeros==false&&numerico==false) {
		   evnt.cancelBubble = true;
	       evnt.returnValue = false; 
		   return false;    
	   }
	}else{
       if ((numeros==false&&numerico==false)&&evnt.keyCode==0) {
		  evnt.cancelBubble = true;
		  evnt.returnValue = false; 		   
		  return false;    
	   }
	}
}


////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Verifica_Valor
///////////   Parametros: minimo, maximo, campo
///////////   Objetivo..: Testar se o valor digitado atende o minimo ou maximo informado
///////////   Uso.......: onblur="Verifica_Valor(1, 30, this)"
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function Verifica_Valor(minimo,maximo,campo){
	if (campo.value<minimo) {
		MsgAlerta('Valor menor que o permitido (O m&iacute;nimo &eacute; '+minimo+')');
		return false;
	}
	if (campo.value>maximo) {
		MsgAlerta('Valor maior que o permitido (O m&aacute;ximo &eacute; '+maximo+')');
		return false;
	}
	return true;
}
  
  
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Ajusta_Hora
///////////   Parametros: campo, evento
///////////   Objetivo..: Testar se o valor digitado é uma hora válida
///////////   Uso.......: onkeyup="Ajusta_Hora(this, event)"
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
  
function Ajusta_Hora(input, evnt){   
//Ajusta máscara de Hora e só permite digitação de números  
	//Chama a função SoNumeros para só permitir a digitação de números   
    if (input.value.length == 2){   
        if(clientNavigator == "IE"){   
            input.value += ":";   
        }else{   
            if(evnt.keyCode == 0){   
                input.value += ":";   
            }   
        }   
    }   
    return SoNumeros(evnt);   
}

 
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Atualiza_Opener
///////////   Parametros: -
///////////   Objetivo..: Atualizar a janela que instanciou um popup
///////////   Uso.......: chamada direta
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
  
function Atualiza_Opener(){   
//Atualiza a página opener da popup que chamar a função   
    window.opener.location.reload();   
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   AjaxLib
///////////   Parametros: op (nome da operacao opp em acoes_ajax.php), valores
///////////   Objetivo..: Executar uma operação Ajax, chamando acoes_ajax.php
///////////   Uso.......: chamada direta
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function AjaxLib(){
	
	//var obj = new AjaxLib();
	//obj.processa(arquivo,op,valores,tiporetorno,funcao);
	
	var req = null;
    if (window.XMLHttpRequest) { // Mozilla/Firefox/Safari
        req = new XMLHttpRequest();
    } else if (window.ActiveXObject) { // Internet Explorer
        req = new ActiveXObject("Microsoft.XMLHTTP");
    }
	if (req) {
		this.processa=function(arquivo,op,valores,tiporetorno,funcao,metodo){
		
			metodo      = metodo || 'GET';
			tiporetorno = tiporetorno || 'TEXT';
			valores     = valores || '';
			funcao      = funcao || ProcessaRetorno;
			var resultado = '';
			
			if(arquivo.indexOf("?op=")>-1){
				op = arquivo.substr(eval(arquivo.indexOf("?op=")+4),arquivo.length) || op;
				var arquivo = arquivo.substr(0,arquivo.indexOf("?op="));			
			}
						
			var variaveis = 'op='+encodeURI(op)+'&'+valores;
			for(xx=0;xx<variaveis.indexOf('&&');xx++){variaveis = variaveis.replace('&&','&');}
						
			req.onreadystatechange = function(){
				if (req.readyState == 4) {
			        if (req.status == 200 || req.status == 0) {	
						if (tiporetorno=='XML'){ resultado=req.responseXML; }else{ resultado=req.responseText; }
						if (req.responseText == '') return false; // nao tem retorno
						if (funcao) funcao(op,resultado);
	    			} else {
            			switch(req.status){
                                case 204: { MsgAlerta("Erro Ajax: O servidor n&atilde;o respondeu ao chamado."); break }
                                case 400: { MsgAlerta("Erro Ajax: Endere&ccedil;o inv&aacute;lido."); break }
                                case 403: { MsgAlerta("Erro Ajax: Voc&ecirc; n&atilde;o possui permiss&atilde;o para acessar esse arquivo."); break }
                                case 404: { MsgAlerta("Erro Ajax: Arquivo n&atilde;o encontrado."); break }
                                case 500: { MsgAlerta("Erro Ajax: Erro interno do servidor."); break }
                                case 502: { MsgAlerta("Erro Ajax: Servidor ocupado."); break }
                                case 503: { MsgAlerta("Erro Ajax: O servidor n&atilde;o respondeu no tempo limite."); break }
                                 default: { MsgAlerta("Erro Ajax: Algum erro ocorreu ao carregar este conte&uacute;do."); break }
                        }
        			}
    			}				
			}
			variaveis=this.antiCache(variaveis);
			
			if(metodo.toUpperCase()=='POST'){ var arquivofinal = arquivo; } else { var arquivofinal = arquivo+'?'+variaveis; var variaveis=null; }
			
			req.open(metodo, arquivofinal, true);
			req.setRequestHeader('Content-Type', "application/x-www-form-urlencoded; charset=iso-8859-1");
			req.send(variaveis);
			
		}
		this.antiCache = function(aurl){
    		var dt = new Date();
       		return aurl + "&" + encodeURI(Math.random() + "_" + dt.getTime());
	    } 
	}

}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   CarregaDados -> Possivel substituta da Funcao Altera
///////////   Parametros: XML vindo do Ajax (gerado por acoes_ajax.php), array de campos e se esta funcionando com abas (true/false)
///////////   Objetivo..: Buscar os campos e preenchê-los com o conteúdo do XML
///////////   Uso.......: chamada direta, após XML ter retornado do Ajax
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////


function CarregaDados(result,campos,objeto){	

	var itens     = result.getElementsByTagName("item");	
	var atributos = itens[0].attributes;
	var cp,nomeCampo,tipoCampo,d,acao;
	function VerificaAlt(alt,valor){		
		switch (alt){
			case 'Data formato dd/mm/aaaa' : valor = DataPort(valor); break;
			case 'MaskN'                   : valor = Mascara(valor,alt.substr(6)); break;
			case 'valor monetario'         : valor = FormataDinheiro(valor);break;
		}
		return valor;
	}

	for(var x=0;x<campos.length;x++){

		cp         = campos[x].split('|');
		nomeCampo  = cp[0];
		tipoCampo  = cp[1] || 'input';
		
		if(tipoCampo=='checkbox') {
		   d = DefineD('input',nomeCampo,objeto);
		}else{
		   d = DefineD(tipoCampo,nomeCampo,objeto);
		}
		
		for(var y=0;y<atributos.length;y++)
		{
			if(tipoCampo=='multiplo')
			{
				if(atributos[y].nodeName == 'MULTIPLO.'+nomeCampo||atributos[y].nodeName == nomeCampo) valor = unescape(atributos[y].nodeValue);
			}else
			{
				if(atributos[y].nodeName == nomeCampo) valor = unescape(atributos[y].nodeValue);	
			}			
		}
		
		
		if(tipoCampo=='input') tipoCampo = d.type;
	
		switch (tipoCampo){
			case 'textarea' : acao = 'value'; break;
			case 'file'     : acao = 'value';
			                  if(valor){
								  
								 DefineD('div',['div_'+nomeCampo],objeto).style.display='none';
								 DefineD('input',[nomeCampo+'2'],objeto).value = valor;
								 
								 funcao = DefineD('form',['form_'+nomeCampo],objeto).action;
								 funcao = funcao.substr(eval(funcao.indexOf("funcao=")+7),funcao.length);
								 
								 imagem = valor;
								 
								 if (DefineD('input',nomeCampo+'_preview',objeto).value!="") {
									 extensao = valor.substr(valor.length-4).toLowerCase();
									 if (extensao=='.jpg'||extensao=='.gif'||extensao=='.png') {
										imagem='<a id="img_'+nomeCampo+'" onmouseover=javascript:VisualizaImagem("'+valor+'","img_'+nomeCampo+'")>'+valor+'</a>'
									 }
								 }
								 
								 var html = '<ul>';
								 html += '<li style="float:left"><b>'+imagem+'</b></li>';
								 html += "<li style='float:right'><a href=javascript:UploadExcluirArquivo('"+nomeCampo+"','"+valor+"','"+funcao+"')>";
								 html += "<img src='/lib/2us/icones/erro.png' alt='Excluir arquivo' border='0'></a></li>";
								 html += '</ul>';
								 
								 DefineD('div',['status_'+nomeCampo],objeto).innerHTML = html;
								 
							  }
							  break;
			case 'multiplo' : var cps = DefineD('input',nomeCampo,objeto).value;
							  var cps_preenchidos = valor.split(',');
							  for(var z=0;z<parseInt(cps_preenchidos.length-1);z++){
									if(cps_preenchidos[z]) DefineD('input',[nomeCampo+'_'+cps_preenchidos[z]],objeto).checked=true;
							  }
							  break;
			case 'select'   : acao = 'value'; break;
			case 'checkbox' : acao = 'checked';
							  if(valor==0) valor=false;
							  if(valor==1) valor=true;
							  break;
			case 'selectEXT' : Ext.getCmp(nomeCampo).setValue(valor);
							   break;
			case 'cor'      : PaletaDeCor('div_'+nomeCampo,valor);
							  break;
			default         : acao = 'value';
		}
		
		if(valor.length==10&&valor.indexOf('-')>0) valor = DataPort(valor);
		
		if(tipoCampo!='file'&&tipoCampo!='multiplo'&&tipoCampo!='cor'&&tipoCampo!='selectEXT'){
			valor = VerificaAlt(d.alt,valor);					
			d[acao] = valor;
		}
		
	}
	
}

function VisualizaImagem(foto,objeto){
	var diretorio=DefineD('input',objeto.substr(4)+'_preview').value;
	Dica("","<img src='"+diretorio+foto+"'>",objeto);
	Ext.QuickTips.init();
}	

function Dica(titulo,mensagem,objeto,largura){
    
	if (typeof(largura)=='undefined') largura=200;

	var dica=new Ext.ToolTip({
        target: objeto,
        title: titulo,
        width:largura,
        html: mensagem,
		script: true,
        trackMouse:true
    });
	return dica;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Altera
///////////   Parametros: XML vindo do Ajax (gerado por acoes_ajax.php), nome do formulario
///////////   Objetivo..: Buscar os campos e preenchê-los com o conteúdo do XML
///////////   Uso.......: chamada direta, após XML ter retornado do Ajax
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////


function Altera(xmlRes){
	
	var itens = xmlRes.getElementsByTagName("item");
	var itCnt = itens.length;
	var primeirocampo='';
	var objeto = null;
	var pseudodocument = null;
	var i,x,y,z;
	var inputs;
	var selects;
	
	//inputs
	
	if (typeof(tabBusca)=='undefined') {
	   objeto = 'document';
	}else{
	   inputs = tabBusca.getActiveTab().body.dom.getElementsByTagName('input');
	   selects = tabBusca.getActiveTab().body.dom.getElementsByTagName('select');
	   textareas = tabBusca.getActiveTab().body.dom.getElementsByTagName('textarea');
	   objeto = 'tabBusca';
	}
	
	if (itCnt > 0){
		for (x=0; x<itCnt; x++){
			campos=itens[x].attributes;			
			for (z=0; z<campos.length; z++){
				campo = campos[z].nodeName;
				valor = unescape(campos[z].nodeValue);
				if (campo.substr(0,9)!="MULTIPLO.") { // nao tem virgulas no valor					
					d=null;
					if (objeto=='document') {
					   d=document.getElementById(campo);					   
					}else{
					   for (i=0;i<inputs.length;i++){						   
					   		if (inputs[i].name==campo) {								
								if(inputs[i].type!="radio"){
									d=inputs[i];
									i=inputs.length;
								}else
								{
									if (inputs[i].value==valor)
									{
										d=inputs[i];
										i=inputs.lenght;
									}										  
								}
							}							
					   }
					   for (i=0;i<textareas.length;i++){					
					   		if (textareas[i].name==campo) {
								d=textareas[i];
								i=textareas.length;
							}
					   }
					}
					if (d!=null) {
						if (primeirocampo==''&&d.type!='hidden') primeirocampo=d;
						switch(d.type){								
								case "checkbox" : d.checked = (valor==1);
												  break;
								case "radio"    : d.checked = (d.value==valor);
												  break;
								case "file"     : 
												  if (valor!='') {
													  var display='none';
													  var html = "<table cellpaddding=0 cellspacing=0 width='100%'><tr><td><b>"+valor+"</b></td>";
													  html+="<td align='right'>";
													  html+="<a href=javascript:UploadExcluirArquivo('"+campo+"','"+valor+"')><img src='/lib/2us/icones/erro.png' alt='Excluir arquivo' border='0'></a>";
													  html+="</td></tr></table>";
													  //document.write(html);
												  }else{
													  var html = '';
													  var display = '';
												  }
												  document.getElementById('div_'+campo).style.display = display;
												  document.getElementById('status_'+campo).innerHTML = html;
								
												  break;
    							default         : if (d.value.length==10&&d.value.indexOf('-')>0)   valor = DataPort(valor);
												  if (d.alt&&d.alt=='Data formato dd/mm/aaaa') valor = DataPort(valor);
												  if (d.alt&&d.alt.substr(0,5)=='MaskN')       valor = Mascara(valor,d.alt.substr(6));
												  if (d.alt&&d.alt=='valor monetario')         valor = FormataDinheiro(valor);
												  d.value = valor;												  
												  break;
						}
					}
				}else{
					if (objeto=='document') {
				    	checkboxes = document.getElementsByTagName("input"); // Zerar todos os checkboxes deste campo multiplo
					}else{
					    checkboxes = inputs; // Zerar todos os checkboxes deste campo multiplo
					}
					campo=campo.substr(9); // o nome do campo real está a partir da posiçao 9. Antes disso é MULTIPLO.
					for (i=0;i<checkboxes.length;i++){
						if (checkboxes[i].type=='checkbox'&&checkboxes[i].name.substr(0,campo.length+1)==campo+"_") {
							checkboxes[i].checked=false;
						}
					}
				    valores=valor.split(","); // no tipo de campo multiplo, os valores estcao separados por virgula
					for (var i = 0; i < valores.length; i++) {
						if (objeto=='document') {
					       if (d=inputs.getElementById(campo+'_'+valores[i]))  d.checked = true; 
						}else{
						   for (i=0;i<inputs.length;i++){
							   for (y=0;y<valores.length;y++){
									if (inputs[i].id==campo+'_'+valores[y]) {
										d=inputs[i];
										d.checked = true;
									}
							   }
						   }
						}
					}
				}
			}
		}
	}
	
	//selects
	if (itCnt > 0){
		for (x=0; x<itCnt; x++){
			campos=itens[x].attributes;			
			for (z=0; z<campos.length; z++) {
				campo = campos[z].nodeName;
				valor = unescape(campos[z].nodeValue);			
				d = null;
				if (objeto=='document') {				
				   d=document.getElementById(campo);
				   if (d.type!="select") break;
				}else{
					for (i=0;i<selects.length;i++){
						if (selects[i].name==campo) {
							d=selects[i];						
						}
					}								 			
				}
				if(d!=null){			
				 for(j=0;j<d.options.length;j++) {					 				
					if(d.options[j].value==valor){						
						d.options[j].selected = true;
						j=d.options.length;
					}	
				 }
			  }
		   }
		}
	 }
					
	
	//replaceChecks();
	//primeirocampo.focus();
}

function ProcuraElementoTab(elemento,id,objeto,idTab){
	objeto = objeto || 'tabBusca';
	if(typeof(idTab)=='undefined'||idTab==''){
		var elementos = eval(objeto+".getActiveTab().body.dom.getElementsByTagName(elemento)");
	}else{
		var elementos = eval(objeto+".getItem(idTab).body.dom.getElementsByTagName(elemento)");
	}		
	for (i=0;i<elementos.length;i++){ 
		if (elementos[i].id==id) {return elementos[i]};
	}
}

function ProcuraElementoTabName(elemento,name){
	var elementos = tabBusca.getActiveTab().body.dom.getElementsByTagName(elemento);
	var elements = new Array(elementos.lenght);
	for (i=0;i<elementos.length;i++){
		if (elementos[i].name==name){
			elements[i] = elementos[i];			
		};		
	}
	return elements;
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   LimparCampos()
///////////   Parametros: 
///////////   Objetivo..: Limpar um formulário e focar no primeiro campo
///////////   Uso.......: chamada direta
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function LimparCampos(){
	if(typeof(tabBusca) != 'undefined') var tab = true;
	var tab = tab || false;
	
	if (tab) {
	    var inputs = tabBusca.getActiveTab().body.dom.getElementsByTagName('input');
	    var textareas = tabBusca.getActiveTab().body.dom.getElementsByTagName('textarea');
	    var selects = tabBusca.getActiveTab().body.dom.getElementsByTagName('select');
	}else{
		var inputs = document.getElementsByTagName("input");
		var textareas = document.getElementsByTagName("textarea");
	    var selects = document.getElementsByTagName("select"); 
	}
	

	var primeiroinput=null;
	for (var i=0;i<inputs.length;i++){
	  switch (inputs[i].type) {
			case "button"   : break;
			case "hidden"   : break;
			case "checkbox" : inputs[i].checked = false;
	                          break;
			case "radio"    : inputs[i].checked =false;
							  break;	
			case "file"		: DefineD('div',['div_'+inputs[i].name]).style.display='';
							  DefineD('input',[inputs[i].name+'2']).value = '';
							  DefineD('div',['status_'+inputs[i].name]).innerHTML='';
							  break;
			default         : inputs[i].value = "";
			  				  if (primeiroinput==null) primeiroinput = inputs[i];
			                  break;
	  }
	}
	// Zerar Textareas
	for (var i=0;i<textareas.length;i++){
		textareas[i].value = "";
	}
	// Zerar Selects
	for (var i=0;i<selects.length;i++){
		selects[i].value = "";
	}

//	if (primeiroinput!=null) primeiroinput.focus();
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   LimparCamposAba()
///////////   Parametros: 
///////////   Objetivo..: Limpar um formulário e focar no primeiro campo apenas na aba ativa
///////////   Uso.......: chamada direta
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function LimparCamposAba(){
	var inputs = tabBusca.getActiveTab().body.dom.getElementsByTagName("input"); // Zerar todos os campos
	var primeiroinput=null;
	for (var i=0;i<inputs.length;i++){
	  switch (inputs[i].type) {
			case "button"   : break;
			case "hidden"   : break;
			case "checkbox" : inputs[i].checked = false;
	                          break;
			case "radio"    : inputs[i].checked =false;
							  break;	
			default         : inputs[i].value = "";
			  				  if (primeiroinput==null) primeiroinput = inputs[i];
			                  break;
	  }
	}
	var textareas = tabBusca.getActiveTab().body.dom.getElementsByTagName("textarea"); // Zerar todos os campos
	for (var i=0;i<textareas.length;i++){
		textareas[i].value = "";
	}

	var combobox = tabBusca.getActiveTab().body.dom.getElementsByTagName("select");
	for(var l=0;l<textareas.length;l++){
		combobox[l].selectedIndex = 0;
	}
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   ValoresInputs()
///////////   Parametros: 
///////////   Objetivo..: Carregar os valores que estao em todos os inputs
///////////   Uso.......: chamada direta
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function ValoresInputs(valor_op_bd){
	document.getElementById('op_bd').value=valor_op_bd;
	
	var valores=""; 
	var op_bd = false;
	var inputs;
	
	if (typeof(tabBusca)=='undefined') {
	   inputs = document.getElementsByTagName('input'); 
	}else{
	   inputs = tabBusca.getActiveTab().body.dom.getElementsByTagName('input');
	}
	
	for (var i=0;i<inputs.length;i++){
	  switch (inputs[i].type) {
			case "radio"    : valores += inputs[i].name+"*"+inputs[i].checked+"|";
							  break;
			case "checkbox" : valores += inputs[i].name+"*"+inputs[i].checked+"|";
							  break;
			case "file"		: valores += inputs[i].name+'*'+inputs[i+1].value+"|"; // Em GetCampo cria-se um campo oculto com o nome do upload feito
							  break;
			default			: 
							  if (inputs[i].alt&&inputs[i].alt.substr(0,5)=='MaskN') {
								 valores += inputs[i].name+"*"+TiraMascara(inputs[i].value)+"|";
							  }else if (inputs[i].alt&&inputs[i].alt=='Data formato dd/mm/aaaa') {
								  if (inputs[i].value==''||inputs[i].value=='//') {
									  valores += inputs[i].name+"*NULL|";
								  }else{
							          valores += inputs[i].name+"*"+DataIng(inputs[i].value)+"|";
								  }
							  }else if (inputs[i].alt&&(inputs[i].alt=='valor monetario'||inputs[i].alt.substr(0,5)=='MaskN')) {
							     valores += inputs[i].name+"*"+TiraMascara(inputs[i].value)+"|";
							  }else{
							     valores += inputs[i].name+"*"+inputs[i].value+"|";
							  }
							  if (inputs[i].id=='op_bd') op_bd=true;
	  }
	}
	if (typeof(tabBusca)=='undefined') {
	   inputs = document.getElementsByTagName("select"); 
	}else{
	   inputs = tabBusca.getActiveTab().body.dom.getElementsByTagName('select');
	}
	for (var i=0;i<inputs.length;i++){
		valores += inputs[i].name+"*"+inputs[i].value+"|";
	}
	if (typeof(tabBusca)=='undefined') {
	   inputs = document.getElementsByTagName("textarea"); 
	}else{
	   inputs = tabBusca.getActiveTab().body.dom.getElementsByTagName('textarea');
	}
	for (var i=0;i<inputs.length;i++){
		valores += inputs[i].name+"*"+inputs[i].value+"|";
	}
	if (!op_bd) valores+='op_bd*'+valor_op_bd; // Pode ser uma aba e nao ter o valor de op_bd definido, pois está em desktop
	return valores;
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   ValoresInputsPost()
///////////   Parametros: 
///////////   Objetivo..: Carregar os valores que estao em todos os inputs
///////////   Uso.......: chamada direta
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function ValoresInputsPost(operacao,campos,objeto){

	operacao = operacao || '';
	
	var valores = '';
	var valor;
	var cp, nomeCampo, tipoCampo;
	
	if(operacao) valores = 'opp='+operacao;
	
	for(x=0;x<campos.length;x++){
		
		cp         = campos[x].split('|');
		nomeCampo  = cp[0];
		tipoCampo  = cp[1] || 'input';
		
		
		//alert(nomeCampo+" - "+tipoCampo);
		
		var pegaCampo = nomeCampo;
		var multiplo  = '';
		
		if(tipoCampo=='file'||tipoCampo=='cor') { tipoCampo='input'; pegaCampo=[nomeCampo+'2']; }
		if(tipoCampo=='multiplo'){ tipoCampo='input'; multiplo='sim'; } 
					
		
		switch(tipoCampo)
		{			
			case 'checkbox' :var valor = DefineD('input',pegaCampo,objeto).checked;
							 break;			
			case 'selectEXT' :
							 var valor = Sanitize(Ext.getCmp(pegaCampo).getValue());
							 break;
			default         :
							 if ((DefineD(tipoCampo,pegaCampo).alt&&DefineD(tipoCampo,pegaCampo,objeto).alt=='valor monetario')||
								 (DefineD(tipoCampo,pegaCampo).alt&&DefineD(tipoCampo,pegaCampo,objeto).alt.substr(0,5)=='MaskN')
								) {
								 valor = TiraMascara(DefineD(tipoCampo,pegaCampo,objeto).value);
							}else{
							     valor = Sanitize(DefineD(tipoCampo,pegaCampo,objeto).value);
							}
							break;
		}
		
		
		
		if(multiplo=='sim'){
			var multFinal   = '';			
			var multValores = valor.split(',');
			for(var z=0;z<parseInt(multValores.length-1);z++){
				if(DefineD('input',[nomeCampo+'_'+multValores[z]],objeto).checked==true) multFinal+=multValores[z]+',';
			}
			valor = multFinal;
		}
		
		if ((typeof(valor)=='string')&&(valor.indexOf('&')!=-1)) { // se tiver & no texto, dá pau
  		   valores  += '&'+nomeCampo+'='+escape(valor);
		}else{
  		   valores  += '&'+nomeCampo+'='+encodeURI(valor);
		}
	}

	return valores;
	
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Verifica_Cep
///////////   Parametros: campo cep, obrigatorio (1=sim, 0=nao)
///////////   Objetivo..: Testar se o valor digitado é um CEP válido
///////////   Uso.......: onblur="Verifica_Cep(this,0)"
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
  
function Verifica_Cep(cep, obrigatorio){   
//Se o parâmetro obrigatório for igual à zero, significa que elepode estar vazio, caso contrário, não   
//    var cep    = document.getElementById(cep);   
    var strcep = cep.value;   
    if((obrigatorio == 1) || (obrigatorio == 0 && strcep != "")){   
        if (strcep.length != 9){   
            MsgErro("CEP informado inv&aacute;lido.");   
            //cep.focus();   
            return false   
        }else{   
            if (strcep.indexOf("-") != 5){   
                MsgErro("Formato de CEP informado inv&aacute;lido.");   
                //cep.focus();   
                return false   
            }else{   
                if (isNaN(strcep.replace("-","0"))){   
                    MsgErro("CEP informado inv&aacute;lido.");   
                    //cep.focus();   
                    return false   
                }   
            }   
        }   
    }       
}   

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Verifica_Cnpj
///////////   Parametros: campo cnpj, obrigatorio (1=sim, 0=nao)
///////////   Objetivo..: Testar se o valor digitado é um CNPJ válido
///////////   Uso.......: onblur="Verifica_Cnpj(this,0)"
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
  
function Verifica_Cnpj(cnpj, obrigatorio){   
//Se o parâmetro obrigatório for igual à zero, significa que elepode estar vazio, caso contrário, não   
// 99.999.999/9999-99
    var strcnpj = cnpj.value;   
    if((obrigatorio == 1) || (obrigatorio == 0 && strcnpj != "")){   
        if (strcnpj.length != 18){   
            MsgErro("CNPJ informado inv&aacute;lido.");   
            return false   
        }else{   
            if (strcnpj.indexOf("/") != 10||strcnpj.indexOf("-") != 15){   
                MsgErro("Formato de CNPJ informado inv&aacute;lido.");   
                return false   
            }else{   
			    numcnpj=strcnpj.replace("-","");
				numcnpj=numcnpj.replace("/","")
				numcnpj=numcnpj.replace(".","")
				numcnpj=numcnpj.replace(".","")
                if (isNaN(numcnpj)){   
                    MsgErro("CNPJ informado inv&aacute;lido.");   
                    return false   
                }   
				if (!valida_cnpj(numcnpj)) {
                    MsgErro("CNPJ informado inv&aacute;lido.\n(D&iacute;gito verificador n&atilde;o confere)");   
                    return false   
				}
            }   
        }   
    }       
}   


////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   valida_cpf
///////////   Parametros: numero do cpf (value do campo)
///////////   Objetivo..: Testar se o valor digitado é um CPF válido (mod 11)
///////////   Uso.......: uso interno
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
function valida_cpf(cpf){
	
	  if(cpf==""){return false;}			
		
	  do { cpf = cpf.replace(".",""); } while( cpf.indexOf(".")>-1 )
	  do { cpf = cpf.replace("-",""); } while( cpf.indexOf(".")>-1 )
      var numeros, digitos, soma, i, resultado, digitos_iguais;
      digitos_iguais = 1;
      if (cpf.length < 11) {alert("Cpf Inv&aacute;lido");return false;}
      for (i = 0; i < cpf.length - 1; i++)
            if (cpf.charAt(i) != cpf.charAt(i + 1))
            {
               digitos_iguais = 0;
               break;
            }	 
      if (!digitos_iguais)
      {
            numeros = cpf.substring(0,9);
            digitos = cpf.substring(9);
            soma = 0;
            for (i = 10; i > 1; i--)
                  soma += numeros.charAt(10 - i) * i;
            resultado = soma % 11 < 2 ? 0 : 11 - soma % 11;
            if (resultado != digitos.charAt(0))
			{
				  MsgErro("Cpf Inv&aacute;lido");
                  return false;
			}
            numeros = cpf.substring(0,10);
            soma = 0;
            for (i = 11; i > 1; i--)
                  soma += numeros.charAt(11 - i) * i;
            resultado = soma % 11 < 2 ? 0 : 11 - soma % 11;
            if (resultado != digitos.charAt(1)) return true;
      }
      else {MsgErro("Cpf Inv&aacute;lido");return false;} 
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   valida_cnpj
///////////   Parametros: numero do cnpj (value do campo)
///////////   Objetivo..: Testar se o valor digitado é um CNPJ válido (mod 11)
///////////   Uso.......: uso interno
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function valida_cnpj(cnpj)
      {
      var numeros, digitos, soma, i, resultado, pos, tamanho, digitos_iguais;
      digitos_iguais = 1;
      if (cnpj.length < 14 && cnpj.length < 15)
            return false;
      for (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 (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;
      } 

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   teclasaceitas
///////////   Parametros: numero ASCII da tecla
///////////   Objetivo..: Testar se a tecla e um TAB, ENTER etc.
///////////   Uso.......: uso interno
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
function teclasaceitas(tecla){
   var teclas=Array(8,9,13,16,17,18,33,34,35,36,37,38,39,40,46); // Enter, tab, backspace, delete, shift, ctrl, alt, home, end, setas
   for(var i=0;i<teclas.length;i++){
	   if (teclas[i]==tecla) return true;
   }
   return false;
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Mascara
///////////   Parametros: valor,mascara
///////////   Objetivo..: Mascara um valor com a mascara informada
///////////   Uso.......: valor=Mascara(valor,'99.999.999/9999-99')
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
function Mascara(valor,mascara){
	var retorno='';
	if (valor=='') return valor;
	var x=0;
	for(i=0;i<mascara.length;i++){
		if (mascara.substr(i,1)=='9'||mascara.substr(i,1)=='X'||mascara.substr(i,1)=='#') {
		   retorno += valor.substr(x,1);		
		   x++;
		}else{
		   retorno += mascara.substr(i,1);
		}
	}
	return retorno;
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   TiraMascara
///////////   Parametros: valor
///////////   Objetivo..: Retira a Mascara de um valor
///////////   Uso.......: valor=TiraMascara(valor)
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
function TiraMascara(valor){
	var retorno='';
	if (valor=='') return valor;
	
							
	retorno=valor.replace('-','');
	retorno=retorno.replace('.','');
	retorno=retorno.replace('.','');
	retorno=retorno.replace('.','');
	retorno=retorno.replace('.','');
	retorno=retorno.replace('/','');
	retorno=retorno.replace(',','.'); // para valores numericos
	retorno=retorno.replace('(','');
    retorno=retorno.replace(')','');
	retorno=retorno.replace(' ','');
	
	return retorno;
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   DataIng
///////////   Parametros: data
///////////   Objetivo..: Coloca a data em formato YYYY-MM-DD
///////////   Uso.......: valor=DataIng(data)
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
function DataIng(data){
	return data.substr(6,4)+'-'+data.substr(3,2)+'-'+data.substr(0,2);
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   DataPort
///////////   Parametros: data
///////////   Objetivo..: Coloca a data em formato DD-MM-AAAA
///////////   Uso.......: valor=DataPort(data)
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
function DataPort(data){
	return data.substr(8,2)+'/'+data.substr(5,2)+'/'+data.substr(0,4);
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   DataPort
///////////   Parametros: datahora
///////////   Objetivo..: Coloca a data em formato DD/MM/AAAA hh:mm:ss
///////////   Uso.......: valor=DataHora(datahora)
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
function DataHora(data){
	return data.substr(8,2)+'/'+data.substr(5,2)+'/'+data.substr(0,4)+data.substr(10,10);
}


////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   FormataDinheiro
///////////   Parametros: valor
///////////   Objetivo..: Formata um valor para moeda 
///////////   Uso.......: valor=FormataDinheiro(valor)
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
function FormataDinheiro(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;

}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   LimpaFormatacao
///////////   Parametros: objeto input
///////////   Objetivo..: Retira a máscara do objeto
///////////   Uso.......: LimpaFormatacao(document.getElementById('cnpj'))
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function LimpaFormatacao(obj){
	obj.value = TiraMascara(obj.value);
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   decbin
///////////   Parametros: numero decimal, quantidade de caracteres
///////////   Objetivo..: Retorna uma string representando o valor binário do valor decimal informado
///////////   Uso.......: valor=decbin( 64, 10 ) retornaria 0000000100
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function decbin(numero,caracteres){
	var i=0; resultado='';
	while (numero >= 1) {
			if( (numero%2) == 0) { 
			    resultado += '0'; 
			}else{ 
			    resultado += '1';
			}
			numero = parseInt( numero / 2);
 			i++;
	}
	caracteres = caracteres-resultado.length;
	for (i=0;i<caracteres;i++) resultado+='0';
	
	return resultado;
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   DefineD 
///////////   Parametros: tipoCampo, NomeCampo
///////////   Objetivo..: Definir se a busca pelo elemento é no document. ou na aba
///////////   Uso.......: Interno
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function DefineD(tipoCampo,nomeCampo,objeto,idTab){
	var tab = (typeof(tabBusca) != 'undefined')&&(typeof(tabBusca.activeTab) != 'undefined');	
	if(tab||objeto){
		return ProcuraElementoTab(tipoCampo,nomeCampo,objeto,idTab);
	} else {
		if(tipoCampo=='form'){
			return document[nomeCampo];
		} else {
			return document.getElementById(nomeCampo);
		}
	}	
}


////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Upload
///////////   Parametros: formulario
///////////   Objetivo..: Utilizado em conjunto com a classe GetCampo
///////////   Uso.......: Interno, em GetCampo
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
function Upload(form,idcampo,funcao,iframe,display){
	//Aguarde('Aguarde...fazendo upload do arquivo',500);	
	if(typeof(display)==undefined) display=false;
	
	_status           = DefineD('div',['status_'+idcampo]);
	_status.innerHTML = '<img src="/lib/2us/img/loading_peq.gif" border="0" align="left">&nbsp;Aguarde...fazendo upload do arquivo';
	_idcampo          = idcampo;
	_idcampo2         = DefineD('input',[idcampo+'2']);
	_div              = DefineD('div',['div_'+idcampo]);
	_form             = DefineD('form',form);
	_funcao           = funcao || "MsgAlerta";	
	_iframe           = DefineD('iframe',iframe);
	_nomeIframe       = iframe;
	_display          = display;
	frames[_nomeIframe].document.body.innerHTML = 'uploading';
	_form.submit();
	setTimeout('UploadRetorno()',300);

}

function UploadRetorno(op,Retorno){
	
	if (op=='tamanho') {
		var tamanho=Retorno;
		_form.submit();
	}else if (op=='exclui') {
		if (Retorno=='ERRO BD') {
			MsgErro('Houve um erro no banco de dados e o arquivo n&atilde;o foi exclu&iacute;do');
		}else if(Retorno!='ok'){
			MsgErro('Houve um erro e o arquivo n&atilde;o foi exclu&iacute;do<br>Erro:<br>'+Retorno);
		}else{
			DefineD('div',['div_'+_campo]).style.display = '';			
			DefineD('div',['status_'+_campo]).innerHTML='';
			DefineD('input',[_campo+'2']).value = '';
			if(typeof(_display ) != 'undefined')
			{
				if(_display) DefineD('div',['div_'+_campo]).style.display='';
			}
			eval(_funcao+"(false)");
			MsgAlerta('Arquivo exclu&iacute;do com sucesso');
		}
	}else if (op==undefined) {
		var resultiframe=frames[_nomeIframe].document.body.innerHTML;
		resultiframe=resultiframe.replace(' ','');
				
		if (resultiframe!=''&&resultiframe!='uploading') {
			if (resultiframe!='ERRO'&&resultiframe!='ERRO files') {
				
				_status.innerHTML = 'Gerado arquivo <b>'+resultiframe+'</b>';
				_form.reset();
				_idcampo2.value = resultiframe;
				if(typeof(_display ) != 'undefined')
				{
					if (_display) _div.style.display = 'none';
				}
				eval(_funcao+"('"+resultiframe+"')");
				
			}else{
				MsgErro('Houve um erro no processamento do upload do arquivo.');
			}
		}else{
 		    setTimeout("UploadRetorno()",1000);
		}
	}
	
}

function UploadExcluirArquivo(campo,valor,funcao){
	_diretorio = DefineD('input',campo+'_diretorio').value;	
	_tabela    = DefineD('input',campo+'_tabela').value;	
	_arquivo   = valor;
	_campo     = campo;
	_funcao    = funcao;
	MsgConfirmacao('Tem certeza que quer excluir esse arquivo?<br><b>'+_arquivo+'</b>',UploadExcluirArquivoConfirma);
}

function UploadExcluirArquivoConfirma(botao){
	if (botao=='yes') {
		var objAjax = new AjaxLib();
		objAjax.processa('/lib/2us/php/upload.php','exclui','diretorio='+_diretorio+'&arquivo='+_arquivo+'&tabela='+_tabela+'&campo='+_campo,'Text',UploadRetorno);
	}
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   HtmlEditor
///////////   Parametros: campo,div,config
///////////   Objetivo..: Cria uma campo editavel e insere numa div informada
///////////   Uso.......: Direto
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function HtmlEditor(campo,div,config){

	var largura     = 510;
	var altura      = 200;
	var inicial     = ' ';
	var alinhamento = true;
	var fontes      = true;
	var tamanhos    = true;
	var cores       = true;	
	var formatos    = true;
	var links       = true;
	var listas      = true;
	var codigoFonte = true;

	cfg = config.split(',');
	for(i=0;i<cfg.length;i++){
		prop = cfg[i].split('=');
		if(prop[0]=='largura')     largura     = eval(prop[1]);
		if(prop[0]=='altura')      altura      = eval(prop[1]);
		if(prop[0]=='inicial')     inicial     = prop[1];
		if(prop[0]=='alinhamento'||prop[0]=='alinhamentos') if(prop[1]=='nao') alinhamento = false;
		if(prop[0]=='fontes')      if(prop[1]=='nao') fontes      = false;
		if(prop[0]=='tamanhos')    if(prop[1]=='nao') tamanhos    = false;
		if(prop[0]=='cores')       if(prop[1]=='nao') cores       = false;
		if(prop[0]=='formatos')    if(prop[1]=='nao') formatos    = false;
		if(prop[0]=='links')       if(prop[1]=='nao') links       = false;
		if(prop[0]=='listas')      if(prop[1]=='nao') listas      = false;
		if(prop[0]=='codigofonte') if(prop[1]=='nao') codigoFonte = false;
	}
	
	Ext.QuickTips.init();
	var temp  = new Ext.form.HtmlEditor({
		id     			 : campo,
		name   			 : campo,
		width  			 : largura,
		height 			 : altura,
		enableAlignments : alinhamento,
		enableFont       : fontes,
		enableFontSize   : tamanhos,
		enableColors     : cores,
		enableFormat     : formatos,
		enableLinks      : links,
		enableLists      : listas,
		enableSourceEdit : codigoFonte,
		value            : inicial
	});
	
	temp.render(DefineD('div',div));
	delete temp;

}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   DataCalendario
///////////   Parametros: campo,div,inicial,desabilitado
///////////   Objetivo..: Utiliza a biblioteca EXT para gerar o calendario
///////////   Uso.......: Direto
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function DataCalendario(campo,div,inicial,desabilitado){
	var temp  = new Ext.form.DateField({
		id   : campo,
		name : campo,
		value : inicial,
		disabled: desabilitado,
		format: 'd/m/Y',
		altFormats: 'd/m/Y|j/n/Y|j/n/y|j/m/y|d/n/y|j/m/Y|d/n/Y|d-m-y|d-m-Y|d/m|d-m|dm|dmy|dmY|d|Y-m-d'
	});
	temp.render(DefineD('div',div));	
	delete temp;
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   HoraCalendario
///////////   Parametros: campo,div,inicial,desabilitado
///////////   Objetivo..: Utiliza a biblioteca EXT para gerar o calendario
///////////   Uso.......: Direto
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function HoraCalendario(campo,div,inicial,desabilitado,largura){
	largura = largura || 80;
	var temp  = new Ext.form.TimeField({
		id   : campo,
		name : campo,
		value : inicial,
		disabled: desabilitado,
		format: 'H:i:s',
		width: largura
	});
	temp.render(DefineD('div',div));	
	delete temp;
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   CampoNumerico
///////////   Parametros: campo,div,inicial,desabilitado
///////////   Objetivo..: Utiliza a biblioteca EXT para gerar um campo numérico
///////////   Uso.......: Direto
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function CampoNumerico(campo,div,inicial,desabilitado,minimo,maximo,tamanho){
	tamanho=Math.min(eval(tamanho),50); 
	var temp  = new Ext.form.NumberField({
		id   : campo,
		name : campo,
		value : inicial,
		disabled: desabilitado,
		minValue : minimo,
		maxValue : maximo,
		width : tamanho
	});
	temp.render(DefineD('div',div));	
	delete temp;
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   CompletaZeros
///////////   Parametros: codigo
///////////   Objetivo..: 
///////////   Uso.......: Direto
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function CompletaZeros(codigo){
	if(codigo<10){
		codigo = '00000'+codigo;
	}else if(codigo<100){
		codigo = '0000'+codigo;
	}else if(codigo<10000){
		codigo = '000'+codigo;
	}else if(codigo<100000){
		codigo = '00'+codigo;
	}else if(codigo<1000000){
		codigo = '0'+codigo;
	}	
	return codigo;
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   CarregaCapaXML
///////////   Parametros: xml,funcaoImagem
///////////   Objetivo..: Carrega o XML dos templates no ADM
///////////   Uso.......: Direto
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function CarregaCapaXML(xml,operacao){
	
	this.TotalLoops = 10;
	this.operacao   = operacao || 'preencher';
	this.valores    = '';
	this.textareas_usados = DefineD('input','textareas_usados').value;
	
	campos = new Array();
	for(a=1;a<=this.TotalLoops;a++){
		tipos_campos=Array("Chapeu","Titulo","Chamada","Credito","Foto","Url","Coordenadas");
		for(i=0;i<tipos_campos.length;i++){
			var campo = tipos_campos[i]+a;
			if(this.textareas_usados.indexOf(campo)>=0) campo = campo + '|textarea';				
			campos.push(campo);
		}
	}
	campos.push("DHCriacao","DHPublicacao");

	if(this.operacao=='preencher') CarregaDados(xml,campos);
	
	if(this.operacao=='carregar'){
		this.valores = ValoresInputsPost('xmlcapa',campos);
		return (this.valores);
	}
	
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   buscavalor
///////////   Parametros: evento,valor,nome campo,query, funcao, where, descricao
///////////   Objetivo..: Definicao do tipo busca do getcampo
///////////   Uso.......: Direto
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function buscavalor(event,value,nomecampo,sql,funcao,where,descricao)
{
	if(event.keyCode==13 && value.length != 0) 
	{
		if(DefineD('input',nomecampo).value == 0){selpri(nomecampo,funcao)};
		return false;
	}
	
	DefineD('input',nomecampo).value = 0;
	
	if(value.length != 0)
	{
		DefineD('div','listaresultados_'+nomecampo).style.display = '';		
		var objAjax = new AjaxLib();
		objAjax.processa('/lib/2us/php/valoresbusca.php',nomecampo,'sql='+sql+'&texto='+value+'&where='+where+'&ordem='+descricao+'&funcao='+funcao,"TEXT",RetornaValoresBusca);
	}else
	{
		DefineD('div','listaresultados_'+nomecampo).style.display = 'none';
		DefineD('div','listaresultados_'+nomecampo).innerHTML = '';
	}
}

function selecionavalorbusca(IdValor,Descricao,nomecampo,funcao)
{
	DefineD('input','R_'+nomecampo).value = Descricao;
	DefineD('input',nomecampo).value = IdValor;
	DefineD('div','listaresultados_'+nomecampo).style.display = 'none';
	DefineD('div','listaresultados_'+nomecampo).innerHTML = '';
	
	funcao = funcao + "("+IdValor+")";
	

	eval(funcao);
}

function RetornaValoresBusca(op,resultadoXML){	
		DefineD('div','listaresultados_'+op).innerHTML = resultadoXML;
}

function selpri(nomecampo,funcao)
{
	if(DefineD('input',nomecampo).value != "")
	{		
		var dados = DefineD('tr','valorbusca_0').title.split(',');
		if(dados[0] == "vazio") return false;
		selecionavalorbusca(dados[0],dados[1],nomecampo,funcao);		
	}
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   CarregaXMLexterno
///////////   Parametros: url
///////////   Objetivo..: cria um objeto DOM com o conteudo de um XML externo
///////////   Uso.......: Direto
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function CarregaXMLexterno(url)
{
    if(window.XMLHttpRequest){
        var Loader = new XMLHttpRequest();
        Loader.open("POST", url ,false);
        Loader.send(null);
        return Loader.responseXML;
    }else if(window.ActiveXObject){
        var Loader = new ActiveXObject("Msxml2.DOMDocument.3.0");
        Loader.async = false;
        Loader.load(url);
        return Loader;
    }	
	
	return false;
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Sanitize
///////////   Parametros: texto
///////////   Objetivo..: Limpa aspas francesas 
///////////   Uso.......: Direto
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function Sanitize(texto){
	var len=texto.length;
	var resultado='';
	for (var i=0;i<len;i++){
		if (texto.charCodeAt(i)==8220||texto.charCodeAt(i)==8221){ // aspas francesas
			resultado+='"';
		}else{
			resultado+=texto.charAt(i);
		}
	}
	return resultado;
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   PaletaDeCor
///////////   Parametros: div,inicial
///////////   Objetivo..: Cria campo de paleta de cores
///////////   Uso.......: Direto
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function PaletaDeCor(div,inicial){
	DefineD('div',div).innerHTML = '';
	if(!inicial) inicial || '000000';
	var cp = new Ext.ColorPalette({value:inicial});  // initial selected color
	cp.render(DefineD('div',div));
	div = div.replace('div_','');
	DefineD('input',div+'2').value = inicial;
	cp.on('select', function(palette, selColor){		
    	DefineD('input',div+'2').value = selColor;
	});
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   ConverteCombo
///////////   Parametros: input,largura,msg,change
///////////   Objetivo..: Cria campo de paleta de cores
///////////   Uso.......: Direto
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function ConverteCombo(input,largura,msg,change,disabled){
	if(!input) return;
	if(!largura) largura = 100;
	if(!msg) msg = '';
	if(!disabled) disabled = false;
	var converted = new Ext.form.ComboBox({
		typeAhead: true,
		triggerAction: 'all',
		transform: input,
		width: largura,
		emptyText: msg,
		forceSelection:true,
		selectOnFocus:true,
		disabled:disabled,
		id:input
	});
	if(change){
		converted.on('select', function(){
			change(converted.getValue());
		});
	}
}


////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   maskIt
///////////   Parametros: elemento, evento, mascara, direita-esquerda, texto pre/pos
///////////   Objetivo..: Função para aplicar máscara em campos de texto
///////////   Uso.......: Direto
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

/**  
 * Função para aplicar máscara em campos de texto
 * Copyright (c) 2008, Dirceu Bimonti Ivo - http://www.bimonti.net 
 * All rights reserved. 
 * @constructor  
 */ 
 
/* Version 0.27 */

/**  
  * Função Principal 
  * @param w - O elemento que será aplicado (normalmente this).
  * @param e - O evento para capturar a tecla e cancelar o backspace.
  * @param m - A máscara a ser aplicada. ###.###.###-## (CPF), (##)####-#### (telefone), ###.###.###,## (dinheiro) etc.
  * @param r - Se a máscara deve ser aplicada da direita para a esquerda. 
  * @param a - .pos = O valor a ser mostrado depois do texto formatado (%, por exemplo) .pre=valor mostrado antes. (R$)
  * @returns null  
  */
function maskIt(w,e,m,r,a){
    
    // Cancela se o evento for Backspace
    if (!e) var e = window.event
    if (e.keyCode) code = e.keyCode;
    else if (e.which) code = e.which;
    
    // Variáveis da função
    var txt  = (!r) ? w.value.replace(/[^\d]+/gi,'') : w.value.replace(/[^\d]+/gi,'').reverse();
    var mask = (!r) ? m : m.reverse();
    var pre  = (a ) ? a.pre : "";
    var pos  = (a ) ? a.pos : "";
    var ret  = "";

	if (typeof(pre)=='undefined') pre="";
	if (typeof(pos)=='undefined') pos="";

//    if(code == 9 || code == 8 || txt.length == mask.replace(/[^#]+/g,'').length) return false;

    if(txt.length == mask.replace(/[^#]+/g,'').length) return false;
	
	//if(!teclasaceitas(code)) return false;
	if(code==9||code==8||code==46) return false;

    // Loop na máscara para aplicar os caracteres
    for(var x=0,y=0, z=mask.length;x<z && y<txt.length;){
        if(mask.charAt(x)!='#'){
            ret += mask.charAt(x); x++;
        } else{
            ret += txt.charAt(y); y++; x++;
        }
    }
    
    // Retorno da função
    ret = (!r) ? ret : ret.reverse()    
	
    w.value = pre+ret+pos;
}

// Novo método para o objeto 'String'
String.prototype.reverse = function(){
    return this.split('').reverse().join('');
};


////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   ChecaMultiplo
///////////   Parametros: Nome do Campo multiplo (string)
///////////   Objetivo..: Verificar se há pelo menos um checkbox do multiplo setado
///////////   Uso.......: Direto, nas validacoes é muito útil
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function ChecaMultiplo(nomeCampo,objeto){
	objeto = objeto || 'tabBusca';
	var campo=DefineD('input',nomeCampo,objeto);
	var valor=campo.value;
	var multFinal   = '';			
	var multValores = valor.split(',');
	
	for(var z=0;z<parseInt(multValores.length-1);z++){
		if(DefineD('input',[nomeCampo+'_'+multValores[z]],objeto).checked==true) multFinal+=multValores[z]+',';
	}
	if (multFinal=="") return false;
	return true;
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   TravaTudo
///////////   Parametros: array de campos e true para travar ou false para destravar
///////////   Objetivo..: Desabilita/Habilita todos os campos passados por array
///////////   Uso.......: Direto, nas validacoes é muito útil
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function TravaTudo(campos,trava){
	
	for (var i=0;i<campos.length;i++){
		if (campos[i].indexOf('|')>-1) {
			var definicao=campos[i].split('|');
			var campo=definicao[0];
			var tipo=definicao[1];
		}else{
			var campo=campos[i];
			var tipo='input';
		}
		if (tipo!='checkbox'&&tipo!='multiplo') DefineD(tipo,campo).disabled=trava;
	}
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Checapermissoes
///////////   Parametros: Número (decimal) representando a permissao ativa 
///////////               (1-Consulta, 2-Inclusao, 3-Alteracao, 4-Exclusao) e a soma destes
///////////   Objetivo..: Cria objeto com as propriedades em forma booleana 
///////////   Uso.......: var permissoes = new ChecaPermissoes(<?=$permissoes->PermissaoAtiva?>);
///////////				  if (permissoes.Inclusao) bla bla bla
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function ChecaPermissoes(permissaoativa){
	var binario = decbin(permissaoativa,4);  
	this.Permissao = binario;
	this.Consulta  = binario.substr(0,1)=='1';	
	this.Inclusao  = binario.substr(1,1)=='1';	
	this.Alteracao = binario.substr(2,1)=='1';	
	this.Exclusao  = binario.substr(3,1)=='1';	
	this.SoConsulta = binario=='1000';
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Botao
///////////   Parametros: tipo do botao (A-Alteracao, E-Exclusao, I-Inclusao) e objeto TabPanel atual
///////////   Objetivo..: Facilita a criacao dos botoes, sempre chamando as funcoes equivalentes (GravaLocal) da aba atual
///////////   Uso.......: botoes += Botoes('A',canais);
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function Botao(tipobotao,objeto){
	tipobotao = tipobotao.substr(0,1).toUpperCase();
	objeto 	  = objeto || 'tabBusca';
	switch (tipobotao){
			case 'I'  : return '<div id="Botoes" onclick="'+objeto+'.fn.GravaLocal(\'Incluir\')"><ul><li><img src="/lib/2us/icones/ok.png" /></li><li>Incluir</li></ul></div>';
						break;
			case 'A'  : return '<div id="Botoes" onclick="'+objeto+'.fn.GravaLocal(\'Alterar\')"><ul><li><img src="/lib/2us/icones/ok.png"></li><li>Alterar</li></ul></div>';
						break;
			case 'E'  : return '<div id="Botoes" onclick="'+objeto+'.fn.GravaLocal(\'Excluir\')" style="margin-left:10px"><ul><li><img src="/lib/2us/icones/erro.png"></li><li>Excluir</li></ul></div>';
						break;
			default	  : return 'tipo botao ' +tipobotao+' nao reconhecido';
	}
}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   FormataCpf
///////////   Parametros: evento, campo
///////////   Objetivo..: Formtar a entrada de dados de CNPJ
///////////   Uso.......: onkeydown="return(FormataCpf(event,this))"
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

function FormataCpf(teclapres,campo) {
	var tecla = teclapres.keyCode;
	vr = campo.value;
		
	do { vr = vr.replace( "/", "" ); } while(vr.indexOf("/")>-1);
	do { vr = vr.replace( ",", "" ); } while(vr.indexOf(",")>-1);
	do { vr = vr.replace( ".", "" ); } while(vr.indexOf(".")>-1);
	do { vr = vr.replace( "-", "" ); } while(vr.indexOf("-")>-1);

	tam = vr.length;
	if (tecla == 8 ){	tam = tam - 1 ; }		
	if ( tecla == 8 || tecla >= 48 && tecla <= 57 || tecla >= 96 && tecla <= 105 ){
		if ( tam <= 2 ){ 
	 		campo.value = vr ; }		
	 	if ( (tam > 2) && (tam <= 5) ){
	 		campo.value = vr.substr( 0, tam - 2 ) + '-' + vr.substr( tam - 2, tam ) ; }
	 	if ( (tam >= 6) && (tam <= 8) ){
	 		campo.value = vr.substr( 0, tam - 5 ) + '.' + vr.substr( tam - 5, 3 ) + '-' + vr.substr( tam - 2, 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 - 2, 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 - 2, 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 ) ;}
	}		
} 

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   UploadArquivo
///////////   Parametros: Objeto xtype fileuploadfield
///////////   Objetivo..: Faz o upload do arquivo, usando uploadext.php
///////////   Uso.......: Interno
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

var UploadArquivo = function(objeto,funcao){
	Aguarde('Fazendo upload do arquivo');
	with (objeto){
		 ownerCt.form.submit({
				url: '/lib/2us/php/uploadext.php',
				params:{ op: 'upload',
						 diretorio: diretorio,
						 nome: nome,
						 tamanhomax: typeof(tamanhomax)=='undefined'?0:tamanhomax,
						 id: id
					   },
				success: function(fp, o){
								Ext.getCmp(id.replace('_upload','')).setValue(o.result.file);
								setValue(o.result.file);
								ownerCt.form.fileUpload = false;
								Ext.MessageBox.hide();
								
								if (funcao) funcao(o.result.file);
						 },
				failure: function(fp, o){
								setValue(OriginalValue);
								Ext.getCmp(id.replace('_upload','')).setValue(OriginalValue);
								if (o.result.tamanho) {
									MsgErro('Ocorreu um erro no upload do arquivo. O tamanho m&aacute;ximo &eacute; '+tamanhomax+' Kb e o arquivo enviado tem '+o.result.tamanho+' Kb');
								}else{
									MsgErro('Ocorreu um erro no upload do arquivo');
								}
						 }
			});
	}
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////
///////////   Estados Brasileiros
///////////   Parametros: -
///////////   Objetivo..: Gerar um store Json
///////////   Uso.......: var store_x = new EstadosBrasileiros;
///////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
var EstadosBrasileiros = function(){
		
	var RegistroEstado = Ext.data.Record.create(
    	{name: 'UF'},
		{name: 'NomeEstado'},
		{name: 'NomeExtenso'});
	
	var store = new Ext.data.JsonStore({ fields: RegistroEstado });
	
	var Sigla = Array("AC","AL","AM","BA","CE","DF","ES","GO","MA","MT","MS","MG","PA","PR","PB","PE","PI","RJ","RN","RS","RO","SC","SP","SE","TO");
	var Nome  = Array("Acre","Alagoas","Amazonas","Bahia","Ceará","Distrito Federal","Espírito Santo","Goiás","Maranhão","Mato Grosso","Mato Grosso do Sul","Minas Gerais","Pará","Paraná","Paraíba","Pernambuco","Piauí","Rio de Janeiro","Rio Grande do Norte","Rio Grande do Sul","Rondônia","Santa Catarina","São Paulo","Sergipe","Tocantins");

	
	for (var i=0;i<Sigla.length;i++){
		var Registro = new RegistroEstado({
							UF: Sigla[i],
							NomeEstado: Nome[i],
							NomeExtenso: Sigla[i]+' - '+Nome[i]});
		store.add(Registro);
	}
	
	return store;

}