/*
 * CodePress regular expressions for SQL syntax highlighting
 * By Merlin Moncure
 */
 Language = {};
 
Language.syntax = [
	{input : /\'(.*?)(\')/g, output : '<v>\'$1$2</v>'}, // strings single quote
	{input : /\b(add|after|aggregate|alias|all|and|as|authorization|between|by|cascade|cache|cache|called|case|check|column|comment|constraint|createdb|createuser|cycle|database|default|deferrable|deferred|diagnostics|distinct|domain|each|else|elseif|elsif|encrypted|except|exception|for|foreign|from|from|full|function|get|group|having|if|immediate|immutable|in|increment|initially|increment|index|inherits|inner|input|intersect|into|invoker|is|join|key|language|left|limit|local|loop|match|maxvalue|minvalue|natural|nextval|no|nocreatedb|nocreateuser|not|null|of|offset|oids|on|only|operator|or|order|outer|owner|partial|password|perform|plpgsql|primary|record|references|replace|restrict|return|returns|right|row|rule|schema|security|sequence|session|sql|stable|statistics|table|temp|temporary|then|time|to|transaction|trigger|type|unencrypted|union|unique|user|using|valid|value|values|view|volatile|when|where|with|without|zone)\b/gi, output : '<b>$1</b>'}, // reserved words
	{input : /\b(bigint|bigserial|bit|boolean|box|bytea|char|character|cidr|circle|date|decimal|double|float4|float8|inet|int2|int4|int8|integer|interval|line|lseg|macaddr|money|numeric|oid|path|point|polygon|precision|real|refcursor|serial|serial4|serial8|smallint|text|timestamp|varbit|varchar)\b/gi, output : '<u>$1</u>'}, // types
	{input : /\b(abort|alter|analyze|begin|checkpoint|close|cluster|comment|commit|copy|create|deallocate|declare|delete|drop|end|execute|explain|fetch|grant|insert|listen|load|lock|move|notify|prepare|reindex|reset|restart|revoke|rollback|select|set|show|start|truncate|unlisten|update)\b/gi, output : '<a>$1</a>'}, // commands
	{input : /([^:]|^)\-\-(.*?)(<br|<\/P|\n)/g, output: '$1<i>--$2</i>$3'} // comments //
]


/*
* Remove os acentos de um string
*/
function retirarAcentos( strValor )
{
	var strAcentos = "áàâãäéèêëíìîïóòôõöúùûüçÁÀÂÃÄÉÈÊËÍÌÎÏÓÒÔÕÖÚÙÛÜÇ-";
	var arrSemAcento = new Array(   "a", "a", "a", "a", "a", "e", "e", "e", "e", "i", "i", "i", "i", "o", "o", "o", "o", "o", "u", "u", "u", "u", "c"
	 		, "A", "A", "A", "A", "A", "E", "E", "E", "E", "I", "I", "I", "I", "O", "O", "O", "O", "O", "U", "U", "U", "U", "C", "" );
		
	var strSaida = "";
	for (var i=0;i<strValor.length;i++)
	{		
		var posicao = strAcentos.indexOf(strValor.charAt(i));
		if(posicao>=0)
		{
			strSaida += arrSemAcento[posicao];
		}
		else
			strSaida +=strValor.charAt(i);			
	}
	return strSaida;	
} 

/*
* Troca enter (\n) por br
*/
function trocarEnterPorBr(strValor)
{
        strValor = strValor.replace(/\n/g, "<br />");
        return strValor;
}

/* 
retira caracteres acima da tabela ascii 
*/
function retiraEspeciais(strValor)
{
	var strSaida = "";
	for (var i=0;i<strValor.length;i++)
	{
		if(strValor.charCodeAt(i)<256)
		{
			strSaida +=  strValor.charAt(i);
		}
	}
	return strSaida;
}


function retirarEnterDuplicado(strValor)
{
	while (strValor.indexOf("\n\n")>=0)
	{
		strValor = strValor.replace("\n\n","\n");
	}
	return strValor;
}
/*
* Troca enter (\n) por br
*/
function retiraEnter(strValor)
{
        strValor = strValor.replace(/\n/g, "");
	strValor = strValor.replace("\n","");
	strValor = strValor.replace("\\n","");
        return strValor;
}
	
// funcao que elimina o caminho na hora de buscar elementos
	function $() {
	    var elements = new Array();
	    for (var i = 0; i < arguments.length; i++) {
		var element = arguments[i];
		if (typeof element == 'string')
		    element = document.getElementById(element);
		if (arguments.length == 1)
		    return element;
		elements.push(element);
	    }
	    return elements;
	}


        // sort function - ascending (case-insensitive)
        function sortFuncAsc(record1, record2) {
            var value1 = record1.optText.toLowerCase();
            var value2 = record2.optText.toLowerCase();
            if (value1 > value2) return(1);
            if (value1 < value2) return(-1);
            return(0);
        }

        // sort function - descending (case-insensitive)
        function sortFuncDesc(record1, record2) {
            var value1 = record1.optText.toLowerCase();
            var value2 = record2.optText.toLowerCase();
            if (value1 > value2) return(-1);
            if (value1 < value2) return(1);
            return(0);
        }

        function sortSelect(selectToSort, ascendingOrder) {
            if (arguments.length == 1) ascendingOrder = true;    // default to ascending sort

            // copy options into an array
            var myOptions = [];
            for (var loop=0; loop<selectToSort.options.length; loop++) {
		 myOptions[loop] = {optText:selectToSort.options[loop].text, optValue:selectToSort.options[loop].value};
            }
	    
	    intValue = -1;
	    if (selectToSort.selectedIndex>0)
	    {
		    intValue = selectToSort.options[selectToSort.selectedIndex].value;
	    }

            // sort array
            if (ascendingOrder) {
                myOptions.sort(sortFuncAsc);
            } else {
                myOptions.sort(sortFuncDesc);
            }

            // copy sorted options from array back to select box
            selectToSort.options.length = 0;
            for (var loop=0; loop<myOptions.length; loop++) {
                var optObj = document.createElement('option');
                optObj.text = myOptions[loop].optText;
                optObj.value = myOptions[loop].optValue;
                selectToSort.options.add(optObj);
		
		if (intValue==optObj.value)
		{
			selectToSort.selectedIndex = loop;
		}
            }
        }
	
	
	/*
	* Funcao para ordenar select
	* Deve substituir a anterior, mas precisa de mais alguns testes em outras aplicacoes 
	* Utilizada inicialmente no blog do vestibular
	*/
	function ordenarSelect(selectToSort, ascendingOrder, bolIgnoraValuesNulo) 
	{
            if (arguments.length == 1) ascendingOrder = true;    // default to ascending sort

            // copy options into an array
            var myOptions = [];
	    var arrOpcoesSemValue = [];
	    var intContComValue = 0;
	    var intContSemValue = 0;
            for (var loop=0; loop<selectToSort.options.length; loop++) {
		    
		    if (!selectToSort.options[loop].value & bolIgnoraValuesNulo)
		    {
			    arrOpcoesSemValue[intContSemValue] = {optText:selectToSort.options[loop].text, optValue:selectToSort.options[loop].value};
			    intContSemValue++;
		    }
		    else
		    {
			    myOptions[intContComValue] = {optText:selectToSort.options[loop].text, optValue:selectToSort.options[loop].value};
			    intContComValue++;
		    }
            }
	    
	    intValue = -1;
	    if (selectToSort.selectedIndex>0)
	    {
		    intValue = selectToSort.options[selectToSort.selectedIndex].value;
	    }

            // sort array
            if (ascendingOrder) {
                myOptions.sort(sortFuncAsc);
            } else {
                myOptions.sort(sortFuncDesc);
            }

            // copy sorted options from array back to select box
            selectToSort.options.length = 0;
	    
	    //adiciona itens nao ordenados - sem value
	    for (var loop=0; loop<arrOpcoesSemValue.length; loop++) {
		var optObj = document.createElement('option');
                optObj.text = arrOpcoesSemValue[loop].optText;
                optObj.value = arrOpcoesSemValue[loop].optValue;
                selectToSort.options.add(optObj);
		
		if (intValue==optObj.value)
		{
			selectToSort.selectedIndex = loop;
		}
	    }
	    
	    //adiciona itens ordenados
            for (var loop=0; loop<myOptions.length; loop++) {
                var optObj = document.createElement('option');
                optObj.text = myOptions[loop].optText;
                optObj.value = myOptions[loop].optValue;
                selectToSort.options.add(optObj);
		
		if (intValue==optObj.value)
		{
			selectToSort.selectedIndex = selectToSort.length-1;
		}
            }
        }
	

//dado um campo e um valor, se este campo existir no combo com esse valor ele será marcado
//mara marcar combos sem array, é só passar o campo como value
function marcarItemCombo(objCombo,strCampo,strValor)
{
	for (x=0; x<objCombo.length; x++)
	{
		strValorCombo = objCombo[x].value;
		if (strValorCombo!="")
		{
			strValorItem = recuperarItemArrayPhp(strCampo,objCombo[x].value);

			if (strValorItem==strValor)
			{
				objCombo.selectedIndex = x;
				break;
			}
		}
	}
}
	
function recuperarValorIndiceArrayCombo(objCombo, strNomeCampo)
{
	strValor = objCombo[objCombo.selectedIndex].value;
	if (strValor!="")
	{
		return recuperarItemArrayPhp(strNomeCampo,strValor);
	}
	return "";
}

function abrirAsp(strEndereco)
{	
	//alert(document.frmCabecalhoAluno.hidCodAluno.value);
	intCodAluno = document.frmCabecalhoAluno.hidCodAluno.value;
	strNumMatricula = document.frmCabecalhoAluno.hidNumMatricula.value;
	
	strEndereco = strEndereco+'?hidCodAluno='+intCodAluno+'&hidNumMatricula='+strNumMatricula;
	//alert(strEndereco);
	self.location = strEndereco;
}

//Verifica se o objeto passado nao e nulo
function verificaObjeto(objCampo)
{	
	objCampo = "" + objCampo;
	//if (objCampo != undefined & objCampo != '' & trim(objCampo) != 'null' & objCampo != 'undefined') com erro no ie 5	
	if (objCampo != '' & trim(objCampo) != 'null' & objCampo != 'undefined')
	{
		return true;
	}
	return false;
}

/*
* Retorna um determinado item do combo selecionado
*/
function recuperarItemSelecionadoCombo(objCombo,strNomItem)
{	
	return recuperarItemArrayPhp(strNomItem,objCombo[objCombo.selectedIndex].value);
}

/**
 * retorna um array com cada strNomItem => indiceCombo
 */
function mapeiaIndiceValorCombo(objCombo,strNomItem)
{
    var arrValoresCombo = new Array();
    if(objCombo != undefined)
    {
        for (var x=0; x<objCombo.length; x++)
        {
            var strValorCombo = objCombo[x].value;
            if (strValorCombo!="")
            {
                var strValorItem = recuperarItemArrayPhp(strNomItem,strValorCombo);
                arrValoresCombo[strValorItem] = x;
            }
        }

    }
    arrValoresCombo[""]  = 0;
    return arrValoresCombo;

}


/*
* Converte o array no padrao PhpJs e retorna o valor do campo informado
*/
function recuperarItemArrayPhp(strNomItem,strValorItemCombo)
{
	var arrTempRecupera = new Array;
	arrTempRecupera = converterArrayPhpJs(strValorItemCombo);
	return arrTempRecupera[strNomItem];
}

function isArray(testObject) {
    return testObject && !(testObject.propertyIsEnumerable('length')) && typeof testObject === 'object' && typeof testObject.length === 'number';
}
/*
* Pega um array em js e gera um array em php
*/
function converterArrayJsPhp(arrItensJs, bolAjax)
{
	if(bolAjax==undefined)
	{
		bolAjax = false;
	}
	//construtor do array para comparacao
	var strConstrutorArr=(new Array()).constructor;
	var strConstrutorObject=(new Object()).constructor;
	
	var strRetorno = "array(";
	for (var strNome in arrItensJs)
	{ 
		if(arrItensJs[strNome]==undefined || arrItensJs[strNome]==null)
		{
			arrItensJs[strNome] = "";
		}
		//verifica se é um array
		if(isArray(arrItensJs[strNome]) | arrItensJs[strNome].constructor == strConstrutorObject)
		{
			var intCont = 0;
			for(var strCampo in arrItensJs[strNome])
			{
				intCont++;
				break;
			}
			if(intCont>0)
			{
				//se for um array com elementos, é executadoo nos elementos filhos
				strRetorno +="'"+strNome+"'  => "+converterArrayJsPhp(arrItensJs[strNome],bolAjax)+",";
			}
			else
			{
				//caso contrario eh gerado um array vazio
				strRetorno +="'"+strNome+"'  => array(),";
			}
		}else
		{
			var strConteudo = arrItensJs[strNome];
			
			if(typeof(strConteudo)=="string")
			{
				if (strConteudo.indexOf("array(")==0)
				{				
					strRetorno += "'"+strNome+"'  => "+arrItensJs[strNome]+",";				
				}
				else
				{				
					if(bolAjax)
					{
						var strValor = arrItensJs[strNome];
						if(strValor.indexOf("'")>0)
						{
							strValor = trocarTodosExpressao(strValor,"'","\\\'");
						}
						var intI = strValor.length-1;						
						while(intI>=0 && strValor.charAt(intI)=='\\')
						{
							strValor = strValor.substring(0,intI);
							intI--;
						}
						strRetorno += "'"+strNome+"'  => '"+strValor+"',";
					}
					else
					{
						strRetorno += "'"+strNome+"'  => '"+arrItensJs[strNome]+"',";
					}
				}
			}else
			{
				strRetorno += "'"+strNome+"'  => '"+arrItensJs[strNome]+"',";
			}
		}
	}
	strRetorno = strRetorno.substring(0,strRetorno.length-1);
	strRetorno += ")";	
	//alert(strRetorno);
	return strRetorno;
}

/* retorna a extensao de um arquivo */
function retornarExtensao(strArquivo)
{
	start = strArquivo.lastIndexOf(".")
	extension = strArquivo.substring(start+1, strArquivo.length).toLowerCase()
	return extension;
}

/*
* Pega um array do tipo php e tranforma em js
*/
function converterArrayPhpJs(strValorCombo)
{
	//alert(strValorCombo);
	if (strValorCombo.indexOf('=>')>=0)
	{
		//O 5 no substring ta lixao
		var strValorCombo = strValorCombo.substring(5,strValorCombo.length);
		if (strValorCombo == '')
		{
			return null;
		}
		
		//array multidimensional
		if (strValorCombo.indexOf("array(")>=0 | strValorCombo.indexOf("array (")>=0)
		{
			//retira enter
			strValorCombo = retiraEnter(strValorCombo);
			
			//troca setas pelo separador javascript
			strValorCombo = trocarTodos(strValorCombo,"=>",":");
			
			//devolve o inicio do array removido
			strValorCombo = "array"+strValorCombo;
			
			//abertura do array
			strValorCombo = trocarTodos(strValorCombo,"array(","{");
				
			//troca  o final no casso de array associativo
			strValorCombo = trocarTodos(strValorCombo,"))","}}");
			strValorCombo = trocarTodos(strValorCombo,"')","'}");
			
			//prepara comando
			var strComandoTexto = 'var arrValoresTemp = '+strValorCombo;
			
			//executa comando
			eval(strComandoTexto);
			
			//retorna array pronto
			return arrValoresTemp;
		}
		
		//troca separador
		strValorCombo = trocarTodos(strValorCombo,"=>",",");
		
		var strComandoTexto = 'arrValoresTemp = new Array '+strValorCombo;
		//alert(strComandoTexto);
		eval(strComandoTexto);		
		var arrTempGeracao = new Array;
			
		for (s=0; s<arrValoresTemp.length; s=s+2)
		{	
			if (!is_array(arrValoresTemp[s+1]))
			{
				strLinhaExecucao = trocarTodos(arrValoresTemp[s+1],"'","&#39;");
				var strComandoTemp = 'arrTempGeracao[\''+arrValoresTemp[s]+'\'] = \''+strLinhaExecucao+'\'';
			
				eval(strComandoTemp);   		
				arrTempGeracao[arrValoresTemp[s]] = trocarTodos(arrTempGeracao[arrValoresTemp[s]],"&#39;","'");
			}
			else
			{
				//alert('foi entao '+arrValoresTemp[s]+' e '+arrValoresTemp[s+1]);
				arrTempGeracao[arrValoresTemp[s]] = arrValoresTemp[s+1];
			}
		}
	}
	else
	{
		var arrTempGeracao = new Array;
		arrTempGeracao['value'] = strValorCombo;
	}
	return arrTempGeracao;
}

/*
* Centraliza a janela
*/
function centralizarJanela(strArquivo,strJanela,intLargura,intAltura,strOpcoes) 
{
	var w = intLargura;
	var h = intAltura;
	var lado = (screen.width - w) / 2;
	var topo = (screen.height - h) / 2;
	
	features =  " width=" + intLargura + ", height=" + intAltura+', top='+topo+', left='+lado;
	
	if (strOpcoes.length>0)
	{
		features = strOpcoes + ", "+features;
	}
	return window.open(strArquivo,strJanela,features) 
} 

/*
* Centraliza a janela sem barra de menu ou ferramentas
*/
function centralizarJanelaPopup(strArquivo,strJanela,intLargura,intAltura) 
{ 
	return centralizarJanela(strArquivo,strJanela,intLargura,intAltura,'toolbar=no, menubar=no, resizable=yes, scrollbars=yes');
}

function retornaTam(valor) {
    retorno = 0;
    for (w=0; w<=valor; w++) {  
        retorno+=G[w];
    }
    return retorno; 
}


/*
* Verifica o cep no modelo 99.999-999 
*/
function verificarCep(objCampoCep)
{	
	strTeste = new String(objCampoCep.value);	
	if (strTeste.search(/^[0-9]{2}.[0-9]{3}-[0-9]{3}/)>=0)
	{
		return true;
	}	
	return false;
}

/*
* Verifica o cep no modelo 99999999 
*/
function verificarCepNum(objCampoCep)
{	
	strTeste = new String(objCampoCep.value);	
	if (strTeste.search(/^[0-9]{2}[0-9]{3}[0-9]{3}$/)>=0)
	{
		if (parseInt(objCampoCep.value) != 0) {
			return true;
		}
	}	
	return false;
}

/*
* Sobregcarga da funcao criaMascara, com menos parametros,
* os parametros da outra chamada sao desnecessario mas ja estao
* sendo usados em algumas telas
* exemplo
* <input type="text" name="cpf" size=16 maxlength=14 class=texto onkeypress="criaMascara(this,event,'999.999.999-99');">
*/
function criaMascaraCampo(objCampo,TeclaPres,maskara) {
	
	//criaMascara(objCampo.form,objCampo.name,TeclaPres,maskara);
	aplicarMascara(objCampo,TeclaPres,maskara);
}

// ESTA CLASSE NAO E MAIS PUBLICA - UTILIZAR A CHAMADA ACIMA
// exemplo
// <input type="text" name="cpf" size=16 maxlength=14 class=texto onkeypress="criaMascara(document.frmInc,this.name,event,'999.999.999-99');">
function criaMascara(frm,campo,TeclaPres,maskara) {

var Vr = frm[campo].value;

//Tratamento para browser IE ou MOZILLA
var Tecla;
if (TeclaPres.keyCode) Tecla = TeclaPres.keyCode;
else if (TeclaPres.which) Tecla = TeclaPres.which;

var num = Vr;
var novaMask = new Array();
var campoFinal = new Array();
var outro;
var ind = 0;
var ind1 = 0;
var ind2 = 0;
var tamMask = maskara.length;
var contMask = 0;
var contem;
var grupo =0;
var controle = 0;
var p1 = 0;
var p2 = 1;

//Grupos
G[ind] = 0;
//Pontos de Edicao
P[ind1] = 0;
   
    //Verifica o tamanho dos grupos, local dos grupos e pontos      
	while(contMask <= tamMask) {
	  contem = maskara.substring(p1,p2);
		 if (contem == 9) {
 			 if (grupo > controle) {
 			  ind ++;
			  ind1 ++;
			  G[ind] = 0; 
			  P[ind1] = 0;
			  controle = controle + 1;
		     }
		   G[ind] = G[ind]+1;
	    }else{
		   P[ind1] = contem;
		   grupo = grupo + 1
        }
	  contMask = contMask + 1;
	  p1 = p1 + 1;
  	  p2 = p2 + 1;
   }
   
   
  
//Declarando variaveis da montagem para nova mascara


   
  if (Vr.length!=maskara.length) {

	  
  for ( x=0 ; x < P.length; x++ ) {
      Vr = Vr.toString().replace( P[x], "" );
  }
    
   Tam = Vr.length;
   if (Tam <= maskara.length  && Tecla != 8) { 
	    Tam = Vr.length;       
   } else {
    return false;
   }
		
	if (Tecla == 8 ) { 
     Tam = Tam - 1 ; 
	}

  
	// montando a mascara no campo
 if ( Tecla == 8 || Tecla == 88 || Tecla >= 48 && Tecla <= 57 || Tecla >= 96 && Tecla <= 105 ){
    tamTempo = G.length - 1;
    k=0;
    for (k=0; k<=tamTempo; k++) {      
      if (Tam >= retornaTam(k) && Tam < retornaTam(k+1)) {
            rodar = "";            
            for (z=0; z<=k+1; z++) {
                valorSub = "retornaTam("+(z-1)+")";
                valorSub1 = "retornaTam("+(z)+")";
                if (z==0) {
                    valorSub = "0";
                    valorSub1 = "retornaTam("+z+")";
                }                                
                if (z==k+1) {
                    valorSub = "retornaTam("+(z-1)+")";
                    valorSub1 = "Tam";
                }
                valorSub = eval(valorSub);
                valorSub1 = eval(valorSub1);              
                rodar += "Vr.substring("+valorSub+","+valorSub1+")";                                              
                rodar += "+P["+z+"]+";                                   
            }                           
            rodar = "Vr = "+rodar.substring(0,rodar.length-6);
            eval(rodar);
      }      
    }       
    frm[campo].value = Vr;  
 }
 } 	
}
//codigo retirado de: http://www.java2s.com/Code/JavaScript/Language-Basics/Stringutilitywordcountreplaceandcapitalize.htm
function capitalize(str) {
  var tempArray = str.split(' ');

  // Make the first character of each word upper- or lowercase
  // depending on the value of theCase
  for (var i = 0; i < tempArray.length; i++) 
  {
	  tempArray[i] = tempArray[i].charAt(0).toUpperCase() + tempArray[i].substring(1);
  }
  
  return tempArray.join(' ');
  }
  

function trocarTodos(strTextoTroca,strValorDe,strValorPadrao)
{	
	while (strTextoTroca.indexOf(strValorDe)>=0)
	{
		strTextoTroca = strTextoTroca.replace(strValorDe,strValorPadrao);	
	}
	return strTextoTroca;
}

function alterarPropriedade(strNomeCampo,strValorAlterar,strValorCombo)
{
	if (strValorCombo == "")
	{		
		strValorCombo = "array ( )";	
	}
	
	strValorCombo = trocarTodos(strValorCombo,"=>",",");	
	strValorCombo = strValorCombo.substring(5,strValorCombo.length);
	if (strValorCombo == '')
	{
		return null;
	}	
	strComandoTexto = 'arrValoresTemp = new Array '+strValorCombo;		
	eval(strComandoTexto);		
	arrTempGeracao = new Array;
	
	strComandoTemp = '';
	
	//verifica se ja tem, senao cria um novo item no array
	if (arrValoresTemp.length <= 0)
	{
		arrValoresTemp[0] = strNomeCampo;
		arrValoresTemp[1] = strValorAlterar;
	}
	bolCampoEncontrado = false;
	for (x=0; x<arrValoresTemp.length; x=x+2)
	{		
		if (arrValoresTemp[x] == strNomeCampo)
		{
			bolCampoEncontrado = true;
			arrValoresTemp[x+1] = strValorAlterar;
		}
		strComandoTemp += '\''+arrValoresTemp[x]+'\' => \''+arrValoresTemp[x+1]+'\', ';
	}
	
	if (!bolCampoEncontrado)
	{
		strComandoTemp += '\''+strNomeCampo+'\' => \''+strValorAlterar+'\', ';
	}
	
	strComandoTemp = strComandoTemp.substring(0,strComandoTemp.length-2);
	strComandoTemp = "array ( "+strComandoTemp+" )";
	return strComandoTemp;
}


function toH(red, green, blue) {return retornaH(red) + retornaH(green) + retornaH(blue)}

function retornaH(color)
{
hn = new Array("0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A" ,"B", "C", "D", "E", "F")
if (color < 0)
    {return "00"}
    else if (color > 255) {return "FF"}
else
    {
        s = "" + hn[Math.floor(color/16)] + hn[color%16]
        return s
    }
}

function rgb(red, green, blue) {return toH(red, green, blue)}


function status_email(result, cod_erro) //Fale Comigo
{
    if (result) {
    	alert("Mensagem enviada com sucesso");
	return true;
    } 
    	alert("Ocorreu um problema ao enviar a mensagem\nCodigo do erro: "+cod_erro);
	return true;
}

function terminarSessao()
{
	objForm = document.frmFormularioSecao;
	objForm.action = 'SOL_035.php';
	objForm.hidAcao.value = 'terminarSecao';
	objForm.submit();
}

/*
* Verifica se o valor do campo presente em uma p?gina HTML est? vazio.
* Exibe uma mensagem de erro caso o valor do campo esteja vazio.
* @param Object objCampo campo presente em uma p?gina HTML cujo valor deve ser verificado. 
*			 Se o valor do campo estiver vazio, o campo permanecer? com o foco.
* @param String strMensagem: mensagem a ser exibida se o valor do campo estiver vazio.
* @param Boolean bolExibirMensagem: indica se deve ser exibida mensagem em caso de valor nulo
*
* @return Boolean Retorna true se o valor do campo presente na p?gina HTML estiver vazio e false caso contr?rio
* @author Cristiano Falinacio Barbosa
* @since 14/08/2002
* @access public
*/
function verificarNulo(objCampo, strMensagem, bolExibirMensagem,bolIgnoraNaoExiste)
{
	if (typeof(objCampo) != "object")
	{
		if (bolIgnoraNaoExiste) return false;
                
		return true;
	}
	if (trim(objCampo.value) == "")
	{
		if (trim(strMensagem) == "" || typeof(strMensagem) == "undefined")
		{
			strMensagem = "Informe um valor para o campo " + objCampo.id + ".";
		}
		
		if (typeof(bolExibirMensagem) == "undefined")
			bolExibirMensagem = true;      
		
		if (typeof(bolExibirMensagem) != "boolean")
		{
			alert("Erro na chamada da fun?ao ValorNulo." +
			" O tipo do valor passado para o par?metro bExibirMensagem n?o ? o esperado." +
			" Deve ser true ou false.");
			return false;
		}      
		if (bolExibirMensagem)
			alert(strMensagem);
		setFocus(objCampo);
		return true;
	}
	return false;
}

/*
* Retorena o valor selecionado em um radio 
*
* @return Boolean Retorna true se o valor do campo presente na p?gina HTML estiver vazio e false caso contr?rio
* @author Flávia Hozana Pereira de Miranda
/* @since 27/11/2002
* @access public
*/
function retornarValorCheck(objCampo)
{
	if (typeof(objCampo) != "object")
	{
		alert("Erro na chamada da funcao verificarNuloRadio." +
		" O tipo do valor passado para o parametro objCampo nao e o esperado." +
		" Deve ser um campo de uma pagina HTML, ou seja, um objeto");
		return "";
	}	
	strSaida = '';
	
	if (objCampo.length)
	{
		for (x=0; x<objCampo.length; x++) 
		{ 
			if (objCampo[x].checked) 
			{ 
				strSaida += " - "+objCampo[x].value; 
			} 
		}
	}
	else if (objCampo.checked)
	{
		strSaida = objCampo.value;
	}

	return strSaida;	
}

/*
* Retorena o valor selecionado em um radio 
*
* @return Boolean Retorna true se o valor do campo presente na p?gina HTML estiver vazio e false caso contr?rio
* @author Flávia Hozana Pereira de Miranda
/* @since 27/11/2002
* @access public
*/
function retornarValorRadio(objCampo)
{
	if (typeof(objCampo) != "object")
	{
		alert("Erro na chamada da funcao verificarNuloRadio." +
		" O tipo do valor passado para o parametro objCampo nao e o esperado." +
		" Deve ser um campo de uma pagina HTML, ou seja, um objeto");
		return "";
	}	

	for (x=0; x<objCampo.length; x++) 
	{ 
		if (objCampo[x].checked) 
		{ 
			return objCampo[x].value; 
		} 
	} 

	return "";	
}


/*
* Verifica se o valor do campo Radio presente em uma p?gina HTML est? vazio.
* Exibe uma mensagem de erro caso o valor do campo esteja vazio.
* @param Object objCampo campo Radio presente em uma p?gina HTML cujo valor deve ser verificado. 
*			 Se o valor do campo estiver vazio, o campo permanecer? com o foco.
* @param String strMensagem: mensagem a ser exibida se o valor do campo estiver vazio.
* @param Boolean bolExibirMensagem: indica se deve ser exibida mensagem em caso de valor nulo
* @param Boolean bolIgnoraNaoExiste: indica se deve validar se o campo existe no formulário
*
* @return Boolean Retorna true se o valor do campo presente na p?gina HTML estiver vazio e false caso contr?rio
* @author Flávia Hozana Pereira de Miranda
/* @since 27/11/2002
* @access public
*/
function verificarNulo(objCampo, strMensagem, bolExibirMensagem,bolIgnoraNaoExiste)
{    
    if (typeof(objCampo) != "object")
    {
            if (bolIgnoraNaoExiste) return false;

            return true;
    }	

    if (trim(objCampo.value) == "")
    {
            if (trim(strMensagem) == "" || typeof(strMensagem) == "undefined")
            {
                    strMensagem = "Informe um valor para o campo " + objCampo.id + ".";
            }

            if (typeof(bolExibirMensagem) == "undefined")
                    bolExibirMensagem = true;      

            if (typeof(bolExibirMensagem) != "boolean")
            {
                    alert("Erro na chamada da fun?ao ValorNulo." +
                    " O tipo do valor passado para o par?metro bExibirMensagem n?o ? o esperado." +
                    " Deve ser true ou false.");
                    return false;
            }      
            if (bolExibirMensagem)
                    alert(strMensagem);
            setFocus(objCampo);
            return true;
    }
/*
    bolMarcado = false; 
    if (!objCampo.length) 
    { 

            if (objCampo.checked) 
            { 
                    bolMarcado = true; 
            } 

            if (objCampo.value!="")
            {
                bolMarcado = true; 
            }

    } 
    else 
    { 
            for (x=0; x<objCampo.length; x++) 
            { 
                    if (objCampo[x].checked) 
                    { 
                            bolMarcado = true; 
                    } 
            } 

    } 
    if (!bolMarcado) 
    { 
            if (trim(strMensagem) == "" || typeof(strMensagem) == "undefined")
            {
                    strMensagem = "Informe um valor para o campo " + objCampo.id + ".";
            }

            if (typeof(bolExibirMensagem) == "undefined")
                    bolExibirMensagem = true;      

            if (typeof(bolExibirMensagem) != "boolean")
            {
                    alert("Erro na chamada da fun?ao verificarNuloRadio." +
                    " O tipo do valor passado para o parametro bExibirMensagem nao e o esperado." +
                    " Deve ser true ou false.");
                    return false;
            }      
            if (bolExibirMensagem)
                    alert(strMensagem);
            setFocus(objCampo);
            return true;		
    }*/
    return false;
}
/*
* Retira os espa?os em branco ? direita e ? esquerda de um texto
* @param String strTexto texto a cujos espa?os em branco ? esquerda e ? direita devem ser eliminados
*
* @return Boolean Retorna o texto sem espa?os em branco ? esquerda e ? direita
* @author Cristiano Falinacio Barbosa
* @since 14/08/2002
* @access public
*/
function trim(strTextoParametro)
{
   //String Texto sem espa?os em branco ? esquerda e ? direita
   var strTextoSemEspacos
   strTextoSemEspacos = rTrim(strTextoParametro);
   strTextoSemEspacos = lTrim(strTextoSemEspacos);
   return strTextoSemEspacos;
}

/*
* Retira os espacos em branco ? esquerda de um texto
* @param String strTexto texto a cujos espa?os em branco ? esquerda devem ser eliminados
*
* @return Boolean Retorna o texto sem espa?os em branco ? esquerda
* @author Cristiano Falinacio Barbosa
* @since 14/08/2002
* @access public
*/
function lTrim(strTextolTrim)
{
   //Object Objeto do tipo String para receber o texto a ser verificado
   var objString
   //Integer Contador
   var intCont
   //String Texto sem espa?os em branco ? esquerda
   var strTextoSemEspacos
   strTextoSemEspacos = ""
   objString = new String(strTextolTrim);
   for (intCont=0; intCont < objString.length; intCont++) 
   {
      if (objString.charAt(intCont) != " ")
      {
     	 strTextoSemEspacos = objString.substring(intCont,objString.length)
         return strTextoSemEspacos;
      }
   }  
   return strTextoSemEspacos;
}

/*
* Retira os espacos em branco ? direita de um texto
* @param String strTexto texto a cujos espa?os em branco ? direita devem ser eliminados
*
* @return Boolean Retorna o texto sem espa?os em branco ? direita
* @author Cristiano Falinacio Barbosa
* @since 14/08/2002
* @access public
*/
function rTrim(strTexto)
{
   //Object Objeto do tipo String para receber o texto a ser verificado
   var objString
   //Integer Contador
   var intCont
   //String Texto sem espa?os em branco ? direita
   var strTextoSemEspacos

   strTextoSemEspacos = ""
   objString = new String(strTexto);
   for (intCont=objString.length -1; intCont >= 0; intCont--) 
   {
      if (objString.charAt(intCont) != " ")
      {
	 strTextoSemEspacos = objString.substring(0, intCont +1);
         return strTextoSemEspacos;
      }
   }  
   return strTextoSemEspacos;
}

/*
* Verifica se um caracter passado como par?metro ? um n?mero de zero a nove

* @param String contenmdo o valor a verificar
*
* @author Flávia Hozana Pereira de Miranda
* @since 27/08/2002
* @access public
*/
function eNumero(strDigito)
{
   if (strDigito=="0" || strDigito=="1" || strDigito=="2" || strDigito=="3" || strDigito=="4" || 
       strDigito=="5" || strDigito=="6" || strDigito=="7" || strDigito=="8" || strDigito=="9" )
       return true ;
   else 
      return false; 
}

/*
* Verifica se o valor de um campo de uma página HTML é uma data válida. Exibe uma mensagem
*de erro caso o valor do campo não seja uma data válida
*
* @param Object Campo presente em uma página HTML cujo valor deve ser verificado. 
*               Se o valor do campo não for uma data, o campo permanecerá com o foco.
* @param String Mensagem a ser exibida se o valor do campo não for uma data. Parâmetro Opcional
*
* @author Flávia Hozana Pereira de Miranda
* @since 27/08/2002
* @access public
*
* @return Boolean Retorna True se o valor do campo presente na página HTML for uma data e false caso contrário
*/
function verificarData(objCampo, sMensagem)
{
   //Verifica se os valores passados para os parametros da funcao sao validos
   if (typeof(objCampo) != "object")
   {
      alert("Erro na chamada da funcao ValorData." +
            " O tipo do valor passado para o parametro objCampo nao e o esperado." +
            " Deve ser um campo de uma pagina HTML, ou seja, um objeto")
      return false;
   }
   if (!eData(objCampo.value))
   {
      if (trim(sMensagem) == "" || typeof(sMensagem) == "undefined")
      {
         sMensagem = "O valor informado para o campo " + objCampo.dataFld + 
                     " não é uma data válida.";
      }
      alert(sMensagem);
      setFocus(objCampo);
      return false;
   }
   return true;
}
/*
* retorna o ultimo dia do mes
* retirado de: http://javascript.about.com/library/bllday.htm
* @author Daniel Hasan Dalip
* @since 26/01/2010
* @access public
*
* @return Integer com o nome do dia
*/
function retornaUltDiaMes(intMes,intAno)
{
    var m = [31,28,31,30,31,30,31,31,30,31,30,31];
    if (intMes != 2) return m[intMes - 1];
    if (intAno%4 != 0) return m[1];
    if (intAno%100 == 0 && intAno%400 != 0) return m[1];
    return m[1] + 1;
}

/*
* Verifica se um valor é uma data válida
*
* @param String contendo o valor a verificar
*
* @author Flávia Hozana Pereira de Miranda
* @since 27/08/2002
* @access public
*
* @return Boolean Retorna true se o valor for uma data v?lida e false caso contr?rio
*/
function eData(sData)
{
   //Objeto data utilizado para verificar se o valor est? em um formato correto de data
   var objData;
   //Dia da Data
   var sDia;
   //M?s da Data
   var sMes;
   //Ano da Data
   var sAno;
   //Objeto do tipo String para receber a data
   var objStringData;

   objStringData = new String(sData);
   if (objStringData.length == 0) 
      return true;
   objData = new Date(sData);
   if (isNaN(objData))
      return false;
   else
   {
      //O valor est? no formato correto de data. Deve-se verificar se os dias e meses est?o v?lidos
      sDia = objStringData.substring(0,2);
      sMes = objStringData.substring(3,5);
      if (objStringData.length > 8)
         //Recupera o ano com 4 d?gitos		
         sAno = objStringData.substring(6,10);
      else
         //Recupera o ano com 2 d?gitos
         sAno = objStringData.substring(6,8);
      //Verifica se o mes e o dia s?o v?lidos
      if (sMes < 1 || sMes > 12)
         return false;
      if (sDia < 1 || sDia > 31) 
         return false;
      //Verifica os meses com 30 dias
      if (sMes == 4 || sMes == 6 || sMes == 9 || sMes == 11)
      {
         if (sDia == 31) 
            return false;
      }
      // fevereiro, ano bissexto
      if (sMes == 2)
      {
         if (sDia > 29) 
            return false;
         if (sDia == 29 && ((sAno/4) != parseInt(sAno/4))) 
            return false;
      }
   }  
   return true;
}

/*
* Verifica se uma data (objDataInicial) é menor ou igual a uma outra data (objDataFinal)
*
* @param Object Objeto referente a Data Inicial
* @param Object Objeto referente a Data Final
* @param String Mensagem a ser exibida caso a data inicial seja maior que a data final
* @param Boolean Indica se a mensagem será exibida ou não
*
* @author Flávia Hozana Pereira de Miranda
* @since 27/08/2002
* @access public
*
* @return Boolean Retorna true a data inicial for menor ou igual a data final
*                 e false caso contrário
*/
function verificarDataMenorIgual(objDataInicial, objDataFinal, sMensagem, bExibirMensagem)
{
   //Verifica se os valores passados para os par?metros da fun??o s?o v?lidos
   if (typeof(objDataInicial) != "object")
   {
      alert("Erro na chamada da fun?ao DataMenor." +
            " O tipo do valor passado para o par?metro objDataInicial n?o ? o esperado." +
            " Deve ser um campo de uma p?gina HTML, ou seja, um objeto")
      return false;
   }

   if (typeof(objDataFinal) != "object")
   {
      alert("Erro na chamada da fun?ao DataMenor." +
            " O tipo do valor passado para o par?metro objDataFinal n?o ? o esperado." +
            " Deve ser um campo de uma p?gina HTML, ou seja, um objeto")
      return false;
   }

   if (typeof(bExibirMensagem) == "undefined")
      bExibirMensagem = true;
   else
      bExibirMensagem = false;

   if (typeof(bExibirMensagem) != "boolean")
   {
      alert("Erro na chamada da fun?ao DataMenorIgual." +
            " O tipo do valor passado para o par?metro bExibirMensagem n?o ? o esperado." +
            " Deve ser true ou false.");
      return false;
   }      

   if (eDataMenorIgual(objDataInicial.value,objDataFinal.value))
      return true;
   else
   {
      if (bExibirMensagem)
      {
         if (typeof(sMensagem) == "undefined")
            alert("A data " + objDataInicial.dataFld + " deve ser menor que a data " + objDataFinal.dataFld);
         else
            alert(sMensagem);
      }
      setFocus(objDataInicial);
   }
   return false;
}
/*
* Verifica se uma data é menor ou igual a uma outra data
*
* @param String Data Inicial
* @param String Data Final
*
* @author Flávia Hozana Pereira de Miranda
* @since 27/08/2002
* @access public
*
* @return Boolean Retorna true a data inicial for menor ou igual a data final
*                 e false caso contrário
*/
function eDataMenorIgual(sDataInicial,sDataFinal)
{
   //Dia da Data
   var sDiaInicial;
   //M?s da Data
   var sMesInicial;
   //Ano da Data
   var sAnoInicial;
   //Dia da Data
   var sDiaFinal;
   //M?s da Data
   var sMesFinal;
   //Ano da Data
   var sAnoFinal;

   if (!eData(sDataInicial) || !eData(sDataFinal))
      return false;

   sDiaInicial = sDataInicial.substring(0,2);
   sMesInicial = sDataInicial.substring(3,5);
   if (sDataInicial.length > 8)
      //Recupera o ano com 4 d?gitos		
      sAnoInicial = sDataInicial.substring(6,10);
   else
      //Recupera o ano com 2 d?gitos
      sAnoInicial = sDataInicial.substring(6,8);

   sDiaFinal = sDataFinal.substring(0,2);
   sMesFinal = sDataFinal.substring(3,5);
   if (sDataFinal.length > 8)
      //Recupera o ano com 4 d?gitos		
      sAnoFinal = sDataFinal.substring(6,10);
   else
      //Recupera o ano com 2 d?gitos
      sAnoFinal = sDataFinal.substring(6,8);
   
   sDataInicial = sAnoInicial + sMesInicial + sDiaInicial;
   sDataFinal = sAnoFinal + sMesFinal + sDiaFinal;  

   if (sDataInicial <= sDataFinal)
      return true;
   return false;
}


/********************** VALIDACAO DE CAMPOS E VALORES *************************************/

/*
* Funcao criada para validar email
* Recene um string contendo o email e retorna uma mensagem de erro e false caso
* o email estaje incorreto.
*/
function validarEmail(emailStr) 
{
	validarEmail(emailStr,true);
}

/*
* Funcao criada para validar email
* Recene um string contendo o email e retorna uma mensagem de erro e false caso
* o email estaje incorreto.
*/
function validarEmail(emailStr,bolExibirErro) 
{
      	var emailPat=/^(.+)@(.+)$/
        var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]"
        var validChars="\[^\\s" + specialChars + "\]"
        var quotedUser="(\"[^\"]*\")"
        var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/
        var atom=validChars + '+'
        var word="(" + atom + "|" + quotedUser + ")"
        var userPat=new RegExp("^" + word + "(\\." + word + ")*$")
        var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$")

        var matchArray=emailStr.match(emailPat)
        if (matchArray==null) 
        { 
                if (bolExibirErro) alert("Email inválido !");
                return false;
        } 

        var user=matchArray[1] 
        var domain=matchArray[2] 
         
        if (user.match(userPat)==null) 
        { 
                // usuario invalido 
                if (bolExibirErro) alert("Nome do usuário inválido.");
                return false;
        } 

        var atomPat=new RegExp(atom,"g") 
        var domArr=domain.match(atomPat) 
        var len=domArr.length 
        if (domArr[domArr.length-1].length<2 || 
            domArr[domArr.length-1].length>3) 
        {          

							 if (bolExibirErro) {
										alert("Email inválido !! O email tem que terminar com 3 letras do domínio ou 2 letras do país.");
										 return false;
									} 
					
									if (len<2) 
									{ 
													var errStr="Está faltando o nome do servidor no email!";
													if (bolExibirErro) alert(errStr);
													return false;
									} 
													return true; 
				}
}

function validaTeclaInteiro(objeto,TeclaPres)
{
	var tecla;
	if (TeclaPres.keyCode) tecla = TeclaPres.keyCode;
	else if (TeclaPres.which) tecla = TeclaPres.which;
	//tecla==46 || - ponto
	if ((tecla>=48 && tecla<=57) || tecla==8 || tecla==9 || tecla==0 || tecla==32 || tecla==37)
	{
		return true;
	}
	else
	{
		return false;
	}
}


function validaValorInteiro(pStr)
{
	var reDigits = /^\d+$/;
	if (reDigits.test(pStr)) {
		return true;
	} else if (pStr != null && pStr != "") {
		return false;
	}
}


/********************** VALIDACAO DE CAMPOS E VALORES *************************************/

/*
* Transforma um array do PHP para um array Javascript

* @param String contendo o valor a verificar
*
* @author Flávia Hozana Pereira de Miranda
* @since 27/08/2002
* @access public
*
* @return Array convertida (ArrString) 
*/
function transformarArray(strArray)
{
	   //Object Objeto do tipo String para receber o texto a ser verificado
	   var objString
	   //Integer Contador
	   var intCont
	   //integer Contador auxiliar
	   var intReg
	   //array Posicao do elemento procurado na string
	   var arrPosicao;
	   //string Indice do array retorno
	   var strIndice;
	   //string Valores do array retorno
	   var strValor;
	   //array Array retorno
	   var arrString;
	   
	   arrPosicao = new Array;
	   arrString = new Array;
	   intCont = 0;
	   intReg = 0;
	   
	   objString = new String(strArray);
	   
	   //Percorre a string e atribui as posições do caracter 'aspas simples' para o array arrPosicao
	   for (intCont=0; intCont<objString.length; intCont++) 
	   {
		   if (objString.charAt(intCont) == "'")
		   {
			   arrPosicao[intReg] = intCont;
			   intReg++;
		   }
	   }
	   intCont = 0;
	   /*Percorre o array onde estão as posições do caracter 'aspas simples' 
	   e preenche o array do javascript (arrString) com os valores*/
	   for (intCont=0; intCont<intReg+1; intCont=intCont+4)
	   {
		   //atribui o valor do indice para o array javascript com o valor do indice do array PHP
		   strIndice = objString.substring(arrPosicao[intCont]+1, arrPosicao[intCont+1]);
		   
		   //atribui o valor do array javascript com o valor do array PHP
		   strValor = objString.substring(arrPosicao[intCont+2], arrPosicao[intCont+3]+1);
		   
		   if (strIndice != null)
		   {
			   arrString[strIndice] = strValor;
		   }
	   }
	   return arrString;
}

/*
* Limpa os campos presentes em uma form (Reset)
*
* @param Object objeto form cujos campos devem ser limpos
*
* @author Flávia Hozana Pereira de Miranda
* @since 13/11/2002
* @access public
*
*/
function limparForm(objElementoForm)
{
   if (typeof(objElementoForm) != "object")
   {
      alert("Erro na chamada da funçao LimparForm." +
            " O tipo do valor passado para o parâmetro objElementoForm não é o esperado." +
            " Deve ser uma form de uma página HTML, ou seja, um objeto");
      return true;
   }
   objElementoForm.reset();
   return false;
}

/*
* Limpa os campos presentes em uma form
*
* @param Object objeto form cujos campos devem ser limpos
* @param String nomes dos campos do form que não devem ser limpos.
*               Estes nomes devem estar separados por vírgula
*
* @author Flávia Hozana Pereira de Miranda
* @since 29/08/2002
* @access public
*
*/
function limparCampos(objElementoForm, strNomesElementosManterValor)
{
   // Contador
   var iCont 
   // String tempor?ria que indica o nome de um campo da tela
   var objNomeElemento
   // nomes de campos
   var iIndice
   // Arranjo contendo os nomes dos campos que n?o devem ser limpos
   var arrNomesElementos 
   // Quantidade de elementos (campos da tela) que n?o devem ser limpos
   var iQuantNomesElementos
   // Indica se um determinado elemento est? presente no arranjo arrNomesElementos
   var bNomeExiste
  	
   if (typeof(objElementoForm) != "object")
   {
      alert("Erro na chamada da função limparCampos." +
            " O tipo do valor passado para o par?metro objElementoForm n?o ? o esperado." +
            " Deve ser uma form de uma p?gina HTML, ou seja, um objeto");
      return true;
   }
   iCont = 0;
   arrNomesElementos = new Array;
   objNomeElemento = new String(strNomesElementosManterValor);
   // Pesquisa a string dada por strNomesElementosManterValor e coloca os nomes dos campos
   // em um arranjo
   do
   {
      iIndice = objNomeElemento.indexOf(',');
	  if (iIndice != -1) 
	  {
         arrNomesElementos[iCont] = objNomeElemento.substr(0,iIndice);
         objNomeElemento = new String(objNomeElemento.substr(iIndice+1));
	     iCont = iCont + 1;
	  }
	  else
	  {
	     if (objNomeElemento.length != 0)
		    arrNomesElementos[iCont] = objNomeElemento.substr(0);
		 objNomeElemento = new String("");
	  }
   }
   while (objNomeElemento.length != 0);
   iQuantNomesElementos = iCont + 1;
   // Percorre os elementos da tela e verifica se os mesmos devem ou n?o ser limpos
   for (var iCont = 0; iCont < objElementoForm.elements.length; iCont++)
   {
       bNomeExiste = verificarArranjo(objElementoForm.elements[iCont].name, arrNomesElementos,   iQuantNomesElementos)
	   // Somente limpa o campo se ele n?o foi informado para ser preservado
	   if (!bNomeExiste)
	   {
		  // Somente limpa campos do tipo text, select,
	      if ((objElementoForm.elements[iCont].type == "text") ||
		      (objElementoForm.elements[iCont].type == "hidden") ||
			  (objElementoForm.elements[iCont].type == "file") ||
		      (objElementoForm.elements[iCont].type == "textarea") ||
			  (objElementoForm.elements[iCont].type == "password"))
			  objElementoForm.elements[iCont].value = "";
		  if ((objElementoForm.elements[iCont].type == "checkbox") ||
			  (objElementoForm.elements[iCont].type == "radio"))
			  objElementoForm.elements[iCont].checked = false;
	      if ((objElementoForm.elements[iCont].type == "select-one") ||
		     (objElementoForm.elements[iCont].type == "select-multiple"))
		     objElementoForm.elements[iCont].selectedIndex = 0
	   }   
    }
   return false;
}

/*
* Verifica se um determinado nome est? em um arranjo
*
* @param String Nome a ser verificado
* @param Array Arranjo contendo os nomes
* @param Integer Quantidade de nomes presente no arranjo
*
* @author Flávia Hozana Pereira de Miranda
* @since 29/08/2002
* @access public
*
*/
function verificarArranjo(strNomePesquisado, arrNomes, intQuantNomes)
{
   // Contador
   var intCont

   for (intCont=0; intCont < intQuantNomes; intCont++)
   {
      // Encontrou o nome no arranjo
	  if (trim(arrNomes[intCont]) == trim(strNomePesquisado))
	  {
	     return true;
	  }
   }
   return false;
}
/*
* Verifica se um determinado nome está em um arranjo.
*
* @param String strNomePesquisado: nome a ser verificado
* @param Array arrNomes: arranjo contendo os nomes
* @param Inteiro intQuantNomes: quantidade de nomes presente no arranjo
*
* @author Flávia Hozana Pereira de Miranda
* @since 14/11/2002
* @access public
*
*/
function verificarNomeNoArranjo(strNomePesquisado, arrNomes, intQuantNomes)
{
   // Contador
   var intCont

   for (intCont=0; intCont < intQuantNomes; intCont++)
   {
      // Encontrou o nome no arranjo
	  if (trim(arrNomes[intCont]) == trim(strNomePesquisado))
	  {
	     return true;
	  }
   }
   return false;
}


/*
* Desabilita os campos presentes em uma form
*
* @param Objeto objElementoForm: objeto form cujos campos devem ser limpos
* @param String sNomesElementosManterValor: nomes dos campos da form que não devem ser desabilitados. Estes 
*                                           nomes devem estar separados por vírgula.
* @param Boolean bFlag: indica se os campos serão habilitados ou desabilitados.
*
* @author Flávia Hozana Pereira de Miranda
* @since 14/11/2002
* @access public
*
*/
function habilitarDesabilitarCampos(objElementoForm, sNomesElementosManterValor, bFlag)
{
   // Contador
   var iCont 
   // String temporária que indica o nome de um campo da tela
   var objNomeElemento
   // Posição da vírgula na string sNomesElementosManterValor que indica a separação entre dois
   // nomes de campos
   var iIndice
   // Arranjo contendo os nomes dos campos que não devem ser limpos
   var adNomesElementos 
   // Quantidade de elementos (campos da tela) que não devem ser limpos
   var iQuantNomesElementos
   // Indica se um determinado elemento está presente no arranjo adNomesElementos
   var bNomeExiste
  	
   if (typeof(objElementoForm) != "object")
   {
      alert("Erro na chamada da funçao DesabilitarCampos." +
            " O tipo do valor passado para o parâmetro objElementoForm não é o esperado." +
            " Deve ser uma form de uma página HTML, ou seja, um objeto");
      return true;
   }
   iCont = 0;
   adNomesElementos = new Array;
   objNomeElemento = new String(sNomesElementosManterValor);

   // Pesquisa a string dada por sNomesElementosManterValor e coloca os nomes dos campos
   // em um arranjo
   do
   {
	   iIndice = objNomeElemento.indexOf(',');
	   if (iIndice != -1) 
	   {
		   adNomesElementos[iCont] = objNomeElemento.substr(0,iIndice);
		   objNomeElemento = new String(objNomeElemento.substr(iIndice+1));
		   iCont = iCont + 1;
	   }
	   else
	   {
		   if (objNomeElemento.length != 0)
		   adNomesElementos[iCont] = objNomeElemento.substr(0);
		   objNomeElemento = new String("");
	   }
   }
   while (objNomeElemento.length != 0);
   iQuantNomesElementos = iCont + 1;
   // Percorre os elementos da tela e verifica se os mesmos devem ou não ser limpos
   for (var iCont = 0; iCont < objElementoForm.elements.length; iCont++)
   {
	   bNomeExiste = verificarNomeNoArranjo(objElementoForm.elements[iCont].name, adNomesElementos,iQuantNomesElementos)
	   // Somente limpa o campo se ele não foi informado para ser preservado
	   if (!bNomeExiste)
	   {
		  objElementoForm.elements[iCont].disabled = bFlag;
	   }   
    }
   return true;
}


/*
* A funcao anterior nao esta funcionando do jeito que deveria, na hora de desabilitar os campos que nao estao listados.
*/
function habilitaDesabilitaCampos(objElementoForm,strNomeElementos,bolOpcao)
{
	var arrElementos = strNomeElementos.split(",");
	for (var iCont = 0; iCont < objElementoForm.elements.length; iCont++)
	{
		if (in_array(objElementoForm.elements[iCont].name,arrElementos))
		{
			objElementoForm.elements[iCont].disabled = bolOpcao;
		}
	}
}

 	
/*
* Função para validar o numero PIS/PASEP - Validando apenas formato
*/
function validarPIS(objCampo) 
{
	value = trim(objCampo.value);
	
	/*
	if (value.length != 14) return false;
	if (isNaN(value.substr(0,3))) return false;
	if (value.substr(3,1) != '.') return false;
	if (isNaN(value.substr(4,5))) return false;
	if (value.substr(9,1) != '.') return false;
	if (isNaN(value.substr(10,2))) return false;
	if (value.substr(12,1) != '-') return false;
	if (isNaN(value.substr(13,1))) return false;
	*/
	
	arrMultiplicador = new Array();
	arrMultiplicador[0] = 3;
	arrMultiplicador[1] = 2;
	arrMultiplicador[2] = 9;
	arrMultiplicador[3] = 8;
	arrMultiplicador[4] = 7;
	arrMultiplicador[5] = 6;
	arrMultiplicador[6] = 5;
	arrMultiplicador[7] = 4;
	arrMultiplicador[8] = 3;
	arrMultiplicador[9] = 2;

	pis = trim(value);
	pis = trocarTodos(pis,"-","");
	pis = trocarTodos(pis,".","");
        
	if (pis.length != 11) return false;
	
	if (pis=='00000000000') return false;
	
	soma = 0;
	for (g=0; g<10; g++)
	{
		soma += parseInt(pis.substr(g,1)) * arrMultiplicador[g];
	}
	resto = soma % 11;
	if ( resto < 2 )
		resto = 0;
	else
		resto = 11 - resto;

	//se o ultimo numero (digito) for o resto, pis esta ok 
	if (pis.lastIndexOf(resto)==(pis.length-1))
	{
		return true;
	}
	return false;
}


/************************************************************
* Funcções para validação de CPF
* Ainda precisam ser traduzidas para a nomenclatura padrão
************************************************************/
function Len(str)
{  
  	return String(str).length;  
}
  
function Mid(str, start, len)  
{         
	if (start < 0 || len < 0) 
		return "";

	var iEnd, iLen = String(str).length;
	if (start + len > iLen)
		iEnd = iLen;
	else
		iEnd = start + len;

	return String(str).substring(start,iEnd);
}

function verificarCPF(CPF)
{
	//Valida argumento
	if (Len(CPF) != 11)
		return false;
	
	Repetido=true;
	for (i=1;i<=10;i++)
	{
		if (Mid(CPF,i,1)!=Mid(CPF,0,1))
			{Repetido=false;
			 break;
			}
	}
	
	if (Repetido)
		return false;
							 
	soma = 0
	for (i = 1;i<=9;i++)
		soma = soma + parseInt(Mid(CPF, i-1, 1)) * (11 - i);

	Resto = 11 - (soma - (parseInt(soma / 11) * 11));

	if (Resto == 10 || Resto == 11) 
		 Resto = 0;
				
	if (Resto != parseInt(Mid(CPF, 9, 1)))
		return false;
							
	soma = 0
	for (i = 1;i<=10;i++)
		soma = soma + parseInt(Mid(CPF, i-1, 1)) * (12 - i);
	
	Resto = 11 - (soma - (parseInt(soma / 11) * 11));

	if (Resto == 10 || Resto == 11) 
		Resto = 0;
														
	if (Resto != parseInt(Mid(CPF, 10, 1)))
		return false;
		
	return true;
}

function verificarCGC(cgc) 
{
	if (Len(cgc)== 8 && parseInt(cgc,10) > 0)
	  {a = 0;
		 J = 0;
		 d1 = 0;
		
		for (i = 0;i<7;i++)
		{a = parseInt(Mid(cgc, i, 1));
							
			if (((i+1) % 2) != 0)
				a = a * 2;					 									
															
			if (a > 9)
				J = J + parseInt(a / 10) + (a % 10);
			else
				J = J + a;								
		}
		
		d1 = ((J % 10) != 0) ? (10 - (J % 10)) : 0 ;			
		
		if (d1 == parseInt(Mid(cgc, 7, 1)))
			 return true;
		else
			return false;
		}			
	else
	  {// if (Len(cgc) == 14 && parseInt(cgc) > 0)
		 if (Len(cgc) == 14  && parseInt(cgc,10) > 0)
		{a = 0;
			i = 0;
			d1 = 0;
			d2 = 0;
			J = 5;
			
			for (i = 0;i<12;i++)
			 {a = a + (parseInt(Mid(cgc, i, 1)) * J);
				 J = (J > 2) ? (J - 1) : 9 ;
			  }
							
			a = a % 11;
			d1 = (a > 1) ? (11 - a) : 0 ;
			a = 0;
			i = 0;
			J = 6;
			
			for (i = 0;i<13;i++)
				{a = a + (parseInt(Mid(cgc, i, 1)) * J);
				 J = (J > 2) ? (J - 1) : 9;
				}				
			
			a = a % 11;
			d2 = (a > 1) ? (11 - a): 0;
			
			if (d1 == parseInt(Mid(cgc, 12, 1)) && d2 == parseInt(Mid(cgc, 13, 1)))
				return true;
			else
				return false;
		}	
	    else
			return false;		
	}
}

/*
* Verfica se o campo foi preenchido com o tamanho minimo de caracteres
*
* @param Objeto intTamanhoMaximo: Tamanho máximo do elemento
* @param  e: evento
* @param objElementoForm.
*
* @author Flávia Hozana Pereira de Miranda
* @since 11/12/2002
* @access public
*
*/
function verificarTamanhoMinimo(intTamanhoMinimo,objElementoForm)
{
	if (trim(objElementoForm.value).length>=intTamanhoMinimo) return true;
	return false;
}


function verificarTamanhoMaximo(intTamanhoMaximo,objElementoForm)
{
	if (trim(objElementoForm.value).length>intTamanhoMaximo) return false;
	return true;
}


/*
* Verifica restrições de caracteres para o elemento, caso este estiver em seu tamanho maximo
*
* @param Objeto intTamanhoMaximo: Tamanho máximo do elemento
* @param  e: evento
* @param objElementoForm.
*
* @author Flávia Hozana Pereira de Miranda
* @since 11/12/2002
* @access public
*
*/
function verificarRestricaoLimite(intTamanhoMaximo,e,objElementoForm)
{
	if (window.event&&event.srcElement.value.length>=intTamanhoMaximo)
	{
		return false;
	}
	else if (e.target&&e.target==eval(objElementoForm)&&e.target.value.length>=intTamanhoMaximo)
	{
		var pressedkey=/[a-zA-Z0-9çÇ\.\,\!\?\:\;\@\#\$\%\&\*\"\'\(\)\-\_\+\=\[\]\{\}\^\~\<\>\|\\\ \`\/]/
		if (pressedkey.test(String.fromCharCode(e.which)) || e.which==13)
			e.stopPropagation()
	}
	
}


function limiteMaximoTextarea(objElementoTextarea,event,intTamanhoMaximo,objRestante)
{
	//se foi chamado por evento
	if (event)
	{
		contarLimite(intTamanhoMaximo,event,objElementoTextarea);
	}
	exibirNumCaracteresTxa(objElementoTextarea,intTamanhoMaximo,true,objRestante); 
}


/*
* Verifica o Limite de caracteres de um input de um form.
*
* @param Inteiro intTamanhoMaximo: tamanho maximo do elemento
* @param  e: evento
* @param objElementoForm: 
*
* @author Flávia Hozana Pereira de Miranda
* @since 11/12/2002
* @access public
*
*/
function contarLimite(intTamanhoMaximo,e,objElementoForm)
{
	var theform=eval(objElementoForm)
	var lengthleft=intTamanhoMaximo-theform.value.length
	var objElementoFormTamanho=document.all? document.all[objElementoForm] : document.getElementById(objElementoForm)
	
	if (window.event||e.target&&e.target==theform)
	{
		if (lengthleft<=0)
		{
			theform.value=theform.value.substring(0,intTamanhoMaximo)
			lengthleft=0
		}
	}
}


/*
* Verifica o Limite de caracteres de um input de um form.
*
* @param Objeto objElementoForm: form.elemento do objeto que terá um limite
* @param Inteiro intLimite: Limite do elemento
* @param Boolean bolExibirLimite: indica se o limite será mostrado ou nao.
*
* @author Flávia Hozana Pereira de Miranda
* @since 11/12/2002
* @access public
*
*/
function verificarLimite(objElementoForm,intLimite,bolExibirLimite)
{
	if (typeof(bolExibirLimite) == "undefined")
		bolExibirLimite = true;      
	
	if (typeof(bolExibirLimite) != "boolean")
	{
		alert("Erro na chamada da funcao verificarLimite." +
		" O tipo do valor passado para o parametro bolExibirLimite nao e o esperado." +
		" Deve ser true ou false.");
		return false;
	}
	var ns6=document.getElementById&&!document.all
	var strLimite='<span id="'+objElementoForm.toString()+'">'+intLimite+'</span>'
	
	if (bolExibirLimite)
	{
		if (document.all||ns6)
			document.write(strLimite)
	}
	if (document.all)
	{
		eval(objElementoForm).onkeypress=function(){return verificarRestricaoLimite(intLimite,event,objElementoForm)}
		eval(objElementoForm).onkeyup=function(){contarLimite(intLimite,event,objElementoForm)}
	}
	else if (ns6)
	{
		document.body.addEventListener('keypress', function(event) {verificarRestricaoLimite(intLimite,event,objElementoForm)}, true);
		document.body.addEventListener('keyup', function(event) {contarLimite(intLimite,event,objElementoForm)}, true);
	}
	
}
/*
* exibe numero de caracteres restantes e máximo de um txa
*
* @param objEmento Elemento
* @param objEmento intTamanhoMaximo - Tamanho maximo de caracteres do elemnto
* @param bolModuloRestante Verifica se será necessário aplicar um modulo no valor restante para este nao ser negativo
* @param spnRestante Span que será armazenado o tamanho restante (opcional)
* @param spnMaximo Span que será armazenado o tamanho maximo(opcional)
* @author Daniel Hasan Dalip
* @since 30/05/2007
* @access public
*/
function exibirNumCaracteresTxa(objElemento,intTamanhoMaximo,bolModuloRestante,spnRestante,spnMaximo)
{
	 if(spnMaximo != undefined)
	 {
		 spnMaximo.innerHTML = intTamanhoMaximo;
	 }
	 if(spnRestante != undefined)
	 {
		 var intValRestante = intTamanhoMaximo - objElemento.value.length;
		 //aplica o modulo do valRestante caso necessario
		 if(bolModuloRestante && intValRestante<0)
		 {
			 intValRestante=-intValRestante;
		 }
		 spnRestante.innerHTML = intValRestante;
	 }
	
	 return objElemento.value.length<=intTamanhoMaximo;

}
/*
* Altera o caracter do texto por um valor escolhido  
*
* @param Integer pos variavel com o nome que será alterado
* @param String strText variavel que contém o texto
* @param String strValue variavel que contem o caracter
* @author Erix Henrique Morato
* @since 13/12/2002
* @access public
*
* @return Retorna o novo texto
*/
function setChar(pos,strText, strValue)
{
	
	var strAux = '';
	
	for(z = 0;z<strText.length;z++)
	{    
		if (z!= pos) 
			strAux = strAux + strText.charAt(z);
		else
			strAux = strAux+ strValue;	

	}
	return strAux;
}

/*
* Altera os caracteres do nome para a forma correta 
*
* @param String strTexto variavel com o Texto que será alterado
*
* @author Erix Henrique Morato
* @since 13/12/2002
* @access public
*
* @return Retorna o nome valido para ser gravado no banco
*/

function retornarTextoPadrao(strTexto)
{

	var strAuxNome; // variavel que ira ajudar na mudança da variavel
	
	strAuxNome = trim(strTexto);
	strUpper = strAuxNome.charAt(0);
	strAuxNome = setChar(0,strAuxNome,strUpper.toUpperCase()); 
	for (i=1;i<strAuxNome.length;i++)
	{
		
		if(strAuxNome.charAt(i)!=' ')
		{
			strLower = strAuxNome[i];
			strAuxNome = setChar(i,strAuxNome,strLower.toLowerCase());
						
		}
		else
		{
		   
		    if(strAuxNome.charAt(i)!=' ')
		    {
			    strUpper = strAuxNome[i]
			    strAuxNome = setChar(i,strAuxNome,strUpper.toUpperCase());
		    }
		    else
		    {    
			 
			    while(strAuxNome.charAt(i)==' ')
			         i++;
			    strUpper = strAuxNome[i]
			    strAuxNome = setChar(i,strAuxNome,strUpper.toUpperCase());
		    }
			    
		}
	
	}
         
	strAuxNome = trocarTodos(strAuxNome,' Da ',' da ');
	strAuxNome = trocarTodos(strAuxNome,' De ',' de ');  
	strAuxNome = trocarTodos(strAuxNome,' Di ',' di ');  
	strAuxNome = trocarTodos(strAuxNome,' Do ',' do ');  
	strAuxNome = trocarTodos(strAuxNome,' E ',' e ');  
	strAuxNome = trocarTodos(strAuxNome,' Das ',' das ');  
	strAuxNome = trocarTodos(strAuxNome,' Dos ',' dos ');  
	
	return strAuxNome;
}

/*
* Remove os itens selecionados de um tag Select
*
* @param Objeto objElementoForm: form.elemento do objeto
*
* @author Flávia Hozana Pereira de Miranda
* @since 18/12/2002
* @access public
*
*/
function removerItensSelect(objElementoForm)
{
   //Contador
   var intCont;
   var intQuantItens;

   intQuantItens = objElementoForm.options.length;
   if (intQuantItens > 0)
      for (intCont=0;intCont<=intQuantItens-1;intCont++)
      {
         if (objElementoForm.options[intCont].selected)
         {
	    	objElementoForm.options[intCont] = null;
	        intCont --;
            intQuantItens --;
         }
      }
   else
      alert("Selecione um item na lista para o mesmo ser removido");
   return false;
}
/*
* Move os itens de um tag select (origem) para um outro tag select (destino)
*
* @param Objeto objSelectOrigem: tag select cujos itens selecionados devem ser movidos 
*				para o outro tag select
* @param Objeto objSelectDestino: tag select que deve conter os itens selecionados no tag select origem
* @param Boolean bolTodos: indica se todos os itens do tag select origem devem ser movidos 
*			para o tag select destino
*
* @author Flávia Hozana Pereira de Miranda
* @since 19/12/2002
* @access public
*
*/
function moverItensSelectOrigemDestino(objSelectOrigem,objSelectDestino,bolTodos,strConcatenar)
{
   //Contador  
   var lCont;
   //Quantidade de itens no tag select de origem
   var lQuantOrigem;
   //Item a ser movido de um tag select para o outro
   var objOption;
   //objeto String que contém o atributo value da opção do tag select
   var objNewOption;
   var objValor;
   //Posição de encontro do caracter - dentro do atributo value da opção do tag select
   var lPosicaoSeparador;
   //Nome da coluna a ser ordenada
   var sColuna;
   //Indica se é para incluir o objeto
   var bIncluir;

   //Recupera a quantidade de itens na lista do tag select origem
   lQuantOrigem = objSelectOrigem.options.length;
   for (lCont=0;lCont <=lQuantOrigem -1;lCont++)
   {
      objOption = objSelectOrigem.options[lCont];
	  bIncluir = false;
	  if (objOption.selected)
	  {
	     bIncluir = true;
      }
	  else
	  {
	     if (bolTodos)
	     {
		    bIncluir = true;
	     }
	  }
      if (bIncluir)
      {
		 //Inclui o item no tag select de itens incluídos
         if (strConcatenar != "")
	     {
            objValor = new String();
	        objValor = objOption.value;
            //Recupera o caracter - que separa o nome da coluna a ser ordenada e o tipo de ordenação
	        lPosicaoSeparador = objValor.search("-");
            if (lPosicaoSeparador != -1)
               //Separador foi encontrado, então recupera o nome da coluna a ser ordenada
               sColuna = objValor.substr(0,lPosicaoSeparador);
            else
               sColuna = objOption.value;
            objOption.value = sColuna + "-" + strConcatenar
	     }
	    //Remove o item do tag select de itens disponíveis
	    objNewOption = new Option(objOption.text, objOption.value, false, false);
		objSelectDestino.options[objSelectDestino.options.length] = objNewOption;
		objNewOption.selected = true;
		objSelectOrigem.options[lCont] = null;
   	    lCont --;
        lQuantOrigem --;
      }
   }
   return false;
}


function FormataValor(campo,tammax,teclapres)
{
	if (teclapres.keyCode) tecla = teclapres.keyCode;
	else if (teclapres.which) tecla = teclapres.which;
	
	vr = campo.value;
	
	vr = vr.replace( "/", "" );
	vr = vr.replace( "/", "" );
	vr = vr.replace( ",", "" );
	vr = vr.replace( /\./, "" );
	vr = vr.replace( /\./, "" );
	vr = vr.replace( /\./, "" );
	vr = vr.replace( /\./, "" );
	
	tam = vr.length;

	if (tam < 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 <= 2 )
		{
			campo.value = vr;
		}
		else
		{
			if ( (tam > 2) && (tam <= 5) )
			{
				campo.value = vr.substr( 0, tam - 2 ) + ',' + vr.substr( tam - 2, tam );
			}
			else
			{
				if ( (tam >= 6) && (tam <= 8) )
				{
					campo.value = vr.substr( 0, tam - 5 ) + '.' + vr.substr( tam - 5, 3 ) + ',' + vr.substr( tam - 2, tam );
				}
				else 
				{
					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 );
					}
					else
					{
						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 );
						}
						else 
						{
							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 );
							}
						}
					}
				}
			}
		}
		return true;
	}	
	return false;
}


function FormataValores(campo,teclapres,intCasaDecimal){
	var tecla;
	vr = campo.value;
	
	//alert(vr);
	
	//Tratamento para browser IE ou MOZILLA
	if (teclapres.keyCode)
	{	
		tecla = teclapres.keyCode;
	}
	else 
	{
		if (teclapres.which)
		{
			tecla = teclapres.which;
		}
	}
	
	//alert(tecla);
	if ( tecla == 8 || tecla >= 48 && tecla <= 57 || tecla >= 96 && tecla <= 105 )
	{
		vr=trocarTodos(vr,",","");
		vr=trocarTodos(vr,".","");
	//	alert('antes: '+vr);
		vr = Math.floor(vr);
	//	alert('depois: '+vr);
		campo.value = formataDecimal(vr,intCasaDecimal);
	}
	else
	{
		vr=trocarTodos(vr,",","");
		vr=trocarTodos(vr,".","");
		campo.value=vr.substr(vr.length-1,vr.length);
	}
	
}

function FormataValores2(campo,teclapres,intCasaDecimal){
	var tecla;
	vr = campo.value;
	
	//alert(vr);
	
	//Tratamento para browser IE ou MOZILLA
	if (teclapres.keyCode)
	{	
		tecla = teclapres.keyCode;
	}
	else 
	{
		if (teclapres.which)
		{
			tecla = teclapres.which;
		}
	}
	
	//alert(tecla);
	if (tecla != 9) {
		if (tecla == 8 || tecla >= 48 && tecla <= 57 || tecla >= 96 && tecla <= 105) {
			vr = trocarTodos(vr, ",", "");
			vr = trocarTodos(vr, ".", "");
			vr = trocarTodos(vr, "R$ ", "");
			//	alert('antes: '+vr);
			vr = Math.floor(vr);
			//	alert('depois: '+vr);
			campo.value = "R$ " + formataDecimal(vr, intCasaDecimal);
		}
		else {
			vr = trocarTodos(vr, ",", "");
			vr = trocarTodos(vr, ".", "");
			campo.value = vr.substr(vr.length - 1, vr.length);
		}
	}	
}


function formataDecimal(intValor,intCasaDecimal)
{
	strValor = ""+intValor;
	intTamanhoValor = strValor.length;
	strValorFinal = "";
	
	//alert(intTamanhoValor+' e '+strValor);
	
	//verifica se o número tem casa decimal
	if (intTamanhoValor > intCasaDecimal)
	{	
		//separando valor inteiro do decimal
		strValorDecimal = ','+strValor.substr(intTamanhoValor-intCasaDecimal,intTamanhoValor);
		strValorInteiro = strValor.substr(0,intTamanhoValor-intCasaDecimal);
		
		//Qtde de pontos a serem colocados.
		intResultadoDivisao = Math.floor(((intTamanhoValor-intCasaDecimal)/3));
		
		//Pontos que não respeitam a métrica de três
		intRestoDivisao = ((intTamanhoValor-intCasaDecimal)%3);
		
		//poe um ponto o primeiro pontos da esquerda para a direita  
		if (intRestoDivisao == 0)
		{
			//decresce a qtde de pontos a ser colocados
			intResultadoDivisao--;
		}
		
		//montando valor final
		strValorFinal=strValorDecimal;
	//	alert("final: "+strValorFinal+" e "+intResultadoDivisao+" e "+strValorInteiro);
		for(j=0;j<intResultadoDivisao;j++)
		{
			strValorFinal="."+strValorInteiro.substr(strValorInteiro.length-3,strValorInteiro.length)+strValorFinal;
	//		alert('limpa: '+strValorFinal);
			strValorInteiro = strValorInteiro.substr(0,strValorInteiro.length-3);
	//		alert('repolho: '+strValorInteiro);
		}
		
		strValorFinal = strValorInteiro+strValorFinal;
	//	alert('maiorsrs: '+strValorFinal);
	}
	else
	{
		strValorFinal = '0,';
		intE = intCasaDecimal-intTamanhoValor;
	//	alert('diferenca: '+intE);		
		for(i=0;i<intCasaDecimal-intTamanhoValor;i++)
		{
			strValorFinal = strValorFinal+'0';
		}
		
		strValorFinal=strValorFinal+strValor;		
	}
	
	
	return(strValorFinal);
}


var G = new Array();
var P = new Array();

// exemplo
// <input type="text" name="cpf" size=16 maxlength=14 class=texto onkeypress="criaMascara(document.frmInc,this.name,event,'999.999.999-99');">

function retornaTam(valor) {
    retorno = 0;
    for (w=0; w<=valor; w++) {  
        retorno+=G[w];
    }
    return retorno; 
}

function criaMascara(frm,campo,TeclaPres,maskara) {

var Vr = frm[campo].value;

//Tratamento para browser IE ou MOZILLA
var Tecla;
if (TeclaPres.keyCode) Tecla = TeclaPres.keyCode;
else if (TeclaPres.which) Tecla = TeclaPres.which;

var num = Vr;
var novaMask = new Array();
var campoFinal = new Array();
var outro;
var ind = 0;
var ind1 = 0;
var ind2 = 0;
var tamMask = maskara.length;
var contMask = 0;
var contem;
var grupo =0;
var controle = 0;
var p1 = 0;
var p2 = 1;

//Grupos
G[ind] = 0;
//Pontos de Edicao
P[ind1] = 0;
   
    //Verifica o tamanho dos grupos, local dos grupos e pontos      
	while(contMask <= tamMask) {
	  contem = maskara.substring(p1,p2);
		 if (contem == 9) {
 			 if (grupo > controle) {
 			  ind ++;
			  ind1 ++;
			  G[ind] = 0; 
			  P[ind1] = 0;
			  controle = controle + 1;
		     }
		   G[ind] = G[ind]+1;
	    }
	    else{
		   P[ind1] = contem;
		   grupo = grupo + 1
	    }
	  contMask = contMask + 1;
	  p1 = p1 + 1;
  	  p2 = p2 + 1;
   }
   
   
  
//Declarando variaveis da montagem para nova mascara


   
  if (Vr.length!=maskara.length) {

	  
  for ( x=0 ; x < P.length; x++ ) {
      Vr = Vr.toString().replace( P[x], "" );
  }
    
   Tam = Vr.length;
   if (Tam <= maskara.length  && Tecla != 8) { 
	    Tam = Vr.length;       
   } else {
    return false;
   }
		
	if (Tecla == 8 ) { 
     Tam = Tam - 1 ; 
	}

  
	// montando a mascara no campos
 if ( Tecla == 8 || Tecla == 88 || Tecla >= 48 && Tecla <= 57 || Tecla >= 96 && Tecla <= 105 ){
    tamTempo = G.length - 1;
    k=0;
    for (k=0; k<=tamTempo; k++) {      
      if (Tam >= retornaTam(k) && Tam < retornaTam(k+1)) {
            rodar = "";            
            for (z=0; z<=k+1; z++) {
                valorSub = "retornaTam("+(z-1)+")";
                valorSub1 = "retornaTam("+(z)+")";
                if (z==0) {
                    valorSub = "0";
                    valorSub1 = "retornaTam("+z+")";
                }                                
                if (z==k+1) {
                    valorSub = "retornaTam("+(z-1)+")";
                    valorSub1 = "Tam";
                }
                valorSub = eval(valorSub);
                valorSub1 = eval(valorSub1);              
                rodar += "Vr.substring("+valorSub+","+valorSub1+")";                                              
                rodar += "+P["+z+"]+";                                   
            }                           
            rodar = "Vr = "+rodar.substring(0,rodar.length-6);
            eval(rodar);
      }      
    }       
    frm[campo].value = Vr;  
 }
 } 	
	
}

/*
* Funcao que troca todas as ocorrencias encontradas na string passada
*/
function trocarTodosExpressao(strTexto,AFindText,ARepText)
{
	raRegExp = new RegExp(AFindText,"g")
	return strTexto.replace(raRegExp,ARepText)
}


/*
function converterArrayPhpJs(strValorCombo){
	

	//Array com os valores da linha em php
	//arrValoresTemp;
	//Array temporario retornado no final
	//arrTempGeracao;
	//Contador auxiliar do arrTempGeracao
	//y;
	//String com o comando de atribuicao para o arrTempGeracao
	//strComandoTemp;
	//String com o comando de atribuicao para o arrValoresTemp
	//strComandoTexto;
	
	strValorCombo = trocarTodos(strValorCombo,"=>",",");
	
	strValorCombo = strValorCombo.substring(5,strValorCombo.length);
	
	strComandoTexto = 'arrValoresTemp = new Array'+strValorCombo;		
	eval(strComandoTexto);		
	arrTempGeracao = new Array;
	
	y=0;
	for (x=0; x<arrValoresTemp.length; x=x+2)
	{		
		strComandoTemp = 'arrTempGeracao[\''+arrValoresTemp[x]+'\'] = \''+arrValoresTemp[x+1]+'\'';
		eval(strComandoTemp);   			
	}
	return arrTempGeracao;
}
*/
function status_email(result, cod_erro) //Fale Comigo
{
    if (result) {
    	alert("Mensagem enviada com sucesso");
	return true;
    } 
    	alert("Ocorreu um problema ao enviar a mensagem\nCodigo do erro: "+cod_erro);
	return true;
}

function terminarSessao()
{
	objForm = document.frmFormularioSecao;
	objForm.hidAcao.value = 'terminarSecao';
	objForm.submit();
}

//preenche valor com uma quantidade de zeros a equerda
function zeroEsquerda(strValor,intQuantidade)
{
	for (x=strValor.length; x<intQuantidade; x++)
	{
		strValor = '0'+strValor;
	}
	return strValor;
}

/*
* Retira os espa?os em branco ? direita e ? esquerda de um texto
* @param String strTexto texto a cujos espa?os em branco ? esquerda e ? direita devem ser eliminados
*
* @return Boolean Retorna o texto sem espa?os em branco ? esquerda e ? direita
* @author Cristiano Falinacio Barbosa
* @since 14/08/2002
* @access public

function trim(strTexto)
{
   //String Texto sem espa?os em branco ? esquerda e ? direita
   var strTextoSemEspacos
   strTextoSemEspacos = lTrim(strTexto);
   strTextoSemEspacos = lTrim(strTextoSemEspacos);
   return strTextoSemEspacos;
}
*/
function trim(s) 
{
	//transforma o s em um string valido caso ele nao o seja
	s = s+'';
	
	while (s.substring(0,1) == ' ') {
		s = s.substring(1,s.length);
	}
	while (s.substring(s.length-1,s.length) == ' ') {
		s = s.substring(0,s.length-1);
	}
	return s;
}

/*
* Retira os espacos em branco ? esquerda de um texto
* @param String strTexto texto a cujos espa?os em branco ? esquerda devem ser eliminados
*
* @return Boolean Retorna o texto sem espa?os em branco ? esquerda
* @author Cristiano Falinacio Barbosa
* @since 14/08/2002
* @access public
*/
function lTrim(strTexto)
{
   //Object Objeto do tipo String para receber o texto a ser verificado
   var objString
   //Integer Contador
   var intCont
   //String Texto sem espa?os em branco ? esquerda
   var strTextoSemEspacos
   strTextoSemEspacos = ""
   objString = new String(strTexto);
   for (intCont=0; intCont < objString.length; intCont++) 
   {
      if (objString.charAt(intCont) != " ")
      {
     	 strTextoSemEspacos = objString.substring(intCont,objString.length)
         return strTextoSemEspacos;
      }
   }  
   return strTextoSemEspacos;
}

/*
* Retira os espacos em branco ? direita de um texto
* @param String strTexto texto a cujos espa?os em branco ? direita devem ser eliminados
*
* @return Boolean Retorna o texto sem espa?os em branco ? direita
* @author Cristiano Falinacio Barbosa
* @since 14/08/2002
* @access public
*/
function rTrim(sTexto)
{
   //Object Objeto do tipo String para receber o texto a ser verificado
   var objString
   //Integer Contador
   var intCont
   //String Texto sem espa?os em branco ? direita
   var strTextoSemEspacos

   strTextoSemEspacos = ""
   objString = new String(strTexto);
   for (intCont=objString.length -1; intCont >= 0; intCont--) 
   {
      if (objString.charAt(intCont) != " ")
      {
	 strTextoSemEspacos = objString.substring(0, intCont +1);
         return strTextoSemEspacos;
      }
   }  
   return strTextoSemEspacos;
}

/*
* Faz com que um campo presente em uma p?gina HTMl fique com o foco
* @param Object objCampo campo presente em uma p?gina HTML que deve ter o foco.
*
* @author Cristiano Falinacio Barbosa
* @since 14/08/2002
* @access public
*/
function setFocus(objCampo)
{
   var objString
   //Verifica se os valores passados para os par?metros da fun??o s?o v?lidos
   if (typeof(objCampo) != "object")
   {
      alert("Erro na chamada da fun?ao SetFocus." +
            " O tipo do valor passado para o par?metro objCampo n?o ? o esperado." +
            " Deve ser um campo de uma p?gina HTML, ou seja, um objeto");
      return false;
   }
   objString = new String(objCampo.tagName);
   objString = objString.toUpperCase();
   if (objString == "INPUT")
   {
      objString = new String(objCampo.type);
      objString = objString.toUpperCase();
 	  if ((objString != "HIDDEN") && (!objCampo.disabled))
      {
      		try
      		{
      			objCampo.focus();
      		}
      		catch(e)
      		{      		
      		}
      }
   }
   return true;
}

/*
* Verifica se o valor de um campo de uma página HTML é um valor numérico
* @param Object Campo presente em uma p?gina HTML cujo valor deve ser verificado. 
*             Se o valor do campo n?o for um n?mero, o campo permanecer? com o foco.
*
* @param Boolean Indica se o valor a ser verificado pode conter o caracter v?rgula
*                Par?metro Opcional.
* @param Boolean Indica se o valor a ser verificado pode conter o caracter ponto
*                Par?metro Opcional.
* @param String Mensagem a ser exibida se o valor do campo n?o for um n?mero.
*               Par?metro Opcional.
* @author Flávia Hozana Pereira de Miranda
* @since 27/08/2002
* @access public
*
* @return Boolean Retorna True se o valor do campo presente na p?gina HTML for um n?mero 
*                 e false caso contr?rio
*/
function verificarNumero(objCampo, bPodeConterVirgula, bPodeConterPonto, sMensagem)
{
   //Verifica se os valores passados para os par?metros da fun??o s?o v?lidos
    if (typeof(objCampo) != "object")
    {
        return true;
    }	
   
   /*if (typeof(objCampo) != "object")
   {
      alert("Aqui..Erro na chamada da fun?ao ValorNumerico." +
            " O tipo do valor passado para o par?metro objCampo n?o ? o esperado." +
            " Deve ser um campo de uma p?gina HTML, ou seja, um objeto")
      return false;
   }*/
   if (typeof(bPodeConterVirgula) == "undefined")
      bPodeConterVirgula = true;
   if (typeof(bPodeConterPonto) == "undefined")
      bPodeConterPonto = true;
   if (typeof(bPodeConterVirgula) != "boolean")
   {
      alert("Erro na chamada da fun?ao ValorNumerico." +
            " O tipo do valor passado para o par?metro bPodeConterVirgula n?o ? o esperado." +
            " Deve ser true ou false.");
      return false;
   }      
   if (typeof(bPodeConterPonto) != "boolean")
   {
      alert("Erro na chamada da fun?ao ValorNumerico." +
            " O tipo do valor passado para o par?metro bPodeConterPonto n?o ? o esperado." +
            " Deve ser true ou false.")
      return false;
   }      
   if (!verificarDecimal(objCampo.value,bPodeConterVirgula,bPodeConterPonto))   
   {
      if (trim(sMensagem) == "" || typeof(sMensagem) == "undefined")
      {
         sMensagem = "O valor informado para o campo " + objCampo.dataFld + 
                     " não é um valor numérico.";
      }
      alert(sMensagem);
      objCampo.focus();
      return false;
   }
   return true;
}

/*
* Verirfica se o valor passado e numerico ou nao
* @param Object objCampo campo presente em uma p?gina HTML que deve ter o foco.
*
* @author Flávia Hozana Pereira de Miranda
* @since 27/08/2002
* @access public
*/
function verificarDecimal(strNumero, bolPodeConterVirgula, bolPodeConterPonto)
{
   //Cont?m o caracter v?rgula
   var strVirgula
   //Cont?m o caracter strPonto
   var strPonto
   //Contador
   var iCont
   //Objeto do tipo String para receber o valor a ser verificado
   var objString
   //Caracter contido no valor a ser verificado
   var strCaracter
   
   strVirgula = ",";
   strPonto = ".";
   //Percorre todos os caracteres do valor do campo para verificar se o caracter pode
   //fazer parte de um n?mero
   

   objString = new String(strNumero)
   for (iCont=0; iCont < objString.length; iCont++)
   {
      strCaracter = objString.charAt(iCont);
      if (!eNumero(strCaracter))
      {
         if ((strCaracter == strVirgula && !bolPodeConterVirgula)  ||
            (strCaracter == strPonto && !bolPodeConterPonto) || 
            (strCaracter != strVirgula && strCaracter != strPonto))
         {
            return false;
         }
      }
   }
   return true;
}

/*
* Verifica se o valor de um campo de uma página HTML é uma data válida. Exibe uma mensagem
*de erro caso o valor do campo não seja uma data válida
*
* @param Object Campo presente em uma página HTML cujo valor deve ser verificado. 
*               Se o valor do campo não for uma data, o campo permanecerá com o foco.
* @param String Mensagem a ser exibida se o valor do campo não for uma data. Parâmetro Opcional
*
* @author Marcelo Jorge Vieira <metal@alucinados.com>
* @since 01/04/2003
* @access public
* @return Boolean Retorna true se o valor for uma data válida e false caso contrário
*/
function verificarData(objCampoData, sMensagemErro)
{
	return verificarData(objCampoData, sMensagemErro, false);
}

/*
* Verifica se o valor de um campo de uma página HTML é uma data válida. Exibe uma mensagem
*de erro caso o valor do campo não seja uma data válida
*
* @param Object Campo presente em uma página HTML cujo valor deve ser verificado. 
*               Se o valor do campo não for uma data, o campo permanecerá com o foco.
* @param String Mensagem a ser exibida se o valor do campo não for uma data. Parâmetro Opcional
*
* @param Boolean bol4DigitosAno Usado para definir se será usado o método de verificar o ano
*                               com 4 digitos
*
* @author Flávia Hozana Pereira de Miranda adaptada por Marcelo Jorge Vieira em 01/04/2003
* @since 27/08/2002
* @access public
*
* @return Boolean Retorna True se o valor do campo presente na página HTML for uma data e false caso contrário
*/
function verificarData(objCampo, sMensagem, bol4Digitos)
{
   //Verifica se os valores passados para os parametros da funcao sao validos
   if (typeof(objCampo) != "object")
   {
       return true;
   }
   
   /*if (typeof(objCampo) != "object")
   {
      alert("Erro na chamada da funcao ValorData." +
            " O tipo do valor passado para o parametro objCampo nao e o esperado." +
            " Deve ser um campo de uma pagina HTML, ou seja, um objeto")
      return false;
   }*/

   if (!eData(""+objCampo.value,bol4Digitos))
   {
      if (trim(sMensagem) == "" || typeof(sMensagem) == "undefined")
      {
         sMensagem = "O valor informado para o campo " + objCampo.dataFld + 
                     " não é uma data válida.";
      }
      alert(sMensagem);
      setFocus(objCampo);
      return false;
   }
   return true;
}


/**
*Susbstitui a tecla enter por tab.
*/
function substituirEnterPorTab(objEvent) 
{		   
	if (objEvent.which) 	  
	{
		if (objEvent.which==13)
		{
			objEvent.keyCode = 9;
		} 
	}
	else (objEvent.keyCode)
	{
		if (objEvent.keyCode==13)
		{
			objEvent.keyCode = 9;
		}
		
	}
}

/*
* Verifica se um valor é uma data válida
*
* @param String sData contendo o valor a verificar
*
* @author Marcelo Jorge Vieira <metal@alucinados.com>
* @since 01/04/2003
* @access public
* @return Boolean Retorna true se o valor for uma data válida e false caso contrário
*/
function eData(sValorData)
{
	return eData(sValorData,false);
}

/*
* Verifica se um valor é uma data válida
*
* @param String contendo o valor a verificar
*
* @param Boolean bol4DigitosAno Usado para definir se será usado o método de verificar o ano
*                               com 4 digitos
*
* @author Flávia Hozana Pereira de Miranda adaptada por Marcelo Jorge Vieira em 01/04/2003
* @since 27/08/2002
* @access public
*
* @return Boolean Retorna true se o valor for uma data v?lida e false caso contr?rio
*/
function eData(sData,bol4DigitosAno)
{
   //Objeto data utilizado para verificar se o valor está em um formato correto de data
   var objData;
   //Dia da Data
   var sDia;
   //M?s da Data
   var sMes;
   //Ano da Data
   var sAno;
   //Objeto do tipo String para receber a data
   var objStringData;
   
   //Detecta se é chrome 
   var  isChrome = navigator.userAgent.toLowerCase().indexOf('chrome') > -1;

   objStringData = new String(sData);
   if (objStringData.length == 0)
      return true;
   
   if(isChrome){
	   var dLocale = new  Date();
	   objData = new Date(dLocale.toLocaleDateString(sData));
   }
   else
	   objData = new Date(sData);
   if (isNaN(objData))
      return false;
   else
   {
	//O valor está no formato correto de data. Deve-se verificar se os dias e meses estão válidos
	sDia = objStringData.substring(0,2);
	sMes = objStringData.substring(3,5);

	//pegar somente datas com o ano de 4 digitos
	if (bol4DigitosAno)
	{
		if (objStringData.length == 10)
			//Recupera o ano com 4 dígitos
			sAno = objStringData.substring(6,10);
		else
			return false;
	}
	else
	{
		if (objStringData.length == 10)
			//Recupera o ano com 4 dígitos
			sAno = objStringData.substring(6,10);
		else if (objStringData.length == 8)
			//Recupera o ano com 2 dígitos
			sAno = objStringData.substring(6,8);
		else
			return false;
	}

	//Verifica se o mes e o dia são válidos
	if (sMes < 1 || sMes > 12)
		return false;
	if (sDia < 1 || sDia > 31)
		return false;

	//Verifica os meses com 30 dias
	if (sMes == 4 || sMes == 6 || sMes == 9 || sMes == 11)
	{
		if (sDia == 31)
			return false;
	}
	// fevereiro, ano bissexto
	if (sMes == 2)
	{
		if (sDia > 29)
			return false;
		if (sDia == 29 && ((sAno/4) != parseInt(sAno/4)))
			return false;
	}
   }
   return true;
}



/*
* Verifica se uma data (objDataInicial) é menor ou igual a uma outra data (objDataFinal)
*
* @param Object Objeto referente a Data Inicial
* @param Object Objeto referente a Data Final
* @param String Mensagem a ser exibida caso a data inicial seja maior que a data final
* @param Boolean Indica se a mensagem será exibida ou não
*
* @author Flávia Hozana Pereira de Miranda
* @since 27/08/2002
* @access public
*
* @return Boolean Retorna true a data inicial for menor ou igual a data final
*                 e false caso contrário
*/
function verificarDataMenorIgual(objDataInicial, objDataFinal, sMensagem, bExibirMensagem)
{
   //Verifica se os valores passados para os par?metros da fun??o s?o v?lidos
   if (typeof(objDataInicial) != "object")
   {
      alert("Erro na chamada da fun?ao DataMenor." +
            " O tipo do valor passado para o par?metro objDataInicial n?o ? o esperado." +
            " Deve ser um campo de uma p?gina HTML, ou seja, um objeto")
      return false;
   }

   if (typeof(objDataFinal) != "object")
   {
      alert("Erro na chamada da fun?ao DataMenor." +
            " O tipo do valor passado para o par?metro objDataFinal n?o ? o esperado." +
            " Deve ser um campo de uma p?gina HTML, ou seja, um objeto")
      return false;
   }

   if (typeof(bExibirMensagem) == "undefined")
      bExibirMensagem = true;

   if (typeof(bExibirMensagem) != "boolean")
   {
      alert("Erro na chamada da fun?ao DataMenorIgual." +
            " O tipo do valor passado para o par?metro bExibirMensagem n?o ? o esperado." +
            " Deve ser true ou false.");
      return false;
   }      

   if (eDataMenorIgual(objDataInicial.value,objDataFinal.value))
      return true;
   else
   {
   	if (bExibirMensagem)
      {
         if (typeof(sMensagem) == "undefined")
            alert("A data " + objDataInicial.dataFld + " deve ser menor que a data " + objDataFinal.dataFld);
         else
            alert(sMensagem);
      }
      setFocus(objDataInicial);
   }
   return false;
}
/*
* Verifica se uma data é menor ou igual a uma outra data
*
* @param String Data Inicial
* @param String Data Final
*
* @author Flávia Hozana Pereira de Miranda
* @since 27/08/2002
* @access public
*
* @return Boolean Retorna true a data inicial for menor ou igual a data final
*                 e false caso contrário
*/
function eDataMenorIgual(sDataInicial,sDataFinal)
{
   //Dia da Data
   var sDiaInicial;
   //M?s da Data
   var sMesInicial;
   //Ano da Data
   var sAnoInicial;
   //Dia da Data
   var sDiaFinal;
   //M?s da Data
   var sMesFinal;
   //Ano da Data
   var sAnoFinal;

   if (!eData(sDataInicial) || !eData(sDataFinal))
      return false;

   sDiaInicial = sDataInicial.substring(0,2);
   sMesInicial = sDataInicial.substring(3,5);
   if (sDataInicial.length > 8)
      //Recupera o ano com 4 d?gitos		
      sAnoInicial = sDataInicial.substring(6,10);
   else
      //Recupera o ano com 2 d?gitos
      sAnoInicial = sDataInicial.substring(6,8);

   sDiaFinal = sDataFinal.substring(0,2);
   sMesFinal = sDataFinal.substring(3,5);
   if (sDataFinal.length > 8)
      //Recupera o ano com 4 d?gitos		
      sAnoFinal = sDataFinal.substring(6,10);
   else
      //Recupera o ano com 2 d?gitos
      sAnoFinal = sDataFinal.substring(6,8);
   
   sDataInicial = sAnoInicial + sMesInicial + sDiaInicial;
   sDataFinal = sAnoFinal + sMesFinal + sDiaFinal;  

   if (sDataInicial <= sDataFinal)
      return true;
   return false;
}

/*
* Verifica se uma data é menor ou igual a uma outra data
*
* @param String Data Inicial
* @param String Data Final
*
* @author Flávia Hozana Pereira de Miranda
* @since 27/08/2002
* @access public
*
* @return Boolean Retorna true a data inicial for menor ou igual a data final
*                 e false caso contrário
*/
function eDataMenor(sDataInicial,sDataFinal)
{
   //Dia da Data
   var sDiaInicial;
   //M?s da Data
   var sMesInicial;
   //Ano da Data
   var sAnoInicial;
   //Dia da Data
   var sDiaFinal;
   //M?s da Data
   var sMesFinal;
   //Ano da Data
   var sAnoFinal;

   if (!eData(sDataInicial) || !eData(sDataFinal))
      return false;

   sDiaInicial = sDataInicial.substring(0,2);
   sMesInicial = sDataInicial.substring(3,5);
   if (sDataInicial.length > 8)
      //Recupera o ano com 4 d?gitos		
      sAnoInicial = sDataInicial.substring(6,10);
   else
      //Recupera o ano com 2 d?gitos
      sAnoInicial = sDataInicial.substring(6,8);

   sDiaFinal = sDataFinal.substring(0,2);
   sMesFinal = sDataFinal.substring(3,5);
   if (sDataFinal.length > 8)
      //Recupera o ano com 4 d?gitos		
      sAnoFinal = sDataFinal.substring(6,10);
   else
      //Recupera o ano com 2 d?gitos
      sAnoFinal = sDataFinal.substring(6,8);
   
   sDataInicial = sAnoInicial + sMesInicial + sDiaInicial;
   sDataFinal = sAnoFinal + sMesFinal + sDiaFinal;  

   if (sDataInicial < sDataFinal)
      return true;
   return false;
}


/*
* Funcao criada para validar email
* Recene um string contendo o email e retorna uma mensagem de erro e false caso
* o email estaje incorreto.
*/
function validarEmail (emailStr) 
{
        var emailPat=/^(.+)@(.+)$/
        var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]"
        var validChars="\[^\\s" + specialChars + "\]"
        var quotedUser="(\"[^\"]*\")"
        var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/
        var atom=validChars + '+'
        var word="(" + atom + "|" + quotedUser + ")"
        var userPat=new RegExp("^" + word + "(\\." + word + ")*$")
        var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$")

        var matchArray=emailStr.match(emailPat)

        if (matchArray==null) 
        { 
                alert("Email inválido !");
                return false;
        } 

        var user=matchArray[1] 
        var domain=matchArray[2] 
         
        if (user.match(userPat)==null) 
        { 
                // usuario invalido 
                alert("Nome do usuário inválido.");
                return false;
        } 

        var atomPat=new RegExp(atom,"g") 
        var domArr=domain.match(atomPat) 
        var len=domArr.length 
        if (domArr[domArr.length-1].length<2 || 
            domArr[domArr.length-1].length>3) 
        {          
           alert("Email inválido !! O email tem que terminar com 3 letras do domínio ou 2 letras do país.");
           return false;
        } 

        if (len<2) 
        { 
                var errStr="Está faltando o nome do servidor no email!";
                alert(errStr);
                return false;
        } 
                return true; 
}

/*
* Transforma um array do PHP para um array Javascript

* @param String contendo o valor a verificar
*
* @author Flávia Hozana Pereira de Miranda
* @since 27/08/2002
* @access public
*
* @return Array convertida (ArrString) 
*/
function transformarArray(strArray)
{
	   //Object Objeto do tipo String para receber o texto a ser verificado
	   var objString
	   //Integer Contador
	   var intCont
	   //integer Contador auxiliar
	   var intReg
	   //array Posicao do elemento procurado na string
	   var arrPosicao;
	   //string Indice do array retorno
	   var strIndice;
	   //string Valores do array retorno
	   var strValor;
	   //array Array retorno
	   var arrString;
	   
	   arrPosicao = new Array;
	   arrString = new Array;
	   intCont = 0;
	   intReg = 0;
	   
	   objString = new String(strArray);
	   
	   //Percorre a string e atribui as posições do caracter 'aspas simples' para o array arrPosicao
	   for (intCont=0; intCont<objString.length; intCont++) 
	   {
		   if (objString.charAt(intCont) == "'")
		   {
			   arrPosicao[intReg] = intCont;
			   intReg++;
		   }
	   }
	   intCont = 0;
	   /*Percorre o array onde estão as posições do caracter 'aspas simples' 
	   e preenche o array do javascript (arrString) com os valores*/
	   for (intCont=0; intCont<intReg+1; intCont=intCont+4)
	   {
		   //atribui o valor do indice para o array javascript com o valor do indice do array PHP
		   strIndice = objString.substring(arrPosicao[intCont]+1, arrPosicao[intCont+1]);
		   
		   //atribui o valor do array javascript com o valor do array PHP
		   strValor = objString.substring(arrPosicao[intCont+2], arrPosicao[intCont+3]+1);
		   
		   if (strIndice != null)
		   {
			   arrString[strIndice] = strValor;
		   }
	   }
	   return arrString;
}

/*
* Limpa os campos presentes em uma form
*
* @param Object objeto form cujos campos devem ser limpos
* @param String nomes dos campos do form que não devem ser limpos.
*               Estes nomes devem estar separados por vírgula
*
* @author Flávia Hozana Pereira de Miranda
* @since 29/08/2002
* @access public
*
*/
function limparCampos(objElementoForm, strNomesElementosManterValor)
{
   // Contador
   var iCont 
   // String tempor?ria que indica o nome de um campo da tela
   var objNomeElemento
   // Posi??o da v?rgula na string strNomesElementosManterValor que indica a separa??o entre dois
   // nomes de campos
   var iIndice
   // Arranjo contendo os nomes dos campos que n?o devem ser limpos
   var arrNomesElementos 
   // Quantidade de elementos (campos da tela) que n?o devem ser limpos
   var iQuantNomesElementos
   // Indica se um determinado elemento est? presente no arranjo arrNomesElementos
   var bNomeExiste
  	
   if (typeof(objElementoForm) != "object")
   {
      alert("Erro na chamada da função limparCampos." +
            " O tipo do valor passado para o par?metro objElementoForm n?o ? o esperado." +
            " Deve ser uma form de uma p?gina HTML, ou seja, um objeto");
      return true;
   }
   iCont = 0;
   arrNomesElementos = new Array;
   objNomeElemento = new String(strNomesElementosManterValor);
   // Pesquisa a string dada por strNomesElementosManterValor e coloca os nomes dos campos
   // em um arranjo
   do
   {
      iIndice = objNomeElemento.indexOf(',');
	  if (iIndice != -1) 
	  {
         arrNomesElementos[iCont] = objNomeElemento.substr(0,iIndice);
         objNomeElemento = new String(objNomeElemento.substr(iIndice+1));
	     iCont = iCont + 1;
	  }
	  else
	  {
	     if (objNomeElemento.length != 0)
		    arrNomesElementos[iCont] = objNomeElemento.substr(0);
		 objNomeElemento = new String("");
	  }
   }
   while (objNomeElemento.length != 0);
   iQuantNomesElementos = iCont + 1;
   // Percorre os elementos da tela e verifica se os mesmos devem ou n?o ser limpos
   for (var iCont = 0; iCont < objElementoForm.elements.length; iCont++)
   {
       bNomeExiste = verificarArranjo(objElementoForm.elements[iCont].name, arrNomesElementos,   iQuantNomesElementos)
	   // Somente limpa o campo se ele n?o foi informado para ser preservado
	   if (!bNomeExiste)
	   {
		  // Somente limpa campos do tipo text, select,
	      if ((objElementoForm.elements[iCont].type == "text") ||
		      (objElementoForm.elements[iCont].type == "hidden") ||
			  (objElementoForm.elements[iCont].type == "file") ||
		      (objElementoForm.elements[iCont].type == "textarea") ||
			  (objElementoForm.elements[iCont].type == "password"))
			  objElementoForm.elements[iCont].value = "";
		  if ((objElementoForm.elements[iCont].type == "checkbox") ||
			  (objElementoForm.elements[iCont].type == "radio"))
			  objElementoForm.elements[iCont].checked = false;
	      if ((objElementoForm.elements[iCont].type == "select-one") ||
		     (objElementoForm.elements[iCont].type == "select-multiple"))
		     objElementoForm.elements[iCont].selectedIndex = 0
	   }   
    }
   return false;
}

/*
* Verifica se um determinado nome est? em um arranjo
*
* @param String Nome a ser verificado
* @param Array Arranjo contendo os nomes
* @param Integer Quantidade de nomes presente no arranjo
*
* @author Flávia Hozana Pereira de Miranda
* @since 29/08/2002
* @access public
*
*/
function verificarArranjo(strNomePesquisado, arrNomes, intQuantNomes)
{
   // Contador
   var intCont

   for (intCont=0; intCont < intQuantNomes; intCont++)
   {
      // Encontrou o nome no arranjo
	  if (trim(arrNomes[intCont]) == trim(strNomePesquisado))
	  {
	     return true;
	  }
   }
   return false;
}

/*
* Verifica se um string está no format hh:mm:ss. Retorna true se o string estiver no formato
adequado e false caso contrário
*
* @param Object Objeto a ser verificado
* @param Boolean Indica se os segundos são obrigatórios ou não
* @param String Mensagem a ser exibida caso o campo não seja válido
* @param Boolean Indica a verificação de hora máxima
*
* @author Flávia Hozana Pereira de Miranda
* @since 08/08/2003
* @access public
*
*/
function valorHoraMinuto(objCampo, bSegundoObrigatorio, sMensagem, bVerificarHoraMaxima)
{
   var sHoraMinuto;
   var sHora;
   var sMinuto;
   var sSegundo;

   //Verifica se os valores passados para os parâmetros da função são válidos
   if (typeof(objCampo) != "object")
   {
      alert("Erro na chamada da funçao ValorHoraMinuto." +
            " O tipo do valor passado para o parâmetro objCampo não é o esperado." +
            " Deve ser um campo de uma página HTML, ou seja, um objeto")
      return false;
   }
   if (typeof(bSegundoObrigatorio) == "undefined")
      bSegundoObrigatorio = false;

   if (typeof(bVerificarHoraMaxima) == "undefined")
      bVerificarHoraMaxima = true;

   if (typeof(bSegundoObrigatorio) != "boolean")
   {
      alert("Erro na chamada da funçao ValorHoraMinuto." +
            " O tipo do valor passado para o parâmetro bSegundoObrigatorio não é o esperado." +
            " Deve ser true ou false.");
      return false;
   }      

   if (typeof(bVerificarHoraMaxima) != "boolean")
   {
      alert("Erro na chamada da funçao ValorHoraMinuto." +
            " O tipo do valor passado para o parâmetro bVerificarHoraMaxima não é o esperado." +
            " Deve ser true ou false.");
      return false;
   }      

   sHoraMinuto = objCampo.value;
   
   if (sHoraMinuto == "")
      return true;

   if (trim(sMensagem) == "" || typeof(sMensagem) == "undefined")
   {
      sMensagem = "O valor informado para o campo " + objCampo.dataFld + 
                  " não não está no formato hh:mm:ss.";
   }

   if ((sHoraMinuto.length < 5) || (sHoraMinuto.length > 8) || 
       ((sHoraMinuto.length > 5) && (sHoraMinuto.length < 8)) || 
       ((sHoraMinuto.length < 8) && bSegundoObrigatorio))
   {
      alert(sMensagem);
      setFocus(objCampo);
      return false;
   }      
   if (sHoraMinuto.substring(2,3) != ":")
   {
      alert(sMensagem);
      setFocus(objCampo);
      return false;
   }      
   sHora = sHoraMinuto.substring(0,2);
   sMinuto = sHoraMinuto.substring(3,5);
   sSegundo = "";
   if (sHoraMinuto.length > 5)
      sSegundo = sHoraMinuto.substring(6,8);

   if ((!verificarDecimal(sHora, false, false)) || (sHora > 24 && bVerificarHoraMaxima) || (!verificarDecimal(sMinuto, false, false)) || 
       (sMinuto > 60))
   {
      alert(sMensagem);
      setFocus(objCampo);
      return false;
   }      

   if (trim(sSegundo) != "")
      if ((!verificarNumero(sSegundo)) || (sSegundo > 60) || (sHoraMinuto.substring(5,6) != ":"))
      {
         alert(sMensagem);
         setFocus(objCampo);
         return false;
      }         
   return true;
}


/************************************************************
* Funcções para validação de CPF
* Ainda precisam ser traduzidas para a nomenclatura padrão
************************************************************/
function Len(str)
{  
  	return String(str).length;  
}
  
function Mid(str, start, len)  
{         
	if (start < 0 || len < 0) 
		return "";

	var iEnd, iLen = String(str).length;
	if (start + len > iLen)
		iEnd = iLen;
	else
		iEnd = start + len;

	return String(str).substring(start,iEnd);
}

function verificarCPF(CPF)
{
	//Valida argumento
	if (Len(CPF) != 11)
		return false;
	
	Repetido=true;
	for (i=1;i<=10;i++)
	{
		if (Mid(CPF,i,1)!=Mid(CPF,0,1))
			{Repetido=false;
			 break;
			}
	}
	
	if (Repetido)
		return false;
							 
	soma = 0
	for (i = 1;i<=9;i++)
		soma = soma + parseInt(Mid(CPF, i-1, 1)) * (11 - i);

	Resto = 11 - (soma - (parseInt(soma / 11) * 11));

	if (Resto == 10 || Resto == 11) 
		 Resto = 0;
				
	if (Resto != parseInt(Mid(CPF, 9, 1)))
		return false;
							
	soma = 0
	for (i = 1;i<=10;i++)
		soma = soma + parseInt(Mid(CPF, i-1, 1)) * (12 - i);
	
	Resto = 11 - (soma - (parseInt(soma / 11) * 11));

	if (Resto == 10 || Resto == 11) 
		Resto = 0;
														
	if (Resto != parseInt(Mid(CPF, 10, 1)))
		return false;
		
	return true;
}

function verificarCGC(cgc) 
{
	if (Len(cgc)== 8 && parseInt(cgc,10) > 0)
	  {a = 0;
		 J = 0;
		 d1 = 0;
		
		for (i = 0;i<7;i++)
		{a = parseInt(Mid(cgc, i, 1));
							
			if (((i+1) % 2) != 0)
				a = a * 2;					 									
															
			if (a > 9)
				J = J + parseInt(a / 10) + (a % 10);
			else
				J = J + a;								
		}
		
		d1 = ((J % 10) != 0) ? (10 - (J % 10)) : 0 ;			
		
		if (d1 == parseInt(Mid(cgc, 7, 1)))
			 return true;
		else
			return false;
		}			
	else
	  {// if (Len(cgc) == 14 && parseInt(cgc) > 0)
		 if (Len(cgc) == 14  && parseInt(cgc,10) > 0)
		{a = 0;
			i = 0;
			d1 = 0;
			d2 = 0;
			J = 5;
			
			for (i = 0;i<12;i++)
			 {a = a + (parseInt(Mid(cgc, i, 1)) * J);
				 J = (J > 2) ? (J - 1) : 9 ;
			  }
							
			a = a % 11;
			d1 = (a > 1) ? (11 - a) : 0 ;
			a = 0;
			i = 0;
			J = 6;
			
			for (i = 0;i<13;i++)
				{a = a + (parseInt(Mid(cgc, i, 1)) * J);
				 J = (J > 2) ? (J - 1) : 9;
				}				
			
			a = a % 11;
			d2 = (a > 1) ? (11 - a): 0;
			
			if (d1 == parseInt(Mid(cgc, 12, 1)) && d2 == parseInt(Mid(cgc, 13, 1)))
				return true;
			else
				return false;
		}	
	    else
			return false;		
	}
}

/*
* Remove o indice selecionado
*/
function removerValorCombo(objCombo) 
{	
	for (t=0; t<objCombo.length; t++)
	{
		if (objCombo[t].selected)
		{
			intIndice = t;
			objCombo[t] = null;
			t--;
			if (intIndice==objCombo.length) {
				intIndice--;
			}			
		}
	}
	objCombo.selectedIndex = intIndice;
}

/*
* Limpa todo os valores nao nulos do combo (ignorando o selecione e a linha tracejada)
*/
function limparValoresComboNaoNulos(objCombo)
{
	limparValoresCombo(objCombo,false);
}


/*
* Limpa todos os valores do combo
* bolNulos true indica que os elementos nulos devem ser ignorados 
*/
function limparValoresCombo(objCombo,bolIgnoraNulos)
{
	for (h=0; h<objCombo.length; h++)
	{	
		if (objCombo[h].value!="" | bolIgnoraNulos)
		{
			objCombo[h] = null;
			h--;
		}
	}
}

function limparTabela(objTabela,intPosicaoInicial)
{
	if (!intPosicaoInicial)
	{
		intPosicaoInicial = 0;
	}
	
	for (x=objTabela.rows.length-1; x>=intPosicaoInicial; x--)
	{
		objTabela.deleteRow(x);		
	}
}


/************ Funcoes para controlar exibicao de elementos ****************************/

//verifica se é a bosta do IE
var IE = document.all?true:false

function versaoBrowser()
{
var nVer = navigator.appVersion;
var nAgt = navigator.userAgent;
var browserName  = navigator.appName;
var fullVersion  = ''+parseFloat(navigator.appVersion); 
var majorVersion = parseInt(navigator.appVersion,10);
var nameOffset,verOffset,ix;

// In MSIE, the true version is after "MSIE" in userAgent
if ((verOffset=nAgt.indexOf("MSIE"))!=-1) {
 browserName = "Microsoft Internet Explorer";
 fullVersion = nAgt.substring(verOffset+5);
}
// In Opera, the true version is after "Opera" 
else if ((verOffset=nAgt.indexOf("Opera"))!=-1) {
 browserName = "Opera";
 fullVersion = nAgt.substring(verOffset+6);
}
// In Chrome, the true version is after "Chrome" 
else if ((verOffset=nAgt.indexOf("Chrome"))!=-1) {
 browserName = "Chrome";
 fullVersion = nAgt.substring(verOffset+7);
}
// In Safari, the true version is after "Safari" 
else if ((verOffset=nAgt.indexOf("Safari"))!=-1) {
 browserName = "Safari";
 fullVersion = nAgt.substring(verOffset+7);
}
// In Firefox, the true version is after "Firefox" 
else if ((verOffset=nAgt.indexOf("Firefox"))!=-1) {
 browserName = "Firefox";
 fullVersion = nAgt.substring(verOffset+8);
}
// In most other browsers, "name/version" is at the end of userAgent 
else if ( (nameOffset=nAgt.lastIndexOf(' ')+1) < (verOffset=nAgt.lastIndexOf('/')) ) 
{
 browserName = nAgt.substring(nameOffset,verOffset);
 fullVersion = nAgt.substring(verOffset+1);
 if (browserName.toLowerCase()==browserName.toUpperCase()) {
  browserName = navigator.appName;
 }
}
// trim the fullVersion string at semicolon/space if present
if ((ix=fullVersion.indexOf(";"))!=-1) fullVersion=fullVersion.substring(0,ix);
if ((ix=fullVersion.indexOf(" "))!=-1) fullVersion=fullVersion.substring(0,ix);

majorVersion = parseInt(''+fullVersion,10);
if (isNaN(majorVersion)) {
 fullVersion  = ''+parseFloat(navigator.appVersion); 
 majorVersion = parseInt(navigator.appVersion,10);
}

/*
document.write('Browser name  = '+browserName+'<br>');
document.write('Full version  = '+fullVersion+'<br>');
document.write('Major version = '++'<br>');
document.write('navigator.appName = '+navigator.appName+'<br>');
document.write('navigator.userAgent = '+navigator.userAgent+'<br>');
*/

return majorVersion;
}


//força ignorar regra ie
var bolForcarIgnoraRegra = false

//exibe um elemento
function exibirElemento(objElemento,strTipoElemento)
{
//	alert('mostres: '+objElemento.id);
//	alert(bolForcarIgnoraRegra+' e '+IE);
	objElemento.style.visibility = 'visible';
//	objElemento.style.position = 'relative';
	
	if (IE & bolForcarIgnoraRegra!=true)
	{
		objElemento.style.height = '100%';
	}
	if (strTipoElemento)
	{
		objElemento.style.display = strTipoElemento;
	}
	else
	{
		objElemento.style.display = 'block';
	}	
}

//esconde um elemento
function esconderElemento(objElemento)
{
//	objElemento.style.visibility = 'hidden';
//	objElemento.style.position = 'absolute';
	objElemento.style.display = 'none';
}

function mudarVisibilidadeElemento(objElemento)
{
	if (objElemento)
	{
		if (objElemento.style.visibility=='hidden' | objElemento.style.display=='none')
		{
			exibirElemento(objElemento);
		}
		else
		{
			esconderElemento(objElemento);
		}
	}
}


/***********************************************************************************/

/**
* Metodo para recuperar todos os campos do formulario retornando um array
*
* @since 14/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @param objForm - formulario da tela
* @return - array de parametros - arrParametro[nomedoelementonoform] = valor
* @access public
*/
function recuperarCamposForm(objForm,bolString)
{
	arrParametros = new Array();
	for(i=0; i<objForm.length;i++)
	{
		tipo = objForm[i].type;
		if(tipo=='select' || tipo=='select-one')
		{						
			strValor = objForm[i].value;
		}
		else
		{			
			if (!bolString)
			{
				strValor = trocarTodos(objForm[i].value,"'","");
				strValor = trocarTodos(strValor,'"',"");
			}
			else
			{
				strValor = objForm[i].value;
			}
		}
		if(tipo=='checkbox' || tipo=='radio')
		{
			if(objForm[i].checked)
			{	
				if(objForm[i].name)
					arrParametros[objForm[i].name] = strValor;
				if(objForm[i].id)
					arrParametros[objForm[i].id] =strValor;	
			}
		}
		else if(tipo=='select-multiple')
		{		
			var intPosicao = 0;
			var strNome = '';
			if(objForm[i].name)
				strNome = objForm[i].name;
			else if(objForm[i].id)
				strNome = objForm[i].id;				
			arrParametros[strNome] = new Array();
			for(var intI=0;intI<objForm[i].options.length;intI++)
			{
				if(objForm[i].options[intI].selected && objForm[i].options[intI].value)
				{
					arrParametros[strNome][intPosicao] = objForm[i].options[intI].value;
					intPosicao++;
				}
			}			
		}
		else if(tipo!='img' || tipo!='image' || tipo != 'button' || tipo!='submit')
		{			
			if(objForm[i].name)
				arrParametros[objForm[i].name] = strValor;
			else
			if(objForm[i].id)
				arrParametros[objForm[i].id] = strValor;
		}
	}
	
	if (bolString)
	{
		strRetornoElementos = '';
		for (var item in arrParametros)
		{
			strRetornoElementos += ''+item+'='+arrParametros[item]+'&';
		}
		strRetornoElementos = retiraEnter(strRetornoElementos);
		strRetornoElementos = strRetornoElementos.replace("  ","");
		strRetornoElementos = strRetornoElementos.replace(" ","");
		strRetornoElementos = trim(strRetornoElementos);
		return strRetornoElementos;
	}
	return arrParametros;
}


function findPosX(obj)
{
	var curleft = 0;
	if (obj.offsetParent)
	{
		while (obj.offsetParent)
		{
			curleft += obj.offsetLeft
			obj = obj.offsetParent;
		}
	}
	else if (obj.x)
		curleft += obj.x;
	return curleft;
}

function findPosY(obj)
{
	var curtop = 0;
	if (obj.offsetParent)
	{
		while (obj.offsetParent)
		{
			curtop += obj.offsetTop
			obj = obj.offsetParent;
		}
	}
	else if (obj.y)
		curtop += obj.y;
	return curtop;
}


//mostra um elemento como destaque na tela
function exibirElementoDestaque(objElemento,objForm)
{	
	//verifica se eh o objeto ou seu id
	var strTipoElemento = typeof objElemento; 
	if (strTipoElemento=='string') objElemento = $(objElemento);
	
	//exibe elemento - verfificar se eh div?
	objElemento.style.display = 'block';
	
	if($('divBloqueio'))
	{
		$('divBloqueio').style.display = 'block';
	}
	else
	{
		var objDivBloqueio = criaDiv('divBloqueio', 'bloqueiaTela', '', true );
		document.body.appendChild(objDivBloqueio);	
	}
	
	if (!IE)
	{
		$('divBloqueio').style.height = document.body.offsetHeight;
	}
	else
	{
		arrTamanho = getPageSize();
		$('divBloqueio').style.height = arrTamanho[1];
		//$('divBloqueio').style.height = document.body.clientHeight+document.body.scrollTop;
	}
	$('divBloqueio').style.width = document.body.clientWidth+document.body.scrollLeft;
	
	//esconde os combos
	alterarCombosParaSpan(objForm,'texto');	
	
	//centarliza o elemento
	centralizarObjeto(objElemento);
	
	// habilitando elementos combos que estado na janela
	habilitarElementosCombo(objElemento);	
}

//esconde elemento destaque da tela
function esconderElementoDestaque(objElemento,objForm)
{	
	objElemento.style.display = 'none';
	$('divBloqueio').style.display = 'none';
	
	//mostra devolta os combos
	alteraSpanParaCombo(objForm);
}

//centraliza o objeto na tela
function centralizarObjeto(objElemento)
{
	var intWidthElemento = objElemento.offsetWidth;
	if (intWidthElemento==0)
	{
		intWidthElemento = trocarTodos(objElemento.style.width,'px','');
	}
	
	//pega tamanho da tela do browser (janela)
	if (IE)
	{
		intTamanhoTelaHeight = document.documentElement.clientHeight;
		intTamanhoTelaWidth = document.documentElement.clientWidth;
		
		if (intTamanhoTelaWidth==0)
		{
			intTamanhoTelaHeight = document.body.clientHeight;
			intTamanhoTelaWidth = document.body.clientWidth;
		}
	}
	else
	{
		intTamanhoTelaWidth = window.innerWidth;
		intTamanhoTelaHeight = window.innerHeight;
	}	
	
//	alert('janela '+document.body.clientHeight+' e Scrroll: '+document.body.scrollTop+' elemento: '+objElemento.offsetHeight);
//	alert(objElemento.style.top);	
//	alert((document.body.clientHeight+document.body.scrollTop)-(document.body.clientHeight/2)-(objElemento.offsetHeight/2));

	//topo nao pode ser 0 nunca
    //quando o arquivo é xhtml o document.body.scrollTop nao funciona (é sempre zero)
    var intScrollTop = window.pageYOffset ||
                       document.body.scrollTop ||
                       document.documentElement.scrollTop;
    intTopElemento = (intTamanhoTelaHeight+intScrollTop)-(intTamanhoTelaHeight/2)-(objElemento.offsetHeight/2);

	if (intTopElemento<0) intTopElemento = '0';
	
	objElemento.style.top = intTopElemento+'px';
	objElemento.style.left = (intTamanhoTelaWidth+document.body.scrollLeft)-(intTamanhoTelaWidth/2)-(intWidthElemento/2)+'px';
}

/*
* Recebe o nome de um campo e um valor e procura no combo passado este valor e o marca
*/
function selecionarItemComboPorValor(objCombo, strNomeCampo, mixValorCampo)
{	
	objCombo.selectedIndex = recuperarIndiceCombo(objCombo, strNomeCampo, mixValorCampo);
}

function recuperarValorIndiceArrayCombo(objCombo, strNomeCampo)
{
	strValor = objCombo[objCombo.selectedIndex].value;
	if (strValor!="")
	{
		return recuperarItemArrayPhp(strNomeCampo,strValor);
	}
	return "";
}

function recuperarIndiceCombo(objCombo, strNomeCampo, mixValorCampo)
{
	//Array Valores associados ao elemento selecionado do combo
	var arrCamposCombo;
		
	//Verifica se o campo é um objeto JavaScript
	if (!objCombo.type == Object)
	{
		alert ('Tipo do campo inválido');
		return null;
	}
	
	//Encontra o valor associado correspondente ao parâmetro selecionado
	for (intI=0; intI < objCombo.length; intI++)
	{
		arrCamposCombo = converterArrayPhpJs(objCombo[intI].value);
		//alert(arrCamposCombo[strNomeCampo]+' e '+strNomeCampo);
		if (arrCamposCombo != null && arrCamposCombo[strNomeCampo]!=undefined && mixValorCampo!=undefined)
		{			
			//DEBUG >> alert(objCombo[intI].value+" E "+mixValorCampo);			
			if (trim(arrCamposCombo[strNomeCampo]) == trim(mixValorCampo))
			{
				//alert('achei: '+intI);
				return intI;
			}
		}
	}
	return null;
}

/*
* verifica se o needle existe no array haystack
* apenas para arrays numericos
*/
function in_array(needle, haystack) {
	var n = haystack.length;
	for (var i=0; i<n; i++) {
		if (haystack[i]==needle) {
			return true;
		}
	}
	return false;
}

/* copia os itens de um combo para outro */
function copiarItensCombo(objCampoOrigem,objCampoDestino)
{
	//limpa combo
	limparValoresCombo(objCampoDestino,true);
	
	for (x=0; x<objCampoOrigem.length; x++)
	{
		objCampoDestino[objCampoDestino.length] = new Option(objCampoOrigem[x].text,objCampoOrigem[x].value);
	}
}

/*************** FUNCOES PARA RETORNAR POSICAO DO MOUSE NA TELA ***********/
/*
* busca e retorna a posicao do mouse
*/
function mouseCoords(ev){
	if(ev.pageX || ev.pageY){
		return {x:ev.pageX, y:ev.pageY};
	}
	return {
		x:ev.clientX + document.body.scrollLeft - document.body.clientLeft,
		y:ev.clientY + document.body.scrollTop  - document.body.clientTop
	};
} 

function getMouseOffset(target, ev){
	ev = ev || window.event;

	var docPos    = getPosition(target);
	var mousePos  = mouseCoords(ev);
	return {x:mousePos.x - docPos.x, y:mousePos.y - docPos.y};
}

/*
* busca a posicao atual do elemento (x e y)
*/
function getPosition(e){
	var left = 0;
	var top  = 0;

	while (e.offsetParent){
		left += e.offsetLeft;
		top  += e.offsetTop;
		e     = e.offsetParent;
	}

	left += e.offsetLeft;
	top  += e.offsetTop;

	return {x:left, y:top};
}

/***********************************************************************/
/**
* Valida hora no formato hh:mm
*/
function validarHora(strHora,bolExibirMensagem)
{
        var objHorarioPat=new RegExp("[0-2]?[0-9]:[0-9][0-9]");
        

        var matchArray = strHora.match(objHorarioPat)
        if (matchArray==null) 
        { 
                if (bolExibirMensagem)
		{
			alert("O hor"+String.fromCharCode(225)+"rio n"+String.fromCharCode(227)+"o est"+String.fromCharCode(225)+" no formato hh:mm");
		}
                return false;
        } 
	
	var arrHorario = strHora.split(":");
	var intHora = parseInt(arrHorario[0]);
	var intMinuto = parseInt(arrHorario[1]);
	//verifica a hora
	if(intHora < 0 || intHora > 24)
	{
                if (bolExibirMensagem)
		{
			alert("Erro! Hora inv"+String.fromCharCode(225)+"lida");
		}
		return false;
	}
	//verifica o minuto
	if(intMinuto < 0 || intMinuto > 59)
	{
                if (bolExibirMensagem)
		{
			alert("Erro! Minuto inv"+String.fromCharCode(225)+"lido");
		}
		return false;
	}
	return true;

}
function verificarHoraMenorIgual(objHoraInicial, objHoraFinal, sMensagem, bExibirMensagem,bolLiberarHoraIgual)
{
	// verificando mensagem
	if(sMensagem==undefined)
	{
		sMensagem = '';
		bExibirMensagem = false;
	}
	if(bolLiberarHoraIgual==undefined)
	{
		bolLiberarHoraIgual = true;
	}
	
	// verificando exibir mensagem
	if(bExibirMensagem==undefined)
	{
		bExibirMensagem = false;
	}
	
	var objDateInicio = new Date();
	var objDateFim = new Date();
								
	// recuperando hora
	var strHorInicio = objHoraInicial.value;
	var strHorFim = objHoraFinal.value;
	var arrHoraInicio = strHorInicio.split(":");
	var arrHorFim = strHorFim.split(":");
	
	// data inicial
	if(arrHoraInicio.length == 3)
	{
		objDateInicio.setHours(arrHoraInicio[0],arrHoraInicio[1],arrHoraInicio[2],0);
	}
	else
	{
		objDateInicio.setHours(arrHoraInicio[0],arrHoraInicio[1],0,0);
	}

	// data final
	if(arrHorFim.length == 3)
	{
		objDateFim.setHours(arrHorFim[0],arrHorFim[1],arrHorFim[2],0);
	}
	else
	{
		objDateFim.setHours(arrHorFim[0],arrHorFim[1],0,0);
	}
	
	// retornado situacao das datas	
	if(objDateInicio.getTime()>objDateFim.getTime())
	{
		if(bExibirMensagem)
		{
			alert(sMensagem);
		}
		setFocus(objHoraInicial);
		return false;
	}
	else if(objDateInicio.getTime()==objDateFim.getTime() && !bolLiberarHoraIgual)
	{
		if(bExibirMensagem)
		{
			alert(sMensagem);
		}
		setFocus(objHoraInicial);
		return false;
	}
	else
	{
		return true;
	}
} 
function verificarStringHoraIgual(strHorInicio, strHorFim)
{
	var objDateInicio = new Date();
	var objDateFim = new Date();
	var arrHoraInicio = strHorInicio.split(":");
	var arrHorFim = strHorFim.split(":");
	
	// data inicial
	if(arrHoraInicio.length == 3)
	{
		objDateInicio.setHours(arrHoraInicio[0],arrHoraInicio[1],arrHoraInicio[2],0);
	}
	else
	{
		objDateInicio.setHours(arrHoraInicio[0],arrHoraInicio[1],0,0);
	}

	// data final
	if(arrHorFim.length == 3)
	{
		objDateFim.setHours(arrHorFim[0],arrHorFim[1],arrHorFim[2],0);
	}
	else
	{
		objDateFim.setHours(arrHorFim[0],arrHorFim[1],0,0);
	}
	
	// retornado situacao das datas
	return	objDateInicio.getTime() == objDateFim.getTime();
	
}
function verificarStringHoraMenorIgual(strHorInicio, strHorFim,bolLiberarHoraIgual)
{
	var objDateInicio = new Date();
	var objDateFim = new Date();
	var arrHoraInicio = strHorInicio.split(":");
	var arrHorFim = strHorFim.split(":");
	
	// data inicial
	if(arrHoraInicio.length == 3)
	{
		objDateInicio.setHours(arrHoraInicio[0],arrHoraInicio[1],arrHoraInicio[2],0);
	}
	else
	{
		objDateInicio.setHours(arrHoraInicio[0],arrHoraInicio[1],0,0);
	}

	// data final
	if(arrHorFim.length == 3)
	{
		objDateFim.setHours(arrHorFim[0],arrHorFim[1],arrHorFim[2],0);
	}
	else
	{
		objDateFim.setHours(arrHorFim[0],arrHorFim[1],0,0);
	}
	
	// retornado situacao das datas	
	if(objDateInicio.getTime()>objDateFim.getTime())
	{
		return false;
	}
	else if(objDateInicio.getTime()==objDateFim.getTime() && !bolLiberarHoraIgual)
	{
		return false;
	}
	else
	{
		return true;
	}
}
/*
Verifica se há choque entre o dois horarios 
*/
function verificaChoqueHorario(strHoraInicio1,strHoraFim1,strHoraInicio2,strHoraFim2)
{
	//se o horario inicio 2 esta entre a data inicio 1 e a data fim 1
	if(verificarStringHoraMenorIgual(strHoraInicio1, strHoraInicio2,false)
	   && verificarStringHoraMenorIgual(strHoraInicio2, strHoraFim1,false) )
	{
		return true;
	}
	//se o horario fim 2 esta entre a data inicio 1 e a data fim 1
	if(verificarStringHoraMenorIgual(strHoraInicio1, strHoraFim2,false)
	   && verificarStringHoraMenorIgual(strHoraFim2 , strHoraFim1, false) )
	{
		return true;
	}
	//se o horario fim 2 esta entre a data inicio 1 e a data fim 1
	if(verificarStringHoraMenorIgual(strHoraInicio2, strHoraFim1,false)
	   && verificarStringHoraMenorIgual(strHoraFim1 , strHoraFim2, false) )
	{
		return true;
	}
	//se a hora fim e inicio de ambos forem iguais
	if(verificarStringHoraIgual(strHoraInicio1, strHoraInicio2) &&  
		verificarStringHoraIgual(strHoraFim1, strHoraFim2)
	)
	{
		return true;
	}
	return false;
}
/*
Verifica se há choque entre o duas datas
*/
function verificaChoqueData(strDataInicio1,strDataFim1,strDataInicio2,strDataFim2)
{
	//se o horario inicio 2 esta entre a data inicio 1 e a data fim 1
	if(eDataMenorIgual(strDataInicio1, strDataInicio2)
	   && eDataMenorIgual(strDataInicio2, strDataFim1) 
	   && (strDataInicio1 != strDataInicio2) && (strDataInicio2 != strDataFim1)
	   )
	{
		return true;
	}
	//se o horario fim 2 esta entre a data inicio 1 e a data fim 1
	if(eDataMenorIgual(strDataInicio1, strDataFim2,false)
	   && eDataMenorIgual(strDataFim2 , strDataFim1, false) 
	   && (strDataInicio1 != strDataFim2) && (strDataFim2 != strDataFim1)
	)
	{
		return true;
	}
	//se o horario fim 2 esta entre a data inicio 1 e a data fim 1
	if(eDataMenorIgual(strDataInicio2, strDataFim1)
	   && eDataMenorIgual(strDataFim1 , strDataFim2) 
	  && (strDataInicio2 != strDataFim1) && (strDataFim1 != strDataFim2)
	)
	{
		return true;
	}
	//se a hora fim e inicio de ambos forem iguais
	if((strDataInicio1 == strDataInicio2) 
           && (strDataFim1 == strDataFim2)
	)
	{
		return true;
	}
	return false;
}

/*
calcula a quantidade de horas a partir de um horario inicio ate o fim
*/
function calculaQtdHoras(strHorInicio,strHorFim)
{
	var objDateInicio = new Date();
	var objDateFim = new Date();
	var arrHoraInicio = strHorInicio.split(":");
	var arrHorFim = strHorFim.split(":");
	
	// data inicial
	if(arrHoraInicio.length == 3)
	{
		objDateInicio.setHours(arrHoraInicio[0],arrHoraInicio[1],arrHoraInicio[2],0);
	}
	else
	{
		objDateInicio.setHours(arrHoraInicio[0],arrHoraInicio[1],0,0);
	}

	// data final
	if(arrHorFim.length == 3)
	{
		objDateFim.setHours(arrHorFim[0],arrHorFim[1],arrHorFim[2],0);
	}
	else
	{
		objDateFim.setHours(arrHorFim[0],arrHorFim[1],0,0);
	}
	
	// retornado a subtracao das duas datas (converte de milisegundos para hora)
	return (objDateFim.getTime() - objDateInicio.getTime())/3600000;

}
function retornaLenghtComboComValue(objCombo)
{
	var cont = 0;
	
	for (var g=0; g<objCombo.length; g++)
	{
		strValorItemCombo = objCombo[g].value;
		if (strValorItemCombo.length>0)
		{
			cont++;
		}
	}
	return cont;
}

function selecionarUnicoItemCombo(objCombo)
{
	if (retornaLenghtComboComValue(objCombo)==1)
	{
		for (var g=0; g<objCombo.length; g++)
		{
			strValorItemCombo = objCombo[g].value;
			if (strValorItemCombo.length>0)
			{
				objCombo.selectedIndex = g;
				return true;
			}
		}
	}
}

/**
* Metodo criar div 
*
* @since 30/08/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
function criaHtmlDiv(strId, strClasse, strConteudo, arrEventos)
{
	// conteudo do div
	var strDiv = "<div id='"+strId+"' class='"+strClasse+"' ";
	for(var strEvento in arrEventos)
	{
		strDiv += strEvento+"='"+arrEventos[strEvento]+"' ";
	}
	strDiv +=">"+strConteudo+"</div>";
	return strDiv;
}


/**
* Metodo criar div 
*
* @since 30/08/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
function criaDiv(strId,strClasse,objElemento,bolTexto)
{
	if(bolTexto==undefined)
	{
		bolTexto = false;
	}
	var objDiv = document.createElement('div');
	objDiv.id = strId;
	objDiv.className = strClasse;
	if(bolTexto)
	{
		objDiv.innerHTML = objElemento;
	}
	else
	{
		objDiv.appendChild(objElemento);
	}
	return objDiv;
}

/**
* Metodo criar img 
*
* @since 30/08/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
function criaImagem(strId, strClasse, strCaminhoImagem,strFuncaoClick)
{
	var objImg = document.createElement('img');
	objImg.id = strId;
	objImg.className = strClasse;
	objImg.src = strCaminhoImagem;		
	objImg.onclick = function(e)
	{
		if(IE)
		{
			e = event;
		}				
		eval(strFuncaoClick);	
	}
	return objImg;
}

function criaData(strData,strHora)
{
	// criando data
	var objData = new Date();
	
	// atribuindo data
	if(strData!='' && strData!=null)
	{
		var arrData = strData.split('/');
		if(arrData[1][0]==0)
			arrData[1] = arrData[1][1];
		objData.setFullYear(arrData[2],parseInt(arrData[1])-1,arrData[0]);
	}
	// atribuindo hora
	if(strHora!='' && strHora!=null)
	{
		var arrHora = strHora.split(':');
		if(arrHora.length == 3)
		{
			objData.setHours(arrHora[0],arrHora[1],arrHora[2],0);
		}
		else
		{
			objData.setHours(arrHora[0],arrHora[1],0,0);
		}
	}
	return objData;	
}

/**
* Metodo para validar um cnpj
* retirado do site: http://www.htmlstaff.org/ver.php?id=5036
* disponivel em: 02/04/2007
* @since 02/04/2007
* @author Daniel Hasan dalip
* @access public
*/
function validaCnpj(cnpj)
      {
	      //eliminar todos os ".","/" e "-"
	      cnpj=trocarTodos(cnpj,".","");
	      cnpj=trocarTodos(cnpj,"/","");
	      cnpj=trocarTodos(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;
      }
      /*
      *Converte um valor de ponto flutuante para o formato de moeda
      * intValor: Valor a ser convertido
      * strSglMoeda: sigla da moeda (R$)
      * strSeparador: separador (. ou ,) 
	* @since 23/04/2007
	* @author Daniel Hasan dalip
	* @access public
      */
function valorToMoeda(intValor, strSglMoeda, strSeparador)
{
	//lado esquerdo e direito da virgula
	var intLadoEsquerdo;
	var intLadoDireito;
	var intPosSeparador;
	intPosSeparador=(""+intValor).indexOf(".");
	if(intPosSeparador<0)
	{
		intPosSeparador=(""+intValor).length;
	}
	
	//resgata o lado esquerdo
	intLadoEsquerdo=(""+intValor).substring(0,intPosSeparador);
	
	
	//resgata o lado direito
	intLadoDireito=(""+intValor).substring(intPosSeparador+1);
	
	//completar com zeros a direita ate o intLadoDireito tiver 2 caracteres
	while(intLadoDireito.length<2)
	{
		intLadoDireito+="0";
	}

	return strSglMoeda+" "+intLadoEsquerdo+strSeparador+intLadoDireito;
	
}

function cloneObject(objeto,bolCompleto) {
  if(objeto == null)
  {
	  return null;
  }
  var objectClone = new objeto.constructor();
  for (var property in objeto)
    if (!bolCompleto)
      objectClone[property] = objeto[property];
    else if (typeof objeto[property] == 'object')
      objectClone[property] = cloneObject(objeto[property],bolCompleto);
    else
      objectClone[property] = objeto[property];
  return objectClone;
}

function preencherData(strData,idElemento)
{
	var objData = document.getElementById(idElemento);
	objData.value = strData;
	var objDiv = document.getElementById('divConteinerCalendario_'+idElemento);
	
	objDiv.style.visibility = 'hidden';
}
function exibirCalendarioData(strData,idElementoData)
{
	
	// criando conteiner do calendario
	var objDiv = document.getElementById('divConteinerCalendario_'+idElementoData);
	if(!objDiv)
	{      
	      objDiv = document.createElement("div");
	      objDiv.id="divConteinerCalendario_"+idElementoData;
	      objDiv.className="divCalendario";  
	      document.body.appendChild(objDiv);
	     
	      // criando calendario
	      var objCalendario = new Calendario("calDataNasc", "agenda",new Array());
	      objCalendario.setEventoClick(true,"preencherData", '', idElementoData);
	
	     var objData = document.getElementById(idElementoData);
	     strData = objData.value;
	     if(strData=="" || !eData(strData) )  
	      {
		   strData =  objCalendario.dateToStr(new Date());	
	      }
	      var objReferencia = getPosition(objData);
	      // posicionando elemento
	     objDiv.style.top = objReferencia.y+objData.offsetHeight + 10+'px';
	     objDiv.style.left = objReferencia.x+'px';
	     objCalendario.geraCalendario('divConteinerCalendario_'+idElementoData,strData,true);
	}
	else
	{		
		objDiv.style.visibility = "visible";	    	    
	}
	return objDiv;
}
function exibirCalendario(idElementoData)
{
	// criando conteiner do calendario
	var objDiv = document.getElementById('divConteinerCalendario_'+idElementoData);
	if(!objDiv)
	{      
	      objDiv = document.createElement("div");
	      objDiv.id="divConteinerCalendario_"+idElementoData;
	      objDiv.className="divCalendario";  
	      document.body.appendChild(objDiv);
	      var strData = "";
	    
	      // criando calendario
	      var objCalendario = new Calendario("calDataNasc", "agenda",new Array());
	      objCalendario.setEventoClick(true,"preencherData", '', idElementoData);
	
	     var objData = document.getElementById(idElementoData);
	     if(objData.value!="" && eData(objData.value) )  
	      {
		  strData = objData.value;	
	      }
	      else
	      {
		   strData =  objCalendario.dateToStr(new Date());	
	      }
		var objReferencia = getPosition(objData);
	      // posicionando elemento
	     objDiv.style.top = objReferencia.y+objData.offsetHeight + 10+'px';
	     objDiv.style.left = objReferencia.x+'px';
	     objCalendario.geraCalendario('divConteinerCalendario_'+idElementoData,strData,true);
	}
	else
	{
		objDiv.style.visibility = "visible";	 
	}
}
//esconde uma coluna da tabela
function escondeColuna(objTabela,intPosColuna)
{
	var intI;
	for(intI=0; intI<objTabela.rows.length ; intI++)
	{
		if(objTabela.rows[intI])
		{
			if(objTabela.rows[intI].cells[intPosColuna])
			{
				objTabela.rows[intI].cells[intPosColuna].style.display = "none";
			}
		}
	}
}
//exibe uma coluna da tabela
function exibeColuna(objTabela,intPosColuna)
{
	var intI;
	for(intI=0; intI<objTabela.rows.length ; intI++)
	{
		if(objTabela.rows[intI])
		{
			if(objTabela.rows[intI].cells[intPosColuna])
			{
				objTabela.rows[intI].cells[intPosColuna].style.display = "";
			}
		}
	}
}
/*
* Retorna true se a tecla digitada é um caracter alfabético
* 
* @since 13/11/2007
* @author Paulo Henrique Nonaka <pnonaka@unibh.br>
* @access public
*/

function keyAlfabetico(objEvento)
{
	var intTeclaCode;
	if (objEvento.keyCode) intTeclaCode = objEvento.keyCode;
	else if (objEvento.which) intTeclaCode = objEvento.which;	
	
    if (objEvento.keyCode >= 65 && objEvento.keyCode <= 90) {
        return true;
    }
}

/*
* Retorna true se a tecla digitada é um caracter numérico
* 
* @since 13/11/2007
* @author Paulo Henrique Nonaka <pnonaka@unibh.br>
* @access public
*/

function keyNumerico(objEvento)
{
	var intTeclaCode;
	if (objEvento.keyCode) intTeclaCode = objEvento.keyCode;
	else if (objEvento.which) intTeclaCode = objEvento.which;	
	
    if ((objEvento.keyCode >= 48 && objEvento.keyCode <= 57) || (objEvento.keyCode >= 96 && objEvento.keyCode <= 105)) {
        return true;
    }
}
//altera combos para span (ideal para evitar o prob. do ie ao tentar colocar um div em cima do combo
//retorna um array com todos os combos alterados
function alterarCombosParaSpan(objFormulario,strClasseSpan)
{
	if(objFormulario==undefined)
	{
		objFormulario = null;
	}
	
	if (objFormulario == null) {
		for(var intJ = 0; intJ< document.forms.length; intJ++)
		{
			objFormulario = document.forms[intJ];
			for (var intI = 0; intI < objFormulario.elements.length; intI++) {
				//apenas os combos que estao sendo exibidos
				if (objFormulario.elements[intI].type == "select-one" &&
				objFormulario.elements[intI].style.display != "none" &&
				objFormulario.elements[intI].parentNode.style.display != "none") {
					alteraComboParaSpan(objFormulario.elements[intI], strClasseSpan);
				}
			}			
		}	
	}
	else {
		for (var intI = 0; intI < objFormulario.elements.length; intI++) {
			//apenas os combos que estao sendo exibidos
			if (objFormulario.elements[intI].type == "select-one" &&
			objFormulario.elements[intI].style.display != "none" &&
			objFormulario.elements[intI].parentNode.style.display != "none") {
				alteraComboParaSpan(objFormulario.elements[intI], strClasseSpan);
			}
		}
	}
}
//adiciona um span com o valor(text) selecionado do combo usando o estilo que esta como parametro
//e esconde o combo (eh retornado o objeto do span)
function alteraComboParaSpan(objComboAlteraSpan, strClasseSpan,strFuncao)
{
	var objCombo = objComboAlteraSpan;
	
	var objSpan = document.getElementById("_spnValue"+objCombo.id);
	//se ele nao existe , criar 
	if(objSpan == undefined)
	{
		objSpan = document.createElement("span");
		objSpan.id = "_spnValue"+objCombo.id;
		objSpan.className = strClasseSpan;
		
		var strConteudo = '';
		//alert(objCombo.selectedIndex);
		if (objCombo.selectedIndex<0)
		{
			//alert(objCombo.id+' e '+objCombo.length);
			for (var z=0; z<objCombo.length; z++)
			{
				strConteudo += objCombo[z].text+'<BR>';
			}
			//alert(strConteudo);
		}
		else
		{
			strConteudo = objCombo.options[objCombo.selectedIndex].text;
		}
		objSpan.innerHTML= strConteudo;
		
		if (strFuncao)
		{
			objSpan.onclick = function (){eval(strFuncao+"(this);")};
		}
		
		
		//adicionar span
		objCombo.parentNode.appendChild(objSpan);
		//se a largura do pai nao foi definida, defini-la como o tamanho do combo
		objCombo.parentNode.style.width = objCombo.style.width;
	}
	//esconde combo
	objCombo.style.display = "none";
	
	//exibe span
	objSpan.style.display = "";
	return objSpan;
}
//altera de span para combo para
function alteraSpanParaCombo(objFormulario)
{
	if(objFormulario==undefined)
	{
		objFormulario = null;
	}
	if (objFormulario == null) {
		for (var intJ = 0; intJ < document.forms.length; intJ++) {
			objFormulario = document.forms[intJ];			
			for (var intI = 0; intI < objFormulario.elements.length; intI++) {
				if (objFormulario.elements[intI].type == "select-one") {
					objCombo = objFormulario.elements[intI];
					objSpan = document.getElementById("_spnValue" + objCombo.id);
					if (document.getElementById("_spnValue" + objCombo.id) != undefined) {
						objSpan.style.display = "none";
						objCombo.style.display = "";
					}
				}
			}
		}
	}
	else {
		for (var intI = 0; intI < objFormulario.elements.length; intI++) {
			if (objFormulario.elements[intI].type == "select-one") {
				objCombo = objFormulario.elements[intI];
				objSpan = document.getElementById("_spnValue" + objCombo.id);
				if (document.getElementById("_spnValue" + objCombo.id) != undefined) {
					objSpan.style.display = "none";
					objCombo.style.display = "";
				}
			}
		}
	}
}

//altera um item de span de volta para combo
function alterarItemSpanParaCombo(objCombo)
{
	objSpan = document.getElementById("_spnValue"+objCombo.id);
        if(document.getElementById("_spnValue"+objCombo.id) != undefined)
	{
		objSpan.style.display = "none";
                objCombo.style.display = "";
        }
}


/**
* Metodo para verificar se o popup esta habilitado
*/
function verificarPopupHabilitado(mensagem, bolExibirMensagem)
{
	if(bolExibirMensagem==undefined)
	{
		bolExibirMensagem = true;
	}
	var jnl = window.open("about:blank","", "resizable=no,menubar=no,toolbar=no,status=yes,scrollbars=no,width=-1,height=-1,left=0,top=0");
	var strMensagem = "Favor desabilitar seu bloqueador de popups";
	if(jnl)
 	{
		jnl.close();
 		return true;
 	}
 	else
 	{
		if(bolExibirMensagem)
		{
	 		if(mensagem != undefined)
			{
				strMensagem = strMensagem;
			}
			alert(strMensagem);
		}
		return false;
 	}
}

/**
* Metodo para retirar acentos
*/
function retiraAcentos(objText)
{
	// acentos
	var strCaracteresInvalidos = 'àèìòùâêîôûäëïöüáéíóúãõÀÈÌÒÙÂÊÎÔÛÄËÏÖÜÁÉÍÓÚÃÕ';
	var strCaracteresValidos =   'aeiouaeiouaeiouaeiouaoAEIOUAEIOUAEIOUAEIOUAO';

	// recuperando texto atual
	var strTexto = objText.value;
	var strNovoTexto = "";
	for(var intI=0;intI<strTexto.length;intI++)
	{		
		if (strCaracteresInvalidos.indexOf(strTexto.charAt(intI)) != -1)
		{
			strNovoTexto = strNovoTexto + strCaracteresValidos.charAt(strCaracteresInvalidos.indexOf(strTexto.charAt(intI)));
		}
		else
		{
			strNovoTexto = strNovoTexto + strTexto.charAt(intI);
		}
	}
	
	// atualizando campo
	objText.value = strNovoTexto;
}

function isArray(obj) {
   if (obj.constructor.toString().indexOf("Array") == -1)
      return false;
   else
      return true;
}

function retirarEspeciaisHtml(arrParametrosTrocaAjax)
{
	// convertendo informações para o padrao URI
	for(var strNome in arrParametrosTrocaAjax)
	{				
		if(arrParametrosTrocaAjax[strNome]==undefined)
		{
			arrParametrosTrocaAjax[strNome] = "";
		}
		if(isArray(arrParametrosTrocaAjax[strNome]))
		{
			arrParametrosTrocaAjax[strNome] = retirarEspeciaisHtml(arrParametrosTrocaAjax[strNome]);
		}
		else
		{
			arrParametrosTrocaAjax[strNome] = encodeURIComponent(arrParametrosTrocaAjax[strNome]);
		}
	}
	return arrParametrosTrocaAjax;
}

/*
* Adiciona uma nova linha na tabela replicando uma linha ja existentes
* Utilizar os arrIdsElementosTabela definindo para cada coluna qual é id do elemento dinamico e o tipo 
ex: 
arrElementos[0] = new Array();
arrElementos[0]['NOMTAGELEMENTO'] = 'select';
arrElementos[0]['IDELEMENTO'] = 'cmbDepartamento';

arrElementos[1] = new Array();
arrElementos[1]['NOMTAGELEMENTO'] = 'select';
arrElementos[1]['IDELEMENTO'] = 'cmbNivCurso';

arrElementos[2] = new Array();
arrElementos[2]['NOMTAGELEMENTO'] = 'select';
arrElementos[2]['IDELEMENTO'] = 'cmbCurso';



arrElementos[3] = new Array();
arrElementos[3]['NOMTAGELEMENTO'] = 'select';
arrElementos[3]['IDELEMENTO'] = 'cmbQualificacao';

arrElementos[4] = new Array();
arrElementos[4]['NOMTAGELEMENTO'] = 'img';
arrElementos[4]['IDELEMENTO'] = 'imgRemoveItem';
*/
function adicionaNovaLinhaTabela(strNomTabela,bolEsconderUltLinha,arrIdsElementosTabela)
{
	var intPosUltimoCurso = document.getElementById(strNomTabela).rows.length-1;
    var intIdUltimoCurso =
	//exibe a ultima linha
	document.getElementById(strNomTabela).rows[intPosUltimoCurso].style.display="";
	
	//insere mais uma linha
	var objTRNovaLinha=document.getElementById(strNomTabela).insertRow(intPosUltimoCurso+1)
	
	var intNumColunas = document.getElementById(strNomTabela).rows[intPosUltimoCurso].cells.length;
	var arrTdNovasColunas = new Array();

    objTRNovaLinha.innerHTML = trocarTodos(document.getElementById(strNomTabela).rows[intPosUltimoCurso].innerHTML, "> <", "><");

    arrTdNovasColunas = objTRNovaLinha.cells;
    /*
	for(var intI=0; intI<intNumColunas; intI++)
	{
		arrTdNovasColunas[intI] = objTRNovaLinha.insertCell(intI);
		arrTdNovasColunas[intI].innerHTML = trocarTodos(document.getElementById(strNomTabela).rows[intPosUltimoCurso].cells[intI].innerHTML, "> <", "><");
        arrTdNovasColunas[intI].className = document.getElementById(strNomTabela).rows[intPosUltimoCurso].cells[intI].className;
		arrTdNovasColunas[intI].valign = document.getElementById(strNomTabela).rows[intPosUltimoCurso].cells[intI].valign;

	}
    */
	if(bolEsconderUltLinha)
	{
		objTRNovaLinha.style.display = "none";	
	}
	
	//atualiza os ids da linha alterada
    eval("var intIdUltimoCurso = garrTabela_"+strNomTabela+".length")
    objTRNovaLinha.id = "lin"+strNomTabela+(intIdUltimoCurso+1);
    atualizaIdsLinhaTabela(objTRNovaLinha,intIdUltimoCurso+1,arrIdsElementosTabela)

	return arrTdNovasColunas;
}
/**
*atualiza os ids de uma table com o numero de sua linha
* Utilizar os arrIdsElementosTabela definindo para cada coluna qual é id do elemento dinamico e o tipo 
ex: 
arrElementos[0] = new Array();
arrElementos[0]['NOMTAGELEMENTO'] = 'select';
arrElementos[0]['IDELEMENTO'] = 'cmbDepartamento';

arrElementos[1] = new Array();
arrElementos[1]['NOMTAGELEMENTO'] = 'select';
arrElementos[1]['IDELEMENTO'] = 'cmbNivCurso';

arrElementos[2] = new Array();
arrElementos[2]['NOMTAGELEMENTO'] = 'select';
arrElementos[2]['IDELEMENTO'] = 'cmbCurso';



arrElementos[3] = new Array();
arrElementos[3]['NOMTAGELEMENTO'] = 'select';
arrElementos[3]['IDELEMENTO'] = 'cmbQualificacao';

arrElementos[4] = new Array();
arrElementos[4]['NOMTAGELEMENTO'] = 'img';
arrElementos[4]['IDELEMENTO'] = 'imgRemoveItem';
*/
function atualizaIdsLinhaTabela(objLinha,intId,arrIdsElementosTabela)
{
    	for(var intJ=0 ; intJ<arrIdsElementosTabela.length ; intJ++)
		{
			var arrInputs = objLinha.getElementsByTagName(arrIdsElementosTabela[intJ]['NOMTAGELEMENTO']);
            for(var intK=0 ; intK < arrInputs.length ; intK++)
            {
                var strIdElemento = arrInputs[intK].id;
                if(arrIdsElementosTabela[intJ]['IDELEMENTO'] == strIdElemento.substring(0,arrIdsElementosTabela[intJ]['IDELEMENTO'].length))
                {
                    arrInputs[intK].id = arrIdsElementosTabela[intJ]['IDELEMENTO']+intId;
                    arrInputs[intK].name= arrIdsElementosTabela[intJ]['IDELEMENTO']+intId;
                }
            }

		}
}
function atualizaIdsTabela(strNomTabela,arrIdsElementosTabela)
{
	
	var intId=0;
	var objTabela= document.getElementById(strNomTabela);

    for(intId=0; intId<objTabela.rows.length ; intId++)
	{
		for(var intJ=0 ; intJ<arrIdsElementosTabela.length ; intJ++)
		{
            atualizaIdsLinhaTabela(objTabela.rows[intId],intId,arrIdsElementosTabela);
		}
	}
}

/*
* armazena em objCombo todos os valores de objComboBase em que o campo strNomCampo seja igual a strValorCampo
*/
function filtraCombo(objCombo,objComboBase,strNomCampo,strValorCampo)
{
	//copia todos os itens para o objCombo
	copiarItensCombo(objComboBase,objCombo);
	
	//filtra os itens diferente
	for(var intI = 0; intI< objCombo.options.length ; intI++)
	{
		if(objCombo.options[intI].value!="")
		{
			var strValor = recuperarItemArrayPhp(strNomCampo,objCombo.options[intI].value);
			if(strValorCampo != strValor)
			{
				objCombo.options[intI] = null;
				intI--;
			}
		}
	}
}
/*
* Filtra tabela exibindo apenas as linhas que stao em arrDados estao com os valores determinados em arrFiltro
* retorna o numero de linhas que foram exibidas
* 
 Ex de arrFiltro: arrFiltro['CODFUNCAO'] = 1  arrFiltro['CODTIPO'] = 2 (exibe apenas na tabela os elementos com cod_funcao = 1 e cod_tipo = 2)
*/
function filtraTabela(objTabela,arrDados,arrFiltro,intPosInicialDados,bolDivTabela)
{
	
	var arrLinhasTabela;
	if(!bolDivTabela)
	{
		arrLinhasTabela = objTabela.rows;
	}else
	{
		arrLinhasTabela = objTabela.childNodes;
	}
	var intNumLinhas = 0;
	var intLinha = 0;
	for(var intI =0 ; intI<arrLinhasTabela.length ; intI++)
	{
		if(!arrLinhasTabela[intI].tagName)
		{
			continue;
		}
		if(bolDivTabela && arrLinhasTabela[intI].tagName.toUpperCase()!="DIV")
		{
			continue;
		}
		if(intLinha>=intPosInicialDados)
		{
			var bolIgual = true;
			for(var strCampo in arrFiltro)
			{
				
				if(arrDados[intLinha-intPosInicialDados][strCampo] != arrFiltro[strCampo])
				{
					bolIgual=false;
				}
			}
			 
			if(bolIgual)
			{
				arrLinhasTabela[intI].style.display = "";
				intNumLinhas++;
			}else
			{
				arrLinhasTabela[intI].style.display = "none";
			}
		}
		intLinha++;

	}
	return intNumLinhas;
}
/**
* Metodo para filtrar um combo atraves dos campos arrStrCampoValorFiltro de um combo base
*
* @since 04/09/2009
* @author Daniel Hasan Dalip<dhasan@unibh.br>
* @access public
*/
function filtrarCombo(objCombo,objComboBase,arrStrCampoValorFiltro)
{
    //limpa combo
    var intTam=objCombo.options.length
    for(intI=2 ; intI<= intTam; intI++)
    {
        objCombo.options[2]=null
    }

    //preenche com filtro
    for(var intI=2 ; intI<objComboBase.options.length ; intI++)
    {
		var arrCmbBase=converterArrayPhpJs(objComboBase.options[intI].value)

        //todos os campos devem ser compativeis com o combo base
        var bolTodosCamposIguais = true;
        for(var strCampo in arrStrCampoValorFiltro)
        {

            if(typeof(arrStrCampoValorFiltro[strCampo])=="string")
            {
                bolTodosCamposIguais = arrStrCampoValorFiltro[strCampo] == arrCmbBase[strCampo];
            }else
            {
                //percorre os valores possiveis deste campo, se pelo menos um atendeu
                var bolEncontrouValor = false;
                for(var intJ = 0; intJ<arrStrCampoValorFiltro[strCampo].length ; intJ++)
                {
                    if(arrStrCampoValorFiltro[strCampo][intJ] == arrCmbBase[strCampo])
                    {
                        bolEncontrouValor = true;
                        break;
                    }
                }
                bolTodosCamposIguais =  arrStrCampoValorFiltro[strCampo].length==0 || bolEncontrouValor;
            }
            
            if(!bolTodosCamposIguais)
            {
                break;
            }
        }

        //exibe campo caso tenha passado pelo filtro
		if(bolTodosCamposIguais)
		{
			//adiciona o curso
			var objOption = new Option(objComboBase.options[intI].text,objComboBase.options[intI].value);
			objCombo.options[objCombo.options.length]=objOption;
		}
    }
}
/**
* Metodo para filtrar um combo atraves dos campos arrStrCampoValorFiltro de um array
*
* @since 10/09/2009
* @author Daniel Hasan Dalip<dhasan@unibh.br>
* @access public
*/
function filtrarComboPorArray(objCombo,arrValoresBase,arrValoresFiltro,strCampoFiltro,strNomCampoTexto,strNomCampoValor)
{
    //limpa combo
    var intTam=objCombo.options.length
    for(intI=2 ; intI<= intTam; intI++)
    {
        objCombo.options[2]=null
    }

    //preenche com filtro
    for(var intI=0 ; intI<arrValoresBase.length ; intI++)
    {
        //todos os campos devem ser compativeis com o combo base
        var bolEncontrou = false;
        for(var intJ = 0 ; intJ<arrValoresBase.length ; intJ++)
        {
            if(arrValoresFiltro[intJ][strCampoFiltro] == arrValoresBase[intI][strCampoFiltro])
            {
                bolEncontrou = true;
                break;
            }
        }



        //exibe campo caso tenha passado pelo filtro
		if(bolEncontrou)
		{
			//adiciona o curso
			var objOption = new Option(arrValoresBase[strNomCampoTexto],arrValoresBase[strNomCampoValor]);
			objCombo.options[objCombo.options.length]=objOption;
		}
    }
}


/**
* Metodo para fazer upload de arquivos ele cria uma sessao
* indexado pelo nome do file o arquivo que foi dado upload
*
* @since 10/10/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
function efetuarUpload(objForm, strArquivoSubmit,bolRemoveFrame,strAcao)
{
	if(bolRemoveFrame==undefined)
	{
		bolRemoveFrame = true;
	}
	
	// criando iframe
	if($('upload')==undefined)
	{
		var objElementoIframe = document.createElement('iframe');
		objElementoIframe.id = 'upload';
		objElementoIframe.name = 'upload';
		objElementoIframe.frameBorder='0';
		objElementoIframe.width = '1';
		objElementoIframe.height = '1';
		// adicionando iframe ao documento
    	if (IE)
    	{    		
    		document.body.appendChild(objElementoIframe);    		
    	}
    	else
    		document.documentElement.appendChild(objElementoIframe);
	}
	else
	{
		var objElementoIframe  = $('upload');
		objElementoIframe.frameBorder='0';
    	objElementoIframe.width = '1';
    	objElementoIframe.height = '1';
	}
	
    // debug
    //objElementoIframe.width = '500px';
    //objElementoIframe.height = '500px';
    //objElementoIframe.frameBorder='1';
     
    // criando hidden com o nome do arquivo
    var objHidden = document.createElement('input');
    objHidden.type = 'hidden';
    objHidden.value = strAcao;
    objHidden.name='hidAcao';
    objHidden.id='hidAcao';
    objForm.appendChild(objHidden);
    //salva os parametros do form
    var strTargetAntigo = objForm.target ;
    var strActionAntigo = objForm.action ;
    // submentendo formulario
    objForm.target = 'upload';
    objForm.action = strArquivoSubmit;
    objForm.submit();
    
    // removendo elementos criados do documento
    if(bolRemoveFrame)
    {
    	if(IE)
    	{
    		//document.body.removeChild(objElementoIframe);
    	}
    	else
    	{
    		document.documentElement.removeChild(objElementoIframe);
    	}
    }
    objForm.removeChild(objHidden);
    
    //coloca novamente os para os parametros antigos do form
    objForm.target = strTargetAntigo;
    objForm.action = strActionAntigo;
}



/**
* Habilita ou nao os campos inputs para escrita em um determinado nodo
* (combos e input)
* @since 08/08/2008
* @author Daniel Hasan Dalip <daniel.hasan@unibh.br>
* @access public
*/
function habilitaEscritaObjeto(objNodo,bolHabilitar,arrClassePorTipo)
{
	habilitaEscritaObjetoPorTag(objNodo,bolHabilitar,arrClassePorTipo,"select");
	habilitaEscritaObjetoPorTag(objNodo,bolHabilitar,arrClassePorTipo,"input");	
}
/**
* Habilita ou nao os campos inputs para escrita em um determinado nodo definindo a tag
*
* @since 08/08/2008
* @author Daniel Hasan Dalip <daniel.hasan@unibh.br>
* @access public
*/
function habilitaEscritaObjetoPorTag(objNodo,bolHabilitar,arrClassePorTipo,strTag)
{
	var arrObjInputs = objNodo.getElementsByTagName(strTag);
	
	for(var intI=0 ; intI<arrObjInputs.length ; intI++)
	{
		if(arrObjInputs[intI].type == 'text')
		{
			arrObjInputs[intI].readOnly = !bolHabilitar;
			
		}else
		{
			arrObjInputs[intI].disabled = !bolHabilitar;
		}
		if(arrClassePorTipo)
		{
			if(arrClassePorTipo[arrObjInputs[intI].type])
			{
				arrObjInputs[intI].className = arrClassePorTipo[arrObjInputs[intI].type];
			}
		}
	}
}

/**
* Metodo para colocar caixa alta nos campos do formulario
*
* @param Form objForm - Formulario
* @param Input objInput - Text 
* @since 11/09/2008
* @author Erix Henrique Morato <emorato@unibh.br> 
* @access public
*/
function aplicarCaixaAlta(objForm, objInput)
{
	if (objInput != null) {
		var strTipo = objInput.type;
		if (strTipo == 'text') {
				var strValor = '';
				strValor += objInput.value;
				objInput.value = strValor.toUppercase();
			}
	}
	else {
		for (var i = 0; i < objForm.length; i++) {
			var strTipo = objForm[i].type;
			if (strTipo == 'text') {
				objForm[i].value = objForm[i].value.toLowercase();
				var strValor = '';
				strValor += objForm[i].value;
				objForm[i].value = strValor.toUppercase();
			}
		}
	}	
}

/**
* Metodo para colocar caixa alta nos campos do formulario
*
* @param Form objForm - Formulario
* @param Input objInput - Text 
* @since 11/09/2008
* @author Erix Henrique Morato <emorato@unibh.br> 
* @access public
*/
function aplicarCaixaBaixa(objForm, objInput)
{
	if (objInput != null) {
		var strTipo = objInput.type;
		if (strTipo == 'text') {
				var strValor = '';
				strValor += objInput.value;
				objInput.value = strValor.toLowercase();
			}
	}
	else {
		for (var i = 0; i < objForm.length; i++) {
			var strTipo = objForm[i].type;
			if (strTipo == 'text') {
				objForm[i].value = objForm[i].value.toLowercase();
				var strValor = '';
				strValor += objForm[i].value;
				objForm[i].value = strValor.toLowercase();
			}
		}
	}
}

/**
* Metodo para colocar caixa alta nos campos do formulario no evento on key up
*
* @param Form objForm - Formulario
* @param Input objInput - Text 
* @since 11/09/2008
* @author Erix Henrique Morato <emorato@unibh.br> 
* @access public
*/
function aplicarCaixaAltaOnKeyUp(objForm)
{
	for (var i = 0; i < objForm.length; i++) {
		var strTipo = objForm[i].type;
		if (strTipo == 'text') {
			if (!objForm[i].onkeyup) {
				objForm[i].onkeyup = function(){
					var strValor = '';
					strValor += this.value;
					this.value = strValor.toUpperCase();
				}
			}		
		}
	}
}

/**
* Metodo para colocar caixa alta nos campos do formulario no evento on key up
*
* @param Form objForm - Formulario
* @param Input objInput - Text 
* @since 11/09/2008
* @author Erix Henrique Morato <emorato@unibh.br> 
* @access public
*/
function aplicarCaixaBaixaOnKeyUp(objForm)
{
	for (var i = 0; i < objForm.length; i++) {
		var strTipo = objForm[i].type;
		if (strTipo == 'text') {
			if (!objForm[i].onkeyup) {
				objForm[i].onkeyup = function(){
					var strValor = '';
					strValor += this.value;
					this.value = strValor.toLowercase();
				}
			}
		}
	}
}


/*****************************************************************************/

/**
* Retira as tags passadas como parametro de um texto
*
* @param Array arrTags - Tags
* @param String strTexto -  texto

* @since 18/09/2008
* @author Daniel Hasan Dalip <daniel.hasan@unibh.br> 
* @access public
*/
function retiraTags(arrTags,strTexto)
{
	for(var intI = 0 ; intI<arrTags.length ; intI++)
	{
		strTexto = trocarTodosExpressao(strTexto,"<(/)?"+arrTags[intI]+"[^>]*>","");
	}
	return strTexto;
}

/**
* Metodo para aplicar mascara no campo passado
*
* @since 23/09/2008
* @author Erix Henrique Morato <emorato@unibh.br> 
* @access public
*/
function aplicarMascara(objCampo,TeclaPres,maskara) {

	var Vr = objCampo.value;
	
	//Tratamento para browser IE ou MOZILLA
	var Tecla;
	if (TeclaPres.keyCode) Tecla = TeclaPres.keyCode;
	else if (TeclaPres.which) Tecla = TeclaPres.which;
	
	var num = Vr;
	var novaMask = new Array();
	var campoFinal = new Array();
	var outro;
	var ind = 0;
	var ind1 = 0;
	var ind2 = 0;
	var tamMask = maskara.length;
	var contMask = 0;
	var contem;
	var grupo =0;
	var controle = 0;
	var p1 = 0;
	var p2 = 1;

	//Grupos
	G[ind] = 0;
	//Pontos de Edicao
	P[ind1] = 0;
   
    //Verifica o tamanho dos grupos, local dos grupos e pontos      
	while(contMask <= tamMask) {
	  contem = maskara.substring(p1,p2);
		 if (contem == 9) {
 			 if (grupo > controle) {
 			  ind ++;
			  ind1 ++;
			  G[ind] = 0; 
			  P[ind1] = 0;
			  controle = controle + 1;
		     }
		   G[ind] = G[ind]+1;
	    }else{
		   P[ind1] = contem;
		   grupo = grupo + 1
        }
	  contMask = contMask + 1;
	  p1 = p1 + 1;
  	  p2 = p2 + 1;
   }
   
   
  
	//Declarando variaveis da montagem para nova mascara


   
	if (Vr.length!=maskara.length) {	  
		for ( x=0 ; x < P.length; x++ ) {
		  Vr = Vr.toString().replace( P[x], "" );
		}
    
		Tam = Vr.length;
		if (Tam <= maskara.length  && Tecla != 8) { 
		Tam = Vr.length;       
		} else {
		return false;
		}
		
		if (Tecla == 8 ) { 
		Tam = Tam - 1 ; 
		}

  
		// montando a mascara no campo
		if ( Tecla == 8 || Tecla == 88 || Tecla >= 48 && Tecla <= 57 || Tecla >= 96 && Tecla <= 105 ){
			tamTempo = G.length - 1;
			k=0;
			for (k=0; k<=tamTempo; k++) {      
			  if (Tam >= retornaTam(k) && Tam < retornaTam(k+1)) {
			        rodar = "";            
			        for (z=0; z<=k+1; z++) {
			            valorSub = "retornaTam("+(z-1)+")";
			            valorSub1 = "retornaTam("+(z)+")";
			            if (z==0) {
			                valorSub = "0";
			                valorSub1 = "retornaTam("+z+")";
			            }                                
			            if (z==k+1) {
			                valorSub = "retornaTam("+(z-1)+")";
			                valorSub1 = "Tam";
			            }
			            valorSub = eval(valorSub);
			            valorSub1 = eval(valorSub1);              
			            rodar += "Vr.substring("+valorSub+","+valorSub1+")";                                              
			            rodar += "+P["+z+"]+";                                   
			        }                           
			        rodar = "Vr = "+rodar.substring(0,rodar.length-6);
			        eval(rodar);
			  }      
			}       
			objCampo.value = Vr;  
		}
	} 	
}

/**
* Temporiza o evento de um determinado elemento.
*
* @param objElemento Elemento cuja a ação está ligada
* @param strMetodo Metodo utilizando a compactacao base64
* @param intTimeout Tempo de espera
*
* @since 24/098/2008
* @author Daniel Hasan Dalip <daniel.hasan@unibh.br> 
* @access public
*/
function temporizarEvento(objElemento,strMetodo,intTimeout)
{
	var objDate = new Date();
	var intTempoEmMili = objDate.getMilliseconds();
	objElemento.intTempoUltimoEvento = intTempoEmMili;
	setTimeout("executarEventoTemporizado('"+objElemento.id+"','"+strMetodo+"',"+intTempoEmMili+")",intTimeout);
}
function executarEventoTemporizado(strElementoId,strMetodo,intTempoEmMili)
{
	//se o tempo em milisegundos do ultimo evento for dele, executar o metodo
	var objElemento = $(strElementoId);
	if(objElemento.intTempoUltimoEvento == intTempoEmMili)
	{
		var objBase64 = new Base64();
		var strAcao = objBase64.decode(strMetodo);
		eval(strAcao);
	}
}


//VERIFICA SE O OBJETO É UM ARRAY
function is_array(input){
	return typeof(input)=='object'&&(input instanceof Array);
}

/**
* Metodo para recortar um elemento html
* 
* @param String strId - Id do elemento que esta sendo recortado
* @since 23/09/2008
* @author Erix Henrique Morato <emorato@unibh.br> 
* @access public
*/
function recortarElemento(strId)
{
	var objElement = $(strId);
	if(objElement.parentNode)
		objNovoElemento = objElement.parentNode.removeChild(objElement);
	else
	{
		objNovoElemento = document.removeChild(objElement);
	}	
	return objNovoElemento;
}

/**
* Metodo para colar elemento 
* 
* @param String strIdOrigem - Id do elemento pai que ira recerber o novo elemento
* @param Node objElementoNovo - Elemento html que esta sendo adicionado
* @since 23/09/2008
* @author Erix Henrique Morato <emorato@unibh.br> 
* @access public
*/
function colarElemento(strIdOrigem, objElementoNovo)
{
	var objElement = $(strIdOrigem);
	objElement.appendChild(objElementoNovo);	
}

/**
* Metodo mover elemento de um lugar para outroo 
* 
* @param String strIdElementoPai - Id do elemento que esta sendo recortado
* @param String strIdElementoMovido - Id do elemento que esta sendo movido
* @since 23/09/2008
* @author Erix Henrique Morato <emorato@unibh.br> 
* @access public
*/
function moverElemento(strIdElementoPai, strIdElementoMovido)
{
	var objElementoMovido = recortarElemento(strIdElementoMovido);
	colarElemento(strIdElementoPai, objElementoMovido);	
}

/**
* Metodo para habilitar elementos combos que estao dentro da janela 
* 
* @param Element objElemento - Elemento HTML
* @since 29/10/2008
* @author Erix Henrique Morato <emorato@unibh.br> 
* @access public
*/
function habilitarElementosCombo(objElemento)
{
	var arrElementos = objElemento.childNodes;	
	for(var intI=0;intI<arrElementos.length;intI++)
	{		
		if((arrElementos[intI].type == "select-one") ||
		   (arrElementos[intI].type == "select-multiple"))
		{
			var objCombo = arrElementos[intI];
			var objSpan = document.getElementById("_spnValue"+objCombo.id);
		    if(document.getElementById("_spnValue"+objCombo.id) != undefined)
			{
				objSpan.style.display = "none";
				objCombo.style.display = "";
		    }	
		}
		if(arrElementos[intI].childNodes.length>0)
		{
			 habilitarElementosCombo(arrElementos[intI]);
		}
	}
}


/*
* Retorna o nome base de um caminho
*/
function basename(path, suffix) {
    // http://kevin.vanzonneveld.net
    // +   original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +   improved by: Ash Searle (http://hexmen.com/blog/)
    // +   improved by: Lincoln Ramsay
    // +   improved by: djmix
    // *     example 1: basename('/www/site/home.htm', '.htm');
    // *     returns 1: 'home'
 
    var b = path.replace(/^.*[\/\\]/g, '');
    
    if (typeof(suffix) == 'string' && b.substr(b.length-suffix.length) == suffix) {
        b = b.substr(0, b.length-suffix.length);
    }
    
    return b;
}

/**
* Insere a funcao objFuncao no evento onclick de todos os elementos filhos de objpai com a tag strTag
*/
function eventoOnClickTodosElementos(objElementoPai,objFuncao,strTag)
{
	var arrElementos = objElementoPai.getElementsByTagName(strTag);
	for(intI = 0; intI<arrElementos.length ; intI++)
	{
		arrElementos[intI].onclick = objFuncao;
	}
}

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.scrollHeight;
	} 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;
	}

	//alert(windowHeight+' e '+pageHeight);
	
	arrayPageSize = new Array(pageWidth,pageHeight,windowWidth,windowHeight) 
	return arrayPageSize;
}

// colocar no onkeyup
function somenteNumeros(objText, evento)
{
	var strTecla= "";
	if (evento.keyCode) strTecla = evento.keyCode;
	else if (evento.which) strTecla = evento.which;
	
	if(strTecla>=48 && strTecla<=57)
		return true;
		
	var strValor = objText.value;
	var strRetorno = ""; 
	
	for (var intI=0; intI< strValor.length; intI++)
	{
		if(strValor.charCodeAt(intI)>=48 && strValor.charCodeAt(intI) <= 57)
		{
			strRetorno +=  strValor.charAt(intI);
		}
	}	
	objText.value = strRetorno;	
}

function transferirDiv(objOrigem,objDivDestino)
{
    var objPaiOrigem = objOrigem.parentNode;
    objPaiOrigem.removeChild(objOrigem);
    objDivDestino.appendChild(objOrigem);
}

//Funçao testa senha para ser gravada no oracle, conferindo primeiro digito numero ou se existe especiais
function validaSenhaOracle(strSenha)
{
    //passa tudo para minusculo, pois o oracle nao tem diferença de case
    strSenha = strSenha.toLowerCase();

    //verifica se o primeiro digito é numerico, nao pode
    if (eNumero(strSenha[0]) == true)
        {
        alert("Primeiro digito não pode ser numero.");
        return false;
        }
    //os demais itens devem ser texto ou numeros e nao podem ser especiais
    for (var i=0;i<strSenha.length;i++)
    {
        var digito = strSenha[i];

        //troca as letras de A-Z por 1
        var digitoValida = digito.replace(/([a-z])/g, "1");

        //alert('digito: '+digito+' especial: '+digitoValida+' numero: '+eNumero(digito))

        //se o digito é 1 (texto convertido) ou é numero, pode prosseguir, senao para
        if (eNumero(digitoValida) == false)
            {
            alert ("A senha não pode conter caracteres especiais.");
            return false;
            }
    }
    return true
}