function recuperaHref(){
    if (!document.getElementsByTagName){ return; }
	var anchors = document.getElementsByTagName("a");
    contImg = 0
	// loop through all anchor tags
	for (var i=0; i<anchors.length; i++){
		var anchor = anchors[i];
		if (anchor.getAttribute("href") && anchor.getAttribute("rel")){
			if (typeof(anchor.onclick) != "funciton"){
			   anchor.onclick = function() {showLightbox(this, this.href); return false;}
			}   
		}
		else{
		   if (anchor.getAttribute("href") && anchor.getAttribute("layer")){
			  if (typeof(anchor.onclick) == "function")
			     anchor.funcaoAnt = anchor.onclick;
			  anchor.onclick = function() {
				   var transport = Ajax.transportar();
				   var layer = this.layer
				   var funcaoAnt = this.funcaoAnt
				   transport.open("GET", this.href,true)
				   transport.onreadystatechange = function()
				   {
				      if (transport.readyState == 4)
					  {
						  if (funcaoAnt)
						      funcaoAnt()
						  document.getElementById(layer).innerHTML = unescape(transport.responseText.replace(/\+/g," "))
					  }
					  
			       }
				   transport.send(null);
				   return false;
		      }
		   }
		   else{
		      if (anchor.getAttribute("href") && anchor.getAttribute("img")){
				 if (typeof(anchor.onclick) != "funciton"){
					contImg += 1
					anchor.contar = contImg
			        anchor.onclick = function() {showImagem(this.href,this.contar); return false;}
			     }
			  }
		   }
		}
	}
}


 



//---------------------------Classe refresh OBJETO----------------------------------------------
//------FUNÇÃO QUE RETORNA AS MENSAGENS
var opcoes = new Array();
mensagem = {}
mensagem.erro = function(conteudo){
      return "<table align=center ><tr><td><font color=red size=4>"+
			 "<center> ERRO - Atualize a tela, caso o problema continue<br> contate o administrador do sistema reportando a "+
			 " mensagem:</center></font></td><tr><td><center><font color=\"ffffff\">"+conteudo +
			 "</td></table>";
}
mensagem.retorno = function(conteudo){
      return "<table align=center ><tr><td><font color=red size=4>"+
			 "<center>"+
			 " mensagem:</center></font></td><tr><td><center><font color=\"ffffff\">"+conteudo +
			 "</td></table>";
}

mensagem.login = function(acao){
      return "<table align=center><tr><td colspan=2><font color=\"ffffff\" size=5>"+
			 "<center>"+
			 " <b>LOGIN <br></b></center></font></td>"+
			 "<tr><td align=\"right\"><b><font color=\"ffffff\">Identificação</td><td><input type=text name=\"cod\" id=\"codIdeLogon\" size=50 maxlength=50> <center><font color=\"ffffff\"></td>"+
			 "<tr><td align=\"right\"><b> <font color=\"ffffff\">Senha</td><td><input type=password name=\"codigo\" id=\"codigoIdeLogon\" size=10   maxlength=10></td>" +
			 "<tr><td colspan=2 align=\"center\"><input type=\"button\" value=\"logar\" onclick=\"javascript:var v = new validacao.usuario()\">"
			 "</td></table>";
}



var inicioWindow = [];
var iniciar = function(func){
    inicioWindow[inicioWindow.length] = func;
}



//***** Class ******
//transforma uma função em uma classe com o metodo chamado inicializar como construtor
var Class = {
  create: function() {
    return function() {
      this.inicializar.apply(this, arguments);
    }
  }
}


//***** extend ******
// Usa a metodologia de herança estendendo metodos de um objeto para outro objeto
Object.extend = function(destination, source) {
  for (property in source) {
    destination[property] = source[property];
  }
  return destination;
}
 

navegar = {};
navegar.start = function(aut,par,evt){
   var evento = (evt)?evt:event.srcElement
   var atr = {
             tag:evento,
			 parametros:par,
			 autenticar:aut
             }
   new navegar.enviar(atr)			 
}
navegar.Base = function(){}
navegar.Base.prototype = {
	     Atributos:function(options){
            this.options = {
				tag:false,
				parametros:false,
				autenticar:false
			}
		    Object.extend(this.options,options || {})
		 }
}

navegar.enviar = Class.create();
navegar.enviar.prototype = Object.extend(new navegar.Base(),{
	inicializar:function(options){
	this.Atributos(options);
	   var objTag = this.options.tag;
	   if (!objTag){
		  alert("Erro: A tag onde ocorreu o evento não foi passada");
		  return false;
	   }

	   
	   if (!objTag.getAttribute("idFilho")){
	      if (!objTag.urlFilho){
	         alert("Insira na tag o atributo urlFilho ou o id Filho para saber o que será enviado");
		     return false;
	      }
	      this.Manual();
	   }
	   else{   
	      this.Automatico(objTag.idFilho);
       }
   },
   
   
   Automatico:function(nFilho){
      var opt = inicial.opcoes.opcoesFilhas[nFilho];
	  if (!opt){
	     alert("Erro: O número de identificação da página filho não existe no objeto");
	     return false;
      }
	  document.forms[0].num.value = opt.cdMenu.valor
	  var parExecuta = {
	              url:opt.nmUrlFuncionalidade.valor,
		      	  tipo:opt.idTipo
	                   }
	  this.validar(parExecuta);
	  
   },
   Manual:function(){
      var tag = this.options.tag;
      var url = tag.urlFilho;
      var tipo = 0;
      if (tag.idTipo){
         tipo = tag.idTipo;
      }
      var parExecuta = {
	                 url:url,
					 tipo:{valor:tipo}
	                   }
      this.validar(parExecuta);
   
   },
   
   validar:function(objExe){
      var objTag = this.options.tag;
      var getTag = new tagObject.getTagObject();
	  var arrAtr = [];
      if (objTag.parFilho){
	     if (objTag.parFilho == "all"){
	     }
		 else{
			arrAtr = objTag.parFilho.split(",")
			arrAtr.push("num")
		 }
      }
      var par = (this.options.parametros)?this.options.parametros+"&num="+document.forms[0].num.value:getTag.parametros(arrAtr);
	  objExe.url = objExe.url+"?"+par
      if (this.options.autenticar){
	     var usu = new validacao.usuario({funcao:navegar.executar,argumentos:[objTag,objExe]})
	  }else{
	     navegar.executar([true],[objTag,objExe]);
	  }
	  return false;
   }
})

navegar.executar = function(valida, arrObj){
	 if (!valida[0]){
		 validacao.login();
	     return false;
	  }
	  if (arrObj[1].tipo.valor == 1){
	     showLightbox(arrObj[0],arrObj[1].url);
	  }
	  else{
         if (arrObj[0].targetFilho){
	        window.open(arrObj[1].url,arrObj[0].targetFilho)
	     }
	     else{
		    window.location = arrObj[1].url  
	     }
	  }
   }
//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
/* Classe ajax 
   para carregar o ajax tem que se estanciar um objeto recebendo uma url
   e um objeto com os seguintes methodos
   parametros:
   metodo:
   
   tem tambem os metodos que executão as seguintes funções que mostram o estatus
   do reuqest. esses metodos são
   enviando
   iniciado
   lendo
   retornando
   completo
*/  

var Ajax = {}


Ajax.Base = function() {};
Ajax.Base.prototype = {
  setOpcoes: function(options) {
    this.options = {
      metodo:'post',
      parametros:''
    }
    Object.extend(this.options, options || {});
  }
}

// methodo request(construtor) 
// este metodo funciona como um construtor que ao ser estanciado busca no servidor os resultados obtidos
// parametros(url [string], options [objeto])


Ajax.request = Class.create();
Ajax.transportar=function() {
	          var xmlhttp
			  try{
    			 xmlhttp = new XMLHttpRequest();
              }catch(ee){
                  try{
                     xmlhttp = new ActiveXObject("Msxml2.XMLHTTP");
                  }catch(e){
                      try{
                         xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
                      }catch(E){
                          xmlhttp = false;
                      }
                  }
              }
			  return xmlhttp
}



Ajax.fila = [];
Ajax.execultarFila = function(){
    var obj = Ajax.fila[Ajax.fila.length-1]
	var options = obj.envOptions;
	
   //----- Colocando o carregando
   if (!options.noLoading)
       Ajax.blockLoad()
   //-----------------------------
  
   
   var url = obj.envUrl;
   
   var objAjax = obj.objAjax;
   objAjax.setOpcoes(options)
   objAjax.recuperar(url,options);
}

Ajax.blockLoad = function(){
   var label
   if (!document.getElementById("AjaxLoad")){
      label = document.createElement("span");
      label.style.backgroundColor = "#FF0000";
	  label.id="AjaxLoad"
	  label.style.color = "#FFFFFF";
	  label.style.position = "absolute";
	  label.style.top=0;
	  label.style.left=0;
	  label.innerHTML = "CARREGANDO.....";
	  label.style.display="block";
	  document.body.appendChild(label)
   }  
   else{ 
      label = document.getElementById("AjaxLoad")
	  label.style.display = "block"
   }
}

Ajax.noneLoad = function(){
   if (document.getElementById("AjaxLoad")){
      label = document.getElementById("AjaxLoad")
	  label.style.display = "none"
   }
}


Ajax.request.prototype = Object.extend(new Ajax.Base, {
     inicializar:function(url, options){
		  Ajax.fila.push({envUrl:url,envOptions:options,objAjax:this})
		  if (Ajax.fila.length == 1){
			 Ajax.execultarFila();
		  }
     },
	 evento:['enviando','iniciado', 'lendo', 'retornando', 'completo'],
	 
     recuperar:function(url, opt){
			 if (opt.parametros.length > 0){
				 url = url +"?"+ opt.parametros
			 }
			 var transport = Ajax.transportar();
			 var opcAjax = opt
			 
			 var argumento
			 var objetoRef = (opt.objeto)?opt.objeto:false;
			 var evento = this.evento
			 if (opt.arguments){
			    argumento = opt.arguments
			 }
//-------------------------------------------------AJAX - Fazendo o request e filtrando as informação
			 transport.open("GET", url,true)
			 transport.onreadystatechange = function() {
			 liberar = transport.readyState;
			 
			 if (evento[transport.readyState] == 'completo'){
                //alert(unescape(transport.responseText.replace(/\+/g," ")))
				
				try{
				   ax_valor = eval('['+ unescape(transport.responseText.replace(/\+/g," ")) +']' );
				}
				catch(e){
				   //--------------------------------------------------------------------
				   Refresh.executarFuncao();
				   showLightbox(mensagem.retorno(unescape(transport.responseText.replace(/\+/g," "))));
				   Ajax.noneLoad()
				   return false;
				}
				if (typeof(opcAjax[evento[transport.readyState]]) == 'function'){
					if (argumento){
					   if (objetoRef)	
				          opcAjax[evento[transport.readyState]](ax_valor, eval(argumento), objetoRef);
					   else	opcAjax[evento[transport.readyState]](ax_valor, eval(argumento));  
					}
					else{ 
					   if (objetoRef)	
				          opcAjax[evento[transport.readyState]](ax_valor, objetoRef);
					   else	opcAjax[evento[transport.readyState]](ax_valor);
					}
				}
				else{
				   opcAjax[evento[transport.readyState]] = ax_valor[0];
				}
                Ajax.noneLoad()
			 }
			 }
			 transport.send(null);
			 var descart = Ajax.fila.shift()
			 if (Ajax.fila.length > 0){
				Ajax.execultarFila()
			 }
			 
			 
	 }
}
)



//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
/*  class Refresh
    --> DESCRIÇÃO: Quase todads as funcionalidades do sistema são chamadas de uma tela de consulta, onde alguns registros
	               ja estão sendo exibidos para o usuário. Muitas vezes essas funcionalidades implicam em alterar 
				   , incluir ou excluir alguns registros logo, a consulta que esta sendo exibida deve ser atualizada.
				   Junto com seus metodos e atributos, a classe refresh, guarda uma referencia do objeto de consulta que podera
				   sofrer alterações num futuro imediato fazendo com que, ao termino delas (ao fim da execução de uma ação)
				   o objeto seja atualizado imediatamente, exibindo assim uma consulta precisa e atual sobre a situação dos
				   registros.
				   
				   ---> ATRIBUTOS
				   + funcao:function()    
				   + obj: [object tag]
				   
				   ---> MÉTODOS
				   + inicializar(objTagRef): Construtor
				     -  Este método recebe a referencia da tag que ira fazer a chamada a uma  função de negócio 
					    referente ao objeto solicitado pelo usuario.
					    Este metodo por ser o construtor ira verificar e validar se os dados que foram passados 
						são coerentes para se fazer a atualização. Após a verificação, o atributo setRefObj é instanciado
						passando um prototipo com a ação que será executada.
				   + setFunction(refObj): 
				     - metodo que recebe a referencia do objeto e recupera a ação e qual a consulta será atualizada.
				   + getFunction():   	  
					 - metodo que envia a função que será executada 
					   Obs: Este metodo envia a função que esta no frame pai (parent.nomeFunção) da tela pois 
					   esta é chamada na maioria das vezes pelo su filho na hirarquia.
				   + executarFuncao
				     - metodo que executa a função para o obj
				   
				   ---> MANIPULADOR DE EVENTOS <TAGS>
				   + COMO FUNCIONA: O REFRESH tem uma particularidade diferente das outras classes pois
				                    ele é instanciado do metodo showligthBox da classe ligthBox
									mas as tags tem um papel fundamental pois elas vão enviar dois atributos
									refObjeto(nome do objeto), refAcao(nome da function para executar) exe:
					                
									<a href="" refObjeto="nmObjeto"	refAcao="nmFunction">			
				   
*/
var Refresh = Class.create();
Refresh.functionObj = false;
Refresh.prototype = {
	inicializar:function(objTag){
	     var strObj = ""
		 var obj = false;
		 var objArray = []
		 if ((objTag.refObjeto)&&(objTag.refAcao)){
			var funcoes = objTag.refAcao.split(";")
			var objRef = objTag.refObjeto.split(";")
		    
			for (i in funcoes) {
				obj = objRef[i].split(",")
				strObj = ""
				for (o in obj){
			        if (strObj.length == 0)
				       strObj = "'"+obj[o]+"'"
				    else strObj += ",'"+obj[o]+"'"	
			    }
		        var acao = eval(funcoes[i])
		        if (eval(funcoes[i])){
			       objArray.push({f:"parent."+funcoes[i], p:strObj})
		        }
			}
		 }
		 Refresh.setFunction(objArray);
	} 
}

Refresh.setFunction = function(arr){
	    Refresh.functionObj = arr
}
Refresh.getFunction = function(){
	var funcao = parent.Refresh.functionObj;
	if (funcao){
	   return funcao; 
	}
	else{
	   return false;
	}
}
Refresh.executarFuncao = function(){
	var objs = Refresh.getFunction()
	if (objs){
	   for (var i in objs){
	       alert(objs[i].f +"----"+objs[i].p)
		   if (objs[i].f)
		      eval(objs[i].f+"("+objs[i].p+")");
	   }
	}   
}
//-------------------------------------FIM DA CLASSE REFRESH-------------------------------------------


//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
/*  class url
    --> DESCRIÇÃO:  Guardar e separar as funções que são passadas pela Url je decodificada 
	
                                                   :METODOS: 
	         # inicializar(construtor) - Ao estanciar a classe url, ele automaticamente
	                                     vai popular todas as suas propriedades com seues 
										 respectivos valores
	         # inputRequest - Este metodo monta os inputs com os parametros que foram respectivamente
			                  Especificado nos manipuladores de eventos
	         
	                                            :PROPRIEDADE: 
	         @ linkNome - retorna uma String com o nome do link que foi passado
	         @ Parametros - Retorna uma array indexada com o nome dos parametros guardando seus valores
			 @ hostNome - retorna uma string com o nome do host
	         @ path - retorna o ptah da url    
	                                    :Manipuladores de evento HTML:
			 * <DIV tipo=["url"] visibilidade=[Esconder, simples, caixa ] parametros=[nParametro] >
			   - tipo: identifica o tipo como sendo para disparar o evento url
			   - visibilidade: [esconder] para montar o input hidden
			                   [simples] mostrar o valor em input text
							   [caixa] mostrar o valor em textarea
			   - Parametros: indicar quais os campos vc quer montar. obs: caso seja mais de um separar por
			                 virgula
*/
var url = Class.create()
url.prototype = {
	parametros:[],
	hostNome:"",
	path:"",
	stringParametro:"",
	inicializar:function(){
		var url = ""+document.location
		var strUrl = ""
		for (var x=0; x<url.length; x++){
			if (url.substr(x,1) == "?"){
			   strUrl = url.substr(x)
			   x = url.length
			}
		}
		if(strUrl.length == 0)
		  return false
		var parametros = unescape(strUrl.replace(/\+/g," "));
		this.stringParametro = parametros;
		parametros = parametros.substring(1).split("&");
		
		var str
		for (var x in parametros){
		    str = parametros[x].split("=")
			this.parametros[str[0]] = str[1]
		}
		this.hostNome = document.location.host
		this.path = document.location.pathname
		
		var span = document.getElementsByTagName("span")
		for (var i=0; i < span.length;i++ ){
			if (span[i].getAttribute("request")){
    		   if (this.parametros[span[i].request]){
			      span[i].innerHTML = this.parametros[span[i].request]
			   }
	        }
        }
			   
	},
    
	bodyRequest:function(request){
		  var parametro = this.parametros
		  var arrArt
		  var objInput;
		  var temp;
		  var objRequest;
		  
		  for (var i=0; i<request.length; i++){
		      temp = request[i].split("=");
			  if (temp.length == 2)
				 objRequest = {name:temp[0], value:temp[1]}
			  else objRequest = {name:temp[0], value:temp[0]}
			  
			  if (parametro[objRequest.value]){
			     if (parametro[objRequest.value].length > 0) {
					if (document.forms[0][objRequest.name]) {
					   document.forms[0][objRequest.name].value = parametro[objRequest.value]
					}
					else{
					   objInput = document.createElement('<input name="'+objRequest.name+'">')
			           objInput.setAttribute("type", "hidden")
                       objInput.setAttribute("value", parametro[objRequest.value])
                       document.forms[0].appendChild(objInput)
                       objInput = null
				    }
				 }
			  }
		  }
    },
	mostrarRequest:function(){
	    
	}
}
//---------------------------------------------FIM CLASSE URL---------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------



inicial = {}
inicial.funcaoLoad;
inicial.contador = 0;
inicial.iniciarSistema = "";


inicial.startWindowOnload = function(){
	initLightbox();
	if (inicioWindow.length > 0){
	   if (document.getElementsByTagName("frameset").length == 0)
	      if (document.body.projeto != "site"){
		     new validacao.usuario({funcao:inicial.validacao})
		  }
	   else	inicial.validacao([true])
	}
	else{ inicial.validacao([true])}   
}


inicial.validacao = function(permissao){
   if (permissao[0]){
	  document.body.onscroll = fixa
      var tela = new inicial.iniciarTela();
      var funcao
      if (typeof document.body.onload == "function"){
         funcao = document.body.onload
	     funcao()
	     document.body.onload = "";
		 return false;
      }
   }
   else{
	  validacao.login()
   }
}

inicial.executa = function(){
	if (inicioWindow[inicial.contador]){
	   inicioWindow[inicial.contador]()
	}
	inicial.contador += 1
	if (inicial.contador >= inicioWindow.length){
	   clearInterval(inicial.iniciarSistema);
	}     
}

inicial.iniciarFrame=function(opt, refTagIni){
		   parRequest = []
		   if (refTagIni.request){
		      parRequest = refTagIni.request.split(",")
			  
		   }
		   var objUrl = new url();
		   var getRequest = objUrl.parametros
		   var parametro = "" ;
		   for (var i in parRequest){
		       if (getRequest[parRequest[i]]){
				  if (parametro.length == 0){
					 parametro = parRequest[i]+"="+getRequest[parRequest[i]];
				  }
				  else{
					 parametro += "&"+parRequest[i]+"="+getRequest[parRequest[i]];
				  }
			   }
		   }
		   if (opt.length == 0){
		      alert("Não a nenhuma opção para este frame");
			  return false;
		   }
		   if (refTagIni.childNodes.length == 0){
		      alert("Especifique os frames");
			  return false
		   }
		   for (var x=0;x < refTagIni.childNodes.length;x++){
		       if(opt[x])
			     refTagIni.childNodes[x].src = opt[x].nmUrlFuncionalidade.valor+"?num="+opt[x].cdMenu.valor+"&"+parametro;
		   }

}

inicial.opcoes = {};

//----Primeira função a ser chamada é esta a função iniciar tela

inicial.iniciarTela = Class.create()
inicial.iniciarTela.prototype = {
	   inicializar:function(){
	   var parRequest = [];
	   var refTagIni
	   var urlPag = new url();
	   var pagina = "";
	   if (urlPag.parametros["num"]){
	      pagina = urlPag.parametros["num"];
	      document.body.pagina = urlPag.parametros["num"];
	   }
		  
	   if (document.getElementsByTagName("frameset").length == 0){ 
	      refTagIni = document.body;
		  if (document.body.request)
		     parRequest = document.body.request.split(",");
		  // - montando o atributo request
		  if (!document.forms[0]){
	         alert("Especifique um form após a tag body");
		     return false;
	      }
		  parRequest.push("num");
		  if (!urlPag.parametros["num"])
		     document.forms[0].appendChild(document.createElement('<input type="hidden" name="num">'))
		  urlPag.bodyRequest(parRequest);
	   }
	   else{
		   // -- Quando a tela for um frame
		  //----Zerando os valores de montar tela pois o document é um frame
		  inicioWindow = [];
		  var frame = document.getElementsByTagName("frameset");
	      refTagIni = frame[0]
		  if (frame.length == 0){
			 alert("Para iniciar uma página tem que inserir as tags frameset ou body") 
			 return false;
		  }
	   }
	   
	   if (document.body.projeto != "site"){
	      var pagFilho = new Ajax.request('JSON/json_menu.asp',
						   { 
						   metodo:'get',
						   parametros:'cdMenu='+pagina ,
						   arguments:refTagIni,
						   completo:this.guardaOpcoes 
						   }
	   				  )
	   }
	   else{inicial.iniciarSistema = window.setInterval(inicial.executa,80)}
       },
       
	   
	   
       //-------FUNÇÃO QUE GUARDA AS OPÇÕES DA PAGINA
       guardaOpcoes:function(opt, refTagIni){
		  if (opt){
		     inicial.opcoes = opt[0];
			 //------CASO FOR FRAME
			 if (refTagIni.tagName == "FRAMESET"){
			    inicial.iniciarFrame(opt[0].opcoesFilhas, refTagIni);    
			 }
		  }
		  //-----------iniciando as funções que vão montar a tela
		  //-----------Aqui é o inicio do sistema
		  inicial.iniciarSistema = window.setInterval(inicial.executa,80)
		  
       }
}


//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
// Classe validacao -(Em estudo no momento utilizando a função env_nav)
/* 
   Nome: validacao
   Função: Controlar a validaçao de usuário e de acesso no sistema
           sua principal caracteristica é validar se o usuário existe e se ele tem permissão para utilizar o sistema
		   esta classe tem um foco maior para os objetos de manipulação de dados
		   
   methodos: #usuário - Verifica se o usuário que esta tentando logar tem permissão para isso

			 #acessoObjeto - Verifica se o usuário logado tem permissão de acesso para efetuar a ação
			 
			 #acessoPagina - Verifica se o usuário logado tem permissão de acesso para efetuar a ação
			 
*/

var validacao = {};
validacao.Base = function(){}
validacao.Base.prototype = {
  setOpcoes:function(options){
      this.options = {
	                funcao:'login',
	                url:'',
	                validaUsu:true
					}
	  Object.extend(this.options, options || {});				
  }
}



validacao.login = function(){
   showLightbox(mensagem.login())
return false;
}

validacao.objExecutar = {};
validacao.funcUsu = {};

validacao.usuario = Class.create();
validacao.usuario.prototype = {
    options:{
		    funcao:'',
	        argumentos:false
	        },
	
	inicializar:function(options){
		  hideLightbox()
		  if (!options){
		     options = validacao.funcUsu
		  }else{validacao.funcUsu = options}
		  
		  Object.extend(this.options, options || {});
		  if (options.funcao) {
	         var str_url = "operacao=validar";
			 if (document.getElementById("codIdeLogon")){ 
	            str_url += '&cod='+document.getElementById("codIdeLogon").value+'&codigo='+ document.getElementById("codigoIdeLogon").value;
             }
			 var argumento = false;
			 if (this.options.argumentos)
			    argumento = this.options.argumentos
			   
				var objUsuario = new Ajax.request("controleObjetos/co_usuario.asp",
			                 {
			                 metodo:'get',
			                 parametros:str_url,
			                 arguments:argumento,
			                 completo:options.funcao
			                 })
          }
		  else{
             alert("Aguarde o fim da operação que está sendo executada")
          }	   	 				 
    }
}



validacao.validarFuncao = Class.create();
validacao.validarFuncao.prototype = Object.extend(new validacao.Base(), {
      
	  inicializar:function(options){
         if (!options){
		    options = validacao.objExecutar;
	     }		   
		 
		 this.setOpcoes(options)
		 //------Guardando o objeto em uma variavel Global de validar para executar as ações após as validações
		 validacao.objExecutar = options;
		 if (options.validaUsu){
		    var usu = new validacao.usuario({funcao:this.executaAcao});
		 }
		 else{this.executaAcao([true])}	
	  },
	     
		 
		 
		 
	  executaAcao:function(permissao){
		 if (permissao[0]){
		    var par = new tagObject.getTagObject();
			var ajax = new Ajax.request(validacao.objExecutar.url,
		               {
		               metodo:'get',
		   			   parametros:"operacao="+validacao.objExecutar.funcao+"&"+par.parametros(),
					   completo:showLightbox
					   }
					   );
	  	 }
	     else{
	        alert("Usuário Inválido")
	        validacao.login(validacao.validarFuncao);
	     }
	  }
})

validacao.acessoPagina = function(confUsu){
    if (confUsu){
	   
	}
	else{
	   alert("Usuário Inválido")
	   validacao.login();
	} 
}

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


/* Classe acao
   Nome: acoes
   Função: Controlar o acesso do usuário deixando que ele altere, exclua e insira dados no sistema
           sua principal caracteristica é de habilitar e controlar botões a baixo de todo o conteúdo da página
		   esses que servirão para que se permita alterar os dados do registros
		   
   methodos: #opcoes - retorna uma array com as opções de site para cadastro
             
		     #inicializar - metodo construtor que carrega as opções assim que o metodo é instanciado
  
             #setAcoes - mostra os atributos padrões que pertencem as tags que são
                    
			 #getAcoes - este metodo tem como finalidade colocar ações e pupular as tags que estão na tela 
			        
			 #executar - este metodo tem como Recupera o valor das tag da tela
*/
var acao = {};
acao.setAcoes = function(){
   var parametro;
   if (document.body.pagina){
	  var cdMenu = document.body.pagina
      opt = inicial.opcoes
	  if (opt){
		 parametro = "cdFuncionalidade="+opt.cdFuncionalidade.valor;
		 var optAjax = new Ajax.request("JSON/json_funcionalidade.asp",
						   {
						   metodo:'get',
						   parametros:parametro,
						   completo:acao.getAcoes
						   });
	  } 
   }   
}

acao.arrayAcoes = new Array();
acao.getAcoes = function(func){
     if (func[0]){
	    acao.arrayAcoes = func[0].operacoes;
		var operacao = func[0].operacoes;
        var criarTabela;
		var idAcao = document.createElement("div");
		idAcao.setAttribute("id","divAcao");
		idAcao.style.align="center";
		
		var tabAcao = document.createElement("table");
		tabAcao.setAttribute("align", "center")
		var linha = tabAcao.insertRow(0);
		var celula;
		var buttom;
		
		for (var i in operacao){
		    celula = linha.insertCell(0);
		    celula.setAttribute("align","center"); 
		    buttom = document.createElement('<input onclick="acao.executar(this)" name="'+operacao[i].nmObjeto.valor+'">');
		    buttom.setAttribute("type", "button");
			buttom.setAttribute("name", operacao[i].nmObjeto.valor);
		    buttom.setAttribute("value", operacao[i].nmObjeto.valor);
			buttom.setAttribute("urlLink", operacao[i].nmUrlObjeto.valor);
	        //if (buttom.addEventListener)
            //   buttom.addEventListener("click", function(){acao.executar(buttom)}, true)
           // if (buttom.attachEvent)
           //    buttom.attachEvent("onclick", function(){acao.executar(buttom)})
			celula.appendChild(buttom);
					    
		}
	    idAcao.appendChild(tabAcao);
		document.body.appendChild(idAcao);
	 }
}

acao.executar = function(botao){
	   if (botao.value){
          var exec = new validacao.validarFuncao({
					  funcao:botao.value,
					  url:botao.urlLink,
					  validaUsu:true
		              })
	   }
	   else{
	      alert("Função inválida");
	   }
}

//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
// Ferramenta converção
/* 
   Nome: convertTagObject
   Função: esta ferramenta pega a tag que foi passada no atributo e chama a função que foi passada pelo atributo getObject do
           objeto. Oconteúdo do getObject tem que ser o nome de uma função que exista dentro do contexto da classe. 
		   Estas funções que estão dentro do contexto da classe retornam o objeto com os atrinutos que são esperados.
		   Cada função dessa trata o objeto de forma unica com o seu funcionamento e retorna um Array com os objetos. 
   
   atributos: functions   [Array] -> este atributo tem o nome dos tipos que possuem a função
              arrResposta [Array] -> Atributo que guarda as respostas(obj com os atributos filhos) que serão enviados
              
   options={elementoPai:(elemento pai), getObject:{tipo do objeto}}
   
   methodos: #validar  - mostra os atributos padrões que pertencem as tags que são
			 #importar(options) - este metodo tem como finalidade colocar ações e pupular as tags que estão na tela 
   
   Classe Herança 
			 nome: consulta - esta classe atende apenas as ferramentas dos objetos do tipo consultar
			 metodos: #inicializar(objFilho) - metodo construtor que é startado quando a classe é estanciada.
			                                   este metodo recebe como parametro obj filho.
											   oa estanciar a classe o metodo construtor chama um metodo normal
											   que popula o otributo arrResposta dando a ele o bjeto com as informações nescessárias
			          #cabecalho(objFilho)   - este método recupera os atributos relevantes para o tipo de serviço e joga para um
					  						   objeto do JavaScript
*/
convertTagObject = {}
convertTagObject.functions = ['consulta']
convertTagObject.validar = function(nmFunc){
   for (var i in convertTagObject.functions){
	   if (convertTagObject.functions[i] == nmFunc)
	      return true;
   }
   return false;
}

convertTagObject.arrResposta = []
convertTagObject.importar = function(options){
	var filhos;
	var func;
	
	if (convertTagObject.validar(options.getObject)){
	   if (options.elementoPai){
	      var filhos = options.elementoPai.childNodes;
		  for (var i=0; i < filhos.length; i++)
	          new convertTagObject[options.getObject](filhos[i])	   
	   }
	   return convertTagObject.arrResposta;
	}
	else {
	   return []
	}
}

convertTagObject.consulta = Class.create();
convertTagObject.consulta.prototype = {
	inicializar:function(obj){
	    if (this[obj.id])
		   this[obj.id](obj)
	},
	cabecalho:function(obj){
	   if (!convertTagObject.arrResposta[obj.id])
	      convertTagObject.arrResposta[obj.id] = [];
	   
	   obj.campoSoma = (obj.campoSoma)?obj.campoSoma.split(","):[];
	   objSoma = {atributo:false, type:false, setResult:false};
	   arrObjSoma = []
	   for (var x in obj.campoSoma){
		   objTemp = obj.campoSoma[x].split(";")
		   objSoma.atributo = objTemp[0]
		   objSoma.type = (objTemp[1])?objTemp[1]:'numero'
		   objSoma.setResult = objTemp[2]
		   arrObjSoma.push(objSoma)
	   }
	   
	   convertTagObject.arrResposta[obj.id].push({
												  campoSoma:arrObjSoma,
												  opcFilho:(obj.opcFilho)?obj.opcFilho.split(","):[],
												  descricao:obj.innerHTML
												})
	}
}


//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
// Classe consulta
/* 
   Nome: consulta
   Função: Controlar, montar, manipular e recuperar valores de todas e qualquer tipo de tag que esta dentro do da página exibida
   methodos: #Base - mostra os atributos padrões que pertencem as tags que são
                    Base.nome - name da tag
					Base.tag - Tipo da tag
					Base.Parametro - valores para refinamento de busca para a tag
			 #setTagObject - este metodo tem como finalidade colocar ações e pupular as tags que estão na tela 
			        setTagObject.inicializar(construtor) - Obtem os resultados para manipular e popular tags usando a classe Ajax
					setTagObject.select - popula tag select
					setTagObject.checar - popula tag input checkbox
			 #getTagObject - este metodo tem como Recupera o valor das tag da tela
			 
			        
			 
*/
var consulta = {};

consulta.Base = function() {}
consulta.Base.prototype = {
     atributos:function(options){
	     this.options = {
			 nome:'', //--|String|--Nome da consulta
			 paginar:false, //--|boolean|--descreve se a pagínação é nescessaria ou não
			 parametros:'',//--|String|--Parametros para selecionar os objetos
			 lista:false,
			 pagina:1,
			 nRegistro:10
			 
		 }
		 Object.extend(this.options, options || {});
	 }
}
consulta.getLista = Class.create();
consulta.parLista = [];
consulta.arrayConsulta = new Array();

consulta.consultaUpdate = function(idConsulta, nPagina){
   if (consulta.arrayConsulta[idConsulta]){
	  if (nPagina){
         consulta.arrayConsulta[idConsulta].tagObject.pagina = nPagina
	  }
	  consulta.arrayConsulta[idConsulta].tagObject.innerHTML = ""
	  consulta.arrayConsulta[idConsulta].objeto.consulta(consulta.arrayConsulta[idConsulta].tagObject)
   }
}

consulta.paginar = function(idConsulta, nPagina){
   if (consulta.arrayConsulta[idConsulta]){
	  consulta.arrayConsulta[idConsulta].tagObject.innerHTML = ""
	  var tag = consulta.arrayConsulta[idConsulta].tagObject
	  var registros = consulta.arrayConsulta[idConsulta].registros
	  var objeto = consulta.arrayConsulta[idConsulta].objeto
	  objeto.montarLista(registros,[objeto,tag], nPagina);
   }
}
/*
consulta.getRelacao = function(d){
     var rel = (document.getElementById(d).rel)?document.getElementById(d).split(","):false
	 var arr = []
	 if (rel){
		for (var i in rel){
			if (document.getElementById(rel[i]))
			   arr.push(document.getElementById(rel[i]))
		}
	 }
	 return (arr.length > 0)?arr:false;
}



consulta.ativarRelacao = function(arr){
     
	 window.setInterval
}
*/

consulta.fila = []
consulta.rodar = ""
consulta.executarFila = function(){
	var temp
	if (consulta.fila.length > 0) {
		temp = consulta.fila.shift()
		temp.f(temp.p)
	}
	else{
	   clearInterval(consulta.rodar)
	}
}

consulta.getLista.prototype = Object.extend(new consulta.Base(),{
	 inicializar:function(){
	     var Consulta = document.getElementsByTagName("div");
		 for (var i in Consulta){
		     if (Consulta[i].tipo){
			    if (typeof this[Consulta[i].tipo] == "function"){
				   consulta.arrayConsulta[Consulta[i].id] = {tagObject:Consulta[i], objeto:this};	
	               //-----------Buscando as ferramentas para consulta 
				   if (Consulta[i].tipo == "consulta")
				      consulta.arrayConsulta[Consulta[i].id].ferramentas = convertTagObject.importar({elementoPai:Consulta[i],getObject:'consulta'})
				   //----------------
				   if (Consulta[i].ini){
					  if (Consulta[i].tipo != "consulta")
					     consulta.fila.push({f:this[Consulta[i].tipo],p:Consulta[i]});
					  else this[Consulta[i].tipo](Consulta[i])
				   }
				}
			 }
		 }
		 var Consulta = document.getElementsByTagName("span");
		 for (var i in Consulta){
		     if (Consulta[i].tipo){
			    if (typeof this[Consulta[i].tipo] == "function"){
				   consulta.arrayConsulta[Consulta[i].id] = {tagObject:Consulta[i], objeto:this};	
	               //-----------Buscando as ferramentas para consulta 
				   if (Consulta[i].tipo == "consulta")
				      consulta.arrayConsulta[Consulta[i].id].ferramentas = convertTagObject.importar({elementoPai:Consulta[i],getObject:'consulta'})
				   //----------------
				   if (Consulta[i].ini){
					  if (Consulta[i].tipo != "consulta")
					     consulta.fila.push({f:this[Consulta[i].tipo],p:Consulta[i]});
					  else this[Consulta[i].tipo](Consulta[i])
				   }
				}
			 }
		 }
		 consulta.rodar = window.setInterval("consulta.executarFila()",500)
	 },
	 
	 parametros:'',
	 
	 pasta:function(obj){
		 if (!obj.id){
		    alert("Especifique o id para a aasta")
		 }
		 else{
		    new pasta.iniciar(obj);
		 }
	 },
	 caixa:function(obj){
		 new caixa.getCompra(obj.id) 
	 },
	 
	 listaAdicionar:function(obj){
		    if (!obj.id){
			   alert("Especifique o id Da lista Adicionar")
			}
			else{
			   if (!listaAdicionar.listasAtivas[obj.id])
			      listaAdicionar.listasAtivas[obj.id] = new listaAdicionar.Tabela(obj)
			   
			   if (obj.carregarDados){
		          ativarFuncao.listaAdicionar(obj.id)
	           }
			}
	 },
	 
	 
	 consulta:function(options){
			 // aqui o parametro options é a própria tag div da 
			 var pag
			 var tipo
			 if (options.nRegistro){
			    pag = "nRegistro="+options.nRegistro
			 }
			 
             if (options.pagina){
			    numPagina = "pagina="+options.pagina
			 }
			 else{
				options.pagina = 1 
				numPagina = "pagina=1"
			 }
			 tipo = "listar=ok";
			 //--Guradando os objetos Ferramentas
			  
			 
			 var tags = new tagObject.getTagObject();
			 var parametros = tags.parametros();
			 
			 if (parametros.length > 0){
			    par = parametros+"&"+tipo+"&"+pag+"&"+numPagina;
				this.parametro = parametros
			 }
			 else{
				par = tipo+"&"+pag+"&"+numPagina;
			 }
			 var url
			 if (options.url)
				url = options.url
			 else url = "JSON/json_"+options.id+".asp"	
			 
			 var ajax = new Ajax.request(url,
										{
		                                metodo:'get',
		 								parametros:par,
		 								arguments:[this, options],
										completo:this.montarLista
	     	 })
	 },
	 
	 
	 montarLista:function(){
	        var resuLista = arguments[0];
			var objeto = arguments[1][0]
			var tagConsulta = arguments[1][1]
			var pagina = (arguments[2])?arguments[2]:1
			var navPar
	        var refObjeto = (tagConsulta.refObjeto)?tagConsulta.refObjeto+";"+tagConsulta.id:tagConsulta.id;
	        var refAcao = (tagConsulta.refAcao)?tagConsulta.refAcao+";consulta.consultaUpdate":"consulta.consultaUpdate";
			consulta.arrayConsulta[tagConsulta.id].registros = resuLista
		   	
			var opcoes = (inicial.opcoes.opcoesFilhas)?inicial.opcoes.opcoesFilhas:[]
			var camposInativos = new Array()
			if (tagConsulta.camposInativos){
			   camposInativos = tagConsulta.camposInativos.split(",");
			}
            
			var ativo 
			//--- criando a tabela
			var tabela = document.createElement("table");
			tabela.align = "center"
			tabela.cellspacing = 1
			tabela.cellpadding = 0
			tabela.color = "pink"
			var texto;
			var linhaRel;
			var Link
			var linha
			consulta.parLista = []
			var celula;
/* -------------A função abaixo capturaos os filhos da consulta 
			    ou seja são tags cujo seu atributo ID é fixo onde cada
				uma dessas tag possui um comportamento dentro da consulta
				EX: id=BarraTarefas -> esta tag tem a como funcionalidade apresentar
				barra de tarefa no topo e no rodapé da consulta
			    O nome desta função setFerramentas()
----------------*/
			var barraFerramentas = consulta.arrayConsulta[tagConsulta.id].ferramentas 
			var contCols = 0
			for (var i in resuLista[0])
			    contCols += 1 
			if (barraFerramentas["cabecalho"]){
			   linha = tabela.insertRow(0)
			   celula = linha.insertCell(linha.cells.length)
			   celula.colSpan = (contCols)?contCols+2:1;
			   celula.className = "cabecalho"
			   celula.width = "100%"
			  
			   
			   var cabecalho = barraFerramentas["cabecalho"][0]
			   if (cabecalho.campoSoma){
			      var soma = []
				  for (var i in cabecalho.campoSoma){
					  soma[cabecalho.campoSoma[i].atributo] = {valor:0, nome:''}
					  tempSoma = 0
					  for (var r in resuLista){
						  if (!resuLista[r][cabecalho.campoSoma[i].atributo]){
							  alert("o atributo "+cabecalho.campoSoma[i].atributo+" não existe no objeto da consulta "+tagConsulta.id)
						      return false;
						  }
						  // somando
						  tempSoma += convDecimal(resuLista[r][cabecalho.campoSoma[i].atributo].valor)
						  tempDescr = resuLista[r][cabecalho.campoSoma[i].atributo].nome
					  }
					  soma[cabecalho.campoSoma[i].atributo] = {valor:tempSoma, nome:tempDescr}
				  }
			   }
     //----------- Descrição do que vai ser colocado no cabeçalho
               var descrCabecalho =  cabecalho.descricao
               
    //----------- Colcando a soma dos objetos caso tenha---------------------------
			   var textoSoma = "<b><font size=3> Totais</font></b> <table  class=cabecalho border=0 cellpadding=0 cellspacing=0><tr> <td>Total de Registro:"+resuLista.length+"<input type=\"hidden\" name=\"resultLista\" value=\""+resuLista.length+"\">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;  </td>"
			   var arrSoma = cabecalho.campoSoma
			   
			   for (var i in arrSoma){
				   var convSoma = (arrSoma[i].type == "moeda")?pdrBrasil(soma[arrSoma[i].atributo].valor):soma[arrSoma[i].atributo].valor
			       textoSoma += '<td><b>Soma do campo '+soma[arrSoma[i].atributo].nome+':</b>' +
				                convSoma+((arrSoma[i].setResult)?'<input type="hidden" value="'+convSoma+'" name="'+arrSoma[i].atributo+'" >':'')+
								'&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; '+
				                '</td>';
			   }
               textoSoma += "<td><b>"+ descrCabecalho+"</td></tr><table>"
   //-----------Populando a celula
               celula.innerHTML = textoSoma  
    //----------- Colcando as opções dos objetos ----------------------------------
	           
			   
			   for (var opc in cabecalho.opcFilho){
				   if (opcoes[cabecalho.opcFilho[opc]]){ 
					  Link=document.createElement("input")
					  Link.type="button";
					  Link.onclick = function(){
									        navegar.start(true)
									  }
					  Link.style["cursor"] = "hand";
					  Link.setAttribute("idFilho",cabecalho.opcFilho[opc]);
					  Link.setAttribute("refObjeto",refObjeto);
					  Link.setAttribute("refAcao",refAcao);
					  Link.value = " "+opcoes[cabecalho.opcFilho[opc]].dsMenu.valor+" ";
					  celula.appendChild(Link);
				   }else{alert("Não existe filho pra o index "+cabecalho.opcFilho[opc])}
			   }
			}
			
//---------------------------------------------------------------------------------------
//-----------------------Descrição dos conteúdos-----------------------------------------
			
			var linha = tabela.insertRow(tabela.rows.length)
			if (tagConsulta.checkBox){
			   celula = linha.insertCell(linha.cells.length)
			   celula.className = "cabecalho"
			   celula.setAttribute("align","center")
			}
			for (var i in resuLista[0]){
				ativo = true;
				for (var x in camposInativos){
				    if (camposInativos[x] == i){
					   ativo = false;
					}
				}
				if (ativo){
					   celula = linha.insertCell(linha.cells.length)
					   celula.setAttribute("align","center")
					   celula.className = "cabecalho"
					   texto = document.createTextNode(resuLista[0][i].nome);
					   celula.appendChild(texto);
				}
			}
			if (opcoes.length > 0){
			   celula = linha.insertCell(linha.cells.length);
			   celula.setAttribute("align","center")
			   celula.className = "cabecalho"
			   texto = document.createTextNode("Opções");
			   celula.appendChild(texto);
			}
			var optFilho = (tagConsulta.opcFilho)?tagConsulta.opcFilho.split(","):false;
//-------------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------verificando paginação----------------------------------------------------
            var registros = (resuLista)?resuLista.length:0;
			var iniRegistros = 0
			if (tagConsulta.nRegistro < registros){
			   regConsul = tagConsulta.nRegistro*1
			   registros = pagina * regConsul
			   if (resuLista.length < registros)
			      registros = resuLista.length
			   iniRegistros = ((pagina - 1) * regConsul)
			   
			   
			   
			}
//-------------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------Montando o resultado da consulta----------------------------------------------------
			for (var i=iniRegistros; i < registros;i++){
			    linha = tabela.insertRow(tabela.rows.length);
				navPar = "";
				if (tagConsulta.checkBox){
				   if (resuLista[i][tagConsulta.checkBox]){
				      celula = linha.insertCell(linha.cells.length);
					  celula.setAttribute("align","center")
					  celula.className = "conteudo"
					  celula.innerHTML = '<input type="checkbox" name="'+tagConsulta.checkBox+'" value="'+resuLista[i][tagConsulta.checkBox].valor+'"> '
				  
				   }
				}
				for (nmCampo in resuLista[i]){
					ativo = true;
				    for (var x in camposInativos){
					    if (camposInativos[x] == nmCampo){
					       ativo = false;
					    }
					}
					if (ativo){
					   celula = linha.insertCell(linha.cells.length);
					   celula.setAttribute("align","left")
					   celula.className = "conteudo"
					   texto = document.createTextNode(resuLista[i][nmCampo].valor);
					   celula.appendChild(texto);
					   if (navPar.length == 0)
					      navPar += nmCampo+"="+resuLista[i][nmCampo].valor;
					   else navPar += "&"+nmCampo+"="+resuLista[i][nmCampo].valor;	  
					}
			 	}
				if ((opcoes) && (optFilho)){
				   celula = linha.insertCell(linha.cells.length);
				   celula.setAttribute("align","center")	
				   consulta.parLista[i] = navPar
				   
				   for (var opc in optFilho){
					   if (opcoes[optFilho[opc]]){ 
					      Link=document.createElement("span");
						  Link.attachEvent("onclick", function(){
				    							  new navegar.enviar(
		                                                     {
					                                         tag:event.srcElement,
														     parametros:consulta.parLista[event.srcElement.nPar], 
														     autenticar:true
														     }
												  )
										  });
						  Link.style["cursor"] = "hand";
						  Link.style["color"] = "green";
						  Link.setAttribute("nPar",i)
						  Link.setAttribute("idFilho",optFilho[opc]);
						  Link.setAttribute("refObjeto",refObjeto);
						  Link.setAttribute("refAcao",refAcao);
						  texto = document.createTextNode(" "+opcoes[optFilho[opc]].dsMenu.valor+" ");
						  Link.appendChild(texto);
						  celula.appendChild(Link);
					   }else{alert("Não existe filho pra o index "+optFilho[optFilho[opc]])}
				   }
				}
			}
			linha = tabela.insertRow(tabela.rows.length);
			celula = linha.insertCell(0);
			celula.setAttribute("id","paginar");
			celula.setAttribute("colspan", ((resuLista[0])?resuLista[0].length+1:1));
			tagConsulta.appendChild(tabela);
			
			linha = tabela.insertRow(tabela.rows.length);
			celula = linha.insertCell(0);
			celula.setAttribute("id","paginar");
			celula.setAttribute("colSpan",contCols);
			celula.align="center";
			if (!tagConsulta.noBot){
			   var botao = document.createElement("<input type=\"button\" value=\"consultar\" onclick=\"consulta.consultaUpdate('"+tagConsulta.id+"')\">")
			   celula.appendChild(botao)
			}
			tagConsulta.appendChild(tabela);
//----------------------------------------------------------------------------------------------------
//Paginando a consulta-----------------------------------------------------------------------------
			if (tagConsulta.nRegistro && resuLista){
			   if (tagConsulta.nRegistro < resuLista.length){
				  var tbPag  = document.createElement("table")
				  linPagi = tbPag.insertRow(0)
				  numPg = (resuLista.length / (tagConsulta.nRegistro*1) )+""
				  numPg = numPg.split(".")
				  paginas = (numPg[0]*1)+((numPg[1])?1:0)
				  
				  for (var x=1 ; x <= paginas; x++){
				      celPagi = linPagi.insertCell(linPagi.cells.length)
					  celPagi.innerHTML = '<span onclick="consulta.paginar(\''+tagConsulta.id+'\','+x+')"' +
					                      'style="cursor:hand; color:blue;">'+
										  ' '+((x==pagina)?("<b>"+x+"</b>"):x) +'</span>';
				  }
				  tagConsulta.appendChild(tbPag)
			   }
			}
			recuperaHref();
	 },
	 
	 
	 detalhe:function(opcDet){
		var rels
		var url = (opcDet.url)?opcDet.url:'json/json_'+opcDet.id+'.asp';
		var envPar = (opcDet.buscaParametro)?opcDet.buscaParametro.split(","):[]
		var tag = new tagObject.getTagObject()
		var FR = (opcDet.filtroRequerido)?opcDet.filtroRequerido.split(","):[]
		for (var i in FR){
			if (tag.chkAtributo(FR[i])==false){
			   return false;
			}
		}
		
		// argumentos enviados são os objetos para poupular e os objetos relacionados
		args = [, (opcDet.rel)?opcDet.rel.split(","):[]]
		var ajaxDet = new Ajax.request(url,
		                              {
									  metodo:'get',
		 					          parametros:tag.parametros(envPar),
									  objeto:opcDet,
									  arguments:(opcDet.objPopular)?opcDet.objPopular.split(","):[],
		 					          completo:tagObject.popularTag
									  }
									  )
	 },
	 agenda:function(obj){
	    new agenda.setAgenda(obj)
	 },
	 calendario:function(obj){
	    new calendario.getCalendario(obj.id)
	 },
	 menu:function(objMenu){
		 carregarMenu(objMenu);	 
	 }
	 
})


//-----------------------------------------FIM DA FUNÇÃO CONSULTA-----------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------

/*  classe textList
    --> DESCRIÇÃO: Quem nunca viu um sistema que ao inserir alguns digitos em determinado campo ele automaticamente
	               retorna alguns valores para serem selecionados pelo usuário e após a seleção seleção ele preenche
				   outros campos que tem relação com o mesmo? Isto é ótimo não é mesmo?
				   Infelizmente este recurso naum é muito popular na web pois ele precisa carregar muitos registros de 
				   uma única vez prejudicando a performance do sistema (e sem mencionar que é o ó ficar posicionando e
																		controlando divs e caixas externas).
				       A classe textList vem para resolver essa questão, pois ela utiliza a tecnologia ajax melhorando assim
				   a performance do sistema e trazendo dados consistentes para qualquer tipo de consulta.
				   Vejamos agora como ela funciona com seus metodos e atributos.
				   
                                                   
             		                                     :METODOS:
			       # textList.getList - Metodo inicial que sera chamado apartir do evento onkeyup disparado de um objeto
				                        input text.
										A primeira coisa que ele faz é verificar se a text list ja foi iniciada e 
										qual tecla foi digitada pois algumas recebem funções especiais 
										exe: Ceta para cima - subir um registro(se a textList ja estiver Ativa)
										     Ceta para baixo - descer um registro(se a textList ja estiver Ativa)
											 Enter - confirmar seleção se a textList ja estiver Ativa
										Se a tecla digitada não for nenhuma das anteriores ele vai no servidor buscar 
										os registros.
				   # textList.montarTabela - este metodo recebe as informações vindas do servidor e as ultiliza
				                             para montar a textList com as suas propriedades e funções
				   # textList.selecionar - este Método só é executado quando a textList esta ativa.Ele é executado a partir
				                           dos eventos disparados pelo objetos(onMouseOver, onkeyUp:ceta p/cima, ceta p/baixo)
	               # textList.confirmar  - Metodo que confirma a seleção do registro jogando o seu valor para o objeto e se 
				                           nescessário populando alguns objetos.
			       
			 
			                                           :PROPRIEDADES: 
	         @ textList.objetosAtivos - Array que contem os valores Ativos na list Box
	         @ textList.funcoes - funcao[13], funcao[38], funcao[40] estats funções são as tais para os caracteres especioais
			                      a sua responsabilidade é de selecionar e confirmar a seleção dos registros.
			 @ textList.objSel - mostra o numero de indexação do objeto Selecionado
			 @ textList.objTag - guarda uma referencia da tag que manipula esta função
	                                               
												   
												   :Manipuladores de evento HTML:
			 * <input type="text" tipo=["lista"] campoBusca=[nmCampo] filtro=[nmAtributo,nmAtributo] digitoIni=[n]
			    url=[nmUrl] popular=[nmInput,nmInput=nmAtributo] getListas="[idLista1, IdLista2]">
				
			   - tipo:[lista] indentifica que o text é um textList e atribui para o evento on keyup a chamada para a classe
			   - campoBusca:[nome do campo] Este atributo identifica qual o campo do registro devera ser mostrado no input da tela
			   - filtro:[nome dos atributos] identifica nome de outros atributos que serão usados na busca para comparação
			   - digitoIni:[numero] Este é responsável para saber apartir de quantos digitos ele pode consultar uma lista no
			               servidor.
			   - url:[nome da URL]	nome e caminho de onde vira a consulta dos objetos
			   - popular:[nmAtributo, nmInput=nmAtributo] este atributo informa quais as caixa de de seleção serão populadas
			   - getListas:Neste atributo deve se colocar separado por virgula o id das listas que deverão serão carregadas após o fim da execução caso seja nescessário
			   
*/
var textList = {};
//--- Atributos da classe text Lit
textList.objAtivos = []
textList.funcoes = new Array();
textList.objSel = -1;
textList.objTag;
textList.popup = window.createPopup();

//-- Métodos da classe text List
textList.funcoes[38] = function(){
   if (textList.objSel > -1){
	   if ((textList.objSel <= textList.popup.document.getElementById("tabela").rows.length-1) && (textList.objSel > 0)){
	      textList.selecionar(textList.objSel - 1);
	   }
	}
	return false;
}
textList.funcoes[40] = function(){
   if (textList.objSel > -1){
	   if (textList.objSel < textList.popup.document.getElementById("tabela").rows.length-1){
	      textList.selecionar(textList.objSel + 1);
	   }
	}
	else{
	   textList.selecionar(0);
	}
	return false;
}
textList.funcoes[13] = function(e){
	if (textList.objSel > -1){
	   textList.confirmar()
	}
	return false;
}

//--metodos de seleção dos objetos
textList.selecionar = function(num){
   if (textList.objSel > -1)
      textList.limpar(textList.objSel)
   var t = textList.popup.document.getElementById("tabela")
   var r = t.rows(num)
   textList.objSel = num
   r.style.background = "blue"
   r.style.color = "#ffffff"
}
textList.limpar = function(num){
   t = textList.popup.document.getElementById("tabela")
   r = t.rows(num)
   r.style.background = "#ffffff"
   r.style.color = "#000000"
}

textList.confirmar = function(){
   textList.objTag.value = textList.objAtivos[textList.objSel][textList.objTag.campoBusca].valor
   var obj = {};
   //--- populando outro objeto e outros atributos
    if (textList.objTag.getObjetos){
	   //---- Nesta tag recebe-se a url dos objetos que serão chamados
	   var url = textList.objTag.getObjetos.split(",")
       
	}
	
   //--- populando os atributos do mesmo objeto
   
   if (textList.objTag.popular){
      var popular = textList.objTag.popular.split(",")
	  for (var i in popular){
	      popular[i] = popular[i].split("=");
		  v = 0
		  if (popular[i].length > 1)
		     v = 1
		  
		  if (!textList.objAtivos[textList.objSel][popular[i][v]]){
			 alert("O atributo "+popular[i][v]+" da propriedade getAtribute não existe no objeto")
		  	 return false
		  }
		  if (!(document.forms[0][popular[i][0]] || document.getElementById(popular[i][0]))) {
			 alert("O atributo "+popular[i][0]+" da propriedade getAtribute não existe no DOCUMENT verifique o nome")
			 return false
		  }	
		  obj[popular[i][0]] = textList.objAtivos[textList.objSel][popular[i][v]]
	  }
      tagObject.popularTag([obj],[])
   }
   textList.popup.hide()
   
   if (textList.objTag.getListas){
      //LA - Lsita Adicionar
	  //Montando o lup para carregar o lista adicionar 
	  var list = textList.objTag.getListas.split(",")
	  for (var i=0; i<list.length;i++){
	      if (list[i]){
	         if (!document.getElementById(list[i])){
	            alert("O objeto "+list[i]+" não existe no Objeto");
	            return false;
	         }
		     listaAdicionar.listasAtivas[list[i]].setCarregarObjetos(list[i])
		  }
      }
	  
	  //textList.funcCarregarLA = setInterval("textList.carregarLA()",100)
   }	  
}


textList.getList = function(evt){
   if (!evt){
      alert("O evento não foi localizado")
	  return false;
   }
   evt.cancelBubble = true;
   //---------------------------limpando o conteúdo antigo
	if (evt.srcElement.limpar){
	   limpar(evt.srcElement.limpar.split(","))
	}
   if (evt.srcElement.digitoIni){
      if ((evt.srcElement.digitoIni*1) >= evt.srcElement.value.length){
		 if (textList.popup)
		    textList.popup.hide()
		 return false
	  }
   }
   if ((textList.funcoes[evt.keyCode]) && (textList.popup.document.getElementById("tabela")) ){
	  var validaCaixa = textList.funcoes[evt.keyCode](evt);
      if (!validaCaixa){
         return false;
      }
   }
   
   textList.objSel = -1;
   textList.objTag = evt.srcElement;
   
   if (!evt.srcElement.url){
      alert("Informe a url");
	  return false
   }
   
   if (!evt.srcElement.campoBusca){
      alert("Informe o campo de busca");
	  return false
   }
   var parametros =  evt.srcElement.campoBusca +"="+ evt.srcElement.value
   if (evt.srcElement.filtro){
      var atr = evt.srcElement.filtro.split(",")
	  var parFiltro = new tagObject.getTagObject()
	  parametros += "&"+parFiltro.parametros(atr)
   }
   var url = evt.srcElement.url
   var ajax = new Ajax.request(url, {
					   metodo:'get',
		 			   parametros:parametros,
					   arguments:[evt.srcElement, evt.srcElement.value],
		 			   completo:textList.montarTabela
					   })
}   
   

textList.montarTabela = function(valor,args){
   if (valor.length == 0){
      if (textList.popup){
	     textList.popup.hide()
	  }
	  return false
   }
   var e = args[0]
   val = args[1]
   if (!val == e.value)
      return false;
   textList.objAtivos = valor;
   textList.caixaAtiva = true;
   var posicao = getPositionObj(e)
   var y = e.offsetHeight + posicao.y ;
   var x = posicao.x + e.clientLeft
   var h = 10 
   if (valor.length < 10)
      h = valor.length
   var altura = 24*h
   var largura = e.offsetWidth
   
   var conteudo = '<div id="Pop" style="width:'+largura+'px;height:'+altura+'px;overflow: auto; font-size:xx-small">'
   conteudo += "<table width=\"100%\" id=\"tabela\" cellspacing=0 cellpadding=0>"
  
   if (!valor[0][e.campoBusca]){
      alert("O campo para busca "+e.campoBusca+" não existe no objeto")
	  return false
   }
   for (var i in valor){
	   conteudo += "<tr><td onmouseover=\"parent.textList.selecionar("+i+")\" onclick=\"parent.textList.confirmar("+i+")\">"+ valor[i][e.campoBusca].valor+"</td></tr>"
   }
   conteudo += "</table></div>"
   textList.popup.document.body.style.border = "solid 1px black";
   textList.popup.document.body.innerHTML = conteudo;
   textList.popup.show(x,y,largura,altura,document.body);
}



//-----------------------------------------------------------------------------------------------------------------------
//----------------------------------------Função que monta Pastas de seleção--------------------------------------------

var pasta = {}
pasta.container = [];
pasta.objPastaAtiva = [] ;
pasta.Base = function(){};
pasta.Base.prototype = {
	getPastas:function(obj){
	   var objPasta = obj.childNodes;
	   var objPastaTemp;
	   var inpt;
	   var getCondicao = function(obj){
	        var arr = (obj.objCondicao)?obj.objCondicao.split(","):false
		    if (arr){
			   for (var i in arr){
				   arr[i] = arr[i].split("=");
				   if (arr[i].length == 2){
					  arr[i] = {nmAtributo:arr[i][0],idValorAtributo:arr[i][1]}
				   }else{arr[i] = {nmAtributo:arr[i][0],idValorAtributo:arr[i][0]}}
			   }
		    }
			return arr;
	   }
	   
	   var optFilhas = inicial.opcoes.opcoesFilhas
	   for (var x=0 ; x<objPasta.length; x++){
		   objPastaTemp = {
			              obj:objPasta[x],
						  id:objPasta[x].id,
						  filho:(objPasta[x].rel)?objPasta[x].rel:false,
						  getAtributos:(objPasta[x].setAtributos)?objPasta[x].setAtributos.split(","):false,
						  campos:(objPasta[x].campos)?objPasta[x].campos:false,
						  objCondicao:getCondicao(objPasta[x]),
						  url:(objPasta[x].url)?objPasta[x].url:false,
						  acoes:(objPasta[x].acoes)?objPasta[x].acoes.split(","):false,
						  openPagina:{
							        idFilho:(objPasta[x].idFilho)?objPasta[x].idFilho:false,
						            url:(objPasta[x].url)?objPasta[x].url:false, 
						            target:(obj.target)?obj.target:false}
		                  }
		   if (objPastaTemp.getAtributos){
			  for (var i in objPastaTemp.getAtributos){ 
		          if (!document.forms[0][objPastaTemp.getAtributos[i]]){
				     inpt = document.createElement('<input name="'+objPastaTemp.getAtributos[i]+'">');
		             inpt.setAttribute("type","hidden");
				     inpt.setAttribute("atributoPasta","true");
		             document.forms[0].appendChild(inpt);
				  }
			  }
		   }
		   if (objPastaTemp.objCondicao){
			  for (var i in objPastaTemp.objCondicao){ 
		          if (!document.forms[0][objPastaTemp.objCondicao[i].nmAtributo]){
				     inpt = document.createElement('<input name="'+objPastaTemp.objCondicao[i].nmAtributo+'">');
		             inpt.setAttribute("type","hidden");
				     inpt.setAttribute("atributoPasta","true");
		             document.forms[0].appendChild(inpt);
				  }
			  }
		   }
		   pasta.container[objPasta[x].id] = objPastaTemp;
	   }
	}
}
pasta.iniciar = Class.create();

pasta.iniciar.prototype = Object.extend(new pasta.Base(),{
		inicializar:function(obj){
		    if (!obj.inicio){
			   alert("Indique qual pasta será iniciada");
			   return false;
			}
			this.getPastas(obj);
			if (!pasta.container[obj.inicio]){
				alert("Verifique o valor do atributo inicio pois, "+obj.inicio+" não existe no objeto")
			    return false;
			}
			var pacote = {
				         nmObjeto:obj.id,
			             refContainer:pasta.container[obj.inicio]
					     }
			pasta.requestPastas(pacote);
		}
}
)

pasta.requestPastas = function(pacote){
	  container = pacote.refContainer
      if (!container.url){
	     alert("Preencha a tag url para o objeto "+container.obj.id);
		 return false;
	  }
	  
	  var url = container.url;
	  var par = "";
	  for (var i in container.objCondicao){
	      if (document.forms[0][container.objCondicao[i].nmAtributo]){
	         if (par.length > 0)
			    par += "&";
			 par += container.objCondicao[i].nmAtributo+"="+document.forms[0][container.objCondicao[i].nmAtributo].value;
		  }
	  }
	  // -- chamando a página no ajax
	  var ajax = new Ajax.request(url,
				 {
		         metodo:'get',
		 		 parametros:par,
		 		 arguments:[pacote],
				 completo:pasta.montarPasta
	     	     })
}

pasta.montarPasta = function(valor, pacote){
     objPai = document.getElementById(pacote[0].nmObjeto);
	 var container = pacote[0].refContainer;
	 var div;
	 var a;
	 var img;
	 var texto;
     var objAtributos;
	 var arrAtributos;
	 var vlCondicao;
	 var atributoErro;
	 if (!container.campos){
	    alert("Especifique quais são os camposde retorno do objeto ("+container.obj.id+")");
		return false;
	 }
	
	 for (var i in valor){
		 if (!(valor[0][container.campos]) ){
	        alert("Os campos ("+container.campos+") não existe no obj ");
	        return false;
	     }
	     if (container.getAtributo){
	        for (var x in container.getAtributo){
		        if (!valor[0][container.getAtributo[x]]){
				   atributoErro.push(container.getAtributo[x]);
			    }
		    }
		    if (atributoErro.length > 0){
			   alert("Os seguintes valores "+atributoErro+" da tag setAtribute não existem no objeto");
			   return false;
		    }
	     }
	 
	     if (container.objCondicao){
		    atributoErro = [];
	        for (var x in container.objCondicao){
		        if (!valor[0][container.objCondicao[x].idValorAtributo]){
				   atributoErro.push(container.objCondicao[x].idValorAtributo);
			    }
		    }
		    if (atributoErro.length > 0){
			   alert("Os seguintes valores "+atributoErro+" da tag objCondicao não existem no objeto");
			   return false;
		    }
	     }
		 div = document.createElement("div");
		 div.setAttribute("id",div.uniqueID);
		 div.setAttribute("containerFilho",container.filho);
		 div.setAttribute("container",container.id);
		 div.setAttribute("sitPasta","fechada");
		 div.style.position="relative"; 
		 div.style.top=0;
		 div.style.left=5;
		 vlCondicao = [];
		 if (container.filho){
		    if (!pasta.container[container.filho]){
			   alert("O objeto ("+container.filho+") não existe no documento verifique se o atriuto rel do obj ("+container.obj.id+") foi digitado corretamente");
			   return false;
			}
		    a = document.createElement("a");
			for (var x in container.objCondicao){
			    vlCondicao.push("'"+valor[i][container.objCondicao[x].idValorAtributo].valor+"'");
			}
		    a.setAttribute("href","javascript:pasta.movimento('"+div.id+"',["+vlCondicao+"])");
			img = document.createElement("<img name="+div.uniqueID+"_pm>");
			img.src = "img/pmais.png";
			img.border = 0;
			img.name = div.uniqueID+"_pm";
			a.appendChild(img);
			div.appendChild(a);
		 }
		 paiPasta = div;
		 if (container.acoes){
			arrAtributos = [];
			for (var y in container.getAtributos){
			    objAtributos = "'"+valor[i][container.getAtributos[y]].valor+"'";
			    arrAtributos.push(objAtributos)
			}
			paiPasta = document.createElement("a")
			paiPasta.setAttribute("href","javascript:pasta.enviar('"+container.id+"',["+arrAtributos+"])");
			div.appendChild(paiPasta);
		 }
		 
		 img = document.createElement("img");
		 img.src = "img/pasta_fechada.png";
		 img.border = 0;
		 img.name = div.uniqueID+"_pasta";
		 texto = document.createTextNode(valor[i][container.campos].valor);
		 paiPasta.appendChild(img);
		 paiPasta.appendChild(texto);
	     objPai.appendChild(div);
	 }
}

pasta.enviar = function(containerId, valores){
	  var container = pasta.container[containerId];
	  pasta.limpar();
	  var parFilho = "";
	  for (var i in container.getAtributos){	  
	      parFilho += (parFilho.length==0)?container.getAtributos[i]:","+container.getAtributos[i];
		  if (document.forms[0][container.getAtributos[i]])
	         document.forms[0][container.getAtributos[i]].value = valores[i];
	  }
	  var obj = container.obj
	  obj.parFilho = parFilho
	  new navegar.enviar({tag:obj});
}

pasta.movimento = function(nmDiv, valor){
      var objDiv = document.getElementById(nmDiv);
	  var objContainer = pasta.container[objDiv.container];
	  var pc = new pasta.controle();
	  pasta.limpar();
	  for (var i in objContainer.objCondicao){	  
	      if (document.forms[0][objContainer.objCondicao[i].nmAtributo])
	         document.forms[0][objContainer.objCondicao[i].nmAtributo].value = valor[i];
	  }
	  pc[objDiv.sitPasta](objDiv);
}

pasta.controle = function(){}
pasta.controle.prototype = {
     aberta:function(objDiv){
	     for (var x = (objDiv.childNodes.length-1); x > -1; x--){
		     if (objDiv.childNodes(x).tagName == "DIV")
			    objDiv.removeChild(objDiv.childNodes(x));
		 }
		 objImg = document.images[objDiv.id+"_pm"];
		 objImg.src = "img/pmais.png";
		 objDiv.sitPasta = "fechada";
	 },
	 fechada:function(objDiv){
	     objImg = document.images[objDiv.id+"_pm"];
		 objImg.src = "img/pmenos.png";
		 objDiv.sitPasta = "aberta";
		 var pacote = {
				      nmObjeto:objDiv.id,
			          refContainer:pasta.container[objDiv.containerFilho]
					  }
		 pasta.requestPastas(pacote);
	 }
}
pasta.limpar = function(){
     var inputs = document.getElementsByTagName("input")
	 for (var i in inputs){
	     if (inputs.atributoPasta)
		    inputs[i].values="";
	 }
}




/*
---------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------
---------------------------------------Classe caixa --------------------------------------------------------------
Classe que controla o caixa financeiro de uma empresa
*/
var caixa = {}

caixa.objetos = [];
caixa.addCompras=function(){}
caixa.addPagamentos=function(){}

caixa.descValor = function(id){}
caixa.porcValor = function(id){}

caixa.getCompra = function(){}
caixa.getCompra = Class.create()
caixa.getCompra.prototype = {
   object:'',
   getCarroCompra:function(){
      var tags = new tagObject.getTagObject()
	  //--- objCC: Objeto carrinho de Compras([0]=valores, [1]=quantidade)
	  var objCC = this.object.carroCompras.split(",");
	  var objetos = tags.setParametro(objCC);
	  var valor = 0;
	  for (var x=0; x<objetos[objCC[0]].length; x++){
		  if (!objetos[objCC[0]][x].notEnvio){
		     if ((objetos[objCC[1]][x].value))
		        valor += objetos[objCC[1]][x].value *(convDecimal(objetos[objCC[0]][x].value)*1)
		     else 	valor += (convDecimal(objetos[objCC[0]][x].value))
		  }
	  }
	  return valor.toFixed(2)
	  
   },
   getPagamento:function(){
	  var tags = new tagObject.getTagObject()
	  //--- objP: Objeto pagos([0]=valores)
	  var objP = this.object.pagamentos.split(",");
	  var objetos = tags.setParametro(objP);
	  var valor = 0;
	  for (var y=0; y<objP.length; y++){
	      for (var x=0; x<objetos[objP[y]].length; x++){
		      if (!objetos[objP[y]][x].notEnvio){
				 valor += (convDecimal(objetos[objP[y]][x].value)*1)
			  }
		  }
	  }
	  return valor
   },
   
   getDesconto:function(){
	  var tags = new tagObject.getTagObject()
	  //--- objD: Objeto Descontos([0]=valores)
	  if (this.object.descDinheiro)
	    var objD = this.object.descDinheiro.split(",");
	  //---objP: objeto porcentagem([0]=valores)
	  if (this.object.descPorcentagem)
	    var objP = this.object.descPorcentagem.split(",");
	  if (this.object.carroCompras)	
	  if (objP.length != 1){
		 alert("a porcentagem só pode ser indicada por um objeto")
		 return false
	  }
	  if ((!objD)&&(!objP))
	     return 0
	  // verificando e onde foi disparado o evento
	  /* 
	  caso o objeto que disparaou o evento tenha o atributo moeda significa que a porcentagem foi alterada então 
	  deve-se calcular o valor do desconto em dinheiro com referencia no total
	  */
      if (objD){
	     if (event.srcElement.name == objD[0]){
		   //--- setando o evento para valor
		   this.eventDescAnt = "valor"
		 
		   if (event.srcElement.value.length > 0)
			  valDesc = event.srcElement.value
		   else  valDesc = "0,00"
	       var valor = operacoes.descontoPorcentagem({
								 valorTotal:pdrBrasil(this.getCarroCompra()),
								 valorDesconto:valDesc
								})
	     		    document.forms[0][this.object.descPorcentagem].value = valor;
					if (valor == "0")
					   event.srcElement.value = "0,00"
		   return convDecimal(valDesc)
	     }
	  }
	  /* 
	  caso o objeto que disparaou o evento tenha o atributo porcentagem significa que valor foi alterada então 
	  deve-se calcular o valor da porcentagem com referencia no total
	  */
	  if (objP){
	     if (event.srcElement.name == objP[0]){
	        //--- setando o evento para valor
		    this.eventDescAnt = "porc"
		    var valorPorc = event.srcElement.value
		    var valorD = operacoes.descontoValor({
		 			      valorTotal:pdrBrasil(this.getCarroCompra()),
		 				  valorPorc:valorPorc 
		 			})
		   //--------- colocar o valor do desconto para a tela -------------//
		   document.forms[0][objD[0]].value = valorD;
					if (valorD == "0,00")
					   event.srcElement.value = "0"
		   return convDecimal(valorD)
	     }
	  }
	  /* 
	  caso o envento não tenha sido disparado de um objeto de desconto todos os objetos de descontos devem ser zerados altomaticamente caso o atributoDescAnt não tenha sido preenchido
	  */
	  if (this.eventDescAnt.length == 0){
	     if (objD){
		 	var objetos = tags.setParametro(objD);
	        for (var y=0; y < objD.length;y++){
		        if (objetos[objD[y]].length){
			       for (var x=0; x<objetos[objD[y]].length; x++){
		               //-- neste caso verifica se o objto é fixo caso seja o valor não pode ser alterado
			           if (!objetos[objD[y]][x].headOnly)
			              objetos[objD[y]][x].value ='0,00'
				   }
			    }
			    else {
				     if (!objetos[objD[y]].headOnly)
			            objetos[objD[y]].value ='0,00'
			    }
	        }
	     }
	     if (objP){
	        if (document.forms[0][objP[0]])
		       document.forms[0][objP[0]].value = '0'
         }
	     return 0
	  }
	  else
	  {
		  /* caso o eventDescAnt tenha algum conteúdo ele verifica de onde veio o pedido de desconto e o conserva de maneria 
		     que possa ser manipulado pelo mesmo motivo quando o disparo foi feito do carro de compras ou do pagamento
		  */
		  
		  //---- desconto anterior disparado do valor
		  if (this.eventDescAnt == "valor"){
			 valDesc = document.forms[0][objD[0]].value
			 var valor = operacoes.descontoPorcentagem({
							valorTotal:pdrBrasil(this.getCarroCompra()),
							valorDesconto:valDesc
						 })
	     		    document.forms[0][this.object.descPorcentagem].value = valor;
					if (valor == "0")
					   event.srcElement.value = "0,00"
		      return convDecimal(valDesc)
		  }
		  else{
			  //---- desconto anterior disparado da porcentagem
		     this.eventDescAnt = "porc"
		     var valorPorc = document.forms[0][objP[0]].value
		     var valorD = operacoes.descontoValor({
		 			      valorTotal:pdrBrasil(this.getCarroCompra()),
		 				  valorPorc:valorPorc 
		 			})
		    //--------- colocar o valor do desconto para a tela -------------//
		    document.forms[0][objD[0]].value = valorD;
			 		 if (valorD == "0,00")
					   event.srcElement.value = "0"
		    return convDecimal(valorD)
		  }
	  }
   },
   
   operacao:function(){
	  document.forms[0].cxSaldo.value = saldo.mostrar((this.getCarroCompra()*-1),(this.getPagamento()*-1),this.getDesconto()*-1)
	  document.forms[0].cxCompra.value = pdrBrasil(this.getCarroCompra())
	  document.forms[0].cxPago.value = pdrBrasil(this.getPagamento())
	  
	  document.getElementById("vlTotApagar").innerHTML = "R$ "+pdrBrasil(this.getCarroCompra())
	  document.getElementById("vlTotPago").innerHTML = "R$ "+pdrBrasil(this.getPagamento())
	  document.getElementById("vlDesconto").innerHTML = "R$ "+pdrBrasil(this.getDesconto())
	  var totSaldo = convDecimal(document.forms[0].cxSaldo.value)
	  var inptSaldo 
	  if (totSaldo < 0)
	      inptSaldo = '<font color="red">R$ '+document.forms[0].cxSaldo.value+'</font>'; 
	  else inptSaldo = '<font color="blue">R$ '+document.forms[0].cxSaldo.value+'</font>'; 
	  document.getElementById("vlSaldo").innerHTML = '<table width="100%"><td>'+inptSaldo+'</td><td aling="right"> <input type="checkBox" name="idAcumulaSaldo">Acumular Saldo</td></table>'
   },
   /* 
      Este atributo é um atributo de estado que muda conforme a forma de desconto pedida
      ele existe no motivo de quando há uma alteração nas informações de pagamento e carro de compras
      sua obrigação é conservar de onde veio o evento do ultimo desconto dado (porcentagem ou valor)
	  e conservalo para que seja mantido quando o carro de compras ou o pagamento seja alterado
   */
   eventDescAnt:'',
   
   inicializar:function(id){
      this.object = document.getElementById(id);
	  if (!document.forms[0][id]){
	     var input = document.createElement('<input type="hidden" name="'+id+'">');
	     document.forms[0].appendChild(input);
		 // -- Fazendo a tabela de valores informados
		 var tabelaValores = '<table width="100%" border=1>'+
		 '<tr><td><b>Carro de Compras:</td><td><font color="red"><span id="vlTotApagar">R$ 0,00</span></font</td></tr>'+
		 '<tr><td><b>Valor de Desconto:</td><td><font color="blue"><span id="vlDesconto">R$ 0,00</span></font</td></tr>'+
		 '<tr><td><b>Valor Pago:</td><td><font color="blue"><span id="vlTotPago">R$ 0,00</span></font></td></tr>'+
		 '<tr><td><b>Valor Saldo:</td><td><span id="vlSaldo">R$ 0,00</span></td></tr></table>'
		 
		 var inputValor = '<input type="hidden" name="cxCompra">'+
		 '<input type="hidden" name="cxPago">'+
		 '<input type="hidden" name="cxSaldo">'
		 this.object.innerHTML = tabelaValores + inputValor
		 
	  }
	  caixa.objetos[id] = this;
   }
}



//-------------------
//--- função que controla todas as operações de caixa tanto como calcular descontos e calcular a subtração do carrinho de compras com os valores pagos

var saldo = {
   /*
   Função mostrar saldo do caixa recebe 4 parametros e retorna o valor correto
   1º- vlC:valor da compra
   2º- vlP:Valor Pago
   3º- dP:Desconto Porcentagem
   4º- dD:Desconto em dinheiro
   */
   mostrar:function(vlC,vlP,dD){
      var n1 = (dD)?vlC-dD:vlC
	  var n2 = vlP
	  var valor = (n1*1).toFixed(2) - n2;
	  return (pdrBrasil(valor));
   }
}


//-- Esta função converte um numero decimal para a moeda brasileira 1.00 = 1,00
var pdrBrasil=function(numero){
      if (!numero)
	      return "0,00";
	  numero = numero+""
	  var negativo=false
	  if (numero.indexOf("-") != -1)
	     negativo=true
	  numero = numero.replace("-","")
	  var temp = numero.replace(".",",")
	  temp = temp.split(",")
	  var numRet = temp[0].length
	  var flagPonto = 0
	  var valor = "";
	  if (numRet > 3){
	     for (var x=numRet; x > 0; x--){
			 valor = temp[0].substr(x-1,1)+valor
			 if ((x-1)%3==0 && (x-1) > 0)
			    flagPonto=1
			 else flagPonto=0	
			  if (flagPonto==1)
			    valor = "."+valor
		 }
	  }
	  else{valor = temp[0]}
	  if (temp[1]){
	     if (temp[1].length == 1) 
	        temp[1] += "0" 
	  }
	  else{temp[1]="00"}		
	     return ((negativo)?'-':'')+valor+","+temp[1].substr(0,2)
}

//-- Esta function recebe um valor em formato da moeda brasileira e converte para formato de numero decimal com 2 casas decimais 1,00 = 1.00
var convDecimal=function(numero){
      if (!numero)
	      return "0.00";
	  numero = numero+""
	  expr = /\W/g
	  var negativo=false
	  if (numero.indexOf("-") != -1)
	     negativo=true
	  numero = numero.replace("-","")
	  
	  var temp = numero.replace(",","")
	  var temp = temp.replace(expr,"")
	  for (var x=0; x<temp.length; x++){
	      if (numero.substr(x-1,1) < "0" && numero.substr(x-1,1) > "9"){
		     alert("Número Inválido")
		     return false
		  }
	  }
	  var num=numero.split(",")
	  if (!num[1])
	     num[1] = ".00"
	  else num[1] = "."+num[1]	 
	  return (((negativo)?'-':'')+(num[0].replace(expr,""))+num[1])*1
}

var operacoes = {}


/*-- função que recebe objeto e retorna a porcentagem do desconto dado
     {valorTotal:'',
	  valorDesconto:''
	 }
*/
operacoes.descontoPorcentagem = function(object){
//   alert(object.valorTotal+"--"+object.valorDesconto)
   if (!object.valorTotal){
	  return '0';
   }
   if (!object.valorDesconto){
	  return '0';
   }
   if (object.valorTotal != "0,00")
      var resultado = ((convDecimal(object.valorDesconto)*100)/convDecimal(object.valorTotal)).toFixed(2)
   else var resultado = 0
   return resultado
}
/*-- função que recebe objeto e retorna a porcentagem do desconto dado
     {valorTotal:'',
	  porcDesconto:''
	 }
*/
operacoes.descontoValor = function(object){
   if (!object.valorTotal){
      alert("O valor Total não foi informado")
	  return '0,00';
   }
   if (!object.valorPorc){
      alert("A porcentagem do desconto não foi informado")
	  return '0,00';
   }
   var resultado = (convDecimal(object.valorPorc)*convDecimal(object.valorTotal))/100
   return pdrBrasil(resultado)
}





//--------------------------------------------------------------------------------------------------------------------------
/*  objeto listaAdicionar
    --> DESCRIÇÃO: Esta classe controla a seleção de multiplos registro para um unico 
	               objeto Pai. Isso acontece no momento em que se quer inserir uma pessoa no sistema
				   pois uma unica pessoa pode ter muitos telefones como explica o exemplo aseguir.
				   exe:
				                             cadastro de pessoas
						      
							  nome: Thiago Ribeiro        CPF:334.987.000.09				
						      Fone:______________         E-Mail:______________
						           _______                       _________
								  |addFone|                     |addE-mail|
								  |_______|                     |_________|
					    ___________________________    _____________________________
					   |      lista Fone           |  |       lista E-Mail          |
					   |___________________________|  |_____________________________|
					   |   NOME  |    FONE    |    |  |  NOME    |   E-Mail   |     |
					   |_________|____________|____|  |__________|____________|_____|
					   |  Thiago |  6667-9008 | EXC|  |  Thiago  | thi@js.com | EXC |
					   |  Thiago |  6678-0098 | EXC|  |  Thiago  | thi2@js.com| EXC |
					   |---------------------------|  |-----------------------------|
                                                   
	         classe - tabela
			                                     :METODOS:
			          # inicializar(construtor) - Metodo que monta a tabela onde serão guardado os valores
	                  # Adicionar(public) - Metodo responsavel pela inserção de registro na tabela chamado de uma
			                                ação de um botão ou um link.
								            {listaAdicionar.adicionar  this.checarChave}
			          # Remover(public) - Metodo responsavel pela remoção de registro na tabela, este metodo
			                              é chamado apartir de um botão ou um link.
			          # checarChave(private) - Checa a consistencia dos registros de acordo com a especificações 
			                                   do programador
			 fim classe tabela
			 
			                                           :PROPRIEDADE: 
	         @ objetosAtivos - Array que contem os valores dos objetos que estão ativos na tela indexado Pelo nome do objeto
	         
			 
	                                    :Manipuladores de evento HTML:
			 * <DIV tipo=["listaAdicionar"] chave=[objtos chaves] objetos=[nObjetos([camposREL])] setNull=[objetos que não podem ser nulos] url=[nome da url] filtro=[nmObjeto,nmatributo=nmObjeto] camposCarregar="[nmObjhtml=nmatributoValue(nmAtributoDescr)]"> 
			   - tipo: identifica o tipo como sendo para disparar o evento listaAdicionar
			   - chave: [nObjetos]Mostra quais são os objetos chaves para garanmtir a consistencia dos registros
			   - objetos([camposREL]): na ordem em que for colados sera a ordem en que o objeto ira aparecer para o usuario.
			             O camposREL serão os campos que acompanham o bjeto na tabela eles são separados por ; e ficam dentro de                         um parenteses após o nome do objeto.
			   - notNull: Identifica quais campos não podem ser nulos
			   - url: tag que só é preenchida quando for fazer a carga dos objetos que ja existem no objeto
			   - camposCarregar: Serão os campos carregados na json, estes campos tem que coincidir com a ordem e com os valores que poderão ser inseridos portanto fique atento quando for inserir os dados que farão parte dessa lista.
			   - filtro: Objetos do HTML que farão parte da clausula where 
			   
			   
*/

var listaAdicionar = {};
//----Propriedades
listaAdicionar.objetosAtivos = new Array(); 
listaAdicionar.Base = function(){};
listaAdicionar.Base.prototype = {
   getAtributos:function(obj){
       var objTemp = (obj.objetos)?obj.objetos.split(","):[]
	   var objRelTemp;
	   var campoRel = [];
	   if (objTemp.length > 0){
	      for (var i in objTemp){
			  if (objTemp[i].indexOf("(") > 0){
			     objRelTemp = objTemp[i].substring(objTemp[i].indexOf("(")+1, objTemp[i].length - 1);
			     objTemp[i] = objTemp[i].substring(0, objTemp[i].indexOf("("));
   		         campoRel[objTemp[i]] = (objRelTemp.length > 0)?objRelTemp.split(";"):false;
			  }
		  }
	   }

       this.options = {
	   idDiv:obj.id,
	   url:obj.url,
	   camposCarregar:(obj.camposCarregar)?obj.camposCarregar.split(","):[],
	   filtro:obj.filtro,
	   getObjs:(obj.getObjs)?true:false,
	   linhaTabela:new Array(), 
	   chave:(obj.chave)?obj.chave.split(","):[],
	   objetos:objTemp,
	   camposRel:campoRel,
	   Null:(obj.setNull)?obj.setNull.split(","):[],
	   descricao:(obj.descricao)?obj.descricao.split(","):[],
	   registros:[],
	   objResultado:function(){
	      var array = []
		  var classTemp;
	      var tempVal;
		  var controlBox = true;
		  var nRegistro = 0
		  var flagBox;
		  var tags = [];
		  var objsTemp = document.forms[0].elements;
	      for (var vt=0; vt < objsTemp.length; vt++){
			  if (objsTemp[vt].objeto){
				 for (var n in this.objetos){
			         if (objsTemp[vt].objeto == this.objetos[n])
					    objsTemp[vt].notEnvio = "true"
			     }
				 if (!tags[objsTemp[vt].name]){
					 tags[objsTemp[vt].name] = objsTemp[vt];
				 }
				 else{
					if (tags[objsTemp[vt].name].value){ 
					   tags[objsTemp[vt].name] = [tags[objsTemp[vt].name],objsTemp[vt]]
					}
					else{
					   tags[objsTemp[vt].name].push(objsTemp[vt]);
					}
				 }
			  }
		  } 
		  for (var x in tags){
			  for (var i in this.objetos){
				  classTemp = false
				  tempVal = tags[x]
				  if ((tempVal.value)||(!tempVal.length)){
					 if (this.objetos[i] == tempVal.objeto){  
						if (tempVal.name){
						   if (tempVal.tagName == "INPUT"){
						      if (tempVal.type == "checkbox" || tempVal.type == "radio"){
							     if (tempVal.checked){
								    classTemp = {valor:tempVal.value,
								       descr:tempVal.nmDescr,
								       index:0,
								       name:tags[x].name
								    }
								 }
								 else{
								    classTemp = false
								 } 
							  }
							  else{
								 classTemp = {valor:tempVal.value,
								              descr:(tempVal.nmDescr)?tempVal.nmDescr:tempVal.value,
								  			  index:false,
											  name:tempVal.name}
							  }
						   }
						   else{
							  classTemp = {
								          valor:tempVal.value,
								          descr:tempVal[tempVal.selectedIndex].innerHTML,
								 		  index:tempVal.selectedIndex-1,
										  name:tempVal.name}
						   }
						   array[tags[x].objeto] = classTemp;
						}
						else{
						   array[tags[x].objeto] = false; 
						   alert("Erro no objeto "+tags[x].objeto+": O name não foi especificado")
						   return false; 
						}
					 }
				  }
				  else{
					 if (this.objetos[i] == tempVal[0].objeto){ 
					    if (tempVal[0].name){
						   array[this.objetos[i]] = [];
						   if (tempVal[0].type == "checkbox"){
						      if (controlBox){
							     controlBox = false;
							     for (var y = 0; y < tempVal.length; y++){
							         if (tempVal[y].checked){
									    classTemp = {valor:tempVal[y].value,
									                descr:tempVal[y].nmDescr,
										            index:y,
										  	   	    name:tempVal[y].name}
								     }
								     else{
									    classTemp = false
								     } 

									 array[tempVal[y].objeto][array[tempVal[y].objeto].length] = classTemp;
							     }
						      }
						      else{
						  	     alert("só pode ter um único chekbox para adicionar na lista");
							     return false;
						      }
						   }
						   else{
						      //------------ verificação radio
						      for (var y = 0; y < tempVal.length; y++){
							      if (tempVal[y].checked){
							         classTemp = {valor:tempVal[y].value,
							                     descr:tempVal[y].nmDescr,
									             index:y,
											     name:tags[x].name}
								     y = tempVal.length
							      }
							      else{
								     classTemp = false
							      } 
							      array[tags[x].objeto] = classTemp;
						      }
						   }
						}
					    else{
					       array[tags[x].objeto] = false; 
						   alert("Erro no objeto "+tags[x].objeto+": O name não foi especificado")
						   return false;
						}
				     }
			      }
		      }
	      }
		  return array;
	   }
	   }
   }
}


//---METODOS

listaAdicionar.listasAtivas = new Array();
listaAdicionar.Fila = [];
listaAdicionar.executarFila = function(){
    var temp = []
	if (listaAdicionar.Fila.length > 0){
	   temp.pop(listaAdicionar.Fila);
	   temp.obj.montarRegistros(temp.valores);
	   listaAdicionar.executarFila()
	}
}
listaAdicionar.Tabela = Class.create();
listaAdicionar.Tabela.prototype = Object.extend(new listaAdicionar.Base(),{
	getCarregarObjetos:function(valor, obj){
		var registro = []	
		var form = document.getElementsByTagName("form");
		var input = [];
		var temp = [];
		var campoTemp;
		var valTemp;
		for (var i in obj.options.camposCarregar){
		    temp = obj.options.camposCarregar[i].split("(");
			if (temp.length == 2){
			   descrTemp = temp[1].substring(0, temp[1].length - 1);
			   valTemp = temp[0]
			}
			else{
			   descrTemp = temp[0]
			   valTemp = temp[0]
			}
   	        input[input.length] = {
			                  nmDocHtml:temp[0],
				     		  vlrObj:valTemp,
							  descrObj:descrTemp
								  }
		}
		for (var i in valor){
			registro[i] = new Array()
			
			for (var x in input){
			    if (!valor[i][input[x].vlrObj]){
				   alert("O campo "+input[x].vlrObj+" não existe no objeto")
				   return false;
				}
				
				if (!valor[i][input[x].descrObj]){
				   alert("O atributo "+input[x].descrObj+" não existe no objeto")
				   return false;
				}
				
				registro[i][registro[i].length] = {
			                                    valor:valor[i][input[x].vlrObj].valor,
			     			                    descricao:valor[i][input[x].descrObj].valor,
  		     				                    name:input[x].nmDocHtml,
 		     					                valorAgregado:null
			     				                  }
		   }
		}
		
		for (var i in registro){
		    obj.montarRegistros(registro[i])
		 }
	},
	
	setCarregarObjetos:function(divId,valorFiltro){
          var obj = listaAdicionar.listasAtivas[divId]
		  var tab = obj.options.tabela
		  //Limpando a tabela
		  
  	      while (tab.rows[1]){
				obj.remover(0)
		  }
		  //-- Url que carrega o objeto
		  var url = obj.options.url
		  //--Parametros de busca
		  var objTag = new tagObject.getTagObject()
		  var arrFiltro = (obj.options.filtro)?obj.options.filtro.split(","):[]
		  var filtroSel=[]
		  var par = ""
		  
		  		  
		  if (valorFiltro){
		     for (var i in arrFiltro){
				 if (valorFiltro[arrFiltro[i]])
					 par += arrFiltro[i]+'='+valorFiltro[arrFiltro[i]].valor+'&'
				 else filtroSel[filtroSel.length] = arrFiltro[i]
			 }
		  }
		  else{
			 filtroSel = arrFiltro
		  }

		  if (filtroSel.length > 0)
		     par += objTag.parametros(filtroSel)


		  //-- montando quais campos receberão o atributo que vem da consulta
		  //Exe fone1=nrfone - O primeiro valor é do document e o segundo é o que vem do asp
		  var atributos = []
		  var temp
		  var campos = obj.options.camposCarregar
		  for (var i in campos){
		      temp = campos[i].split("=");
			  if (temp.length == 2)
			     atributos[temp[0]] = temp[1]
    	  }
		  // recuperando todos os objetos para se fazer a carga
		  var ajax = []
		  ajax[divId] = new Ajax.request(url,
				     {
		             metodo:'get',
		 			 parametros:par,
		 			 arguments:obj,
					 completo:obj.getCarregarObjetos
	     	         }
		  )
		  ajax[divId] = null
    },
	
	inicializar:function(objDiv){
	   this.getAtributos(objDiv)
	   if (this.options.objetos.length > 0){
		  var objsTemp = document.forms[0].elements;
	      for (var vt=0; vt < objsTemp.length; vt++){
			  if (objsTemp[vt].objeto){
				 for (var n in this.objetos){
			         if (objsTemp[vt].objeto == this.objetos[n])
					    objsTemp[vt].notEnvio = "true"
			     }
			  }
		  }
		  this.options.tabela = document.createElement("table");
		  var objetos = this.options.objetos
		  var descr = this.options.descricao
		  if (!descr || objetos.length > descr.length){
			 alert("ERRO: NA LISTA ADICIONAR - ("+ objDiv.id +") insira no campo [descricao] a descrição dos campos de acordo com o número de objetos ")
		     return false; 
		  }
		  if (objDiv.tabWidth)
		     this.options.tabela.width = objDiv.tabWidth
		  
		  if (objDiv.borda){
		     this.options.tabela.border = 1
		     this.options.tabela.cellSpacing = 0
			 this.options.tabela.cellPadding = 2
		  }
		  if (objDiv.corBorda)
		     this.options.tabela.borderColor = objDiv.corBorda	 
		  var objTabela = this.options.tabela
		  var linha = objTabela.insertRow(0)
		  var celula
		  for (var i=0; i < objetos.length; i++){
		      celula = linha.insertCell(i)
			  celula.innerHTML = descr[i]
		  }
		  celula = linha.insertCell(objetos.length)
		  celula.innerHTML = "Opções"
		  objDiv.appendChild(this.options.tabela)
		  //--Carregandos objetos ja cadastrados
		  if (this.getObjs)
		     this.setCarregarObjetos(this.options.divId);
	   }
	   else{
		  alert("selecione os objetos que farão parte da tabela")  
	   }
	   //---------------------Carregando os dados ja existentes para o objeto no banco
	   
	   
	},
	montarRegistros:function(registro){
	   var objTabela = this.options.tabela;
	   var celula;
	   var input;
	   var inputAgrega;
	   var valor;
	   var descricao;
	   var remover;
	   var campos = registro;
	   if (campos){
	      var linha = objTabela.insertRow(1);
		  for (var i in campos){
			  celula = linha.insertCell(i);
			  input = document.createElement('<input name="'+campos[i].name+'">');
			  input.setAttribute("type","hidden");
			  input.setAttribute("setNull","true")
			  input.value = campos[i].valor;
			  celula.innerHTML = campos[i].descricao
			  celula.appendChild(input);
			  if (campos[i].valorAgregado) {
			     for (var y in campos[i].valorAgregado){
					 inputAgrega = document.createElement('<input name="'+y+'">');
			         inputAgrega.setAttribute("type","hidden");
			         inputAgrega.value = campos[i].valorAgregado[y];
					 celula.appendChild(inputAgrega);
				 }
			  }
          }
		  remover = document.createElement("a")
		  remover.refId = this.options.idDiv
		  remover.refLinha = this.options.linhaTabela.length
		  remover.setAttribute("onclick",function(){
										  obj = listaAdicionar.listasAtivas[this.refId]
										  obj.remover(this.refLinha)
										 }
	                          ) 
		  remover.innerHTML = "Remover"
		  celula = linha.insertCell(linha.cells.length);
		  celula.appendChild(remover);
		  this.options.linhaTabela[this.options.linhaTabela.length] = linha
		  this.options.registros.unshift(campos);
	   }
	   //--- Chamando a classe ativarFuncao
	   ativarFuncao.Ativar(document.getElementById(this.options.idDiv))
	},
    
	
	checarChave:function(registro){
		var flag = false;
		var flagChave = false;
		var fPop;
		var regAnterior = this.options.registros;
		var obj = this.options.objetos;
		var chave = this.options.objetos;
		var objChave = []
		for (var i in chave){
		    objChave[chave[i]] = chave[i];
		}
		for (var x in registro){
		    if (registro[x].valor.length > 0)flag=true;
		}
		if (flag){
			
		   for (var i=0; i < regAnterior.length; i++){
		       flagChave = false
			   for (var y in regAnterior[i]){
				   if (objChave[obj[y]]){
					  if (regAnterior[i][y].valor != registro[y].valor){
				         flagChave = true;
					  }
				   }
			   }
			   
			   if (!flagChave){
				  i = regAnterior.length
				  return false;
			   }
		   }
		}
		return true;
		
	},
	
	
	checarNULL:function(nomeObj){
		var Null = this.options.Null
		if (Null){
		   for (var i in Null){
			   if (nomeObj == Null[i]){
				  return true;
			   }
		   }
		}
		return false;
	},
	
	
	adicionar:function(){
		//-- os arrays são indexados pelo nomee do objeto
		//-- ele pode ser um tipo array ou um unico objeto
		var campos = this.options.objResultado();
		var obj = this.options.objetos;
		var nRegistro = 0;
		var registro = [];
		var descr = [];
		var rel;
		var objAtivos = listaAdicionar.objetosAtivos;
		var valRel;

        for (var i=0; i<obj.length;i++){
			if (campos[obj[i]]){
			   nRegistro = 1;
			   if (campos[obj[i]].length){
				  nRegistro = campos[obj[i]].length
				  i = obj.length
			   }
			}
		}
		
		//---------montando o array de registros
		for (var x=0; x<nRegistro; x++){
		    registro[x] = new Array()
			//--- recuperando os objetos
			for (var i in obj){
		        rel = []
				//-- verificando se o campo do objeto existe
				if (campos[obj[i]]){
			       //-- verificando se é um array
				   if (campos[obj[i]].length){
					  //--montando array de campos relacionados e verificando se o campo[Obj][x] existe
					  if (campos[obj[i]][x]){
					     if (this.options.camposRel[obj[i]]){
						    valRel = this.options.camposRel[obj[i]]
						    for (var y in valRel){
								if (objAtivos[obj[i]][campos[obj[i]][x].index][valRel[y]]){
								   rel[valRel[y]] = objAtivos[obj[i]][campos[obj[i]][x].index][valRel[y]].valor
							    }
							    else{
							       alert("O Atributo "+valRel[y]+" não foi encontrado na coleção do objeto "+[obj[i]]);
							    }
						    }
					     }
					     registro[x][registro[x].length] = {valor:campos[obj[i]][x].valor,
					                                        descricao:campos[obj[i]][x].descr,
							                                name:campos[obj[i]][x].name,
														    valorAgregado:rel}
						 rel = null; 								  
					  }
					  else{
					     registro[x][registro[x].length] = {valor:'',
					                                      descricao:'',
							                              name:'',
														  valorAgregado:rel}
						 rel = null;
					  }
					  
				   }
				   else{
					  if (this.options.camposRel[obj[i]]){
					     valRel = this.options.camposRel[obj[i]]
						 for (var y in valRel){
							 if (objAtivos[obj[i]][campos[obj[i]].index][valRel[y]]){
							    rel[valRel[y]] = objAtivos[obj[i]][campos[obj[i]].index][valRel[y]].valor
							 }
							 else{
							    alert("O Atributo "+valRel[y]+" não foi encontrado na coleção do objeto "+[obj[i]]);
							 }
						 }
					  }
					  registro[x][registro[x].length] = {valor:campos[obj[i]].valor,
					                                     descricao:campos[obj[i]].descr,
														 name:campos[obj[i]].name,
														 valorAgregado:rel}
					  rel = null; 
				   }
			    }
				else{
				   registro[x][registro[x].length] = {valor:'',
					                                  descricao:'',
													  name:'',
													  valorAgregado:rel}
				}
			}
		}
		
		
		
		// ------ verificando a consistencia dos registro
		var contador = registro.length 
		var flagAdd = true;
		for (var x=0; x < contador; x++){
			flagAdd = true
			for (var i=0; i<obj.length;i++){
			    if (registro[x][i].valor.length == 0){
				   if (!this.checarNULL(obj[i])){
					  flagAdd = false;
				   }
				}
			}
			if (flagAdd){
			   if (this.checarChave(registro[x])){
				  this.montarRegistros(registro[x])
			   }
			}
		}
	},
	
	
	remover:function(nLinha){
		var linha = this.options.linhaTabela[nLinha];
		var tabela = this.options.tabela;
		var registro = this.options.registros
		var newRegistro = [];
		registro[linha.rowIndex-1] = false
		tabela.deleteRow(linha.rowIndex);
		
		for (var x=(registro.length-1); x > -1; x--){
		    if (registro[x]){
			   newRegistro.unshift(registro[x])
			}
		}
		this.options.linhaTabela[nLinha] = null
		this.options.registros = newRegistro
		//-- Chamando para verificar o ativar função
		ativarFuncao.Ativar(document.getElementById(this.options.idDiv))
	}
})


//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
// Classe Limpar
/*
   Nome: Limpar
   Função: esta é uma fução interna que limpa os campos que foram descriminados no atributo limpar dentro do objeto exe:
   <input type="text" tipo="listaAdicionar" limpar="nmPessoa,cdFone,idEmail" 
   
   
   funções que invoncam
   - textList.getList()
   - (inicializacao.js) montarTag()
   - ativarFuncao.popularTag
   - (validacao.js) verificaCampo()-*onchange na tag select*-
*/
//--------------------------------------------------------------------------------------------------------------------------
var limpar = function(campos){
    var objT;
	var obj;
	var tab;
    if (!campos)
		return false
	for (var x in campos){
		// ------ Verificando os objetos Id
		if (document.forms[0][campos[x]]){

			objT = document.forms[0][campos[x]]
			if (!objT.tagName){
			   alert("Há dois objetos distintos com o mesmo name ("+campos[x]+")")	
			}
			else{
			   if (objT.tagName != "INPUT"){
				  objT.selectedIndex = 0;
			   }
			   else{
				  if (!objT.length){
			         if ((objT.type == "checkbox")||(objT.type == "radio")){
					    objT.checked = false;
			         }
				     else{
					    objT.value = "";
				     }
				  }
			      else{
			         if (objT.length){
				        for (var i=0; i < objT.length; i++){
						    if ((objT[i].type == "checkbox")||(objT[i].type == "radio")){
					           objT[i].checked = false;
			                }
				            else{
					           objT[i].value = "";
				            }
					    }
					 }
				  }
			   }
			}
		 }
		 else{
			if (document.getElementById(campos[x])) {
			   objT = document.getElementById(campos[x])
			   if (objT.tipo){
			      if ((objT.tipo == "checkbox")||(objT.tipo == "radio")){
					 objT.innerHTML = ""
			      }
			      else{
				      if ((objT.tipo == "listaAdicionar")){
				         if (listaAdicionar.listasAtivas[objT.id]){
		                    obj = listaAdicionar.listasAtivas[objT.id]
						    tab = obj.options.linhaTabela
		                    var linha
							//Limpando a tabela
   	                        
							for (var i in tab){
								/*--Este código é usado para remover a linha 
								correta ou seja ele pega o atributo refLinha 
								que é o indice da linha para apagar as linhas corretas
								*/
								if (tab[i]){
								   linha = tab[i].cells[tab[i].cells.length - 1].getElementsByTagName("a")[0]
				                   if (linha){
								      if (!(isNaN(linha.getAttribute("refLinha"))))
									     obj.remover(linha.refLinha)
								   }
							    }
		                    }
					     }
				      }
		          }
			   }
			   else{objT.innerHTML = ""}
		   }
		   // --- verificando os objetos das tags
		}
	}
}

//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
// Classe ativarFuncao
/*
    
   Nome: ativarFuncao
   Função: esta classe permite que a ativação de funções que estão definidas na tela sempre ao término de outra função ou da 
           ação de algun evento. Ela recebe qual função será ativada e seus atributos.
		   O evento que chama essa função varia dependendo do objeto exe:
		   SELECT      - Dispara a partir do onchange
		   INPUT RADIO - Dispara a partir do onchange
		   INPUT TEXT  - Dispara a partir do onblur
		   
*/
var ativarFuncao = {}
var funcaoATV = ['popularTag','consulta','listaAdicionar','montarTag','setCalendario','addCaixa']
ativarFuncao.Ativar = function(obj,valores){
	var obj = (obj)?obj:event.srcElement
	
	var elementos = []
	for (var i in funcaoATV){
		if (obj[funcaoATV[i]]){
		   elementos = obj[funcaoATV[i]].split(",")
		   for (var x in elementos){
			   ativarFuncao[funcaoATV[i]](elementos[x],obj,valores)
		   }
		}
	}

}
ativarFuncao.setCalendario = function(idCal,obj,valores){
	if (!document.getElementById(idCal)){
	   alert("O Calendário "+idPopular+" não existe no documento")
	   return false;
	}
	var objCalendario = document.getElementById(idCal)
	if (!valores[objCalendario.setDate])
	   return false
	
	var data = valores[objCalendario.setDate].valor
	var arrData = data.split("/")
	if (!calendario.ativos[idCal]){
	   objCalendario.dataInicial = data
	   new calendario.getCalendario(idCal)
	}
	else{
	   var dtSel = new Date(arrData[2],arrData[1],arrData[0])
	   calendario.ativos[idCal].getObjDate = dtSel
	   calendario.ativos[idCal].mes = arrData[1]
	   calendario.ativos[idCal].ano = arrData[2]
	   calendario.montar(idCal)
	}   
}

ativarFuncao.addCaixa = function(idPopular,obj, valores){
   
   var c = caixa.objetos[idPopular]
   if (!c){
	  c = new caixa.getCompra(idPopular)}
   	   
   c.operacao()

}

ativarFuncao.popularTag=function(idPopular,obj, valores){

		if (!document.getElementById(idPopular)){
		   alert("O objeto "+idPopular+" não existe no documento")
		   return false;
		}
		//---------------------------limpando o conteúdo antigo
	   
	//   if(document.getElementById(idPopular).objPopular){
	  //    limpar(document.getElementById(idPopular).objPopular.split(","))
	   //}
	   
	   
	   if (obj.limpar && obj.tagName=="SELECT"){
		  limpar(obj.limpar.split(","))
	   }
	   var enviar = []
	   var parametro = ""
	  //---------------------------------------------------------
	   var opcDet = document.getElementById(idPopular)
       var url = (opcDet.url)?opcDet.url:'json/json_'+opcDet.id+'.asp';
	   var envPar = ((opcDet.buscaParametro)?opcDet.buscaParametro.split(","):((opcDet.filtro)?opcDet.filtro.split(","):[]))
	   if (valores){
	       for (var i in envPar){
		       if (valores[envPar[i]]){
			      parametro += envPar[i]+"="+valores[envPar[i]].valor+"&"
			   }
			   else{
				  enviar[enviar.length] = envPar[i]
			   }
		   }
	   }
	   var tag = new tagObject.getTagObject()
	   var FR = (opcDet.filtroRequerido)?opcDet.filtroRequerido.split(","):[]
	   var detFR = []
	   if (valores){
	      for (var i in FR){
		      if (valores[[FR[i]]]){
		         if (valores[[FR[i]]].valor.length == 0)
				    detFR[detFR.length] = FR[i]
			  }
		   }
	   }
	   else{
		  detFR = FR
	   }
       
	  
	   for (var i in detFR){
		  if (tag.chkAtributo(FR[i])==false){
		     return false;
    	  }
	   }
		
   	   var ajaxDet = new Ajax.request(url,
		                              {
									  metodo:'get',
		 					          parametros:parametro+tag.parametros(envPar),
									  objeto:opcDet,
									  arguments:(opcDet.objPopular)?opcDet.objPopular.split(","):[],
		 					          completo:tagObject.popularTag
									  }
									  )
}

ativarFuncao.consulta=function(idPopular,obj){
   consulta.consultaUpdate(idPopular)
}

ativarFuncao.listaAdicionar = function(idLista,obj,valores){
	if (!listaAdicionar.listasAtivas[idLista])
	   listaAdicionar.listasAtivas[idLista] = new listaAdicionar.Tabela(document.getElementById(idLista))
   listaAdicionar.listasAtivas[idLista].setCarregarObjetos(idLista,valores)
}

ativarFuncao.montarTag=function(Obj,obj){
	
	Obj = Obj.split("/")
	nmObj = Obj[0]
	if (Obj[1])
	   obj = document.forms[0][Obj[1]]
	
	
	for (var i in tagObject.tags.arrObject){
		if (tagObject.tags.arrObject[i].nmObj == nmObj){
		   var stancia = tagObject.tags
		   var tag = new tagObject.getTagObject()
		   opcDet = tagObject.tags.arrObject[i].getObjeto
	       var FR = (opcDet.filtroRequerido)?opcDet.filtroRequerido.split(","):[]
		   for (var i in FR){
			   if (tag.chkAtributo(FR[i])==false)
			      return false;
		   }
	       stancia.carregar([opcDet],obj)
		}
	}
}


//--------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------
// Classe tagObject
/* 
   Nome: tagObject
   Função: Controlar, montar, manipular e recuperar valores de todas e qualquer tipo de tag que esta dentro do da página exibida
   methodos: #Base - mostra os atributos padrões que pertencem as tags que são
                    Base.nome - name da tag
					Base.tag - Tipo da tag
					Base.Parametro - valores para refinamento de busca para a tag
			 #setTagObject - este metodo tem como finalidade colocar ações e pupular as tags que estão na tela 
			        setTagObject.inicializar(construtor) - Obtem os resultados para manipular e popular tags usando a classe Ajax
					setTagObject.select - popula tag select
					setTagObject.checar - popula tag input checkbox e radio
			 #getTagObject - este metodo tem como Recupera o valor das tag da tela
			        getTagObject.arrayTagObject - monta os resultados com os seus respectivos names
					getTagObject.input - recupera os valores dos inputs na tela
					getTagObject.select - recupera os valores dos selects na tela
			 
*/

tagObject = {}
tagObject.Base = function() {}
tagObject.Base.prototype = {
	 atributos:function(options){
	     this.options = {
			 nome:'', //-----Name do objeto 
			 tag:'', //-----Verifica se é Select ou se é checkbox ou radio
			 parametro:'',//-----Parametros para selecionar os objetos
			 type:''
		 }
		 Object.extend(this.options, options || {});
	 }
}

tagObject.setTagObject = Class.create();
tagObject.setTagObject.prototype = Object.extend(new tagObject.Base,{
	 arrObject:[],
	 inicializar:function(options){
		   var df = document.forms[0].elements
	       var arrObjetos = [];
		   for (var x=0 ;x < df.length;x++){
			   if (df[x].getAttribute("objeto")){
			      arrObjetos[arrObjetos.length] = {
		                 getObjeto:df[x],
		                 referencia:(df[x].rel)?df[x].rel.split(","):false,
						 filtro:(df[x].filtro)?df[x].filtro.split(","):false,
						 inicio:df[x].ini,
						 descricao:df[x].objeto,
						 nmObj:df[x].name}
			   }
		   }
		   var od = document.getElementsByTagName("DIV")
		   for (var x=0; x < od.length;x++){
		       if ((od[x].getAttribute("tipo")) && (od[x].getAttribute("objeto"))){
		          if ((od[x].tipo=="checkbox")||(od[x].tipo=="radio")){
			         arrObjetos[arrObjetos.length] = {
		                 getObjeto:od[x],
		                 referencia:(od[x].rel)?od[x].rel.split(","):false,
						 filtro:(od[x].filtro)?od[x].filtro.split(","):false,
						 inicio:od[x].ini,
						 descricao:od[x].objeto,
						 nmObj:od[x].id}
		          } 
			   }
		   }
		   this.arrObject = arrObjetos
	 },
	 
	 carregar:function(objetoTag, objRel){
		   var par = "";
		   var objeto;
		   var url;
		   var arrClass = []
		   var ajax
		   var filtro = new tagObject.getTagObject()
		   if (objetoTag && objRel){
			  for (var i in objetoTag){
				  if (objetoTag[i].objeto){
		             if (!objetoTag[i].idUrl){
				        url = 'json/json_'+objetoTag[i].objeto+'.asp'
						url = url.toLowerCase()
				     }
				     else{
					    url = objetoTag[i].idUrl
						url = url.toLowerCase()
				     }
				  }
				  if (arrClass[url]){
					 arrClass[url].push(objetoTag[i]);
				  }
				  else{
					 arrClass[url] = new Array();
				     arrClass[url].push(objetoTag[i]); 
				  }
			  }
			  if (objRel.value.length > 0){
				 for (var i in arrClass){
				     par = objRel.name+"="+objRel.value
					 for (var y in arrClass[i]){
					     if (arrClass[i][y].filtro){
						    var tempFiltro = arrClass[i][y].filtro.split(",")
							var newFiltro = []
							for (var f in tempFiltro){
							    if (tempFiltro[f] != objRel.name)
								   newFiltro[newFiltro.length] = tempFiltro[f]
							}
							par += "&"+filtro.parametros(newFiltro)
					     }
					 }
					 ajax = new Ajax.request(i,{
		                    metodo:'get',
		                    parametros: par,
				            arguments:[this, arrClass[i]],
		                    completo:this.optionTag})
			  	 }
			  }
			  else{
				 for (var i in objetoTag){
					 this.limparRel(objetoTag[i]);
				 }
	          }
		   }
		   else{
			  objeto = [];
			  var nmObjRel
			  var flagRef
		      var no
			  for (var x=0; x < this.arrObject.length; x++){
				  if (this.arrObject[x].referencia){
					 no = this.arrObject[x].nmObj
					 objeto[no] = []
					 for (var i in this.arrObject[x].referencia){
						 flagRef = false
						 nmObjRel = this.arrObject[x].referencia[i]

						 /*
						      Nesta parte do código ele verifica qual é o tipo do objeto de referencia
						      se é um input ou um select ou um div pois existe uma regra para os objetos inputs
							  pois ele só aceita do tipo checkBox e do tipo radio
						 */
						 if (document.forms[0][nmObjRel]){
							if (!document.forms[0][nmObjRel].tagName == "INPUT"){
							   flagRef = true
							   objeto[no][objeto[no].length] = document.forms[0][nmObjRel]
							}
						 }
						 if (document.getElementById(nmObjRel)){
							flagRef = true
							objeto[no][objeto[no].length] = document.getElementById(nmObjRel)
						 }
						 if (flagRef == false){
							alert("O objeto ("+nmObjRel+") não existe no documento")
							return false
						 }
					 }
					 document.forms[0][this.arrObject[x].getObjeto.name].onchange = function(){
						   montarTag(objeto[event.srcElement.name],event.srcElement)
					 }
				  }
				  if (this.arrObject[x].inicio == "automatico"){
					 objetoTag = this.arrObject[x].getObjeto
					 if (objetoTag.objeto){
		                if (!objetoTag.idUrl){
				           url = 'JSON/json_'+objetoTag.objeto+'.asp'
				        }
				        else{
					       url = objetoTag.idUrl
				        }
						par = ""
						if (objetoTag.filtro){
						   par = filtro.parametros(objetoTag.filtro.split(","))
					    }
						//alert(par+"---"+objetoTag.filtro)
						ajax = new Ajax.request(url,
		                         {
		                         metodo:'get',
		                         parametros: par,
					             arguments:[this, [objetoTag]],
		                         completo:this.optionTag
	                    })
					 }
				  }
			  }
		   }
	 },
	 
	 limparRel:function(tag){
	      var limpar = true
		  if (tag){
             if (tag.tagName == "SELECT"){
				contar = tag.length
				for (var x=1; x < contar; x++)
                    tag.options[1] = null;
			 }
			 else{	
			    if (tag.id)
				   document.getElementById(tag.id).innerHTML = "";
			 }
			 if (tag.rel){
				 var relArr = tag.rel.split(",")
				 for (var i in relArr){
				     if (document.getElementById(relArr[i].rel)){
				        relArr[i] = document.getElementById(relArr[i].rel);
					 }
					 else{
					    relArr[i] = document.forms[0][relArr[i].rel]; 	 
					 }
					 this.limparRel(relArr[i])
				 }
			 }
	      }
	},
	
	optionTag:function(valor, argumentos){
			  if (argumentos){
				 //Alimentando a propriedade objetosAtivos da classe listaAdicionar
				 var objetoTag = argumentos[1];
//--------------------------------------------------------------
			     var estancia = argumentos[0];
				 for (var i in objetoTag){
				     if (objetoTag[i].objeto){
						listaAdicionar.objetosAtivos[objetoTag[i].objeto] = arguments[0]
				     }
					 if (objetoTag[i].tagName == "SELECT"){
				        estancia.selecao(arguments[0],objetoTag[i]);
			         }
			         else{
						estancia.checar(arguments[0],objetoTag[i]);
					 }
					 if (argumentos[2]){
						if (argumentos[2].parametros.length == 2)
						   argumentos[2].funcao(argumentos[2].parametros[0],argumentos[2].parametros[1]);
						else argumentos[2].funcao(argumentos[2].parametros[0]);    
					 }
			     }
			  }
	 }
	 ,
	 
	 selecao:function(valor, objetoTag){
			if (objetoTag){
				if (valor){
				   var opt;
				   var sel = objetoTag;
				   var contar = sel.length
				   for (var x=1; x < contar; x++){
                       sel.options[1] = null;
                   }
				   var descrValor;
				   var nmValor;
				   var nmDescricao;
				   
				   for (var y in valor){
					   if (objetoTag.descrValor){
					      descrValor = objetoTag.descrValor.split(",")
						  nmDescricao = descrValor[0]
						  nmValor = descrValor[1]
					   }
					   else{
					      nmDescricao = 'nm'+objetoTag.objeto
						  nmValor = 'cd'+objetoTag.objeto
					   }
					   if (!(valor[y][nmDescricao]) || !(valor[y][nmValor])){
						  var camposValidos = [];
					      for (var cv in valor[y]) 
						      camposValidos.push(cv)
					      alert("Os campos "+nmDescricao+" e "+nmDescricao+" não existem no objeto especifique o campo descrValor corretamente. os Campos existentes para o objeto são ("+camposValidos+")" )
						  return false;
					   }
					   opt = new Option(valor[y][nmDescricao].valor, valor[y][nmValor].valor)
					   sel.add(opt)
				   }
				}
				else{
			       this.limparRel(objetoTag);
			    }
			}
			
	 },

	 checar:function(valor, objetoTag){
		    var coluna = 5;
			var hidden = false
			var tabela = "<table><tr>";
			var nmValor;
			var nmDescricao;
			var chk = ""
			if (objetoTag.checar)
				chk="checked"
			var contador = 0;
			for (i in valor){
				contador += 1
			    if (contador == (coluna+1)){
				   tabela += "<tr>";
				   contador = 1
				}
				
				if (objetoTag.descrValor){
				   descrValor = objetoTag.descrValor.split(",")
				   nmDescricao = descrValor[0]
				   nmValor = descrValor[1]
			    }
				else{
				   nmDescricao = 'nm'+objetoTag.objeto
				   nmValor = 'cd'+objetoTag.objeto
				}
				
				if (!valor[i][nmDescricao] && !valor[i][nmValor]){
					var camposValidos = [];
					for (var cv in valor[i]) 
						camposValidos.push(cv)
					alert("Os campos "+nmDescricao+" e "+nmDescricao+" não existem no objeto especifique o campo descrValor corretamente. os Campos existentes para o objeto são ("+camposValidos+")" )
				    return false;
				}
				tabela += '<td><input objeto="'+objetoTag.objeto+'" '+chk+' nmDescr="'+valor[i][nmDescricao].valor+'" type="'+objetoTag.tipo+'" name="'+objetoTag.id+'" value="'+valor[i][nmValor].valor+'">'+valor[i][nmDescricao].valor+'</td>';
			}
			if (!hidden){
			   tabela += "</table>";
			   if (valor.length == 0){
			      alert("Não foi encontrado nenhum valor para "+ objetoTag.objeto)
				  this.limparRel(objetoTag);
			   }
			}
			objetoTag.innerHTML = tabela;
	 }
  }
)


	 
// -----------tagObject.popularTag-----------------//
/* 
  Function({name:valor},{name:valor})
  esta função recebe como parametro uma classe que contem o name do objeto que ira ser populado e o valor EXE
  {cdUF:'SP'}. 
  A função deste método é encontrar a tag que contenha o name igual ao nome do atributo da classe e popular ela com o valor correspondente
*/
tagObject.tags;
tagObject.getSelChkRadio = function(formTag,valor,obj, funcao){
	
	var funcPar = {
	   funcao:funcao,
	   parametros:(formTag.tagName=="DIV")?[valor]:[formTag,valor]
	}
	
	if (!formTag.objeto){
	   if (funcPar.parametros.length == 2)
	      funcPar.funcao(funcPar.parametros[0],funcPar.parametros[1])
	   else funcPar.funcao(funcPar.parametros[0])
	   return false;
	}

	var url = (formTag.idUrl)?formTag.idUrl:'json/json_'+formTag.objeto+'.asp';
	var tags = tagObject.tags.arrObject;
	var nameObj = (formTag.name)?formTag.name:formTag.id;
	var tagObj
	
	var arrFiltro = (formTag.filtro)?formTag.filtro.split(","):[];
	var filtroSel=[]
	var par = ""
	var filtroBolean = [] 
	if (obj){
	   for (var i in arrFiltro){
		   if (obj[arrFiltro[i]])
			  par += arrFiltro[i]+'='+obj[arrFiltro[i]].valor+'&'
		   else filtroSel[filtroSel.length] = arrFiltro[i]
	   }
	}
	else{
	   filtroSel = arrFiltro
	}
	if (filtroSel.length > 0){
	   tagObj = new tagObject.getTagObject()
	   par += tagObj.parametros(filtroSel)
	}
	for (var i in tags){
	    if (tags[i].referencia){
		   for (var y in tags[i].referencia){
	           if (tags[i].referencia[y] == nameObj)
		          if (obj[tags[i].nmObj]) {
				     if (par.length > 0)
				        par += "&"+tags[i].nmObj+"="+obj[tags[i].nmObj].valor;
				     else par = tags[i].nmObj+"="+obj[tags[i].nmObj].valor;
				 }
		   }
		}
	}
	
	var ajax = new Ajax.request(url,{
	       metodo:'get',
	       parametros: par,
	       arguments:[tagObject.tags,[formTag],funcPar],
	       completo:tagObject.tags.optionTag
		   }
	)
}


tagObject.popularTag = function(obj,campos, refeObj){
        var objeto = obj[0];
		if(!objeto)
		  return false
		if (refeObj){
	       ativarFuncao.Ativar(refeObj,objeto)
		}
		var separacao
		var tempObj = {}
		if (campos){
		   if (campos.length > 0){
		      for (var i in campos){
				  separacao = campos[i].split("=")
				  if (separacao.length == 1)
					 separacao[1] = separacao[0] 
			      if (objeto[separacao[1]])
			         tempObj[separacao[0]] = objeto[separacao[1]]
			  }
		      objeto = tempObj
		   }
		}
		var form;
		var ajax;
		var funcPar;
		var nmFunc
	    
		if (objeto){
		   for (var ob in objeto){
			   nmFunc = "";
			   form = document.forms[0][ob]
			   if (form){
				  if (!form.length || form.tagName == "SELECT"){
					 if (form.tagName == "INPUT"){
						tagObject.popular["popular"+form.type](form,objeto[ob].valor)
				     }else{
						nmFunc = tagObject.popular.popularSELECT 
						tagObject.getSelChkRadio(form,objeto[ob].valor,objeto,nmFunc)
				     }
				  }
				  else{
				     for (var i=0; i < form.length; i++){
					     if (form[i].tagName == "INPUT"){
							if (objeto[ob].valor[i])
							   tagObject.popular["popular"+form[i].type](form[i],objeto[ob].valor[i])
							else{ 
							   for (var f in obj)
							       tagObject.popular["popular"+form[i].type](form[i],obj[f])
							}
			             }else{
					         alert("existem dois "+form[i].tagName+" com o mesmo nome ("+form[i].name+") a propriedade do objeto não suporta este tipo de ação")
							 return false;
				         }
					 }
				  }
			   }
			   if (document.getElementById(ob)){
				  if (document.getElementById(ob).getAttribute("id")){
				     form = document.getElementById(ob)
					 if (form.getAttribute("tipo")){
						if ((form.tipo == "radio")||(form.tipo == "checkbox")){
						   nmFunc = tagObject.popularTag
						   tagObject.getSelChkRadio(form,objeto,objeto,nmFunc)
						}
						else{
					       tagObject.popular["popular"+document.getElementById(ob).tagName](ob,objeto[ob].valor);
						}
				     }
					 else{
					    tagObject.popular["popular"+document.getElementById(ob).tagName](ob,objeto[ob].valor);
					 }
				  }
			   }
		   }
        }
}

tagObject.popular = { 
	 popularSELECT:function(){
		 var objSel = arguments[0];
		 if (objSel){
			 for (var x=0; x<objSel.length; x++){
				 if (objSel.options[x].value){
				    if (objSel.options[x].value == arguments[1]){
				       objSel.options[x].selected = true;
					}
				 }
			 }
		 }
		 
	 },
	 
	 popularDIV:function(){
	     var obj = arguments[0]
		 if (obj){
		    var conteudo = document.createElement("table");
			var linha = conteudo.insertRow(conteudo.rows.length);
			if (typeof arguments[1] == "object"){
			   var contador = 0;
			   for (var i in arguments[1]){
			       if (contador == 5){
					   contador = 1;
					   linha = conteudo.insertRow(conteudo.rows.length);
				   }
				   celula = linha.insertCell(linha.cells.length);
				   texto = document.createTextNode(arguments[1][i].valor);
				   celula.appendChild(texto);
			   }
               document.getElementById(obj).appendChild(conteudo)
			}
			else{
			   document.getElementById(obj).innerHTML = arguments[1]
			}
		 }
	 },
     popularSPAN:function(){
		 var obj = arguments[0]
		 if (obj){
		    var conteudo = document.createElement("table");
			var linha = conteudo.insertRow(conteudo.rows.length);
			if (typeof arguments[1] == "object"){
			   var contador = 0;
			   for (var i in arguments[1]){
			       if (contador == 5){
					   contador = 1;
					   linha = conteudo.insertRow(conteudo.rows.length);
				   }
				   celula = linha.insertCell(linha.cells.length);
				   texto = document.createTextNode(arguments[1][i].valor);
				   celula.appendChild(texto);
			   }
               document.getElementById(obj).appendChild(conteudo)
			}
			else{
			   document.getElementById(obj).innerHTML = arguments[1]
			}
		 }
	 },
	 populartext:function(){
	     var obj = arguments[0];
		 if (obj){
 	        obj.value = arguments[1];
		 }
	 },
	 popularTEXTAREA:function(){
	     
		 var obj = arguments[0];
		 if (obj){
		     obj.value = arguments[1];
		 }
	 },
	 popularcheckbox:function(){
	     var obj = arguments[0];
		 if (obj){
		    if (typeof arguments[1] == "object"){
			   for (var i in arguments[1]){
			   	   if (obj.value == arguments[1][i].valor){
				      obj.checked = true;
				   }
			   }
			}
			else{
			   if (obj.value == arguments[1]){
			      obj.checked = true;
			   }
			}
		 }
	 },
	 popularradio:function(){
	     var obj = arguments[0];
		 if (obj){
		    if (typeof arguments[1] == "object"){
			   for (var i in arguments[1]){
				   if (obj.value == arguments[1][i].valor){
				      obj.checked = true;
					  break;
				   }
			   }
			}
			else{
			   if (obj.value == arguments[1]){
			      obj.checked = true;
			   }
			}
		 }
	 },
	 popularhidden:function(){
	     var obj = arguments[0]
		 if (obj){
		     obj.value = arguments[1];
		 }
	 }
}



// ********** getTagObjects ***********
//-- método QUE retorna uma array com o resultado e os names dos objetos mostrados
//-- função que retorna as opções que foram enviadas do ajax - Sua principal função é armazenar os dados retornados para que se possa manipular seus valores

tagObject.getTagObject = Class.create();
tagObject.getTagObject.prototype = Object.extend(new tagObject.Base,{
	arrayTagObject:new Array() ,
	inicializar:function(){
		        var elementos = document.forms[0].elements 
				for (var x=0; x < elementos.length; x++){
					if ((elementos[x].name) && (!elementos[x].notEnvio)){
					   if (!this.arrayTagObject[elementos[x].name] ){
				          this.arrayTagObject[elementos[x].name] = document.forms[0][elementos[x].name];
					   }
					}
				}
	},
    
	
	
	setParametro:function(arr){
	   var valorArray = [];
	   var flag = false
	   var temp
	   if (!arr)
	      return false
	   if (arr.length > 0){
		  for (var i in arr){
			  temp = arr[i].split("=");
			  if (temp.length == 2)
			     objRequest = {name:temp[0], value:temp[1]}
			  else objRequest = {name:temp[0], value:temp[0]}
			  
			  if (document.forms[0][objRequest.value]){
				 flag = true
				 valorArray[arr[i]] = document.forms[0][objRequest.value];
			  }
		  }
	   }
	   if (!flag)
	      return false
	   else	return valorArray;  
	},
	
	update:function(){
		        this.arrayTagObject = new Array()
		        var elementos = document.forms[0].elements 
				for (var x=0; x < elementos.length; x++){
					if ((elementos[x].name) && (!elementos[x].notEnvio)){
					   if (!this.arrayTagObject[elementos[x].name]){
				          this.arrayTagObject[elementos[x].name] = document.forms[0][elementos[x].name];
					   }
					   
					}
				}
	},
	
	chkAtributo:function(){
		this.update();
		var funcName;
		var index = this.setParametro([arguments[0]])
		var temp
		var result
		var objRequest = {}
		var flag = false;
		if (!index){
		   return false;
		}
		for (var i in index){
		    temp = i.split("=");
			if (temp.length == 2)
			   objRequest = {name:temp[0], value:temp[1]}
			else objRequest = {name:temp[0], value:temp[0]}
			result = this.montarString(this.arrayTagObject[objRequest.value]);
			if (result.length > 0 ){
			   return true;
		   }
		}
		return false;
		
	}
	,
	parametros:function(){
		this.update();
		var par = "";
		var funcName;
		var arr = this.setParametro(arguments[0])
		var index = this.arrayTagObject
		var temp
		var result
		var objRequest = {}
		if (arr){
		   index = arr
		}
		for (var i in index){
		    temp = i.split("=");
			if (temp.length == 2)
			   objRequest = {name:temp[0], value:temp[1]}
			else objRequest = {name:temp[0], value:temp[0]}
			
			result = this.montarString(this.arrayTagObject[objRequest.value]);
			
			if (result.length > 0 ){
			   if (par.length == 0){
		          par += objRequest.name+"="+result
		       }
		       else{
		          par += "&"+objRequest.name+"="+result
			   }
		   }
		}
		return par
	},
	
	
	
	montarString:function(options){
		var ocor = 0
		var concatena = function(opt){
		          if (!opt.notEnvio){
					 if ((opt.value.length > 0)||(opt.setNull)){
					    if (ocor > 0){
  	                       parametro += "[#]"+opt.value
			            }
			            else{
			               parametro = opt.value 
						}
					    ocor = 1
					 }
					 
				  }
		}
		
		if (!options)
		   return '';		
		if (!options.value && options.tagName != "SELECT"){
		   var valor = [];
		   var parametro = "";
		   
		   for (var i=0;i < options.length; i++){
			   if (!options[i].notParametro){
				  if (options[i].tagName.toLowerCase() == "input"){
				     if ((options[i].type == "checkbox") || (options[i].type == "radio") ){
			            //---Caso o type seja checkbox ou radio
					    if (options[i].checked) 
						   concatena(options[i])
			         }
			         else{ //--Caso o type seja text ou hidden 
						concatena(options[i]) 
					 }
			      }
			      else{//--Caso a tag seja SELECT OU TEXTAREA
			         concatena(options[i])
				  }
		       }
		   }
		   
		   valor = parametro
	    }
	    else{
		   valor = options.value;
	    }
		
		return valor;
	}

});
//-----------------------------------------FIM DA FUNÇÃO QUE CONTROLA AS TAGS DA TELA----------------------------------------
//---------------------------------------------------------------------------------------------------------------------------



var calendario = {}
//--- ATRÍBUTOS DA CLASSE CALENDÁRIO
calendario.ativos = []
calendario.selecao = ['diario','semanal','diasSemana','mensal'];
calendario.diasMes = [31,28,31,30,31,30,31,31,30,31,30,31];
calendario.diaSemana = ['Domingo','Segunda-Feira','Terça-Feira','Quarta-Feira','Quinta-Feira','Sexta-Feira','Sabado'];
calendario.mes = ['Janeiro','Fevereiro','Março','Abril','Maio','Junho','Julho','Agosto','Setembro','Outubro','Novembro','Dezembro'];
//---------------------------------------------------------------------------------------------------------------------------------

//--- FUNÇÕES DO CALENDÁRIO
calendario.mudarSelecao = function(nmCalendario,sel, flag){
   if (calendario.ativos[nmCalendario]){
	  if (flag){
	     calendario.travarFunc = flag
	  }
	  calendario.travarFunc
	  calendario.ativos[nmCalendario].selecao=sel;
	  calendario.montar(nmCalendario);
   }
}

calendario.travarFunc = false
calendario.setDate = function(nmId){
   this.objeto = {
              nmId:nmId,
			  nmDiv:nmId+'Inpt'
			     }
   this.limpar();
}

calendario.setDate.prototype = {
  limpar:function(){
      var obj = this.objeto
      document.getElementById(obj.nmDiv).innerHTML = ""
  },
  montar:function(valor){
         var inpt
		 var obj = this.objeto
		 var objAtivo = calendario.ativos[obj.nmId]
		 var dia = (valor.length == 1)?"0"+valor:valor
		 var mes = (objAtivo.mes+1)+""
		 var mes = (mes.length == 1)?"0"+mes:mes 
         var data = new Date()
		 data.setYear(objAtivo.ano)
		 data.setMonth(objAtivo.mes)
		 data.setDate(valor)
		 if (objAtivo.setDates){
            inpt = document.createElement('<input type="hidden" nmDescr="'+calendario.diaSemana[data.getDay()]+'" name="'+objAtivo.setDates+'" value="'+dia+'/'+mes+'/'+objAtivo.ano+'">')
	        document.getElementById(obj.nmDiv).appendChild(inpt)
         }
		 if (objAtivo.setDiaSemana){
            inpt = document.createElement('<input type="hidden" nmDescr="'+calendario.diaSemana[data.getDay()]+'" name="'+objAtivo.setDiaSemana+'" value="'+data.getDay()+'">')
	        document.getElementById(obj.nmDiv).appendChild(inpt)
         }
  }
}
		
calendario.limpar = function(objTab){
    var row = objTab.rows;
	var cell;
	var tbDA;
	for (var r=2 ; r < row.length; r++){
		cell = row[r].cells
		for (var c=0 ; c < cell.length; c++){
		    cell[c].style.border = '1px solid #FCFCF8';
			cell[c].style.backgroundColor = '#FFFFFF'; 
			cell[c].style.color = '#282211'; 
		}
	}
}
calendario.diario = function(objTd){
   var obj = (objTd.tagName)?objTd:event.srcElement
   var objTable = obj 
   var nLinha = obj.parentNode.rowIndex
   var linha;
   //---- Limpar quadradinhos
   //-----------------------------------------------
   while (objTable.tagName != "TABLE"){
         objTable = objTable.parentNode
   }
   calendario.limpar(objTable)
   
   var estSetDate = new calendario.setDate(objTable.calendario)
   if (obj.innerHTML.length > 0){
	  estSetDate.montar(obj.innerHTML)
	  obj.style.border = '1px solid #468BC7'; 
	  obj.style.backgroundColor = '#C0D8EE'; 
	  obj.style.color = '#295E8C';
   }
   if (!calendario.travarFunc){
      if (document.getElementById(objTable.calendario).funcao && event)
         eval(document.getElementById(objTable.calendario).funcao)
   }
   calendario.travarFunc = false
}
calendario.semanal = function(objTd){
   var obj = (objTd.tagName)?objTd:event.srcElement
   var objTable = obj 
   var nLinha = obj.parentNode.rowIndex
   var linha;
   while (objTable.tagName != "TABLE"){
         objTable = objTable.parentNode
   }
   cell = objTable.rows[nLinha].cells
   calendario.limpar(objTable)
   
   var estSetDate = new calendario.setDate(objTable.calendario)
   for (var x=0; x<cell.length; x++){
       if (cell[x].innerHTML.length > 0){
	      estSetDate.montar(cell[x].innerHTML)
	      cell[x].style.border = '1px solid #468BC7'; 
	      cell[x].style.backgroundColor = '#C0D8EE'; 
	      cell[x].style.color = '#295E8C';
	   }	  
   }
   if (!calendario.travarFunc){
      if (document.getElementById(objTable.calendario).funcao && event)
         eval(document.getElementById(objTable.calendario).funcao)
   }
   calendario.travarFunc = false
}


calendario.diasSemana = function(objTd){
   var obj = (objTd.tagName)?objTd:event.srcElement
   var objTable = obj 
   var coluna = obj.cellIndex
   var linhas;
   //---- Limpar quadradinhos
   //-----------------------------------------------
   while (objTable.tagName != "TABLE"){
         objTable = objTable.parentNode
   }
   linhas = objTable.rows
   calendario.limpar(objTable)
   var estSetDate = new calendario.setDate(objTable.calendario)
   for (var x=2; x<linhas.length; x++ ){
       if (linhas[x].cells[coluna].innerHTML.length > 0){
	      estSetDate.montar(linhas[x].cells[coluna].innerHTML)
	      linhas[x].cells[coluna].style.border = '1px solid #468BC7'; 
	      linhas[x].cells[coluna].style.backgroundColor = '#C0D8EE'; 
	      linhas[x].cells[coluna].style.color = '#295E8C';
	   }	  
   }
   if (!calendario.travarFunc){
      if (document.getElementById(objTable.calendario).funcao && event)
         eval(document.getElementById(objTable.calendario).funcao)
   }
   calendario.travarFunc = false
}

calendario.mensal = function(objTd){
   var obj = (objTd.tagName)?objTd:event.srcElement
   var objTable = obj 
   //---- Limpar quadradinhos
   //-----------------------------------------------
   while (objTable.tagName != "TABLE"){
         objTable = objTable.parentNode
   }
   calendario.limpar(objTable)
   var linha = objTable.rows;
   var estSetDate = new calendario.setDate(objTable.calendario)
   for (var x=2; x<linha.length; x++){
       cell = linha[x].cells
	   for (var i=0; i < cell.length; i++){
	       if (cell[i].innerHTML.length > 0){
	          estSetDate.montar(cell[i].innerHTML)
	          cell[i].style.border = '1px solid #468BC7'; 
	          cell[i].style.backgroundColor = '#C0D8EE'; 
	          cell[i].style.color = '#295E8C';
		   }	  
	   }	  
   }
   if (!calendario.travarFunc){
      if (document.getElementById(objTable.calendario).funcao && event)
         eval(document.getElementById(objTable.calendario).funcao)
   }
   calendario.travarFunc = false
}


calendario.avancarMes = function(nmId){
   calendario.ativos[nmId].mes = calendario.ativos[nmId].mes + 1
   if (calendario.ativos[nmId].mes > 11){
      calendario.ativos[nmId].mes = 0
	  calendario.ativos[nmId].ano = calendario.ativos[nmId].ano + 1
   }
   calendario.montar(nmId)
}


calendario.voltarMes = function(nmId){
   calendario.ativos[nmId].mes = calendario.ativos[nmId].mes - 1
   if (calendario.ativos[nmId].mes < 0){
      calendario.ativos[nmId].mes = 11
	  calendario.ativos[nmId].ano = calendario.ativos[nmId].ano - 1
   }
   calendario.montar(nmId)
}


calendario.getCalendario = Class.create();
calendario.getCalendario.prototype = {
   inicializar:function(nmId){
       if (!document.getElementById(nmId)){
	      alert("Objeto "+nmId+" não existe no documento")
		  return false;
	   }
	   var objId = document.getElementById(nmId)
	   var data = new Date()
	   var objdt = new calendario.getData(objId.dataInicial)
	   this.options = {
		   getObjDate:objdt.dt,
	       selecao:(objId.selecao)?objId.selecao.split(","):[],
		   setDiaSemana:(objId.setDiaSemana)?objId.setDiaSemana:false,
		   setDates:(objId.setDate)?objId.setDate:false,
		   ano:objdt.ano(),
		   mes:objdt.mes(),
		   obj:objId,
		   getSelecao:function(num){
		      var sel = this.selecao
			  for (var i in sel){
			      if(sel[i] == num)
				    return true
			  }
			  return false
		   }
	   }
	   
	   if (!this.options.setDates){
	      alert("Digite o nome do campo onde serão carregadas as datas");
		  return false;
	   }
	   calendario.ativos[nmId] = this.options
	   calendario.montar(nmId)
   }	   
}   
calendario.getData = Class.create()
calendario.getData.prototype = {
   dt:new Date(),
   inicializar:function(data){
	  var objF = document.forms[0]
      var arrDate = ((new Date(data) == "NaN")?((objF[data])?objF[data].value.split("/"):false):data.split("/"))
	  if (arrDate){
	     this.dt = new Date()
		 this.dt.setMonth(arrDate[1]-1)
		 this.dt.setYear(arrDate[2])
		 this.dt.setDate(arrDate[0])
      }
   },
   mes:function(){
	    return this.dt.getMonth()
	},
	ano:function(){
	    return this.dt.getFullYear()	
	},
	dia:function(){
		return this.dt.getDay()
	}
}

calendario.montar = function(nmId){
	   
	   var objCell
	   var objDiaCell
	   var objCalend = calendario.ativos[nmId]
	   var hoje = objCalend.getObjDate
	   //--- recuperando se a data para iniciar o calendário é válida
	   document.getElementById(nmId).innerHTML = "";
	   var tabCalendario = document.createElement('<table border=1 calendario="'+nmId+'" cellspacing=0 cellpadding=0>')
	   //---------------- <<< MAIO >> ------------------
	   
	   var linha = tabCalendario.insertRow(0)
	   var cabe = linha.insertCell(0)
	   cabe.setAttribute("colSpan",7)
	   
	   var nmMes
	   if (objCalend.getSelecao(3))
	      nmMes = "<span style=\"cursor:hand\" onclick=\"calendario.mensal()\">"+calendario.mes[objCalend.mes]+"/"+objCalend.ano+"</span>"
	   else nmMes = calendario.mes[objCalend.mes]+"/"+objCalend.ano
	   cabe.innerHTML = '<center><span style="cursor:hand" onclick="calendario.voltarMes(\''+nmId+'\')"> <<< </span>'+nmMes+'<span style="cursor:hand" onclick="calendario.avancarMes(\''+nmId+'\')"> >>> </span>'
	   
	   //----------- D S T Q Q S S
	   linha = tabCalendario.insertRow(1)
	   for (var i in calendario.diaSemana){
	       Cell = linha.insertCell(i)
		   Cell.innerHTML = calendario.diaSemana[i].substr(0,3);

		   if (objCalend.getSelecao(2))
		      Cell.attachEvent("onclick",calendario.diasSemana)
	   }
	   
	   //------------------- 1 2 3 4 5
	   var dias = calendario.diasMes[objCalend.mes]
	   if (objCalend.mes == 1){
	      if (objCalend.ano%4 == 0)
		     dias = 29
	   }
	   var data = new Date()
	   data.setMonth(objCalend.mes)
	   data.setYear(objCalend.ano)
	   
	   linha = tabCalendario.insertRow(2)
	   for (var x=0; x<7; x++)
	       linha.insertCell(x)
	   var celula
	   var dtAnterior
	   for (var x=1; x<=dias;x++){
           data.setDate(x)
		   //alert(x+"--"+data.getDay(x))
		   celula = linha.cells[data.getDay()]
		   if (objCalend.getSelecao(0))
		      celula.attachEvent("onclick",calendario.diario)
		   if (objCalend.getSelecao(1))
		      celula.attachEvent("ondblclick",calendario.semanal)
		   celula.innerHTML = (x.length == 1)?"0"+x:x
		   if (hoje.getDate() == x)
		      objCell = celula
		   if (data.getDay()==6){
		      linha = tabCalendario.insertRow(tabCalendario.rows.length)
			  for (var ax=0; ax<7; ax++)
	              linha.insertCell(ax)
		   }		  
	   }
	   objCalend.obj.appendChild(tabCalendario)
	   if (objCalend.setDates){
	      var inputCalend = document.createElement('<div id="'+nmId+'Inpt">')
		  objCalend.obj.appendChild(inputCalend)
	   }
	   var dtCal = new Date()
	   dtCal.setYear(objCalend.ano)
	   dtCal.setMonth(objCalend.mes)
	   dtCal.setDate(01)
	   if ((objCalend.ano == hoje.getFullYear())&&(objCalend.mes == hoje.getMonth())) {
	      if (objCalend.getSelecao(0))
		     calendario.diario(objCell)
		  else if (objCalend.getSelecao(1))
		       calendario.semanal(objCell)
		  else if (objCalend.getSelecao(2))
		       calendario.semanal(hoje.getDay())
	   }
	   else{
	      if (objCalend.getSelecao(0))
		     calendario.diario(objCell)
		  else if (objCalend.getSelecao(1))
		     calendario.semanal(objCell)
		  else if (objCalend.getSelecao(2))
		      calendario.semanal(dtCal.getDay()) 
	   }
}



//---------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------
//------------------ESTA CLASSE MONTA A AGENDA

//--------------------LOGO MAIS DETALHES
var agenda = {}
agenda.diaSemana = function(data){
   var arrdt = data.split("/")
   var DataSem = new Date();
   DataSem.setMonth((arrdt[1]*1)-1)
   DataSem.setYear(arrdt[2])
   DataSem.setDate(arrdt[0])
   return DataSem.getDay();                                     
}
agenda.limparTabela = function(objTab){
   var linha = objTab.rows;
   var coluna;
   for (var x=1; x<linha.length; x++){
       coluna = linha[x].cells
	   for (var y=1; y<coluna.length; y++){
	       coluna[y].innerHTML = ""
		   coluna[y].style.border = '1px solid #FCFCF8';
		   coluna[y].style.backgroundColor = '#FFFFFF';
		   coluna[y].style.color = '#282211';
		   coluna[y].style.cursor = 'hand';
	   }
   }
}

agenda.alterar = function(nmAgenda){
   if (!document.getElementById(nmAgenda)){
	   alert("O objeto "+nmAgenda+" não existe no documente")
	   return false;
   }
   agenda.montar(agenda.visivel[nmAgenda], nmAgenda);
}

agenda.Ativas = []
agenda.visivel = []
agenda.setAgenda = Class.create()
agenda.setAgenda.prototype = {
    inicializar:function(objAg){
	   var subAg = []
	   objTemp = objAg.childNodes
	   agenda.Ativas[objAg.id] = []
	   for (var i=0; i < objTemp.length; i++){
		   if (!objTemp[i].id){
		      alert("Especifique um id para os filhos da agenda ("+objAg.id+")")
			  return false
		   }
		   agenda.Ativas[objAg.id][objTemp[i].id] = {
		                          parametro:(objTemp[i].enviarParametro)?objTemp[i].enviarParametro:false,
								  pai:objAg.id,
								  objTag:objTemp[i],
								  interHora:(objTemp[i].interHora)?objTemp[i].interHora:"60",
								  hrIni:(objTemp[i].hrIni)?objTemp[i].hrIni.split(":"):[0,0],
								  hrFim:(objTemp[i].hrFim)?objTemp[i].hrFim.split(":"):[23,59],
								  filho:(objTemp[i].filho)?objTemp[i].filho:false,
								  funcao:(objTemp[i].funcao)?objTemp[i].funcao:false,
								  filhoUrl:(objTemp[i].filhoUrl)?objTemp[i].filhoUrl:false,
								  classi:(objTemp[i].classific)?objTemp[i].classific:false,
								  refObjeto:(objAg.refObjeto)?objAg.refObjeto:false,
								  refAcao:(objAg.refAcao)?objAg.refAcao:false,
								  indiceCell:[],
								  indiceLinha:[],
								  horarios:function(){
								        this.indiceLinha = []
										if (this.hrIni.length != 2){
										   alert("Insira o horário corretamente Exe:12:00")
										   return false
										}
										if (this.hrFim.length != 2){
										   alert("Insira o horário corretamente Exe:12:00")
										   return false
										}
										var dt = new Date(2008,05,23);
                                        dt.setHours(this.hrIni[0]);
                                        dt.setMinutes(this.hrIni[1]);
                                        dt.setSeconds(00);
										
										var df = new Date(2008,05,23);
                                        df.setHours(this.hrFim[0]);
                                        df.setMinutes(this.hrFim[1]);
                                        df.setSeconds(00);
										var hora
										var contador = 0
										while ( (dt.getTime()) <= (df.getTime()) ){
										      hora = dt.getTime()
											  contador+=1
											  this.indiceLinha[hora] = contador
											  dt.setTime(dt.getTime()+60*this.interHora*1000)
										}
										return(this.indiceLinha)      
								  }
								  } 
	   }
	   
	   var objSpan = document.createElement('<span id="ag'+objAg.id+'">')
	   objAg.appendChild(objSpan)
	   if (objAg.iniciar){
	      if (!document.getElementById(objAg.iniciar)){
		    alert("O obetoj que foi pedido para iniciar a agenda("+objAg.iniciar+") não existe verifique se o nome foi digitado corretamente")
			return false
		  }	
		  agenda.visivel[objAg.id] = objAg.iniciar
	      agenda.montar(objAg.iniciar, objAg.id)
	   }	  
	}
}	

agenda.montar = function(nmObjeto,agPai){
   var fAnt
   if (!document.getElementById(nmObjeto)){ 
      if (document.getElementById(agenda.visivel[agPai])){
	     nmObjeto = agenda.visivel[agPai]
	  }else{
	     alert("Para montar a agenda o objeto precisa ser especificado corretamente") 
		 return false;
	  }   	 
   }
   agenda.visivel[agPai] = nmObjeto;
   var tabela = document.createElement('<table border=1 cellspacing=0 cellpadding=0>');
   var valores = agenda.getCabecalho(nmObjeto);
   var dt;
   var hrMin;
   var ParEnv;
   if (valores){
      clearInterval(agenda.intervalo)	  
	  document.getElementById("ag"+agPai).innerHTML = "";
      agenda.Ativas[agPai][nmObjeto].indiceCell = [];
      agenda.Ativas[agPai][nmObjeto].tabela = tabela;
	  var linha = tabela.insertRow(0);
	  var cell = linha.insertCell(0);
	  for (var i in valores){
		  agenda.Ativas[agPai][nmObjeto].indiceCell[valores[i].valor] = linha.cells.length
		  cell = linha.insertCell(linha.cells.length)
		  cell.innerHTML = valores[i].descr
	  }
	  var horas = agenda.Ativas[agPai][nmObjeto].horarios()
	  var tags = new tagObject.getTagObject();
	  var parametros = "";
	  if (agenda.Ativas[agPai][nmObjeto].parametro)
	     parametros = tags.parametros(agenda.Ativas[agPai][nmObjeto].parametro.split(","))+"&"; 
      
	  var objAgd = agenda.Ativas[agPai][nmObjeto]
	  var refObjeto = (objAgd.refObjeto)?objAgd.refObjeto+";"+nmObjeto+","+agPai:nmObjeto+","+agPai;
	  var refAcao = (objAgd.refAcao)?objAgd.refAcao+";agenda.atualizar":"agenda.atualizar";
	  for (var x in horas){
	      linha = tabela.insertRow(horas[x]);
		  cell = linha.insertCell(linha.cells.length)
		  dt = new Date()
		  dt.setTime(x)
          hr = dt.getHours()+""
		  mn = dt.getMinutes()+""
          cell.innerHTML = (((hr.length)==1)?"0"+hr:hr)+":"+((mn.length==1)?"0"+mn:mn)
		  dt.setTime(dt.getTime()+60*agenda.Ativas[agPai][nmObjeto].interHora*1000);
		  for (var i in valores){
			  cell = linha.insertCell(linha.cells.length);
			  cell.setAttribute("horaIni",hr+":"+mn);
			  cell.setAttribute("horaFim",dt.getHours()+":"+dt.getMinutes());
			  if (agenda.Ativas[agPai][nmObjeto].filho)
			     cell.setAttribute("idFilho",agenda.Ativas[agPai][nmObjeto].filho)
			  else cell.setAttribute("urlFilho",agenda.Ativas[agPai][nmObjeto].filhoUrl)
			  cell.setAttribute("descrObj",valores[i].descr)
			  cell.setAttribute("refObjeto",refObjeto)
			  cell.setAttribute("refAcao",refAcao)
			  cell.setAttribute("idTipo","1")
              cell.setAttribute("parEnv",parametros+valores[i].name+"="+valores[i].valor+"&horaIni="+hr+"&minIni="+mn+"&horaFim="+dt.getHours()+"&minFim="+dt.getMinutes())
              
			  //alert((agenda.Ativas[agPai][nmObjeto].filho) +"------"+ (agenda.Ativas[agPai][nmObjeto].filhoUrl))
			  if (agenda.Ativas[agPai][nmObjeto].funcao){
				 cell.attachEvent("onclick", function(){
												alert('parar')
												clearInterval(agenda.intervalo)	
												eval(agenda.Ativas[agPai][nmObjeto].funcao)
						          })
			  }

			  
			  if ((agenda.Ativas[agPai][nmObjeto].filho) || (agenda.Ativas[agPai][nmObjeto].filhoUrl)){
				 if (typeof(cell.onclick) == "function")
				    var fAnt = cell.onclick
				 cell.attachEvent("onclick", function(){
										var obj = event.srcElement
										clearInterval(agenda.intervalo)
										if (event.srcElement.tagName == "TABLE")
										    obj = event.srcElement.parentNode
										if (fAnt)
											fAnt()
										new navegar.enviar({
									    tag:obj,
									    parametros:obj.parEnv, 
				 				        autenticar:true})
								 })
			  }
		  }	  
	  }
	  document.getElementById("ag"+agenda.Ativas[agPai][nmObjeto].pai).appendChild(tabela)
	  agenda.tabela = tabela
	  agenda.atualizar(nmObjeto, agPai)
   }
}

 
agenda.atrNumeroAgendas = false

agenda.validarAtualizacaoAutomatica = function(){
   
   var nmObjeto = arguments[1][0]
   var agPai = arguments[1][1]
   var numeroAgendamentos = arguments[0][0]
   //----------verificando se o estado de seção esta sendo iniciado pela primeira vez
   
   //-- neste estado ele apenas recupera o número de agendas existentes utilizando os fitros es as condições nescessárias
   
   if (!agenda.atrNumeroAgendas){
	  agenda.atrNumeroAgendas = numeroAgendamentos
	  return false;
   }
   
   if (agenda.atrNumeroAgendas == numeroAgendamentos)
      return false;
   agenda.atrNumeroAgendas = numeroAgendamentos
   
   agenda.atualizar(nmObjeto, agPai, ['botao'])	
}



agenda.atualizacaoAutomatica=function(nmObjeto, agPai){
   var objAg = agenda.Ativas[agPai][nmObjeto]
   var nodeFilhos = objAg.objTag.childNodes
   var parFiltro = new tagObject.getTagObject()
   var pk
   var flag_pk = true
   var funcao
   
   for (var i=0; i<nodeFilhos.length;i++){
	   if (nodeFilhos[i].botao){
	      if (nodeFilhos[i].url){
	         flag_pk = true
			 if (nodeFilhos[i].pkFiltro){
	            pk = nodeFilhos[i].pkFiltro.split(",")
                for (var x in pk){
	                parametros = parFiltro.parametros([pk[x]])
			        if ((parametros.split("[#]")).length != 1 || (parametros.split("[#]")).length == 0){
				       flag_pk = false
			        }	 
		        }
		     }
		     else{
			    flag_pk = true
		     } 	 
		     if (flag_pk){
			    new Ajax.request("json/json_numeroDeAgendamentos.asp",
		               {
			 		   metodo:'get',
		 			   parametros:(nodeFilhos[i].filtro)?parFiltro.parametros(nodeFilhos[i].filtro.split(",")):'',
					   arguments:[nmObjeto, agPai],
					   noLoading:true,
		 			   completo:agenda.validarAtualizacaoAutomatica
				 	   })
			 }
		  }
	   }
   } 
}

agenda.atualizar = function(nmObjeto, agPai){
   if (nmObjeto == 'visivel')
	  nmObjeto = agenda.visivel[agPai]

   agenda.intervalo = window.setInterval("agenda.atualizacaoAutomatica('"+nmObjeto+"','"+agPai+"')",5000)
   var objAg = agenda.Ativas[agPai][nmObjeto]
   var nodeFilhos = objAg.objTag.childNodes
   var parFiltro = new tagObject.getTagObject()
   var pk
   var flag_pk = true
   var funcao
   agenda.limparTabela(objAg.tabela)
   
   
   for (var i=0; i<nodeFilhos.length;i++){
	   if (nodeFilhos[i].url){
	   	  if (nodeFilhos[i].marcar)
	         funcao = agenda.marcar
	      else	funcao = agenda.botao
	      
		  if (nodeFilhos[i].pkFiltro){
	         pk = nodeFilhos[i].pkFiltro.split(",")
             for (var x in pk){
	             parametros = parFiltro.chkAtributo([pk[x]])
			     if ((parametros.split("[#]")).length != 1 || (parametros.split("[#]")).length == 0){
				    flag_pk = false
			     }	 
		     }
		     if (flag_pk){
			    new Ajax.request(nodeFilhos[i].url,
		                 {
						 metodo:'get',
		 				 parametros:(nodeFilhos[i].filtro)?parFiltro.parametros(nodeFilhos[i].filtro.split(",")):'',
						 arguments:{obj:nodeFilhos[i],agPai:agPai},
		 				 completo:funcao
						 })
		     }
	      }
	      else{
	         new Ajax.request(nodeFilhos[i].url,
		               {
			 		   metodo:'get',
		 			   parametros:(nodeFilhos[i].filtro)?parFiltro.parametros(nodeFilhos[i].filtro.split(",")):'',
					   arguments:{obj:nodeFilhos[i],agPai:agPai},
		 			   completo:funcao
				 	   })
	      }
	   }
   }
}

agenda.marcar = function(valores,objs){
   obj = objs.obj
   agPai = objs.agPai
   if (!obj.iC){
	   alert("Marque o indice da coluna no atributo(iC)")
	   return false;
   }
   var iCell = obj.iC.split("/");
   var indexCell = iCell[0];
   var funcao = agenda[iCell[1]];
   var idCel;
   var nCell = false;
   var linhas = agenda.Ativas[agPai][agenda.visivel[agPai]].indiceLinha;
   var coluna = agenda.Ativas[agPai][agenda.visivel[agPai]].indiceCell;
   var iLinha =  obj.iL.split(",");
   var vI="";
   var vF="";
   var dtF;
   var dtI;
   var horaIni;
   var horaFim = false;
   var celula;

   for (var i in valores){
	   if (!valores[i][indexCell]){
	      alert("o atributo "+indexCell+" não existe no objeto")
		  return false;
	   }
	   if (!valores[i][iLinha[0]]){
	      alert("o atributo "+iLinha[0]+" não existe no objeto")
		  return false;
	   }
	   horaIni = valores[i][iLinha[0]].valor.split(":")
	   if (iLinha[1]){
	      if (!valores[i][iLinha[1]]){
		     alert("o atributo "+iLinha[1]+" não existe no objeto")
		     return false;
		  }
		  horaFim = valores[i][iLinha[1]].valor.split(":")
	   }
       if (!horaFim)
	      horaFim = [23,59]
	   nCell = false;  
	   dtI = new Date(2008,05,23);
       dtI.setHours(horaIni[0]);
       dtI.setMinutes(horaIni[1]);
       dtI.setSeconds(00);
		  
	   dtF = new Date(2008,05,23);
       dtF.setHours(horaFim[0]);
       dtF.setMinutes(horaFim[1]);
       dtF.setSeconds(00);
	   
	   
	   for (var x in coluna){
	       idCel = x
		   if (funcao)
		      idCel = funcao(x);
		   if (idCel == valores[i][indexCell].valor){
			  for (var l in linhas){
			      celula = ""
				  if ((dtI.getTime() <= l) && (dtF.getTime() > l)){
			         celula = agenda.tabela.rows[linhas[l]].cells[coluna[x]]
					 celula.style.border = '1px solid #468BC7';
					 celula.style.backgroundColor = '#C0D8EE';
					 celula.style.color = '#295E8C';
			 	  }
			  }	  	  
		   }	  
 	   }
   }
}

agenda.botao = function(valores,objs){
   obj = objs.obj
   agPai = objs.agPai
   if (!obj.iC){
	   alert("Marque o indice da coluna no atributo(iC)")
	   return false;
   }
   var iCell = obj.iC.split("/");
   var indexCell = iCell[0];
   var funcao = agenda[iCell[1]];
   var idCel;
   var linhas = agenda.Ativas[agPai][agenda.visivel[agPai]].indiceLinha;
   var coluna = agenda.Ativas[agPai][agenda.visivel[agPai]].indiceCell;
   var df = new Date()
   var iLinha = obj.iL
   var horaIni;
   var celula;
   var bot;
   var parEnv;
   if (!obj.enviarParametro){
      alert("especifique o atributo enviarParametro com o código especifico do agendamento")
	  return false;
   }
   if (!obj.enviarParametro){
      alert("especifique o atributo enviarParametro com o código especifico do agendamento")
	  return false;
   }
   var descrBot = obj.botao.split(",")
   var formBot = []
   for (var b in descrBot){
       descrBot[b] = descrBot[b].split("=")
       if (descrBot[b].length == 2){
	      formBot[formBot.length] = descrBot[b]
	   }
   }
   var descricao = ""
   var divBox
   var hrDiv
   for (var i in valores){
	   if (!valores[i][indexCell]){
	      alert("o atributo "+indexCell+" não existe no objeto")
		  return false;
	   }
	   if (!valores[i][iLinha]){
	      alert("o atributo "+iLinha+" não existe no objeto")
		  return false;
	   }
	   if (!valores[i][obj.enviarParametro]){
	      alert("o atributo "+obj.enviarParametro+" não existe no objeto")
		  return false;
	   }
	   for (var b in formBot){
	       if (!valores[i][formBot[b][1]]){
	          alert("o atributo "+formBot[b][1]+" não existe no objeto")
		      return false;
	       }
	   }
	   
	   horaIni = valores[i][iLinha].valor.split(":")
       
	   
	   dtI = new Date(2008,05,23);
       dtI.setHours(horaIni[0]);
       dtI.setMinutes(horaIni[1]);
       dtI.setSeconds(00);

	   for (var x in coluna){
	       idCel = x
		   if (funcao)
		      idCel = funcao(x);
		   if (idCel == valores[i][indexCell].valor){
			  for (var l in linhas){
			      celula = ""
				  df.setTime((l*1)+60*agenda.Ativas[agPai][agenda.visivel[agPai]].interHora*1000);
				  if ((dtI.getTime() >= l) && (dtI.getTime() < df.getTime())){
			         celula = agenda.tabela.rows[linhas[l]].cells[coluna[x]]
					 //----  Colocnado o span para posicionar o botão 
					 if (celula.childNodes[0]){
					    if (celula.childNodes[0].tagName == "TABLE"){
					       hrDiv = celula.childNodes[0].rows[0]
						}
					 }
					 else{
						 divBox = document.createElement("<table border=0 cellspacing=6 cellpadding=0>")
						 hrDiv = divBox.insertRow(0)
						 divBox.parEnv = celula.parEnv
						 divBox.horaIni = celula.horaIni
			             divBox.horaFim = celula.horaFim
			             divBox.descrObj = celula.descrObj
			             divBox.refObjeto = celula.descrObjeto
			             divBox.idTipo=celula.idTipo
                         divBox.parEnv = celula.parEnv
						 celula.appendChild(divBox)
					 }
					 //----  Colocando a hora da agenda em cima do botão 
					 cellDiv = hrDiv.insertCell(hrDiv.cells.length)
					 if (obj.filho)
			            cellDiv.setAttribute("idFilho",obj.filho)
			         else if(obj.filhoUrl) cellDiv.setAttribute("urlFilho",obj.filhoUrl)
					 cellDiv.setAttribute("parEnv",obj.enviarParametro+"="+valores[i][obj.enviarParametro].valor)
			         cellDiv.setAttribute("refObjeto",agenda.visivel[agPai]+","+agPai)
                     cellDiv.setAttribute("refAcao","agenda.atualizar")
					 
					 if (obj.funcao){
				        cellDiv.setAttribute("subFuncao",obj.funcao)
						cellDiv.onclick = function(){
											  var tag = function(e){
											      var o = e
												  while (o.tagName != "TD")
												        o = o.parentNode
												  return o
											  }
											  eval(tag(event.srcElement).subFuncao)
											  event.cancelBubble = true
											  }
					 }
					 else{cellDiv.attachEvent("onclick", function(){
				                                var tag = function(e){
												    var o = e
													while (o.tagName != "TD")
													      o = o.parentNode
												    return o
												}
												
												new navegar.enviar({
									            tag:tag(event.srcElement),
									            parametros:tag(event.srcElement).parEnv, 
				 				                autenticar:true
									            });
												event.cancelBubble = true
												}
									)
					 }
					 
					 
					 /*bot.style.border = '1px solid #12D3DE';
                     bot.style.backgroundColor = '#BEF7FA';
                     bot.style.color = '#295E8C';
					 bot.style.cursor = "hand";
					 */
					 
					 descricao = ""
					 for (var fb in formBot){
					     descricao += "<br>"+formBot[fb][0]+":"+valores[i][formBot[fb][1]].valor
					 }
					 cellDiv.setAttribute("msg",descricao)
					 cellDiv.onmouseover = function(){showMsg(event.srcElement.msg,event)}
					 
					 cellDiv.style.fontSize = "xx-small"
					 if (valores[i][obj.descrBot])
					    cellDiv.innerHTML = '<img src="img/band_sino.png" parEnv="'+obj.enviarParametro+'='+valores[i][obj.enviarParametro].valor+'" refObjeto="'+agenda.visivel[agPai]+','+agPai+'" refAcao="agenda.atualizar"><br>'+ valores[i][obj.descrBot].valor
					else cellDiv.innerHTML = '<img src="img/band_sino.png" parEnv="'+obj.enviarParametro+'='+valores[i][obj.enviarParametro].valor+'" refObjeto="'+agenda.visivel[agPai]+','+agPai+'" refAcao="agenda.atualizar">'
					//----  imprimindo a hora na tela
					break;
			 	  }
			  }
			  break;
		   }	  
 	   }
   }
}

agenda.getCabecalho = function(nmObj){
   obj = document.getElementById(nmObj).getCabecalho
   if (!document.forms[0][obj]){
      alert("objeto "+obj+" não existe no document para montar o cabeçalho da agenda");
	  return false;
   }
   var tempVal = document.forms[0][obj];
   var array = [];
   var objetos = []
   var classTemp;
   if ((tempVal.value)||(!tempVal.length)){
 	  if (tempVal.tagName == "INPUT"){
		 if (tempVal.type == "checkbox" || tempVal.type == "radio"){
		    if (tempVal.checked){
			   array[array.length] = {
			                valor:tempVal.value,
				 		    descr:tempVal.nmDescr,
						    index:0,
						    name:tempVal.name
						   }
		    }
		 }
		 else{
		    array[array.length] = {
			            valor:tempVal.value,
			            descr:(tempVal.nmDescr)?tempVal.nmDescr:tempVal.value,
						index:false,
						name:tempVal.name
						}
		 }
	  }
	  else{
		 array[array.length] = {valor:tempVal.value,
					  descr:tempVal[tempVal.selectedIndex].innerHTML,
					  index:tempVal.selectIndex-1,
					  name:tempVal.name} 
	  }
   }
   else{
	  if (tempVal[0].type == "checkbox"){
		 for (var y = 0; y < tempVal.length; y++){
		     if (tempVal[y].checked){
				
				array[array.length] = {
				             valor:tempVal[y].value,
			                 descr:(tempVal[y].nmDescr)?tempVal[y].nmDescr:tempVal[y].value,
			                 index:y,
			                 name:tempVal[y].name
							}
			 }
		 }
	  }
      else{
		 if (tempVal[0].type == "radio"){
		    //------------ verificação radio
		    for (var y=0; y<tempVal.length; y++){
		        if (tempVal[y].checked){
			       array[array.length] = {
				         valor:tempVal[y].value,
			             descr:(tempVal[y].nmDescr)?tempVal[y].nmDescr:tempVal[y].value,
			   	         index:y,
					     name:tempVal[y].name
				   }
				   y = tempVal.length
		   	    }
		    }
		 }
		 else{
		    for (var y=0; y<tempVal.length; y++){
		        array[array.length] = {
				      valor:tempVal[y].value,
			          descr:(tempVal[y].nmDescr)?tempVal[y].nmDescr:tempVal[y].value,
			   	      index:y,
				      name:tempVal[y].name
				}
		    }
		 }
	  }
   }	 
   return (array.length > 0)?array:false;
}






// ----------------------------------------------------
// Esta função mostra a caixa de opções do menu de cima
var oPopup = window.createPopup();

// @Mail assumes 96dpi, so what percentage of 96 DPI are we?
function scaleFactorDPI() {
   return (screen.deviceYDPI / 96);
}

function mostra_opc(evt){
		 enviando = evt.srcElement.value
		 tamanho = evt.srcElement.style.width
		 s_ajax('sel','menu/opcao_sel.asp?enviar='+url_encode(enviando),0,500)
}




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


function menuSusp(ID,atributos){
   if (!document.getElementById(ID))
      return false;
   var menu	= document.getElementById(ID);
   var opcoes = menu.childNodes;
   var arrOpc = [];
   var opcEvt = (event.srcElement)?event.srcElement:false;
   var ncoluna = 0;
   
   for (var i=0; i < opcoes.length;i++){
       if (opcoes[i].id && opcoes[i].descr){
	      if (opcoes[i].descr.length > ncoluna)
		     ncoluna = opcoes[i].descr.length;
		  arrOpc[arrOpc.length] = {
			                       objeto:(opcEvt)?opcEvt:false,
		                           url:(opcoes[i].urlFilho)?opcoes[i].urlFilho:false,
                                   filho:(opcoes[i].idFilho)?opcoes[i].idFilho:false,
				                   descr:opcoes[i].descr,
								   objOrigem:opcEvt,
								   tipo:(opcoes[i].idTipo)?opcoes[i].idTipo:false,
								   parametros:( (opcoes.parEnv)?((opcEvt.parEnv)?opcoes.parEnv+"&"+opcEvt.parEnv:opcoes.parEnv ):((opcEvt.parEnv)?opcEvt.parEnv:false))
				                  }  
	   }
   }
   
   evt = event
   Xpos = document.body.scrollLeft + evt.clientX - evt.offsetX -3;
   Ypos = document.body.scrollTop + evt.clientY - evt.offsetY ;
   montarMenu(arrOpc,Ypos,Xpos,ncoluna*10,atributos)
}



function montarMenu(opcoes,Y,X,Width,atributos){
		 var par
		 var posx = ((opcoes.length-1)*34+40)
		 var opSec = '<table onclick="parent.oPopup.hide();" width='+Width+' bgcolor="#FCFCF8" cellpadding="1" cellspacing="1" border="0" style="border: 1px solid #918E82;">'
        // --------- Urgente --------------------------------------- 
		 for (var x=0; x < opcoes.length; x++){
             opSec += '<tr><td '
			 if (opcoes[x].parametros)
			     opSec += 'parEnv="'+opcoes[x].parametros+'" '
			 if (opcoes[x].url)
			     opSec += 'urlFilho="'+opcoes[x].url+'" '	 
			 if (opcoes[x].filho)
			     opSec += 'idFilho="'+opcoes[x].filho+'" '
			 if (opcoes[x].tipo)
			     opSec += 'idTipo="'+opcoes[x].tipo+'" '
			 if (opcoes[x].objeto.refObjeto)
			     opSec += 'refObjeto="'+opcoes[x].objeto.refObjeto+'" '
			 if (opcoes[x].objeto.refAcao)
			     opSec += 'refAcao="'+opcoes[x].objeto.refAcao+'" '
			 if (atributos){
			    for (var i in atributos){
				    if (opcoes[x].objeto[atributos[i]])
					   opSec +=atributos[i] +'="'+opcoes[x].objeto[atributos[i]]+'" '
				}
			 }
			 opSec +='onclick="new parent.navegar.enviar({tag:event.srcElement,parametros:event.srcElement.parEnv,autenticar:true})"'
			 opSec += ' style="';
			 opSec += 'padding-left : 8px; padding-right: 8px; border : 1px solid #FCFCF8; font : 8pt Tahoma; color : #282211; cursor : hand;"'
			 opSec += '" onmouseover=" '
			 opSec += "this.style.paddingleft ='15px'; this.style.paddingright = '5px'; this.style.border = '1px solid #468BC7'; this.style.backgroundColor ='#C0D8EE'; this.style.font = '8pt Tahoma'; this.style.color = '#295E8C'; this.style.cursor ='hand'; "
			 opSec += '" onmouseout=" '
			 opSec += " this.style.paddingleft = '15px'; this.style.paddingright = '5px'; this.style.border = '1px solid #FCFCF8'; this.style.backgroundColor = '#FCFCF8';this.style.font = '8pt Tahoma'; this.style.color = '#282211'; this.style.cursor = 'hand';"
			 opSec += '">'+opcoes[x].descr+'<hr></td></tr>'
		 }
		 opSec += "</table>"
		 oPopup.document.body.style.backgroundColor = "#f3f3ee";
	     oPopup.document.body.innerHTML = opSec
	     oPopup.show(X,Y,Width,posx * scaleFactorDPI(),document.body);
}




/*
	Lightbox JS: Fullsize Image Overlays 
	by Lokesh Dhakar - http://www.huddletogether.com

	For more information on this script, visit:
	http://huddletogether.com/projects/lightbox/

	Licensed under the Creative Commons Attribution 2.5 License - http://creativecommons.org/licenses/by/2.5/
	(basically, do anything you want, just leave my name and link)
	
	Table of Contents
	-----------------
	Configuration
	
	Functions
	- getPageScroll()
	- getPageSize()
	- pause()
	- getKey()
	- listenKey()
	- showLightbox()
	- hideLightbox()
	- initLightbox()
	- addLoadEvent()
	
	Function Calls
	- addLoadEvent(initLightbox)

*/



//
// Configuration
//

function calculoPorc(p,vt){
   return (p*vt)/100
}

//
// Centralizar()
// Esta função recebe a referencia de um objeto e o centraliza de acordo com o 
// tamanho total da tela ou do objeto
function centralizar(object,objRef){
   arrayPageSize = getPageSize()
   if (object) {
	  var objH = (object.style.height)?object.style.height.replace('px',''):object.offsetHeight
	  var objW = (object.style.width)?object.style.width.replace('px',''):object.offsetWidth	
	  if (objRef){
	     var oRH = (objRef.style.height)?objRef.style.height.replace('px',''):objRef.offsetHeight
	     var oRW = (objRef.style.width)?objRef.style.width.replace('px',''):objRef.offsetWidth	
		   
		   object.style.top = ((oRH-objH)/2)*1 ;
		   object.style.left = ((oRW-objW)/2)*1 ;
		}
		else{
		   object.style.top = ((arrayPageSize[1]-scrollSize().sH) - objH)/2 *1;
		   object.style.left = ((arrayPageSize[0]-scrollSize().sW) - objW)/2 *1;
		}
	}

}



//
// getPositionObj()
// retorna a posição atual do objeto na tela.
// Core code from - OlharWeb
//

function getPositionObj(obj){
   var left = 0;
   var top = 0;
   while (obj.offsetParent) {
      top +=obj.offsetTop
	  left +=obj.offsetLeft 
	  obj = obj.offsetParent
  }
  return {y:top, x:left}
}



//
// getPageScroll()
// Returns array with x,y page scroll values.
// Core code from - quirksmode.org
//
function getPageScroll(){

	var yScroll;

	if (self.pageYOffset) {
		yScroll = self.pageYOffset;
	} else if (document.documentElement && document.documentElement.scrollTop){	 // Explorer 6 Strict
		yScroll = document.documentElement.scrollTop;
	} else if (document.body) {// all other Explorers
		yScroll = document.body.scrollTop;
	}

	arrayPageScroll = new Array('',yScroll) 
	return arrayPageScroll;
}



//
// getPageSize()
// Returns array with page width, height and window width, height
// Core code from - quirksmode.org
// Edit for Firefox by pHaez
//

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

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


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


//
// pause(numberMillis)
// Pauses code execution for specified time. Uses busy code, not good.
// Code from http://www.faqts.com/knowledge_base/view.phtml/aid/1602
//
function pause(numberMillis) {
	var now = new Date();
	var exitTime = now.getTime() + numberMillis;
	while (true) {
		now = new Date();
		if (now.getTime() > exitTime)
			return;
	}
}

//
// getKey(key)
// Gets keycode. If 'x' is pressed then it hides the lightbox.
//

function getKey(e){
	if (e == null) { // ie
		keycode = event.keyCode;
	} else { // mozilla
		keycode = e.which;
	}
	key = String.fromCharCode(keycode).toLowerCase();
	
	if(key == 'x'){ hideLightbox(); }
}


//
// listenKey()
//
function listenKey () {	document.onkeypress = getKey; }


//
//scrollSize()
//  retorna um objeto com dois atributos sW(tamanho horizontal da scrollBar) e sH(tamanho vertical da scrollBar)
//
function scrollSize(){
   if (document.body.scrollHeigth && document.body.scrollWidth)
	  return ({sH:document.body.scrollHeigth,sW:document.body.scrollWidth});
   else return ({sH:0,sW:0});
    
}


//
//findScrollLeft()
// esta função retorna o valor de deslocamento da pagína para esquerda
//
function findScrollLeft(){
   if (window.pageXOffset)
      return window.pageXOffset;
   
   if (document.body.scrollHeigth)
	  return document.body.scrollLeft;

   return null;
}

//
//findScrollLeft()
// esta função retorna o valor de deslocamento da pagína para de cima para baixo
//

function findScrollTop(){
   if (window.pageYOffset)
      return window.pageYOffset;
   
   if (document.body.scrollWidth)
	  return document.body.scrollTop;

   return null;
}

var scrollAntY = 0
var scrollAntX = 0


//
//fixa()
//Ela é chamada só na hora em que há ação na barra de rolagem 
//esta função faz os objetos do ligthBox se posicionarem de acordo com o deslocamento da barra de rolagen 
// da tela
//
function fixa(){
  var opt = new getObjetos();
  //--- ajustar o tamanho da tela de ligthbox lembrando que essa função só é chamada no onscroll
      var medidas = getPageSize()
	  opt.overlay.style.width = medidas[0]
	  opt.overlay.style.height = medidas[1]
  //
   var topscrol = findScrollTop()
   var leftScrol = findScrollLeft()
   // buscando só para os objetos que pertencem ao ligthBox
   
   var posicaoAtual
   for (var i in opt){
	   // iniciando a variavel de posição anterior para o objeto
	   if (i != "overlay"){
	      posicaoAtual = getPositionObj(opt[i])
	      if (opt[i].style) {
		     //alert(i+"--"+posicaoAtual.x+"--"+posicaoAtual.y)
	         opt[i].style.top = (opt[i].style.top.replace('px','')*1) + (findScrollTop()-scrollAntY)
	         opt[i].style.left = (opt[i].style.left.replace('px','')*1) + (findScrollLeft()-scrollAntX)
		  }
	   }
	   //guardando o valor atual
   }
   scrollAntX = findScrollLeft()
   scrollAntY = findScrollTop()
   
}
	

//
// showLightbox()
// Preloads images. Pleaces new image in lightbox then centers and displays.
//




var getObjetos = function(){};
getObjetos = Class.create();
getObjetos.prototype = {
	inicializar:function(){
		   getObjetos.prototype = Object.extend(this, {
		   overlay:document.getElementById('overlay'),
	       menu:document.getElementById('caixaOpc'),
	       mensagem:document.getElementById('msg'),
	       imagem:document.getElementById('imagem'),
	       iframe:document.getElementById('iframe'),
		   loadImage:document.getElementById('loadImagem')
		   })
	}
}



function showLightbox(objLink,url)
{
	hideLightbox(); 
	// prep objects
	var opt = new getObjetos();
	opt.overlay.style.display = 'block';
    //---------------------------------------------------------------
    //selecionando de acordo com a tag o que vai ser executado
    if (objLink){	
	   if (url){
		  //---instanciando a classe refresh
		  new Refresh(objLink);
		  carregaIframe(objLink,url);
	   }
	   else{
		  carregaMensagem(objLink);
	   }
    }
}




function carregaMensagem(msg){
   var opt = new getObjetos();
   //-- Habilitando o Menu -----------
   document.getElementById("imgBarra").src = "img/toolbar.png";
   document.getElementById("imgBarra").useMap = "#toolbar";
   document.getElementById("imgBarra").border = 0
   opt.menu.style.display = "block";
   //------------------------------
   //-- Habilitando a MSG ---------
   opt.mensagem.style.display = "block";
   opt.mensagem.innerHTML = msg
   return false
}


function carregaIframe(objLink, url){
   var opt = new getObjetos()
   //-- Habilitando o Menu -----------
   document.getElementById("imgBarra").src = "img/toolbar.png";
   document.getElementById("imgBarra").useMap = "#toolbar";
   document.getElementById("imgBarra").border = 0
   opt.menu.style.display = "block";
   //------------------------------
   onLoad(opt.iframe,false)
   opt.iframe.style.display = "block"
   opt.iframe.src = url
}

function offLoad(){
   var opt = new getObjetos()
   opt.loadImage.style.display = "none"
}

function onLoad(objRef,opacit){
   var opt = new getObjetos()    
   
   opt.loadImage.style.width = objRef.style.width
   opt.loadImage.style.height = objRef.style.height
   opt.loadImage.style.left = objRef.style.left
   opt.loadImage.style.top = objRef.style.top
   centralizar(document.getElementById("img"),opt.loadImage)
   opt.loadImage.style.display = "block"
   if (opacit)
      opt.loadImage.className = "load"
   else	 opt.loadImage.className = "" 
   
}


//
// hideLightbox()
//
function hideLightbox(){
	Refresh.functionObj = false;
	// get objects
	var opt = new getObjetos();
	if (objImg.funcao)
	   clearInterval(objImg.funcao)
	for (var i in opt){
	    if (opt[i].style && opt[i].style.display)
		   opt[i].style.display = "none"
	}
	// make select boxes visible
	selects = document.getElementsByTagName("select");
    for (i = 0; i != selects.length; i++) {
		selects[i].style.visibility = "visible";
	}

	// disable keypress listener
	document.onkeypress = '';
}




//
// initLightbox()
// Function runs on window load, going through link tags looking for rel="lightbox".
// These links receive onclick events that enable the lightbox display for their targets.
// The function also inserts html markup at the top of the page which will be used as a
// container for the overlay pattern and the inline image.
//
function initLightbox()
{
	

	/* the rest of this code inserts html at the top of the page that looks like this:
	
	 <div id="overlay" style="zIndex:1">
	 </div>  
	*/
    if (document.getElementsByTagName("frameset").length > 0){
		return false;
	}
	
	var objBody = document.getElementsByTagName("body").item(0);
	
	var medidasTela = getPageSize()
	
	// create overlay div and hardcode some functional styles (aesthetic styles are in CSS file)
	var objOverlay = document.createElement("div");
	objOverlay.setAttribute('id','overlay');
	//objOverlay.onclick = function () {hideLightbox(); return false;}
	objOverlay.style.display = 'none';
	objOverlay.style.position = 'absolute';
	objOverlay.style.top = '0';
	objOverlay.style.left = '0';
	objOverlay.style.zIndex = '100';
 	objOverlay.style.width = medidasTela[2] - scrollSize().sW;
	objOverlay.style.height = medidasTela[3]- scrollSize().sH;
	objBody.insertBefore(objOverlay, objBody.firstChild);
	
/*
   <div id="loadFrame style="background-color:#ffffff;position:absolute">
	  <img src="img/indicator.gif">
   </div>
*/
   var loadImg = document.createElement("div");
   loadImg.id="loadImagem";
   loadImg.style.position = 'absolute';
   loadImg.style.zIndex = '102';
   loadImg.style.display="none"
   loadImg.style.border = "1px solid #A19A9A"
   loadImg.style.backgroundColor = "#ffffff"
   objBody.appendChild(loadImg)
     
   
   var lImg = new Image();
   lImg.id="img";
   lImg.style.position="relative"
   lImg.style.width = "150 px"
   lImg.style.height = "150 px"
   lImg.src="img/indicator.gif"
   loadImg.appendChild(lImg)
   
   centralizar(loadImg,objOverlay)
   
	// Objeto tabela que mostra as mensagens 
	var objOpc = document.createElement("div");
	objOpc.id="caixaOpc";
	objOpc.style.position = 'absolute';
	objOpc.style.zIndex = '102';
	objOpc.style.display="none"
	objBody.appendChild(objOpc)
/*
   <map id="toolbar" name="toolbar">
   <area shape="circle" alt="" coords="402,20,18" href="javascrip:hideLigthBox()" title="" />
   <area shape="default" nohref="nohref" alt="" />
   </map>
*/
    var m,a
    m = document.createElement("map")
    m.name="toolbar"
    m.setAttribute("id","toolbar")
    document.body.appendChild(m)
    a = document.createElement("AREA")
    a.shape = "circle"
    a.coords = "402,20,18"
    a.onclick = function(){
        hideLightbox();
    }
    m.appendChild(a)
    objBody.appendChild(m)
/*
  <img src="img/toolbar-back.png" style="position:absolute" name="ig" alt="Fechar" usemap="#toolbar" style="border-style:none" />
  <img style="position:absolute" src="img\toolbar.png"  usemap="#toolbar" style="border-style:none" />
*/
	var imgTb = new Image()
	imgTb.src = "img/toolbar-back.png"
	imgTb.style.position = "absolute"
	imgTb.style["border-style"]="none"
	imgTb.className = "barra"
	//objOpc.appendChild(imgTb)
	objOpc.style.width = imgTb.width
	objOpc.style.height = imgTb.height
	
	var imgB = new Image()
	imgB.src = "img/toolbar.png"
	imgB.id= "imgBarra"
	imgB.className = "barra1"
	imgB.style.position = "absolute"
	imgB.style.top="0px"
	imgB.style.left="11px"
	imgB.usemap="#toolbar"
	imgB.style["border-style"]="none"
	imgB.style.zIndex = '102';
	objOpc.appendChild(imgB)
	
	centralizar(objOpc,objOverlay)
	objOpc.style.top="20px";
	
	
/* - MENSAGEM
   <div id="msg" style="position:absolute;zIndex:3;width=[60% da tela];heigth:[60% da tela]">
   </div>
*/
	var ObjMsg = document.createElement("div");
	ObjMsg.id="msg";
	ObjMsg.style.position = 'absolute';
	ObjMsg.style.zIndex = '101';
	ObjMsg.style.display="none"
	ObjMsg.style.zIndex = '101';
	ObjMsg.style.overflow = "auto";
	ObjMsg.style.border = "1px solid #A19A9A"
	ObjMsg.style.width = calculoPorc(60,(objOverlay.style.width.replace('px','')))
	ObjMsg.style.height = calculoPorc(60,objOverlay.style.height.replace('px',''))
	ObjMsg.style["background-color"] = "#ffffff"
	objBody.appendChild(ObjMsg)
    centralizar(ObjMsg,objOverlay)
/* - IFRAME
	  <iframe src="" id="ifrm" onload="lIframe()" style="position:absolute;width:[75% da tela];height:[75% da tela]" border=0>
	  </iframe>

   var ObjIfrm = document.createElement("div");
   ObjIfrm.id="iframe";
   ObjIfrm.style.position = 'absolute';
   ObjIfrm.style.zIndex = '2';
   ObjIfrm.style.display="none"
   ObjIfrm.style.width=calculoPorc(75,objOverlay.style.width)
   ObjIfrm.style.height=calculoPorc(75,objOverlay.style.height)
   ObjBody.appendChild(ObjIfrm)
*/   
   var ifrm = document.createElement("iframe");
   ifrm.id="iframe";
   ifrm.style.position="absolute";
   ifrm.style.display = "none"
   ifrm.style.zIndex = "101"
   ifrm.src="about:blank"
   ifrm.style.width = calculoPorc(85,objOverlay.style.width.replace('px',''))
   ifrm.style.height = calculoPorc(90,objOverlay.style.height.replace('px',''))
   objBody.appendChild(ifrm)
   ifrm.attachEvent("onload",function(){offLoad()})
   centralizar(ifrm,objOverlay)
/* - IMG
   <img src="" id="img" onload="[Funcao]" style="position:absolute;width:[75% da tela];height:[85% da tela]" border=0>
   var ObjImg = document.createElement("div");
   ObjImg.id="imagem";
   ObjImg.style.position = 'absolute';
   ObjImg.style.zIndex = '2';
   ObjImg.style.display="none"
   ObjImg.style.width=calculoPorc(75,objOverlay.style.width)
   ObjImg.style.height=calculoPorc(85,objOverlay.style.height)
   ObjBody.appendChild(ObjImg)
*/
   var img = new Image();
   img.onload = offLoad
   img.id="imagem";
   img.style.display="none"
   img.style.position="absolute";
   img.style.width = calculoPorc(75,objOverlay.style.width.replace('px',''));
   img.style.height = calculoPorc(85,objOverlay.style.height.replace('px',''));
   img.style.zIndex = "101"
   objBody.appendChild(img)

//----------------------------------------------------
//-----------map slyde show
var mapMenu = document.createElement("map")
mapMenu.name="imag"
mapMenu.setAttribute("id","imag")
document.body.appendChild(mapMenu)

var pf = document.createElement("AREA")
pf.shape = "circle"
pf.coords="16,19,19" 
pf.onclick=function(){objImg.primeira()}//objImg.primeira()}
mapMenu.appendChild(pf)

var fechar = document.createElement("AREA")
fechar.shape = "circle"
fechar.coords = "402,20,18" 
fechar.onclick=function(){hideLightbox()}
mapMenu.appendChild(fechar)

var play = document.createElement("AREA")
play.shape="circle"
play.coords="120,21,23"
play.onclick=function(){objImg.play()}
mapMenu.appendChild(play)

var avancar = document.createElement("AREA")
avancar.shape="circle"
avancar.coords="175,20,17" 
avancar.onclick=function(){objImg.avancar()}
mapMenu.appendChild(avancar)

var voltar = document.createElement("AREA")
voltar.shape="circle"
voltar.coords="68,19,18" 
voltar.onclick=function(){objImg.voltar()}
mapMenu.appendChild(voltar)

var ultima = document.createElement("AREA")
ultima.shape="circle"
ultima.coords="226,20,17" 
ultima.onclick=function(){objImg.ultima()}
mapMenu.appendChild(ultima)

var telaCheia = document.createElement("AREA")
telaCheia.shape="circle"
telaCheia.coords="349,20,18" 
telaCheia.onclick=function(){objImg.telaCheia()}
mapMenu.appendChild(telaCheia)

}
//------------------- IMAGENS
function showImagem(src,sel){
   var opt = new getObjetos();
   opt.overlay.style.display = 'block';
   onLoad(opt.imagem)
   //-- Habilitando o Menu -----------
   document.getElementById("imgBarra").src = "img/toolbar-img.png";
   document.getElementById("imgBarra").useMap = "#imag"
   document.getElementById("imag").areas[2].onclick = function(){objImg.play()};
   document.getElementById("imgBarra").border = 0
   opt.menu.style.display = "block";
   //------------------------------
   centralizar(opt.imagem,opt.overlay)
   opt.imagem.src = src
   opt.imagem.style.display = "block"
   objImg.sel = sel
}

var objImg = {}
objImg.arrImg = [] 
objImg.sel = 0;
objImg.funcao = ""

objImg.mostrarImagem = function(){
    var opt = new getObjetos();
   if (objImg.arrImg[objImg.sel]){
	  opt.imagem.src = objImg.arrImg[objImg.sel]
   }else{
	  if (objImg.sel == objImg.arrImg.length){
	     objImg.sel = 0
         opt.imagem.src = objImg.arrImg[objImg.sel]
      }
	  else{
	     if (objImg.sel < 0){
	     objImg.sel = objImg.arrImg.length 
         opt.imagem.src = objImg.arrImg[objImg.sel]
         }
		 else{
			objImg.sel = 0
            opt.imagem.src = objImg.arrImg[objImg.sel] 
		 }
	  }
   }
}

objImg.carregar = function(arrImg){
   if (!arrImg)
      return false
   objImg.arrImg = arrImg
}

objImg.play=function(){
   if (!objImg.arrImg)
      return false
   //-------------------------------------
   document.getElementById("imgBarra").src = "img/toolbar-pause.png";
   document.getElementById("imag").areas[2].onclick = function(){objImg.pause()};
   document.getElementById("imgBarra").border = 0
   //--------------------------------------
   objImg.funcao = window.setInterval(objImg.avancar,5000)
}


objImg.primeira=function(){
   if (!objImg.arrImg)
      return false

   objImg.sel = 0
   objImg.mostrarImagem()
   
}

objImg.ultima=function(){
   if (!objImg.arrImg)
      return false
   objImg.sel = objImg.arrImg.length-1
   objImg.mostrarImagem()
}

objImg.pause=function(){
   if (!objImg.arrImg)
      return false
   clearInterval(objImg.funcao)
   //-------------------------------------
   document.getElementById("imgBarra").src = "img/toolbar-img.png";
   document.getElementById("imag").areas[2].onclick = function(){objImg.play()};
   document.getElementById("imgBarra").border = 0
   //--------------------------------------
}
objImg.avancar=function(){
   if (!objImg.arrImg)
      return false
   objImg.sel += 1
   objImg.mostrarImagem()
}



objImg.voltar=function(){
   if (!objImg.arrImg)
      return false
   objImg.sel -= 1
   objImg.mostrarImagem()
}
objImg.telaCheia=function(){
   var opt = new getObjetos();
   window.open(opt.imagem.src)
}





/*---------------------------------------------------------------------
 funções para aparecer a msg no onmouseover
 com um balãozinho estiloso
 */
function showMsg(msg,e){
   if (!msg)
      return false
   el = (e)?e.srcElement:event.srcElement
   tooltip=CreateEl("span","tooltip");
   s=CreateEl("span","top");
   s.innerHTML = msg
   tooltip.appendChild(s);
   b=CreateEl("b","bottom");
   l="Kamed"
   b.appendChild(document.createTextNode(l));
   tooltip.appendChild(b);
   setOpacity(tooltip);
   el.tooltip=tooltip;
   el.onmouseover=showTooltip;
   el.onmouseout=hideTooltip;
   el.onmousemove=Locate;
   showTooltip();
}

function showTooltip(e){
   document.getElementById("btc").appendChild(this.tooltip);
   Locate(e);
}

function hideTooltip(e){
   var d=document.getElementById("btc");
   if(d.childNodes.length>0) d.removeChild(d.firstChild);
}

function setOpacity(el){
   el.style.filter="alpha(opacity:95)";
   el.style.KHTMLOpacity="0.95";
   el.style.MozOpacity="0.95";
   el.style.opacity="0.95";
}

function CreateEl(t,c){
   var x=document.createElement(t);
   x.className=c;
   x.style.display="block";
   return(x);
}

function AddCss(){
var l=CreateEl("link");
l.setAttribute("type","text/css");
l.setAttribute("rel","stylesheet");
l.setAttribute("href","visualInterface/bt.css");
l.setAttribute("media","screen");
document.getElementsByTagName("head")[0].appendChild(l);
}

function Locate(e){
   var posx=0,posy=0;
   if (e==null) e=window.event;
      if (e.pageX || e.pageY){
         posx=e.pageX; posy=e.pageY;
      }
      else if (e.clientX || e.clientY){
           if (document.documentElement.scrollTop){
              posx=e.clientX+document.documentElement.scrollLeft;
              posy=e.clientY+document.documentElement.scrollTop;
           }
    else{
        posx=e.clientX+document.body.scrollLeft;
        posy=e.clientY+document.body.scrollTop;
        }
    }
    document.getElementById("btc").style.top=(posy+10)+"px";
    document.getElementById("btc").style.left=(posx-20)+"px";
}



//
// addLoadEvent()
// Adds event to window.onload without overwriting currently assigned onload functions.
// Function found at Simon Willison's weblog - http://simon.incutio.com/
//



	  
//----- iniciando as funções

if (window.addEventListener)
   window.addEventListener("load", inicial.startWindowOnload, true)
else if (window.attachEvent)
   window.attachEvent("onload", inicial.startWindowOnload)



	
/*
function startWindowOnload()
{	
    
    window.onload = function(){
	   for (var i in inicioWindow){
	       document.body.innerHTML = i + "<br>"+document.body.innerHTML
		   setTimeout(eval(inicioWindow[i]), 1000);
	   }
}

}

*/