Árvore é sempre o cão.[/quote]
Então irmão, com suas dicas e mais umas alterações(bem poucas…) consegui adicionar uma categoria dentro de outra, agora só falta eu descobrir como colocar uma folha nessa segunda categoria. Vou estudar melhor a parte do getChild acho que é alguma coisa por ali, pois está adicionando a folha(no meu caso um item) dentro do ArrayList da subcategoria, a parada está só na exibição da Folha dentro da árvore mesmo…
Minha classe CategoriasTreeModel está assim no momento:
[code]package treeSample;
import java.util.ArrayList;
import java.util.List;
import javax.swing.tree.TreePath;
public class CategoriaTreeModel extends AbstractTreeModel {
// Raiz da nossa árvore, vamos exibir uma lista de livros.
private List<Categorias> categorias;
private Categorias fakeRoot = new Categorias(“Raiz Categorias”);
public CategoriaTreeModel(List<Categorias> categorias) {
this.categorias = categorias;
//Se a categoria é vazia(adiciona a raiz nela)
if (categorias.isEmpty())
{
categorias.add(fakeRoot);
}
}
/**
* Com esse método, o Java quem é o objeto que está num determinado índice
* do pai. Cada nó de uma árvore pode ser encarado como uma lista. Sendo o
* pai a lista e o índice um dos filhos.
*
* @param parent
* É o pai, que tem os filhos. No caso do Livro, o próprio livro.
* @param index
* Índice do filho. No caso do livro, o índice corresponde aos
* autores.
*/
@Override
public Object getChild(Object parent, int index) {
// if (parent == fakeRoot) // É o nó principal?
// return categorias.get(index); // Pegamos da lista de livro
if (parent instanceof Categorias) // O pai é uma categoria?
{
//List<Categorias> cat = categorias;
if (index < ((Categorias) parent).getSubCategorias().size()) {
return ((Categorias) parent).getSubCategorias().get(index);
}
return ((Categorias) parent).getItens().get(index - ((Categorias) parent).getSubCategorias().size()); // Se não lista os itens(filhos)
}
return null;
}
/**
* Retornamos quantos filhos um pai tem. No caso de um livro, é a contagem
* de autores. No caso da lista de livros, é a quantidade de livros.
*/
@Override
public int getChildCount(Object parent) {
// Mesma lógica.
// if (parent == fakeRoot)
// return categorias.size();
if (parent instanceof Categorias) {
Categorias cat = (Categorias) parent;
return cat.getSubCategorias().size() + cat.getItens().size();
}
return 0;
}
/**
* Dado um pai, indicamos qual é o índice do filho correspondente.
*/
@Override
public int getIndexOfChild(Object parent, Object child) {
//if (parent == fakeRoot)
// return categorias.indexOf(child);
if (parent instanceof Categorias) {
if (child instanceof Categorias)
return ((Categorias) parent).getSubCategorias().indexOf(child);
return ((Categorias) parent).getSubCategorias().size() + ((Categorias) parent).getItens().indexOf(child);
}
return 0;
}
/**
* Devemos retornar quem é o nó raiz da árvore. Afinal, a árvore tem que
* começar em algum lugar.
*/
@Override
public Object getRoot() {
return fakeRoot;
}
/**
* Indicamos se um nó é ou não uma folha. Isso é, se ele não tem filhos. No
* nosso caso, os autores são as folhas da árvore.
*/
@Override
public boolean isLeaf(Object node) {
return node instanceof Itens;
}
//Medoto que chama as rotinas para adição de novas categorias/subcategorias
public void adicionarCategoria(Categorias _categSelecionada, Categorias _categoria)
{
//Obtem a categoria "pai" no array de categorias para adição de nova categoria
Categorias categAdd = percorreCategorias(categorias, _categSelecionada);
//Adiciona a nova categoria
categAdd.addSubCategoria(_categoria);
//monta o caminho para exibição do treeview
fireLastPathComponentInserted(montaPath(_categoria, null));
}
//Percorre recursivamente o ArrayList Categorias
//retornando a classe selecionada
public Categorias percorreCategorias(List<Categorias> arrCategorias, Categorias categSelecionada)
{
Categorias retorno = null;
//Percorre o arraylist para adicionar as novas categorias
for (int i = 0; i < arrCategorias.size(); i++)
{
if (arrCategorias.get(i) == categSelecionada)
{
retorno = arrCategorias.get(i);
if(retorno != null)
{
return retorno;
}
}else{
if(arrCategorias.get(i).getSubCategorias().size() > 0)
{
retorno = percorreSubCategorias(arrCategorias.get(i), categSelecionada);
if(retorno != null)
{
return retorno;
}
}
}
}
return retorno;
}
//Metodo para percorrer recursivamente as subcategorias do ArrayList categorias
//para adicionar as novas categorias no Array
public Categorias percorreSubCategorias(Categorias categI, Categorias categSelecionada)
{
Categorias retorno;
for (int i = 0; i < categI.getSubCategorias().size(); i++)
{
if (categI.getSubCategorias().get(i) == categSelecionada)
{
retorno = categI.getSubCategorias().get(i);
if(retorno != null)
{
return retorno;
}
}else{
if(categI.getSubCategorias().get(i).getSubCategorias().size() > 0)
{
retorno = percorreSubCategorias(categI.getSubCategorias().get(i), categSelecionada);
if(retorno != null)
{
return retorno;
}
}
}
}
return null;
}
public void adicionarItem(Categorias _categorias, Itens _item)
{
_categorias.addItem(_item);
fireLastPathComponentInserted((Object[])montaPath(null, _item));
}
public void remover( Object itemSelecionado)
{
if(itemSelecionado instanceof Categorias)
{
//Monta o Path para notificar a exclusão do nó
Object[] objPath = montaPath((Categorias)itemSelecionado, null);
TreePath path = new TreePath(objPath);
//Obtem o parent na tree para pesquisar no array list a clase "pai"
Object parent = path.getParentPath().getLastPathComponent();
//Notifica a exclusão do nó
fireLastPathComponentRemoved(objPath);
//Retorna a classe do pai do objeto selecionado
//para excluir o objeto selecionado
Categorias teste = percorreCategorias(categorias, (Categorias)parent);
//Remove da classe "pai" o "filho" selecionado
teste.removeSubCategoria((Categorias)itemSelecionado);
}
if(itemSelecionado instanceof Itens)
{
//Monta o Path para notificar a exclusão do nó
Object[] objPath = montaPath(null, (Itens)itemSelecionado);
TreePath path = new TreePath(objPath);
//Obtem o parent na tree para pesquisar no array list a clase "pai"
Object parent = path.getParentPath().getLastPathComponent();
//Notifica a exclusão do item
fireLastPathComponentRemoved(objPath);
//Retorna a classe do pai do objeto selecionado
//para excluir o objeto selecionado
Categorias teste = percorreCategorias(categorias, (Categorias)parent);
//Remove da classe "pai" o "filho" selecionado
teste.removeItens((Itens)itemSelecionado);
}
}
//Método para percorrer o ArrayList categorias para montar o Path do menu selecionado
//public Object[] montaPath(Object sel)
public Object[] montaPath(Categorias _categoriaProcurada, Itens _item)
{
Object[] retorno = new Object[0];
if(_categoriaProcurada != null) //Está procurando uma categoria?
{
for(Categorias categs : categorias)
{
//Percorre recursivamente o arraylist categorias e suas subcategorias
List<Categorias> arrVarreSub = (List<Categorias>) varreSub(categs, _categoriaProcurada, null);
if (arrVarreSub != null)
{
for(Categorias retVarre : arrVarreSub)
{
int ictrl = retorno.length;
retorno = (Object[]) resizeArray(retorno, retorno.length + 1);
retorno[ictrl] = retVarre;
}
return retorno;
}
}
}
if(_item != null){ //Está procurando um Item ?
for(Categorias categs : categorias)
{
//Percorre os itens na raiz
for(Itens item : categs.getItens())
{
//Se o item for igual
if(item == _item)
{
retorno = (Object[]) resizeArray(retorno, retorno.length + 1);
retorno[retorno.length - 1] = categs;
retorno = (Object[]) resizeArray(retorno, retorno.length + 1);
retorno[retorno.length -1] = item;
return retorno;
}
}
if(categs.getSubCategorias().size() > 0)
{
List<Object> arrVarreSub = (List<Object>) varreSub(categs, null, _item);
if (arrVarreSub != null)
{
for(Object obj : arrVarreSub)
{
retorno = (Object[]) resizeArray(retorno, retorno.length + 1);
retorno[retorno.length -1] = obj;
}
return retorno;
}
}
}
}
return null;
}
//Rotina para montar o Path baseado na categoria ou item selecionado
public Object varreSub(Categorias _categorias, Object _categSel, Itens _itemSel)
{
List<Object> retorno = new ArrayList();
retorno.add(_categorias);
for (Categorias categs : _categorias.getSubCategorias())
{
retorno.add(categs);
for(Itens _item : categs.getItens())
{
if(_item == _itemSel)
{
retorno.add(_item);
return retorno;
}
}
retorno.remove(categs);
if(categs == _categSel)
{
retorno.add(categs);
return retorno;
}
if(categs.getSubCategorias().size() > 0)
{
for (Categorias _categs : categs.getSubCategorias())
{
retorno.add(categs);
for(Itens _item : _categs.getItens())
{
retorno.add(_categs);
if(_item == _itemSel)
{
retorno.add(_item);
return retorno;
}
retorno.remove(_categs);
}
if(_categs == _categSel)
{
retorno.add(_categs);
return retorno;
}
if(_categs.getSubCategorias().size() > 0)
{
List<Object> arrVarreSub = (List<Object>) varreSub(_categs, (Categorias) _categSel, _itemSel);
if (arrVarreSub != null)
{
for(Object retVarre : arrVarreSub)
{
retorno.add(retVarre);
}
return retorno;
}
}
retorno.remove(categs);
}
}
}
return null;
}
//Rotina complementar da rotina varresub
//Percorre as subcategorias da tree recursivamente
public Object varreSubCateg(Categorias categ, Categorias categSel)
{
List<Object> retorno = new ArrayList();
for(Categorias categs : categ.getSubCategorias())
{
if(categs == categSel)
{
retorno.add(categ);
retorno.add(categs);
return retorno;
}
if(categs.getSubCategorias().size() > 0)
{
List<Categorias> arrVarreSub = (List<Categorias>) varreSubCateg(categs, (Categorias) categSel);
if (arrVarreSub != null)
{
retorno.add(categ);
for(Categorias retVarre : arrVarreSub)
{
retorno.add(retVarre);
}
return retorno;
}
}
}
return null;
}
//Rotina para redimensionar Arrays
private static Object resizeArray (Object oldArray, int newSize) {
int oldSize = java.lang.reflect.Array.getLength(oldArray);
Class elementType = oldArray.getClass().getComponentType();
Object newArray = java.lang.reflect.Array.newInstance(elementType, newSize);
int preserveLength = Math.min(oldSize, newSize);
if (preserveLength > 0)
System.arraycopy(oldArray, 0, newArray, 0, preserveLength);
return newArray;
}
}[/code]