Nodos en NetBeans Platform parte 2

Hola que tal amigos de Viruz Blog seguiremos con la secuencia de la plataforma de NetBeans hemos aprendido acerca de los nodos, en segundo una parte sobre las dependencias y en tercero y no menos importante como agregar algunos componentes en la paleta.

Así que vamos a poner en marcha en nuestra aplicación todos los puntos vistos para la creación de los primeros nodos y para ello vamos a trabajar en nuestra ventana del primer módulo.

Lo que necesitas conocer

• Agregar componentes a la paleta
  
• Dependencias en NBP
  
• Nodos en NBP
  
• Ventanas en NBP

Pasos:

1. En nuestro TopComponent vamos al diseñador y en nuestra paleta agregamos el componente JScrollPane y hacemos que abarque toda la ventana de la siguiente manera:

2. Seguido agregamos el componente "BeanTreeView" que es del paquete "org-openide-explorer" (agregados en la paleta en el tutorial pasado) dentro del JScrollPane.

En dado caso de que no desees agregar estos componentes a la paleta puedes crear una instancia u objeto a este componente dentro de tu código.

En el módulo debemos tener las siguientes dependencias "Explorer and Property Sheet API" y "Nodes API" en dado caso de tenerlas se deben agregar.

3. Entra a escena la clase "ExplorerManager" quien es la que se encarga de administrar las vistas, por lo que en la clase de la ventana debe implementar ExplorerManager.Provider quedando de la siguiente manera:

public final class PrimeraVentanaTopComponent extends TopComponent implements ExplorerManager.Provider {}

Nota: Se debe importar el paquete y después implementar todos los métodos abstractos.

4. Declaramos y creamos un objeto de la clase ExplorerManager.

Spoiler:

Y dentro del método abstracto implementado indicamos el regreso de la referencia del objeto.

Spoiler:

5. En el constructor de la ventana agregamos lo siguiente:

Spoiler:

La primera línea que es el método associateLookup() es la encargada de asociar el administrador del explorador con la ventana.

La segunda línea nos muestra que el nodo raíz tomará los datos de la clase "SubCategoria".

Y por último la tercera línea indica el nombre que se desplegará en este nodo raíz.

Nota: Al momento de agregar estas 3 líneas marcaran errores por lo que ahí que declarar las importaciones de cada una de ellas.

5. Por último queda agregar 3 clases restantes así que vamos a crear una clase java dentro del paquete con el nombre de SubCategoria quien va hacer la encargada de crear el nodo raíz e introducimos el siguiente código.

package org.prueba.modulo;

import org.openide.nodes.Children;
import org.openide.nodes.Node;

public class SubCategoria extends Children.Keys {
    
    private String[] Categories = new String[]{
        "Noticias",
        "Espectaculos",
        "Deportes",
        "Sociales",
        "Ciencia y Tecnologia"};
    
    public SubCategoria() {
    }
    
    @Override
     protected Node[] createNodes(Object key) {
        Categoria obj = (Categoria) key;
        return new Node[] { new CategoriaNodo( obj ) };
    }
    
    @Override
    protected void addNotify() {
        super.addNotify();
        Categoria[] objs = new Categoria[Categories.length];
        for (int i = 0; i < objs.length; i++) {
            Categoria cat = new Categoria();
            cat.setName(Categories[i]);
            objs[i] = cat;
        }
        setKeys(objs);
    }   
}

Se concluye que en el siguiente código mete las categorías en un arreglo de tipo String y cuenta con 2 métodos createsNodes() y addNotify().

• createsNodes: Es el método encargado de crear los nodos con una clave determinada.
  
• addNotify: Se manda a llamar cuando los children son primeramente llamado por los nodos.

6. Creamos de igual forma la clase Categoria quien será la encargada de tener los métodos set y get de los nodos.

package org.prueba.modulo;
/**
 *
 * @author Viruz
 */
public class Categoria {
    private String name;
    
    public Categoria() {
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}

7. Para finalizar solo queda hacer la última clase que se llamará "CategoriaNodo" la cual es la encargada de simplificar la creación de mensajes, iconos, acciones y otros requisitos comunes e introducimos el siguiente código dentro de la clase.

package org.prueba.modulo;

import javax.swing.Action;
import org.openide.nodes.AbstractNode;
import org.openide.nodes.Children;
import org.openide.util.actions.SystemAction;
import org.openide.util.lookup.Lookups;

/**
 *
 * @author Viruz
 */
public class CategoriaNodo extends AbstractNode {
    
    public CategoriaNodo(Categoria categoria) {
        super(new SubCategoria2(categoria), Lookups.singleton(categoria));
        setDisplayName(categoria.getName());
        setIconBaseWithExtension("org/prueba/modulo/controller.png");
    }
    
    @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;
    }
}

Esta clase hereda de AbstractNode y consta de 2 métodos:

• getCookie(): Se encarga de hacer la función si el nodo recibe una cookie.
  
• canDestroy(): Permite al usuario poder borrar el nodo.

Se debe tener un resultado de la siguiente manera: