markdown Componente Ventana

Posted 2021-05-06

# Clase VentanaTopComponent #
Se implementa ```EsplorerManager.Provider```, la firma de la clase quedaria de la siguinete manera:
~~~
final class VentanaTopComponent extends TopComponent implements ExplorerManager.Provider
~~~

El Explorer manager es el encargado de adiministrar las vistas de las ventanas con los nodos que se mostraran
~~~
private ExplorerManager em = new ExplorerManager();
@Override
public ExplorerManager getExplorerManager() {
  return em; //Se retorna el explorador (gestor de vistas)
}
~~~

En el constructor de la ventana va el siguiente codigo:
~~~
setLayout(new BorderLayout());
add(new BeanTreeView(), BorderLayout.CENTER); //Creacion del arbol de nodos
//Nodos 
associateLookup(ExplorerUtils.createLookup(em, getActionMap())); //Asocia el administrador de vistas con la ventana        
//Se indica que el nodo raiz tome los datos de cierta clase, esta clase debe extender de Children
em.setRootContext(new AbstractNode(new SubCategoria())); 
em.getRootContext().setDisplayName("Mis Categorias"); //Se indica que nombre se desplegara en el Nodo raiz
~~~

Se puede notar que se especifica en la penultima linea hacia que clase se dirigira el nodo raiz, es decir,
```SubCategoria()``` sera el siguinete nivel de nodos hijo.  
```getRootContext()``` nos indica la cracion de nuestro nodo Root o nodo raiz.

# Clase SubCategoria #

La clase ```SubCategoria()``` extiende de ```Children.Keys```  
Es la encargada de crear los nodos a partir de un modelo de datos definido (Lista, Arreglo, etc.)  

En esta clase se crea el contenido del modelo, en este caso, se crean las categorias que existiran en forma de un arreglo: 
~~~
private String[] categorias = new String[]{
                                        "Noticias", "Juegos", 
                                        "Deportes", "Sociales", 
                                        "Ciencia y Tecnologia"};
~~~

El metodo ```createNodes(Object key)``` crea los nodos hijo para el nodo ```Mis Categorias```, ya que este es el 
nodo Root.  
El objeto ```key```, es un identificador predetrminado que se le asignara a los nuevos nodos hijo, es la clave.  
Este metodo es invocado cada vez que se crea un nodo, por tanto, se invocara el mismo numero de veces igual al 
numero de elementos en el modelo de datos.
~~~
@Override
protected Node[] createNodes(Object key) { 
  Categoria obj = (Categoria) key;
  return new Node[]{new CategoriaNodo(obj)};
}
~~~

El metodo ```addNotify()``` se manda a llamar una sola vez en el momento en que se llama a la creacion de los 
nodos hijo.  
Este metodo es el encargado de crear el modelo solido para que a partir de este se creen los nodos.
~~~
@Override
protected void addNotify() { 
  super.addNotify();
  Categoria[] objs = new Categoria[categorias.length];
  for (int i = 0; i < objs.length; i++) {
    Categoria cat = new Categoria();
    cat.setName(categorias[i]);
    objs[i] = cat;
  }
  setKeys(objs);
}
~~~
Se puede notar que la creacion de este modelo se realiza creaando objetos ```Categoria```, esta clase es la 
que se encarga de contener los ```getters()``` y los ```setters()``` de nuestro modelo.

# Clase Categoria #
Esta es la clase que se encarga de escribir y leer la informacion que contendra el nodo.  
Cada ```Subcategoria()``` tendra que estar acompanada de una clase ```Categoria()```
~~~
public class Categoria { //Clase encargada de tener los getters y setters de los nodos(Noticias, Juegos, etc.)
  private String name;
  private Date fecha = new Date();
 
  public String getName() {
    return name;
  }
    
  public void setName(String name) {
    this.name = name;
  }
    
  public Date getDate() {
    return fecha;
  }
    
  public void setDate(Date fecha) {
    this.fecha = fecha;
  } 
}
~~~
En este caso se programo que el nodo tenga Nombre y Fecha de creacion.

# Clase CategoriaNodo #
Esta clase es la encargada de la configuracion de los nodos, es decir, iconos, acciones etc.  
Todo Nodo hijo tiene que ser pasado al constructor de un ```AbstractNode``` y es por eso que esta clase recibe 
los Nodos creados por el metodo ```createNode(Object key)``` de la clase ```SubCategoria()```.  
Al recibir estos nodos, comienza a trabajar directamente con cada uno de ellos para colocarles su nombre por ejemplo, 
y algo muy importante, agregar al objeto nodo al ```Lookup```.  
Este codigo se coloca en el constructor de la clase, que es el que recibe el nodo hijo.
~~~
public class CategoriaNodo extends AbstractNode { //Clase que se encarga de la configuracion de los nodos(iconos, acciones, etc.)
  public CategoriaNodo(Categoria categoria) {
    super(new Subcategoria2(categoria), Lookups.singleton(categoria)); //Asocia el objeto al Lookup
    setDisplayName(categoria.getName());
 
  }
}
~~~
La clase de AbstractNode se complementa con los metodos ```getCookie(Class clazz)``` y ```canDestroy()```
~~~
@Override
public Cookie getCookie(Class clazz) {
  Children ch = getChildren();
  
  if(clazz.isInstance(ch)) {
    return (Cookie) ch;
  }
  return super.getCookie(clazz);  
}

@Override
public boolean canDestroy() {
  return true;        
}
~~~
En esta parte se aprecia en el metodo ```super(new Subcategoria2(categoria), Lookups.singleton(categoria));```
como es que se llama a la clase ```Subcategoria2(categoria)```, es decir, se lanzan los nodos al siguiente nivel
de nodos hijo para indicar que ```SubCategoria``` sera el nodo padre de ```Subcategoria2```.  

En la clase ```Subcategoria2``` comienza de nuevo el proceso para la creacion de nodos hijos en un siguiente nivel.