/**
* Construtor da classe conteiner
*
* @param nome - nome do conteiner
* @param intEspacamento - espacamento dos elementos ao mudar de nivel
* @param strClasseConteiner - classe de estilo do conteiner
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner = function(nome,intEspacamento,strClasseConteiner,strClasseColuna, bolGeraHtml)
{	
	if(bolGeraHtml==undefined)
	{
		bolGeraHtml = true;
	}
	// variavel que ira armazenar o conteudo html
	this.objConteinerHtml="";
	// lista de nodos selecionados
	this.arrSelecionados = new Array();
	// lista de nodos
	this.arrElementos = new Array();
	// espacamento default usado entre os elementos
	this.espacamento = intEspacamento;
	// classe de estilo do conteiner
	this.strClasseConteiner = strClasseConteiner;
	// nome do conteiner
	this.nome = nome;
	// nodo raiz
	this.objNodeRaiz = new Node("raiz",null,"",true,0);
	// referencia para o nodo raiz
	this.arrElementos[this.objNodeRaiz.getId()] = this.objNodeRaiz;
	// elemento onde se localiza o conteiner
	this.divPrincipal = "";
	// posicao de insercao na arvore
	this.intPosicao = 1;
	//funcao chamada a cada movimento de um nodo na arvore
	this.strFuncaoMoveItem = '';
	// node corrente
	this.nodeCorrente = this.objNodeRaiz;
	// atribuindo classe no td
	this.classNameColuna = (strClasseColuna!=undefined)?strClasseColuna:"";
	this.bolGeraHtml = bolGeraHtml;
	this.strAcaoAbrir="";
	this.strAcaoFechar="";
}


/**
* Define a função a ser chamada nas movimentacoes de item
* @param strFuncao - cabecalho da funcao a ser chamada
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.setFuncaoMoveItem = function(strFuncao)
{
	this.strFuncaoMoveItem = strFuncao;
}

/**
* Metodo para retornar o nodo raiz
*
* @since 25/10/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.getNodeRaiz = function()
{
	return this.objNodeRaiz;
}

/**
* Metodo para retornar o primeiro elemento
*
* @since 25/10/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.primeiroNode = function()
{
	this.nodeCorrente = this.objNodeRaiz;	
	return this.nodeCorrente;	
}

/**
* Metodo para retornar o ultimo elemento
*
* @since 25/10/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.ultimoNode = function()
{
	var intPosicao = this.buscaPosicaoElemento(this.countElementos()+1);
	this.nodeCorrente  = this.buscaNodePorPosicao(intPosicao);
	return this.nodeCorrente;
}


/**
* Metodo para retornar o proximo elemento
*
* @since 25/10/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.proximoNode = function()
{
	this.ultimoNode  = this.buscaNodePorPosicao(this.countElementos()+1);
	if(this.nodeCorrente== this.ultimoNode)
	{
		return false;
	}
	
	var intPosicao = this.buscaPosicaoElemento(this.nodeCorrente) +1;	
	if(intPosicao== (this.countElementos()+1))
	{
		this.nodeCorrente = this.ultimoNode;		
	}
	else
	{
		this.nodeCorrente  = this.buscaNodePorPosicao(intPosicao);
	}	
	return this.nodeCorrente;
}

/**
* Metodo para retornar o proximo elemento
*
* @since 25/10/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.nodeAnterior = function()
{
	if(this.nodeCorrente== this.objNodeRaiz)
	{
		return false;
	}
	
	var intPosicao = this.buscaPosicaoElemento(this.nodeCorrente) -1;	
	if(intPosicao==0)
	{
		this.nodeCorrente = this.objNodeRaiz;		
	}
	else
	{
		this.nodeCorrente  = this.buscaNodePorPosicao(intPosicao);
	}	
	return this.nodeCorrente;	
}

/**
* Construtor para buscar node na lista
* @param id - identificador do node do conteiner
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.buscaNode = function(id)
{
	// verificando se o elemento html existe para atualizar o conteudo do node
	if(this.objConteinerHtml!="")
	{
		if(this.arrElementos[id]!=undefined && this.arrElementos[id]!=null)
		{
			var objElemento = document.getElementById(this.nome+"_"+this.arrElementos[id].getId());
			if(objElemento)
				this.arrElementos[id].setConteudo(objElemento.innerHTML);
		}
	}
	// retornando referencia ao elemento buscando
	return this.arrElementos[id];
}

/**
* Construtor para buscar node na lista
* @param id - identificador do node do conteiner
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.alteraIdElemento = function(strIdAntigo,strIdNovo)
{
	var objNode  = this.buscaNode(strIdAntigo)
	if(objNode!=undefined && objNode!=null)
	{
		objNode.setId(strIdNovo);	
		this.arrElementos[id] = null;
		this.arrElementos[strIdNovo] = objNode;
		$(this.nome+"_"+strIdAntigo).id = this.nome+"_"+strIdNovo;
	}	
}

/**
* Metodo para recuperar o node de uma determinada posicao
*
* @param intPos - Posicao a procurar
* @since 14/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.buscaNodePorPosicao = function(intPos)
{
	if (intPos<this.objConteinerHtml.rows.length && intPos>0)
	{
		var objCell = this.objConteinerHtml.rows[intPos].cells[0];
		var idElemento = this.recuperaId(objCell.id);
		return this.buscaNode(idElemento);
	}
	return null;
}

/**
* metodo para adicionar novo node
*
* @param objNode - node que esta sendo adicionado
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.addNode = function(objNode)
{
	// recupera o node pai do elemento
	var objNodePai = objNode.getNodePai();	
	// adicionado o node na lista de filhos do elementos pai
	objNodePai.addItem(objNode);
	// adiciona referencia do node a lista de elementos
	this.arrElementos[objNode.getId()] = objNode;	
}

/**
* metodo  auxiliar para excluir node e seus filhos
*
* @param objNode - node que esta sendo removido
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.excluirElemento = function(objNode)
{
	// remove a referencia do node da lista de elementos
	this.arrElementos[objNode.getId()] = null;
	// remove o node na tela
	this.removeConteiner(objNode);
	// recupera os filhos do node removendo cada elemento
	objNodeFilho = objNode.primeiro();
	while(objNodeFilho = objNode.proximo())
	{
		if(objNodeFilho.isFilhos())
		{
			this.excluirElemento(objNodeFilho);
		}
		else
		{
			this.arrElementos[objNodeFilho.getId()] = null;
			this.removeConteiner(objNodeFilho);
		}
	}
}
/**
* metodo para excluir node e seus filhos
*
* @param objNode - node que esta sendo removido
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.removeNode = function(objNode)
{
	// se o elemento for nodo raiz remove todos os elementos
	if(objNode==this.objNodeRaiz)
	{
		this.arrElementos = new Array();
		if(this.divPrincipal)
		{
			objPrincipal = document.getElementById(this.divPrincipal);
			objPrincipal.innerHTML = "";
		}
	}
	else
	{
		// exclui a referencia ao node e remove ele visualmente
		this.excluirElemento(objNode);
		// recupera o pai do node
		objNodePai = objNode.getNodePai();
		//remove o node da lista do pai
		objNodePai.removeItem(objNode);
	}
}

/**
* Metodo para retornar o html do conteiner
* @since 17/10/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
function getHtmlConteiner()
{	
	if(this.objConteinerHtml!="")
	{
		var objPrincipal = document.getElementById(this.divPrincipal);
		return objPrincipal.innerHTML;		
	}
	return "";	
}

/**
* Metodo para gerar o conteiner
*
* @param strDivConteiner - id do elemento onde sera adicionado o conteiner
* @param intNivel - nivel que deseja ser gerado, vazio ou null para gerar todos
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.geraConteiner = function(strDivConteiner)
{
	// verificando se html deve ser gerado
	if (!this.bolGeraHtml)
	{
		this.objConteinerHtml = document.getElementById(this.nome);
		return true;
	}
	
	// recuperando elemento onde sera colocado o conteiner
	this.divPrincipal = strDivConteiner;
	var objPrincipal = document.getElementById(strDivConteiner);

	// limpando elemento
	objPrincipal.innerHTML = "";
	
	// criacao da tabela
	this.objConteinerHtml = document.createElement('table');
	this.objConteinerHtml.id = this.nome;
	this.objConteinerHtml.className = this.strClasseConteiner;
	this.objConteinerHtml.cellPadding = '0';
	this.objConteinerHtml.cellSpacing = '0';
	//this.objConteinerHtml.border = '1';
	
	// adicionando elemento conteiner no div principal
	objPrincipal.appendChild(this.objConteinerHtml);
	// array onde sao armazenados a lista de elementos ja inseridos
	this.arrElementosInseridos = new Array();
	// varrendo lista de elementos
	for (var strNome in this.arrElementos)
    {	
    	if(this.arrElementos[strNome]!=null)
    	{
    		// adionando elementos pais e filhos
    		if(this.arrElementos[strNome].getNodePai()!=null)
    		{
    			if(this.arrElementosInseridos[this.arrElementos[strNome].getNodePai().getId()] != this.arrElementos[strNome].getNodePai().getId())
				{
					
					this.addItemTabela(this.arrElementos[strNome].getNodePai(),this.objConteinerHtml.rows.length);
					this.arrElementosInseridos[this.arrElementos[strNome].getNodePai().getId()] = this.arrElementos[strNome].getNodePai().getId();
					this.adicionarElementosFilhos(this.arrElementos[strNome].getNodePai());
				}
    		}
    		// adicionando nodo
    		if(this.arrElementosInseridos[this.arrElementos[strNome].getId()] != this.arrElementos[strNome].getId())
			{			
				this.addItemTabela(this.arrElementos[strNome],this.objConteinerHtml.rows.length);
				this.arrElementosInseridos[this.arrElementos[strNome].getId()] = this.arrElementos[strNome].getId();
			}
			// adicionando filhos do nodo
			if(this.arrElementos[strNome].isFilhos())
			{
				this.adicionarElementosFilhos(this.arrElementos[strNome]);
			}
    	}
    }    
}

/**
* Metodo para adicionar os elementos filhos
*
* @param objNode - node que esta sendo adicionado
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.adicionarElementosFilhos = function(objNode)
{	
	// enquanto existir elementos filhos adiciona os elementos na tela
	var objNodeFilho = objNode.primeiro();
	while(objNodeFilho = objNode.proximo())
	{
		if(this.arrElementosInseridos[objNodeFilho.getId()] != objNodeFilho.getId())
		{			
			this.addItemTabela(objNodeFilho,this.objConteinerHtml.rows.length);
			this.arrElementosInseridos[objNodeFilho.getId()] = objNodeFilho.getId();
		}		
		if(objNodeFilho.isFilhos())
		{
			this.adicionarElementosFilhos(objNodeFilho);
		}
	}
}
/**
* Metodo para buscar a posicao do elemento no conteiner
*
* @param node - node que esta buscado
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @return Posicao do elemento ou -1 caso o elemento nao seja encontrado
* @access private
*/
Conteiner.prototype.buscaPosicaoElemento = function(node)
{
	for(var intI=0;intI<this.objConteinerHtml.rows.length;intI++)
	{
		objLinha = this.objConteinerHtml.rows[intI];
		objNode = objLinha.cells[0];
		if(objNode.id == this.nome+"_"+node.getId())
		{
			return intI;
		}
	}
	return -1;
}

/**
* Metodo para retornar a quantidade de elementos
*
* @since 21/08/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @since public
*/
Conteiner.prototype.countElementos = function()
{
	if(this.objConteinerHtml!="")
	{
		return this.objConteinerHtml.rows.length -1 ;
	}
	return 0;
}

/**
* Metodo de interface para adicionar um node no conteiner ()
*
* @param node - node que esta adicionado
* @param posicao - posicao onde sera adicionado o node
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.addItemTabela = function(node,posicao)
{
	if (this.bolGeraHtml)
	{
		// inserirndo elemento na posicao passada
		if(posicao>this.objConteinerHtml.rows.length)
		{
			posicao = this.objConteinerHtml.rows.length;
		}	
		var objLinha = this.objConteinerHtml.insertRow(posicao);		
		var objColuna = objLinha.insertCell(0);
		objColuna.id = this.nome+"_"+node.getId();
		//objColuna.style.border='0px solid black';
		
		// atribuindo classe na coluna
		if(this.classNameColuna!="")
		{
			objColuna.className = this.classNameColuna;
		}
		
		// atualizando conteudo do element
		objColuna.innerHTML = node.getConteudo();
		// verificando se o elemento ? o nodo raiz
		if(node.getNodePai()!=null)
		{
			// se o elemento pai nao foi excluido atualiza espacamento do elemento
			if(this.arrElementos[node.getNodePai().getId()]!=null)
			{	
				if(node.getEspacamentoDefinido())
				{
					var intEspacamento = node.getEspacamento();
				}
				else
				{
					var intEspacamento = parseInt(this.arrElementos[node.getNodePai().getId()].getEspacamento())+parseInt(this.espacamento);				
					node.setEspacamento(intEspacamento);				
				}						
				objColuna.style.paddingLeft = intEspacamento+'px';		
			}
			// verifica se o elemento pode ser exibido ou nao
			if(!node.getNodePai().getAberto())
			{
				this.esconderElemento(node.getId());
			}
		}
		else
		{
			// esconde o nodo raiz 
			objColuna.style.paddingLeft = 0;
			objColuna.style.visibility = 'hidden';
			objColuna.style.display = 'none';
			node.setEspacamento(-1*this.espacamento);
		}
		if (this.strFuncaoMoveItem)
		{
			eval(this.strFuncaoMoveItem+'(node)');
		}
	}
}

/**
* Metodo de interface para adicionar um node no conteiner 
* em relacao ao seu pai
*
* @param node - node que esta adicionado
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.addConteiner = function(objNode)
{
	if(objNode.getNodePai().getId() == null)
	{
		intPosicao = -1;
	}
	else
		intPosicao = this.buscaPosicaoElemento(objNode.getNodePai());
	this.addItemTabela(objNode,intPosicao+1);
}

/**
* Metodo de interface para adicionar um node no conteiner 
* em relacao ao seu pai
*
* @param node - node que esta adicionado
* @since 26/07/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.addNodes = function(objNode)
{
	if(this.buscaPosicaoElemento(objNode)==-1)
	{
		// verifica se o node ja foi inserido e caso contrario adiociona ele na tela
		if(this.arrElementosInseridos[objNode.getId()]!=objNode)
		{
			//alert('node: '+objNode.getId()+" pai:"+objNode.getNodePai().getId());
			this.addItemTabela(objNode,this.intPosicao);
			this.arrElementosInseridos[objNode.getId()] = objNode;
			this.intPosicao++;
		}
		// recupera os nodos filhos
		var objNodeFilho = objNode.primeiro();
		while(objNodeFilho = objNode.proximo())
		{		
			// verifica se o node filho foi inserido e caso contrario adiociona ele na tela
			if(this.arrElementosInseridos[objNodeFilho.getId()]!=objNodeFilho)
			{
				//alert('node: '+objNodeFilho.getId()+" pai:"+objNodeFilho.getNodePai().getId());
				this.addItemTabela(objNodeFilho,this.intPosicao);
				this.arrElementosInseridos[objNodeFilho.getId()] = objNodeFilho;
				this.intPosicao++;
			}
			// caso o node filho tenha filhos adiciona seus filhos
			if(objNodeFilho.isFilhos())
			{			
				this.addNodes(objNodeFilho);
			}
		}
	}
}

/** 
* Metodo de interface para remover um node do conteiner
*
* @param node - node que esta sendo removido
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @return false se o node nao for encontrado
* @access private
*/
Conteiner.prototype.removeConteiner = function(objNode)
{
	intPosicao = this.buscaPosicaoElemento(objNode);
	if(intPosicao!=-1)
	{
		this.objConteinerHtml.deleteRow(intPosicao);
		return true;
	}
	return false;
}

/** 
* Metodo de interface para remover nodes filhos do conteiner
*
* @param objNode - node que esta sendo removido
* @since 26/07/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @return false se o node nao for encontrado
* @access private
*/
Conteiner.prototype.removeNodes = function(objNode)
{
	// recupera filhos do node
	var objNodeFilho = objNode.primeiro();
	while(objNodeFilho = objNode.proximo())
	{		
		// caso o node tenha netos exclui eles
		if(objNodeFilho.isFilhos())
		{
			this.removeNodes(objNodeFilho);
		}
		// excluindo filhos
		var posicao = this.buscaPosicaoElemento(objNodeFilho);
		if(posicao>-1)
			this.objConteinerHtml.deleteRow(posicao);
	}
	// excluindo node
	var posicao = this.buscaPosicaoElemento(objNode);
	if(posicao>-1)		
		this.objConteinerHtml.deleteRow(this.buscaPosicaoElemento(objNode));
}

/** 
* Metodo para trocar um node de posicao
*
* @param node1 - node que esta sendo trocado com o node 2
* @param node2 - node que esta sendo trocado com o node 1
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.trocaNode = function(objNode1,objNode2)
{	
	if(objNode1.getNodePai()==objNode2.getNodePai())
	{
		// trocando nodes
		objNode1.getNodePai().trocaFilhos(objNode2,objNode1);
		//alert("entrou1");
	}
	else
	{
		if(objNode2.getNodePai() == objNode1)
		{
			// atualizando atributos
			nodePai1 = objNode1.getNodePai();
			nivel1 = objNode1.getNivel();
			espacamento1 = objNode1.getEspacamento();
			
			// atualizando propriedades do node 1
			objNode1.setNodePai(objNode2);
			objNode1.setEspacamento(objNode2.getEspacamento());
			objNode1.setNivel(objNode2.getNivel());
			
			// atualizando posicionamento do node 2
			if(nodePai1==null)
			{
				this.objNodeRaiz = objNode1;
				this.arrElementos[this.objNodeRaiz.getId()] = this.objNodeRaiz;
			}
			else
			{
				// atualizando posicionamento do node 2
				nodePai1.setNode(objNode1,objNode2);
			}
			
			// atualizando propriedades do node 2
			objNode2.setNodePai(nodePai1);
			objNode2.setNivel(nivel1);
			objNode2.setEspacamento(espacamento1);	
			
			// removendo node 2 da lista do node 1
			objNode1.removeItem(objNode2);
						
			// inserindo filho no node 2
			objNode2.addItem(objNode1);			
		}
		else if(objNode1.getNodePai() == objNode2)
		{			
			// atualizando atributos
			nodePai2 = objNode2.getNodePai();
			nivel2 = objNode2.getNivel();
			espacamento2 = objNode2.getEspacamento();
			
			// atualizando propriedades do node 1
			objNode2.setNodePai(objNode1);
			objNode2.setEspacamento(objNode1.getEspacamento());
			objNode2.setNivel(objNode1.getNivel());
			
			// atualizando posicionamento do node 2
			if(nodePai2==null)
			{
				this.objNodeRaiz = objNode2;
				this.arrElementos[this.objNodeRaiz.getId()] = this.objNodeRaiz;
			}
			else
			{
				// atualizando posicionamento do node 2
				nodePai2.setNode(objNode2,objNode1);	
			}
			
			// atualizando propriedades do node 2
			objNode1.setNodePai(nodePai2);
			objNode1.setNivel(nivel2);
			objNode1.setEspacamento(espacamento2);	
			
			// removendo node 2 da lista do node 1
			objNode2.removeItem(objNode1);
						
			// inserindo filho no node 2
			objNode1.addItem(objNode2);		
		}
		else
		{
			//alert("entrou4");
			nodePai1 = objNode1.getNodePai();
			nivel1 = objNode1.getNivel();
			espacamento1 = objNode1.getEspacamento();
			
			objNode1.setNodePai(objNode2.getNodePai());
			objNode1.setNivel(objNode2.getNivel());
			objNode1.setEspacamento(objNode2.getEspacamento());
			
			objNode2.setNodePai(nodePai1);
			objNode2.setNivel(nivel1);
			objNode2.setEspacamento(espacamento1);
			
			// trocando nodes
			objNode1.getNodePai().setNode(objNode2,objNode1);
			objNode2.getNodePai().setNode(objNode1,objNode2);
		}
	}
	
	// recuperando posicoes atuais dos elementos
	var intPosicao1 = this.buscaPosicaoElemento(objNode1);
	var intPosicao2 = this.buscaPosicaoElemento(objNode2);
	
	// recuperando elementos anteriores
	var objNodeAnt1 =  this.buscaNodePorPosicao(intPosicao1-1);
	var objNodeAnt2 =  this.buscaNodePorPosicao(intPosicao2-1);
	
	// removendo nodes da tela
	this.removeNodes(objNode1);
	this.removeNodes(objNode2);

	// adicionando node 1 na posicao de 2
	if(objNodeAnt2!=null)
	{
		var intPosAnt = this.buscaPosicaoElemento(objNodeAnt2);
		this.intPosicao = intPosAnt+1;
	}
	else
	{
		this.intPosicao = 1;
	}
	this.addNodes(objNode1);
	
	// adicionando node 2 na posicao de 1
	if(objNodeAnt1!=null)
	{
		var intPosAnt = this.buscaPosicaoElemento(objNodeAnt1);
		this.intPosicao = intPosAnt+1;
	}
	else
	{
		this.intPosicao = 1;
	}
	this.addNodes(objNode2);
}

/** 
* Metodo para mover o node de posicao 
*
* @param objNode1 - node que esta sendo movido
* @param objNode2 - node que serve como referencia para a acao de mover
* @param bolAntes - verifica se necessita mover o elemento para antes
* ou depois do elemento
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.moveNode = function(objNode1,objNode2,bolAntes)
{					
	this.arrElementosInseridos = new Array();
	// verificando se nodes estao no mesmo nivel
	if(objNode1.getNodePai()==objNode2.getNodePai())
	{								
		if(!bolAntes)
		{												
			var intPosicaoAntiga = objNode1.getNodePai().getPosicao(objNode1);
			var intPosicaoNova = objNode1.getNodePai().getPosicao(objNode2)+1;
			if(intPosicaoAntiga == intPosicaoNova)
			{																
				objNode1.setNivel(objNode2.getNivel()+1);
				if(objNode2.isFilhos())
				{
			
					var objNodeFilho = objNode2.primeiro();
					objNode1.getNodePai().removeItem(objNode1);					
					objNode1.setNodePai(objNode2);
					objNode2.insert(objNode1, objNode2.primeiro(), true);
					
					// alterando elemento na tela
					var intPosicao1 = this.buscaPosicaoElemento(objNode1);				
					this.removeNodes(objNode1);
					var intPosicao2 = this.buscaPosicaoElemento(objNode2);					
					this.intPosicao = intPosicao2+1;
					this.addNodes(objNode1);					
				}
				else
				{										
					objNode1.getNodePai().removeItem(objNode1);
					objNode1.setNodePai(objNode2);
					objNode2.addItem(objNode1);
					// alterando elemento na tela					
					var intPosicao1 = this.buscaPosicaoElemento(objNode1);										
					this.removeNodes(objNode1);					
					var intPosicao2 = this.buscaPosicaoElemento(objNode2);					
					this.intPosicao = intPosicao2+1;
					this.addNodes(objNode1);
				}
			}
			else
			{																			
				// trocando nodes
				objNode2.getNodePai().removeItem(objNode1);
				objNode2.getNodePai().insert(objNode1, objNode2, bolAntes);
				// alterando elemento na tela
				var intPosicao1 = this.buscaPosicaoElemento(objNode1);				
				this.removeNodes(objNode1);
				var intPosicao2 = this.buscaPosicaoElemento(objNode2);				
				if (bolAntes)
				{
					this.intPosicao = intPosicao2;
					this.addNodes(objNode1);	
				}
				else
				{
					this.intPosicao = intPosicao2+objNode2.countDescendentes()+1;
					this.addNodes(objNode1);
				}
			}
		}
		else
		{			
			// trocando nodes
			objNode2.getNodePai().removeItem(objNode1);
			objNode2.getNodePai().insert(objNode1, objNode2, bolAntes);
			// alterando elemento na tela
			var intPosicao1 = this.buscaPosicaoElemento(objNode1);			
			this.removeNodes(objNode1);
			var intPosicao2 = this.buscaPosicaoElemento(objNode2);				
			if(intPosicao1<intPosicao2)
			{
				this.intPosicao = intPosicao2-1;
				this.addNodes(objNode1);
			}
			else
			{
				this.intPosicao = intPosicao2;
				this.addNodes(objNode1,intPosicao2);
			}
		}
	}
	else
	{
		// verificando se a alteracao esta sendo feita entre nodes
		// descendentes
		if(objNode2.getNodePai() == objNode1)
		{					
			objNode1.removeItem(objNode2);
			objNode2.setNodePai(objNode1.getNodePai());
			objNode1.getNodePai().insert(objNode2, objNode1, true);
			var intPosicao2 = this.buscaPosicaoElemento(objNode2);
			this.removeNodes(objNode2);
			var intPosicao1 = this.buscaPosicaoElemento(objNode1);
			this.intPosicao = intPosicao1;
			this.addNodes(objNode2);		
		}
		else if(objNode1.getNodePai() == objNode2)
		{							
			objNode2.removeItem(objNode1);			
			objNode1.setNodePai(objNode2.getNodePai());
			objNode2.getNodePai().insert(objNode1, objNode2, bolAntes);
			var intPosicao1 = this.buscaPosicaoElemento(objNode1);			
			this.removeNodes(objNode1);
			var intPosicao2 = this.buscaPosicaoElemento(objNode2);
			if (bolAntes)
			{
				this.intPosicao = intPosicao2;
				this.addNodes(objNode1);	
			}
			else
			{
				this.intPosicao = intPosicao2+objNode2.countDescendentes()+1;
				this.addNodes(objNode1);
			}
		}
		// verificando se a mudanca ? entre nodes sem relacao
		else
		{			
			// trocando nodes
			if(objNode2==this.objNodeRaiz)
			{
				objNode1.getNodePai().removeItem(objNode1);	
				objNode1.setNodePai(objNode2);
				objNode1.setEspacamento(parseInt(objNode2.getEspacamento())+parseInt(this.espacamento));
				objNode1.setNivel(objNode2.getNivel()+1);
				if(objNode2.isFilhos())
				{
					objNode2.addItem(objNode1);
					objNode2.insert(objNode1,objNode2.primeiro(),true);
				}
				else
				{
					objNode2.addItem(objNode1);
				}
				if(bolAntes)
				{
					this.trocaNode(objNode1,objNode2)
				}
			}
			else
			{				
				if(objNode1.isDescendente(objNode2))
				{													
					objNode2.getNodePai().removeItem(objNode2);
					objNode2.setNodePai(objNode1.getNodePai());
					objNode1.setEspacamento(objNode1.getEspacamento());
					objNode2.setNivel(objNode1.getNivel());
					objNode1.getNodePai().insert(objNode2,objNode1, !bolAntes);		
					var intPosicao2 = this.buscaPosicaoElemento(objNode2);
					this.removeNodes(objNode2);
					var intPosicao1 = this.buscaPosicaoElemento(objNode1);					
					this.intPosicao = bolAntes?intPosicao1+objNode1.countDescendentes()+1:intPosicao1;
					this.addNodes(objNode2);					
				}
				else
				{										
					objNode1.getNodePai().removeItem(objNode1);
					objNode1.setNodePai(objNode2.getNodePai());
					objNode1.setEspacamento(objNode2.getEspacamento());
					objNode1.setNivel(objNode2.getNivel());
					objNode2.getNodePai().insert(objNode1, objNode2, bolAntes);
					var intPosicao1 = this.buscaPosicaoElemento(objNode1);					
					this.removeNodes(objNode1);
					var intPosicao2 = this.buscaPosicaoElemento(objNode2);					
					if (bolAntes)
					{						
						this.intPosicao = intPosicao2;
						this.addNodes(objNode1);	
					}
					else
					{
						this.intPosicao = intPosicao2 + objNode2.countDescendentes()+1;
						this.addNodes(objNode1);
					}		
				}
			}
		}
	}
	// atualizando nivel do node 1
	objNode1.setNivel(parseInt(objNode1.getNodePai().getNivel())+1);
}

/**
* Metodo recuperar uma lista de pais excluindo os filhos  
*
* @param arrElementos - lista de elementos ordernada
* @return a lista de elementos pais
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.filtraPais = function(arrElementos)
{
	var arrUsados = new Array();
	var arrItens = new Array();
	for(var intI=0;intI<arrElementos.length;intI++)
	{
		if(arrElementos[intI].getNodePai().getId()!=arrUsados[arrElementos[intI].getNodePai().getId()])
		{
			arrItens[arrItens.length] = arrElementos[intI];
			arrUsados[arrElementos[intI].getId()] = arrElementos[intI].getId();
		}
	}
	return arrItens;
}

//##########################################################
//#
//# Os metodos abaixo devem ser usados para manipulacao do 
//# conteudo do conteiner como:
//# (adicionar, remover, mover, trocar, selecionar)
//#
//##########################################################

/**
* Metodo para recuperar id
*
* @param idElemento - id do elemento de tela que esta sendo recuperado
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.recuperaId = function(idElemento)
{
	posicaoInicio = idElemento.indexOf('_');
	if (posicaoInicio>=0)
	{
		id = idElemento.substring(idElemento.indexOf('_')+1,idElemento.length);
		return id;
	}
	return false;		
}

/**
* Metodo para adicionar um novo item no conteiner
*
* @param idElementoPai - Identificador do elemento pai, atribuir null se o node for raiz
* @param idElemento - identificador do elemento
* @param strConteudo - Conteudo HTML do elemento 
* @param bolAberto - Indica se o elemento adicionado esta aberto ou fechado
* @param espacamento - espacamento do elemento
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.add = function(idElementoPai,idElemento,strConteudo,bolAberto,intEspacamento,bolGeraHtml)
{
	if(bolGeraHtml==undefined)
		bolGeraHtml = true;
	this.arrElementosInseridos = new Array();
	if(idElementoPai==null)
	{
		//idElementoPai = this.name+"_"+this.objNodeRaiz.getId();
		var idElementoPai = this.objNodeRaiz.getId();
	}
	// buscando node
	var objNode = this.buscaNode(idElementoPai);	
	if(objNode)
	{
		// verificando se a veriavel foi passsada
		if(intEspacamento==undefined)
		{
			intEspacamento = -1;
		}
		// verificando se a veriavel foi passsada
		if(bolAberto==undefined)
		{
			bolAberto = false;
		}		
		var objNewNode = new Node(idElemento,objNode,strConteudo,bolAberto,intEspacamento,this.espacamento);				
		this.addNode(objNewNode);
		if(this.objConteinerHtml!="")
		{
			var intPosicaoPai = this.buscaPosicaoElemento(objNode);
			if(intPosicaoPai==0)
			{			
				this.intPosicao = intPosicaoPai+this.countElementos()+1;			
			}
			else
				this.intPosicao = intPosicaoPai+objNode.countDescendentes();			
			if(bolGeraHtml)
				this.addNodes(objNewNode);		
		}		
		return true;
	}
	return false;
}

/**
* Metodo para remover um elemento do conteiner
*
* @param idElemento - identificador do elemento que esta sendo removido
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.remove = function(idElemento)
{
	// buscando node
	var objNode = this.buscaNode(idElemento);
	if(objNode)
	{
		// deselecionando node
		this.deseleciona(objNode.getId());
		// removendo node
		this.removeNode(objNode);
		return true;
	}
	return false;
}

/**
* Metodo para trocar os elementos de posicao
*
* @param idElemento1 - identificador do elemento que esta sendo trocado com 2
* @param idElemento2 - identificador do elemento que esta sendo trocado com 1
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.troca = function(idElemento1,idElemento2)
{
	// recupenrando elemento 1
	var objNode1 = this.buscaNode(idElemento1);
	
	// recupenrando elemento 2
	var objNode2 = this.buscaNode(idElemento2);
	
	// troca os nodes de posicao
	this.trocaNode(objNode1,objNode2);
}

/**
* Metodo para mover o elemento de posicao em relacao a outro
*
* @param idElementoDe - identificador do elemento que esta sendo movido em relacao ao idElementoPara
* @param idElementoPara - identificador do elemento que serve como referencia
* @param bolAntes - indica se o elemento vai ser colocado antes da referencia (true)
* ou depois (false) ou nao passado nada no atributo
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.move = function(idElementoDe,idElementoPara,bolAntes)
{
	if(bolAntes==undefined)
		bolAntes = false;
	
	// recupenrando elemento 1
	var objNode1 = this.buscaNode(idElementoDe);
	
	// recupenrando elemento 2
	var objNode2 = this.buscaNode(idElementoPara);
	
	// move o node de posicao em relacao a outro
	this.moveNode(objNode1,objNode2,bolAntes);
}

/**
* Metodo para ordernar os filhos em relacao ao pai
*
* @param arrFilhos - Lista de elementos filhos
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access private
*/
Conteiner.prototype.ordena = function(arrElementos)
{
	var objNodeTemp;
	for(var intW=0;intW<arrElementos.length;intW++)
	{
		for(var intK=0;intK<arrElementos.length;intK++)
		{
			// ordenando elemento em relacao ao pai
			if(arrElementos[intW]==arrElementos[intK].getNodePai())
			{
				if (intW > intK)
				{
					objNodeTemp = arrElementos[intW];
					arrElementos[intW] = arrElementos[intK];
					arrElementos[intK] = objNodeTemp;	
				}				
			}
			// ordenando elementos em relacao aos irmaos
			else if(arrElementos[intW].getNodePai().getPosicao(arrElementos[intK]) &&
					(arrElementos[intW].getNodePai().getPosicao(arrElementos[intW]) < arrElementos[intW].getNodePai().getPosicao(arrElementos[intK])) &&
					(intW > intK)
				   )
			{
					objNodeTemp = arrElementos[intW];
					arrElementos[intW] = arrElementos[intK];
					arrElementos[intK] = objNodeTemp;	
			}	
		}							
	}
	return arrElementos;
}

/**
* Metodo para verificar se o elemento esta selecionado
*
* @since 03/11/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.isSelecionado = function(idElemento)
{
	for(var intI=0;intI<this.arrSelecionados.length;intI++)
	{
		if(this.arrSelecionados[intI].getId()==idElemento)
		{	
			return true;	
		}
	}
	return false;
}


/**
* Metodo para selecionar o elemento
*
* @param idElemento - identificador do elemento selecionado
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.seleciona = function(idElemento)
{
	// verifica se o elemento ja esta selecionado
	if(this.isSelecionado(idElemento))
	{		
		return true;
	}	
	// buscando elemento que sera selecionado
	var objNode = this.buscaNode(idElemento);
	var bolEntrou = false;
	if(objNode)
	{
		this.arrSelecionados[this.arrSelecionados.length] = objNode;
	}
}
/**
* Metodo para desselecionar o elemento
*
* @param idElemento - identificador do elemento deselecionado
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.deseleciona = function(idElemento)
{
	// buscando elemento que sera selecionado
	var objNode = this.buscaNode(idElemento);
	var arrSel = new Array();
	for(var intI=0;intI<this.arrSelecionados.length;intI++)
	{
		if(objNode!=this.arrSelecionados[intI])
		{
			arrSel[arrSel.length] = this.arrSelecionados[intI];
		}
	}
	this.arrSelecionados = arrSel;
}

/**
* Metodo para desselecionar o elemento
*
* @since 03/11/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.deselecionaTodos = function()
{
	this.arrSelecionados = new Array();
}

/**
* Metodo para remover selecionados
*
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.removeSelecionados = function()
{
	var arrSel = this.getSelecionados(true);
	for(var intI=0;intI<arrSel.length;intI++)
	{
		this.removeNode(arrSel[intI]);
	}
	this.arrSelecionados = new Array();
}

/**
* Metodo trocar selecionados com elemento passado
*
* @param idElemento - elemento que sera trocado
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.trocaSelecionados = function(idElemento)
{
	// buscando node
	var objNode = this.buscaNode(idElemento);
	if(objNode)
	{
		var arrSel = this.getSelecionados(true);
		for(var intI=0;intI<arrSel.length;intI++)
		{
			this.trocaNode(arrSel[intI],objNode);
		}
	}
}

/**
* Metodo mover selecionados para antes ou depois
* do elemento passado como referencia
*
* @param idElemento - elemento que serve como referencia
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.moveSelecionados = function(idElemento,bolAntes)
{
	// buscando node
	var objNode = this.buscaNode(idElemento);
	if(objNode)
	{
		var arrSel = this.getSelecionados(true);
		for(var intI=0;intI<arrSel.length;intI++)
		{
			this.moveNode(arrSel[intI],objNode,bolAntes);
		}
	}
}

/**
* Metodo para abrir elementos filhos
*
* @param objNode - Node pai
* @param bolTodos - Variavel que indica o desejo de abrir todos 
* os descendentes 
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.abrirElementoFilhos = function(objNode,bolTodos)
{
	if(bolTodos==undefined)
	{
		bolTodos = false;
	}
	var objNodeFilho = objNode.primeiro();	
	while(objNodeFilho = objNode.proximo())
	{
		if(bolTodos)
		{
			if(objNodeFilho.isFilhos())
			{
				this.abrirElementoFilhos(objNodeFilho,bolTodos);
			}
		}
		objNodeFilho.setAberto(true);
		if(this.strAcaoAbrir)
			eval(this.strAcaoAbrir+"('"+objNode.getId()+"');");				
		// verificando se o conteiner ja foi criado
	    if(this.objConteinerHtml!="")
	    {
	    	this.aparecerElemento(objNodeFilho.getId());	    	
	    }
	}
}

/**
* Metodo para abrir o elemento
*
* @param idElemento - elemento que ser? aberto
* @param bolTodos - Variavel que indica o desejo de abrir todos 
* os descendentes 
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.abrirElemento = function(idElemento,bolTodos)
{
	if(bolTodos==undefined)
	{
		bolTodos = false;
	}
	var objNode = this.buscaNode(idElemento);		
	if(objNode)
	{
		objNode.setAberto(true);	
		if(this.strAcaoAbrir)
			eval(this.strAcaoAbrir+"('"+idElemento+"');");	
		this.abrirElementoFilhos(objNode,bolTodos);
		return true;
	}
	return false;
}
/**
* Metodo para fechar elementos filhos
*
* @param objNode - Node pai
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.fecharElementoFilhos = function(objNode)
{
	if(bolTodos=undefined)
	{
		bolTodos = false;
	}
	var objNodeFilho = objNode.primeiro();
    if(this.strAcaoFechar)
            eval(this.strAcaoFechar+"('"+objNode.getId()+"');");
	while(objNodeFilho = objNode.proximo())
	{
		if(objNodeFilho.isFilhos())
		{
			this.fecharElementoFilhos(objNodeFilho);
		}
		objNodeFilho.setAberto(false);
		// verificando se o conteiner ja foi criado
	    if(this.objConteinerHtml!="")
	    {
	    	this.esconderElemento(objNodeFilho.getId());	    	
	    }
	}
}

/**
* Metodo para fechar todos os elementos do conteiner
*
* @since 20/11/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.fecharTodosElementos = function()
{
	for(var intI=1;intI<this.objConteinerHtml.rows.length;intI++)
	{
		var objLinha = this.objConteinerHtml.rows[intI];
		var objNode = objLinha.cells[0];		
		var strId = this.recuperaId(objNode.id);			
		objNode = this.buscaNode(strId);
		if(objNode)
		{
			this.fecharElementoFilhos(objNode,false);
			objNode.setAberto(false);	
		}		
	}
}

/**
* Metodo para fechar ou abrir o elemento
* retorna true se o elemento estiver fechado e 
* false se o elemento estiver aberto ou nao tiver filhos
*
* @param idElemento - elemento que ser? fechado
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.abrirFecharElemento = function(idElemento)
{
	objNode = this.buscaNode(idElemento);
	
	objNodeFilho = objNode.primeiro();
	if(objNodeFilho = objNode.proximo())
	{
		if(objNodeFilho.getAberto())
		{
			this.fecharElemento(objNode.getId());
			return false;
		}
		else
		{
			this.abrirElemento(objNode.getId());
			return true;
		}
	}
	return false;
}



/**
* Metodo para fechar o elemento
*
* @param idElemento - elemento que ser? fechado
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.fecharElemento = function(idElemento)
{
	objNode = this.buscaNode(idElemento);
	if(objNode)
	{
		objNode.setAberto(false);
		if(this.strAcaoFechar)
			eval(this.strAcaoFechar+"('"+idElemento+"');");
		this.fecharElementoFilhos(objNode,false);		
		return true;
	}
	return false;
}

/**
* Metodo para verificar se o elemento esta aberto
*
* @param idElemento - elemento que ser? fechado
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.isAberto = function(idElemento)
{
	objNode = this.buscaNode(idElemento);
	return objNode.getAberto();
}

/**
* Metodo para esconder elemento
*
* @param idElemento - elemento que será escondido
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.esconderElemento = function(idElemento)
{
	objElemento = document.getElementById(this.nome+"_"+idElemento);
	if(objElemento)
	{
		objElemento.style.visibility = 'hidden';		
		objElemento.style.display = 'none';
	}
}

/**
* Metodo para esconder todos elementos
*
* @param idElemento - elemento que será escondido
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.esconderTodosElementos = function()
{	
	for(var intI=0;intI<this.objConteinerHtml.rows.length;intI++)
	{
		var objLinha = this.objConteinerHtml.rows[intI];
		var objNode = objLinha.cells[0];		
		var strId = this.recuperaId(objNode.id);		
		this.esconderElemento(strId);				
	}
}

/**
* Metodo para exibir o elemento
*
* @param idElemento - elemento que ser? exibido
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.aparecerElemento = function(idElemento)
{
	objElemento = document.getElementById(this.nome+"_"+idElemento);
	if(objElemento)
	{
		objElemento.style.visibility = 'visible';
		if(IE)
		{		
			objElemento.style.display = 'block';			
		}
		else
		{
			objElemento.style.display = 'table-cell'; //'block' para IE;			
		}
	}
}

/**
* Metodo para subir Elemento
*
* @param idElemento - elemento que ir? subir
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.subirElemento = function(idElemento)
{
	// buscando node
	var objNode = this.buscaNode(idElemento);
	if(objNode)
	{
		var objNodeRef = objNode.getNodePai().primeiro();
		// verificando se o node ? o primeiro elemento em relacao ao pai
		if(objNodeRef==objNode)
		{
			// se o elemento pai for diferente do nodo raiz coloca o elemento acima no nodo do pai
			if(objNode.getNodePai()!=this.objNodeRaiz)
			{
				this.moveNode(objNode,objNode.getNodePai(),true)
			}
		}
		else
		{
			// recuperaca a posicao do irmao e coloca o elemento acima dele
			var intPosicao = (objNode.getNodePai().getPosicao(objNode) -1 );
			this.moveNode(objNode,objNode.getNodePai().getNode(intPosicao),true);
		}
		
	}
}

/**
* Metodo para descer Elemento
*
* @param idElemento - elemento que ir? descer
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.descerElemento = function(idElemento)
{
	// buscando node
	var objNode = this.buscaNode(idElemento);
	if(objNode)
	{
		// verificando se o node ? o ultimo elemento em relacao ao pai
		var objNodeRef = objNode.getNodePai().ultimo();
		if(objNodeRef==objNode)
		{
			// recuperando node avo para descobrir a posicao do pai em relacao ao nodos
			var objNodeAvo = objNode.getNodePai().getNodePai();
			if(objNodeAvo!=this.objNodeRaiz)
			{
				if(objNodeAvo.ultimo()==objNode.getNodePai())
				{
					this.moveNode(objNode,objNode.getNodePai(),false);
				}
				else
				{
					var intPosicao = (objNodeAvo.getPosicao(objNode.getNodePai())+1);
					var objNodeRef = objNodeAvo.getNode(intPosicao);
					this.moveNode(objNode,objNodeRef,true);
				}
			}
		}
		else
		{
			// como o nodo nao ? o ultimo ele apenas desce em relacao ao nodo irmao
			var intPosicao = (objNode.getNodePai().getPosicao(objNode) +1);		
			this.moveNode(objNode,objNode.getNodePai().getNode(intPosicao),false);
		}
	}
}

/**
* Metodo para identar o Elemento
*
* @param idElemento - elemento que sera identado
* @param nivel - 1 para frente e -1 para tras
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.identarElemento = function(idElemento,intNivel)
{
	// buscando node
	var objNode = this.buscaNode(idElemento);
	if(objNode)
	{
		// nivel maior que 0 o elemento vai avanca 1 nivel
		if(intNivel > 0)
		{
			// verificando se ? o primeiro elemento para proibir o movimento
			if(objNode == objNode.getNodePai().primeiro())
			{
				return false;
			}
			// recupera a posicao do node irmao anterior que ser? o node de referencia
			var intPosicao = (objNode.getNodePai().getPosicao(objNode)-1);		
			if(intPosicao>-1)
			{	
				var objNodeRef = objNode.getNodePai().getNode(intPosicao);
			}
			else
			{
				var objNodeRef = objNode.getNodePai();
			}
			// verificando se o node de refencia tem filhos
			if(objNodeRef.isFilhos())
			{
				// movendo o node em relacao ao ultimo filho do node de refencia
				this.moveNode(objNode,objNodeRef.ultimo(),false);
			}
			else
			{
				this.moveNode(objNode,objNodeRef,false);
			}
		}
		// nivel menor que 0 o node retroscede um nivel
		else if(intNivel < 0)
		{
			// verificando se o elemento esta no primeiro nivel para proibir o movimento
			if(objNode.getNivel()==1)
			{
				return false;
			}
			// coloca o node no mesmo nivel de seu pai
			this.moveNode(objNode,objNode.getNodePai(),false);
		}
	}
}

/**
* Metodo para subir selecionados
*
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.subirSelecionados = function()
{
	var arrSel = this.getSelecionados(true);
	for(var intI=0;intI<arrSel.length;intI++)
	{
		this.subirElemento(arrSel[intI].getId());
	}
}

/**
* Metodo para descer selecionados
*
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.descerSelecionados = function()
{
	var arrSel = this.getSelecionados(true);
	for(var intI=arrSel.length-1;intI>-1;intI--)
	{
		this.descerElemento(arrSel[intI].getId());
	}	
}

/**
* Metodo para identar selecionados
*
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.identarSelecionados = function(intNivel)
{
	var arrSel = this.getSelecionados(true);
	for(var intI=0;intI<arrSel.length;intI++)
	{
		this.identarElemento(arrSel[intI].getId(),intNivel);
	}	
}

/**
* Metodo para retornar elementos selecionados
*
* @param bolSomentePais - Variavel que indica que ser? retornados somente os elementos pais
* @return a lista de elementos selecionados
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.getSelecionados = function(bolSomentePais)
{
	// ordenando lista de selecionados
	this.ordena(this.arrSelecionados);
	if(bolSomentePais==undefined)
	{
		bolSomentePais = false;
	}
	// filtrando lista para retornar somente os pais
	if(bolSomentePais)
	{
		return this.filtraPais(this.arrSelecionados);
	}
	return this.arrSelecionados;
}

/**
* Metodo para retornar os ids dos elementos selecionados no array
*
* @param bolSomentePais - Variavel que indica que ser? retornados somente os elementos pais
* @return a lista de ids dos elementos selecionados
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.getIdSelecionados = function(bolSomentePais)
{
	var arrRetorno = new Array();
	// ordenando lista
	this.ordena(this.arrSelecionados)
	if(bolSomentePais==undefined)
	{
		bolSomentePais = false;
	}
	// filtrando lista para buscar somente os ids dos pais
	if(bolSomentePais)
	{
		var arrItens =  this.filtraPais(this.arrSelecionados);
		for(var intI=0;intI<arrItens.length;intI++)
		{
			arrRetorno[intI] = arrItens[intI].getId();
		}
		return arrRetorno;
	}
	// retornando ids de todos elementos selecionados
	for(var intI=0;intI<this.arrSelecionados.length;intI++)
	{
		arrRetorno[intI] = this.arrSelecionados[intI].getId();
	}
	return arrRetorno;
}

/**
* Metodo para retornar os ids dos elementos selecionados no array
*
* @return a lista de ids dos elementos selecionados
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.copiaSelecionados = function()
{
	var arrRetorno = new Array();
	for(var intI=0;intI<this.arrSelecionados.length;intI++)
	{
		arrRetorno[intI] = this.arrSelecionados[intI].clone();
	}
	return arrRetorno;	
}

/**
* Metodo para adicionar os elementos no conteiner
*
* @param idElementoPai - Identificador do elemento pai
* @param arrElementos - Lista de nodos
* @since 13/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.addListaElementos = function(idElementoPai,arrElementos)
{
	var arrItens = new Array();
	arrItens = this.filtraPais(arrElementos);
	var objNodePai = this.buscaNode(idElementoPai);
	for(var intI=0;intI<arrElementos.length;intI++)
	{
		arrElementos[intI].setNodePai(objNodePai);
		this.addNode(arrElementos[intI]);
	}
}
/**
* Metodo para recuperar o id do pai
*
* @param idElementoPai - Identificador do elemento pai
* @param arrElementos - Lista de nodos
* @since 14/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.getIdPai = function(idFilho)
{
	var objNode = this.buscaNode(idFilho);
	if(objNode)
	{
		return objNode.getNodePai().getId();
	}
}
/**
* Metodo para atualizar o conteudo do elemento
*
* @param idElementoPai - Identificador do elemento pai
* @param arrElementos - Lista de nodos
* @since 14/06/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.setConteudo = function(idElemento,strConteudo)
{
	var objNode = this.buscaNode(idElemento);
	if(objNode)
	{
		objNode.setConteudo(strConteudo);
		if(this.objConteinerHtml!="")
		{
			var objElemento = document.getElementById(this.nome+"_"+objNode.getId());
			objElemento.innerHTML = strConteudo;
		}
	}
}

/**
* Metodo para retornar ids dos elementos removidos
*
* @return arrElementos - Lista de ids removidos
* @since 27/07/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.getRemovidos = function(idElemento,strConteudo)
{
	var arrRemovidos = new Array();
	for (var strNome in this.arrElementos)
    {	
    		if(this.arrElementos[strNome] == null)
    			arrRemovidos[arrRemovidos.length] = strNome;
    }
    return arrRemovidos;
}

/**
* Metodo para retornar o array do conteiner
*
* @return Array contendo a estrutura
* @since 27/07/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.getArray = function()
{
	return this.objNodeRaiz.getArray();
}

/**
* Metodo para limpar arvore
*
*
* @since 27/07/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.limparConteiner = function(arrItens,strDivConteiner)
{
	this.arrElementos = new Array();
	this.objNodeRaiz = new Node("raiz",null,"",true,0);
	this.arrElementos[this.objNodeRaiz.getId()] = this.objNodeRaiz;
	if(this.objConteinerHtml!="")
	{
		this.geraConteiner(this.divPrincipal);
	}
}

/**
* Metodo para gerar o  conteiner a partir do array de itens
*
* @param arrItens - Array contendo a estrutura do conteiner
* @param strDivConteiner - id do elemento onde sera adicionado o conteiner
* @since 27/07/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.setArray = function(arrItens)
{
	for(var intI=0; intI<arrItens.length; intI++)
	{
		if(arrItens[intI]["IDPAI"]=="raiz")
		{
			this.add(null,arrItens[intI]["ID"],arrItens[intI]["CONTEUDO"],arrItens[intI]["ABERTO"],arrItens[intI]["ESPACAMENTODEFINIDO"]?arrItens[intI]["ESPACAMENTO"]:-1)
		}
		else
		{
			this.add(arrItens[intI]["IDPAI"],arrItens[intI]["ID"],arrItens[intI]["CONTEUDO"],arrItens[intI]["ABERTO"],arrItens[intI]["ESPACAMENTODEFINIDO"]?arrItens[intI]["ESPACAMENTO"]:-1)			
		}
		var arrFilhos = arrItens[intI]["FILHOS"];
		this.setArray(arrFilhos);
	}
}

/**
* Metodo para gerar o  conteiner a partir do array de itens
*
* @param arrItens - Array contendo a estrutura do conteiner
* @param strDivConteiner - id do elemento onde sera adicionado o conteiner
* @since 27/07/2006
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.geraConteinerPorArray = function(arrItens,strDivConteiner)
{
	this.limparConteiner();
	this.setArray(arrItens);
	this.geraConteiner(strDivConteiner);
}

/**
* Metodo para recuperar o id do elemento html do item
*
* @param strId - Identificador do elemento
* @since 26/09/2008
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.getIdElemento = function(strId)
{
	var objNode = this.buscaNode(strId);
	if(objNode)
	{
		return this.nome+'_'+objNode.getId();
	}
}
/**
* Metodo para alterar a acao de abrir
*
* @param strAcao - Nome do metodo que sera executado {assinatura metodo(iddoelemento)}
* @since 26/09/2008
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.setAcaoAbrir = function(strAcao)
{
		this.strAcaoAbrir= strAcao;
	 
}
/**
* Metodo para alterar a acao de fechar
*
* @param strAcao - Nome do metodo que sera executado {assinatura metodo(iddoelemento)}
* @since 26/09/2008
* @author Erix Henrique Morato <emorato@unibh.br>
* @access public
*/
Conteiner.prototype.setAcaoFechar = function(strAcao)
{
	this.strAcaoFechar= strAcao;
}