Para poder indicarle a NB donde se encuentra la Javadoc a cargar tenemos que ir al menú Tools->Java Platforms:

Tools->Java Platforms

Luego, dentro del diálogo “Java Platform Manager” elegimos la versión de JDK que utilizamos (si tubieramos varios configurados), vamos a la pestaña “Javadoc” y agregamos la ruta al archivo por medio del selector de archivos que aparece al hacer click en “Add ZIP/Folder…”

Diálogo Java Platform Manager

Cerramos el dialogo haciendo click en “Close”

Finalmente probamos que se puede visualizar la Javadoc correctamente

Comprobando Javadoc

Saludos

Instalación

Ver actualización al final del post

Para instalarlo tenemos que seguir unos simples pasos:

1. Descargar el plugin según la versión del IDE que utilizemos:
   • para Netbeans 6.1: http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=6887
     (10Kb aprox)
   • para Netbeans 6.5: http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=13974
     (30,5Kb aprox)



2. Nos vamos al dialogo de Plugins de NetBeans, mediante el menú “Tools->Plugins”
3. Vamos a la pestaña “Downloaded”



4. Hacemos click en “Add Plugins…” y seleccionamos el archivo descargado



5. Hacemos click en “Install”



6. Seguimos el wizard de instalación



7. Si nos indica que el plugin no está firmado, ignoramos el aviso haciendo click en “Continue”



8. El plugin está instalado. Podemos comprobar esto en la pestaña “Installed”

Utilización

Para utilizar el plugin creamos una clase que implemente java.io.Serializable, si la instalación ha funcionado bien nos aparecerá una advertencia en la barra lateral:

La primera opción que nos muestra, nos permite colocar el valor por defecto para el serialVersionUID:

La segunda opción nos permite agregar el serialVersionUID que genera serialver para la clase:

Saludos

Más Info

• Página del plugin para NetBeans 6.1
• Página del plugin para NetBeans 6.5
• Mišo Hlaváč: Desarrollador del plugin

Actualización al 15 de Marzo de 2009

Ya es posible instalar el plugin desde Tools->Plugins en NetBeans 6.5:

Cargando el plugin desde el dialogo de Plugins de NetBeans 6.5

Actualización al 29 de Enero de 2010

El proyecto ahora está alojado en Kenai, desde donde se pueden bajar todas las versiones:

http://kenai.com/projects/nb-svuid-generator/downloads/directory/nbms

NetBeans genera dos archivos de ANT:

• nbproject/build-impl.xml
• build.xml

Podremos verlos desde la pestaña de Archivos del IDE:

En el primero de ellos (build-impl) es donde realmente se implementan todas las tareas y es donde se encuentran definidos los puntos de enganche donde nosotros podremos incorporar tareas. NO es recomendable editar este archivo.

El archivo build.xml es el que se invoca cada vez que hacemos build, clean & build, run, etc. Él simplemente importa todas las tareas definidas en el archivo build-impl:

Aquí es donde podremos (y debemos) sobrescribir las tareas provistas para tal fin. Los puntos de enganche definidos son los siguientes:

• antes de la inicialización de las propiedades del proyecto (-pre-init)
• después de la inicialización de las propiedades del proyecto (-post-init)
• antes de la compilación mediante javac (-pre-compile)
• después de la compilación mediante javac (-post-compile)
• antes de la compilación de un archivo solo mediante javac (-pre-compile-single)
• después de la compilación de un archivo solo mediante javac (-post-compile-single)
• antes de la compilación de los test de JUnit mediante javac (-pre-compile-test)
• después de la compilación de los test de JUnit mediante javac (-post-compile-test)
• antes de la compilación de un archivo de test de JUnit solo mediante javac (-pre-compile-test-single)
• después de la compilación de un archivo de test de JUnit solo mediante javac (-post-compile-test-single)
• antes de construir el Jar (-pre-jar)
• después de construir el jar (-post-jar)
• después de limpiar los archivos generados anteriormente (-post-clean)

Entonces lo que hacemos es simplemente escribir la(s) tarea(s) elegida(s):

<target name="-pre-jar">
       < !—aquí incluimos el codigo -->
 </target>

Por ejemplo, modificaremos el archivo build.xml para mostrar algunos mensajes personalizados:

< ?xml version="1.0" encoding="UTF-8"?>

<project name="testANT" default="default" basedir=".">
    <description>Builds, tests, and runs the project testANT.</description>
    <import file="nbproject/build-impl.xml"/>

    <target name="-pre-compile">
        <echo>Compilando....</echo>
    </target>

    <target name="-post-compile">
        <echo>Fin de la compilacion</echo>
    </target>

    <target name="-pre-jar">
        <echo>Armando el JAR...</echo>
    </target>

    <target name="-post-jar">
        <echo>JAR construido</echo>
    </target>

    <target name="-post-clean">
        <echo>Limpieza de archivos generados anteriormente</echo>
    </target>
</project>

Ahora si realizamos “Clean and Build” obtendremos en la ventana de Output algo como esto:

Adicionalmente podemos sobrescribir cualquiera de las tareas principales de buil-impl. Por ejemplo si queremos mantener una copia del último jar generado antes de borrarlo podríamos modificar la tarea:

<target depends="init" name="-do-clean">
        <delete dir="${build.dir}"/>
        <delete dir="${dist.dir}"/>
</target>

Sobrescribiéndola de la siguiente forma en el archivo build.xml:

<target depends="init" name="-do-clean">
        <delete dir="${build.dir}"/>

        <!-- evita errores si dist.dir no existe -->
        <mkdir dir="${dist.dir}" />
        <copy todir="backup">
            <fileset dir="${dist.dir}" />
        </copy>
        <echo>Guardada copia de dist</echo>
     
        <delete dir="${dist.dir}"/>
</target>

Manteniendo una copia aún después de realizar un “clean”:

De esta forma podemos no solo agregar funcionalidades en los puntos predefinidos (anteriormente listados) sino que podemos llegar a sobrescribir por completo las tareas de ANT.

Se puede descargar el proyecto de ejemplo (aprox. 9.3kB) de: http://lefunes.googlecode.com/files/modificar_ANT_netbeans.zip. En él se incluye el proyecto en NetBeans 6.5 creado para este post.

Espero les sirva
Saludos

Si buscamos que NetBeans oculte nuestro código al igual que realiza con el código autogenerado debemos agregar solamente dos comentarios, que incluyen un tag de apertura y uno de cierre (al estilo XML) al inicio y fin respectivamente de la porción de código a ocultar:

comentario inicio: //<editor-fold defaultstate=”collapsed” desc=”Alguna Descripción”>

comentario fin: //</editor-fold>

en donde incluimos:

• desc = Descripción que se mostrará al ocultar el texto
• defaultstate = si es igual a “collpsed”, cuando NetBeans abra el archivo esta sección se encontrará cerrada por defecto

por ejemplo si tenemos el siguiente código al que queremos realizarle code folding:

public static void main(final String args[]) {
    java.awt.EventQueue.invokeLater(new Runnable() {

        @Override
        public void run() {
            Test011_ConfExterno t = new Test011_ConfExterno();
            t.setLocationRelativeTo(null);
            t.setVisible(true);
        }
    });
}

Simplemente agregamos los comentarios y listo:

// <editorfold defaultstate="collapsed" desc="Metodo Main">
public static void main(final String args[]) {
    java.awt.EventQueue.invokeLater(new Runnable() {

        @Override
        public void run() {
            Test011_ConfExterno t = new Test011_ConfExterno();
            t.setLocationRelativeTo(null);
            t.setVisible(true);
        }
    });
}
// </editorfold>

http://mendozajug.com.ar/portal/index.php?option=com_content&task=view&id=64&Itemid=2

Desde ya muy agradecido a los owners del Mendoza JUG: Sebastian Arbona,  Andres Ceccoli y Javier Quiroga, y felicitaciones por la labor que están realizando para la comunidad de estos lados del mundo.

Actualizado:
He dejado una copia del articulo en tutorial en el NetBeans Community Documentation (NCD): http://wiki.netbeans.org/ConociendoNetbeansPlatformIntroduccion

{PATH INSTALACION NB}/etc/netbeans.conf

y agregamos a las opciones de inicio del IDE, al final del valor del parametro netbeans_default_options la clase:

netbeans_default_options=" . . . --laf javax.swing.plaf.metal.MetalLookAndFeel"

y si tenemos que agregar un L&F desde un jar, por ejemplo de la librería NimROD, lo siguiente:

netbeans_default_options=" . . . --cp:p bin\nimrodlf-1.0c.jar --laf com.nilo.plaf.nimrod.NimRODLookAndFeel"

Acá les dejo un screenshot de NetBeans 6.1 usando NimROD como L&F:

Más Info

• NimRod LookAndFeel

• Can I run NetBeans with a custom look and feel?

En este post veremos como realizar esta integración:

Bajar e Instalar Jad

1- Descargamos Jad de la página oficial: http://www.kpdus.com/jad.html#download

2- Descomprimimos el archivo descargado en un directorio cualquiera, por ejemplo: D:\jad\

Bajar e Instalar NBJAD

1- Descargamos el plugin para NetBeans de aca: http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=1177 (es un archivo .nbm)

2- Lo instalamos en NetBeans:

• Entramos a Tools->Plugins

• En la pestaña Downloaded, hacemos click en el botón Add Plugins…

• Elegimos el plugin aceptamos y elegimos Install para instalar

• Aparecerá un aviso de que ha fallado la validación del plugin, esta es solo una advertencia, pero el módulo ya ha sido instalado. Elegimos Continue y terminará la instalación.

Configurar NBJAD

Para configurar el modulo, lo que debemos realizar es acceder a Tools->Options, y una vez adentro elegir Decompile

Colocamos el path donde instalamos a Jad y las opciones que queramos utilizar al decompilar. Bajo la configuracion de las opciones se ve el listado de las mismas, esto nos ayudará en la configuración.

Una vez terminado aceptamos los cambios haciendo click en OK

Utilizando NBJAD

Para utilizar el módulo elegimos un archivo .class en Files que queramos descompilar.

Elegimos en el menú View->Decompile, y listo. aparecerá el código fuente generado por Jad.

Como última nota puedo decir que todos los archivos que vamos decompilando, NBJAD los va almacenando en ${directorio de usuario}/.nbjad

Hasta la próxima.

Más Info

• NBJAD (simple integration with Jad decompiler) module uploaded

• Jad

]]> http://lefunes.wordpress.com/2008/05/06/integrar-jad-a-netbeans-mediante-nbjad/feed/ 3 Le Funes Instalando NBJAD en NetBeans Falla la comprobación del módulo Configurando NBJAD Elegimos el archivo a descompilar Decompile !!!! http://lefunes.wordpress.com/2008/04/11/soporte-para-librerias-compartidas-en-netbeans-61/ http://lefunes.wordpress.com/2008/04/11/soporte-para-librerias-compartidas-en-netbeans-61/#comments Fri, 11 Apr 2008 13:48:53 +0000 Le Funes http://lefunes.wordpress.com/?p=96 ]]> Cuantas veces nos encontramos al compartir un proyecto con problemas de librerías no referenciadas? Ó, cuantas veces nos piden/tenemos que pedir las dependencias de un proyecto que fue compartido, finalmente pasando jars, javadoc, sources, explicaciones de cómo se tiene que llamar las librerías, etc.? Muchas veces el problema no es notorio si nosotros somos lo que lo compartimos, pero si al momento de recibir un proyecto y encontrar que algo falta para poder compilar el mismo.

Por suerte, desde NB 6.1 Beta podemos ver una luz en el horizonte: Sharable Libraries.

Veremos un repaso a los problemas comunes que nos encontramos hoy en día y como resolverlos con esta nueva característica incorporada en esta versión del IDE.

Conceptos Básicos

Antes de ver un ejemplo, nos adentrarnos en el tema repasaremos algunos conceptos.

Tipos de librerías

Existen tres tipos de librerías que se pueden insertar dentro de un proyecto de NetBeans:

• Jar/Folder: Aquí directamente se indica un .jar que se quiere agregar al proyecto.
  
• Project: Este tipo hace referencia a otro proyecto de NetBeans.
  
• Library: Las librerías son conjuntos de .jar relacionados bajo un mismo nombre, facilitando su referenciación en un proyecto. Pueden incluir no solo los binarios, sino además Javadoc y Sources que nos ayudarán al momento de programar.
  

  Este tipo de librerías a su vez pueden ser de dos tipos: definidas por NB (definidas a la hora de instalar el IDE) o definidas por el usuario. Su configuración es guardado por en un archivo de definiciones de librerías.
  

  Por ejemplo, la librería JAX-WS 2.1 encapsula los siguientes jars:
  

Archivos de definición de librerías

Es un archivo de propiedades (.properties) o XML en el cual se guarda la definición de las librerías, por ejemplo:

libs.junit.classpath=${base}/junit/junit-3.8.2.jar

libs.junit.javadoc=${base}/junit/junit-3.8.2-api.zip

libs.junit_4.classpath=${base}/junit_4/junit-4.1.jar

libs.MyLibrary_01.classpath=${base}/AbsoluteLayout.jar

Hasta NB 6.0 solo existía un archivo de definición de librerías a nivel global del IDE, que hoy es conocido como Catalogo de Librerías.

A partir de NB 6.1 Beta se pueden crear y editar archivos de definición de librerías personalizados, creando repositorios para uno o más proyectos en particular. Esto permite poder compartir no solo el proyecto, sino además este junto con a definición de las librerías y las librerías propiamente dichas que utiliza.

Para editar un archivos de definición (ya sea el global o los personalizados) se debe acceder al Library Manager (desde el menú Tools->Libraries). Una vez que elegimos la localización del archivo de definiciones, podremos ver, definir una nueva, borrar ó modificar la definición de una librería:

Catálogo de Librerías

Como vimos anteriormente, el catalogo de librerías (ó Global Libraries) es el repositorio de librerías a nivel global del IDE. En él vienen definidas las librerías por defecto creadas al momento de realizar la instalación de NB y es el que utilizan todos los proyectos por defecto, salvo que indique un archivo de definición de librerías en particular.

Se puede acceder a él mediante el Library Manager eligiendo como localidad de la librería a “Global Libraries”:

En este caso no se ha agregado ninguna definición de librería nueva, pudiendo observar el listado de librerías definidas por defecto al instalar NB 6.1 Beta.

Estructura de archivos de un proyecto

Al crear un nuevo proyecto en NB (ya sea desde cero o a partir de código existente), por defecto este generará una estructura de archivos que permiten la mejor organización, por ejemplo:

Donde:

• src: aquí se encuentra el código fuente de nuestra aplicación (.java)
  
• test: aquí está el código fuente de las pruebas (.java)
  
• build: aquí contiene los archivos generados por el compilador (.class)
  
• dist: aquí se encuentran los archivos listos para distribuir (.jar y librerías)
  
• nbproject: aquí NB guarda las configuraciones del proyecto
  
  • prívate: configuraciones propias del usuario
    

De los archivos que vemos en la figura, toma vital importancia el archivo build.xml, debido a que este es el script de Ant que configura todos los aspectos relacionados a la compilación del proyecto, indicando los pasos de construcción y empaquetado, ubicación de las librerías de dependencias, etc.

Compartiendo un proyecto

Básicamente existen dos tipos de destinatarios que pueden recibir un proyecto nuestro: otro usuario de NB o uno que no lo sea. Este último deberá valerse del script de Ant para poder realizar la compilación (build.xml).

Como podemos suponer, al compartir un proyecto, no es necesario compartir los directorios build y dist, ya que estos pueden ser generados a partir del código fuente (almacenado en src). Adicionalmente si el destinatario tiene NB no hará falta tampoco compartir el directorio con configuraciones del usuario (nbproject/private) ya que este se configurará al momento de abrir el proyecto.

Un caso extremo (e ideal a la hora de compartir) es un proyecto que no dependa de ninguna librería. No importa el tipo de destinatario del proyecto este no tendría que tener ninguna complicación a la hora de compilar y ejecutar la aplicación, ya que posee todo el código necesario y todas las librerías (es decir, ninguna).

Este no es el común de los casos, aunque sea para realizar test, para visualización, etc. siempre tendremos al menos un librería, y justamente los problemas comienzan cuando tenemos al menos una librería en el proyecto a compartir.

Los problemas más comunes que podemos tener a la hora de utilizar cada tipo de librería son los siguientes:

Librerías provistas por NB

Este tipo de librerías comúnmente no posee ningún problema entre usuarios del IDE debido a que estas librerías ya vienen definidas al instalar el mismo (salvo que la librería usada haya sido borrada del Catalogo Global). El problema que se lo encontrarán los usuarios que quieran compilar el proyecto directamente desde Ant, sin utilizar el IDE, ya que no podrán resolver las referencias a las librerías.

Librerías definidas por el usuario

Aquí la situación es la misma que la anterior para el usuario de Ant, ya que no posee la definición de las librerías.

Para otro usuario de NB que no posee las librerías definidas el IDE le indicará el problema, indicándole el nombre que debe poseer la librería que debe crear, pero no sabrá que jars incluye. En este punto es donde deberá contactarse con la persona que compartió el archivo para completar la definición de las librerías.

Un problema potencial adicional es si el usuario de NB posee definidas librerías con el nombre de las requeridas pero el contenido es totalmente diferente (jars que incluye), debiendo modificar la definición de la librería para solucionar el problema, pero seguramente trasladando los problemas al proyecto para el cual había creado la misma.

Jars

Los jars se agregan a un proyecto con paths relativos al proyecto, por lo que ambos tipos de usuario tendrán problemas si el jar en cuestión no se encuentra en la localización correcta.

Generalmente la forma de solucionar este problema hasta NB 6 era colocarlo dentro de la estructura del proyecto (en un directorio llamado lib por ejemplo), para que al compartir el proyecto el jar vaya dentro del mismo.

Otro proyecto de NB

Cuando un proyecto depende de otro ocurrirá la misma situación anterior, se utiliza el path relativo para referenciarlo, por lo que la localización del mismo será muy importante a la hora de compilar.

Otra vez, la forma de compartir los proyectos que dependen uno del otro debe hacerse de tal forma que el receptor luego no tenga problemas para reubicar los mismos en la forma adecuada. Tanto en NB 6.1 Beta como en las versiones anteriores este problema debe resolverse de esta forma, ya que la librería de la cual se depende es un proyecto en si mismo, no pudiéndose mover/copiar a una ubicación arbitrariamente.

Solución a los Problemas con NetBeans 6.1 Beta

NB 6.1 Beta resuelve los tres primeros casos vistos anteriormente creando un repositorio con todas las librerías (junto a su definición) y jars de los cual depende el proyecto.

El repositorio creado deberá ser compartido junto al proyecto.

El proyecto guarda un path relativo al repositorio, por lo que se debe elegir bien la posición donde se colocara (lo mismo que pasa al compartir un proyecto de NB que depende de otro).

Por ejemplo:

Para este ejemplo, tenemos en el directorio “ProyectoNB” el proyecto que vamos a compartir, mientras que en el directorio “libreries” el repositorio.

Dentro del directorio “Proyecto NB” tenemos la estructura de directorio de nuestro proyecto, y dentro de “libreries” tenemos la definición de las librerías (nblibreries.properties) junto con las librerías y jars requeridos por el proyecto.

Al momento de compartir lo que haríamos seria enviar el directorio “a_compartir” completo al destinatario.

Veremos un par de ejemplos para ver las pantallas que se ven implicadas en el proceso. También veremos que es muy fácil transformar un proyecto existente a compartido.

Ejemplo 1: Crear un proyecto nuevo preparado para ser compartido

En este ejemplo veremos como empezar de cero un nuevo proyecto compartido.

Creamos un nuevo proyecto:

Al llegar a este dialogo nos encontramos con dos nuevos agregados en NB 6.1 Beta:

• A: Si chequeamos indicaremos explícitamente que el proyecto es un proyecto para compartir.
• B: Al chequear A se habilita el textbox para indicar la ubicación que tendrá el repositorio de librerías. Mediante el botón “Browse…” nos facilita la búsqueda del lugar donde se encuentra un repositorio de librerías creado anteriormente.

Una vez aceptado este dialogo (haciendo click en Finish) se tendrá el proyecto listo para compartir.

Ejemplo 2: Pasar de un proyecto no compartido a hacerlo

En este ejemplo veremos como si tenemos un proyecto no compartido (nuevos o de versiones de NB previas a NB 6.1 Beta).

Al crear el nuevo proyecto no compartido:

C: Creamos el proyecto como no compartido (sin chequear la casilla)

Abrimos dentro del proyecto sus propiedades y revisamos las propiedades de las librerías:

Hacemos click en el botón se nos abrirá un dialogo de configuración del archivo de definición de librerías.

y luego de haber aceptado solo queda decir que acción se va a realizar con las librerías a las cuales el proyecto estaba apuntando.

NB nos preguntara que hacer, generalmente conviene “Use Existing Library in New Location”, ya que todas las librerías necesarias por el proyecto serán copiadas en el directorio de librerías, dejando el proyecto listo para ser compartido.

Saludos.

Hasta la próxima.

Más Info

• NetBeans.org
• Notas de Version NB 6.1 RC1
• Descargar NB 6.1 RC1
  
• Apache Ant (Wikipedia)
  

• Descargamos el módulo de la pagina oficial (descarga) .
• Dentro de NB nos dirigimos a Tools->Plugins
• En el dialogo abrimos la pestaña Downloaded
• Hacemos click en Add Plugin… y seleccionamos el archivo descargado
• Hacemos click en Install

Una vez instalado podemos verificar que todo ha salido bien, debemos crear un nuevo proyecto web (Web Application), y luego de elegir un nombre, ubicación, servidor del proyecto, en el tercer paso, el wizard nos pedirá elegir el framework a utilizar, entre los cuales deberá aparecer Google Web Toolkit

Seleccionado la ubicación donde se ubica la carpeta de instalación de GWT y el nombre del modulo principal, damos por finalizado el wizard.

Una vez credo el proyecto lo corremos (Run Main Project ó F6) y deberá mostrar el proyecto de prueba en nuestro navegador.

Otra forma de verificar el proyecto es correrlo en hosted mode , haciendo click en Run->GWT Hosted Mode

Enlaces

• Pagina Principal gwt4nb (Ingles): https://gwt4nb.dev.java.net/
• Quick Start (Ingles) : https://gwt4nb.dev.java.net/manual/quickstart.html
• Página Principal GWT: http://code.google.com/webtoolkit/
• Blog oficial GWT: http://googlewebtoolkit.blogspot.com/

Queremos insertar un Beans desde la paleta a un formulario y NetBeans nos responde:

The class must be compiled and must be on the classpath of the project to which this form belongs

Este error nos indica que el Beans del proyecto que queremos insertar tiene dependencias no resueltas en nuestro proyecto.

Solución

Tenemos que fijarnos que cuando intentamos insertar, por ejemplo, un Bean de un proyecto A que tiene dependencias a un proyecto B, en nuestro proyecto debemos tener referencias tanto al proyecto A como a B.

Para ver las dependencias de un proyecto en NetBeans, hacemos click sobre en el directorio “Libreries” dentro del árbol del proyecto.

Si deseamos agregar una nueva librería hacemos click derecho sobre “Libreries” y elegimos de que tipo es la librería a utilizar.

Para ver en mas detalles podemos ir a “Properties” y editar o eliminar dependencias, elegir la plataforma a utilizar, etc.

Cordiales saludos, espero que les sirva

El Filesystem esta compuesto por FileObjects. Posee un directorio principal o raíz (root), que es un FileObject que puede tener anidado otros FileObjects (ya sean ficheros o mas directorios).

Cada archivo para el Filesystem es considerado un stream de bytes con un tipo MIME asociado.

Prácticamente se comporta de igual manera que un sistema de ficheros real, permitiendo:

• Buscar archivos y carpetas
• Crear, borrar y renombrar archivos y carpetas
• Leer y escribir archivos

Pero como gran ventaja adicional nos permite ser notificados cuando un archivo o carpeta son modificados.

Tipos de Filesystems

Existen diversas implementaciones de la clase abstracta FileSystem (y mas específicamente de sus subclases abstractas AbstractFileSystem y MultiFileSystem) como en el caso de JarFileSystem, LocalFileSystem o XMLFileSystem

Más Info:

• File System API
• Overview (File System API)

Dentro del un module suite podemos elegir que librerías de NetBeans cargaremos y cuales no, como así también cargar módulos creados por nosotros mismos. También podemos especificar un nombre e icono que poseerá la aplicación, la pantalla de inicio (splash screen), etc.

Para ello hacemos lo siguiente:

• Creamos un nuevo proyecto dentro de NetBeans:
  • Elegimos File->New Project…
  • Dentro de NetBeans Modules elegimos Module Suite y hacemos click en Siguiente

  

  • Elegimos un nombre y ubicación para el Module Suite y hacemos click en Finish.

• Configurar el nuevo Module Suite:
  • Vamos a las propiedades del proyecto recién creado (click derecho sobre el modulo y ahí a propiedades)
  • Dentro de la pantalla de propiedades nos encontramos con tres secciones:
    • Sources: Permite modificar los módulos que incluiremos dentro del proyecto.
    • Libreries: Permite modificar las librerías que incluiremos en el proyecto.
    • Build: Permite modificar el tipo de aplicación que crearemos, nombre, icono y pantalla de inicio de la misma (dentro de Splash Screen)

  Nos dirigimos a Build

  • Como crearemos una aplicación (y no una extensión para el IDE) elegimos Create Standalone Application. Aparecerá un dialogo preguntándonos si queremos que NB excluya todas las librerías que tienen algo que ver con el IDE de nuestro proyecto, respondemos Exclude.

  

  • Elegimos el nombre de la aplicación y el titulo que aparecerá en la barra de titulo de nuestra aplicación. Si queremos podemos elegir un nuevo icono.
  • Dentro de Splash Screen podemos cambiar la pantalla de inicio de la aplicación. En ella podemos elegir la imagen a mostrar; el color, tamaño y posición del texto de los mensajes de inicio; si se muestra, el color, forma y posición de la barra de progreso.

  

  • Dentro de Libreries veremos las librerías que han sido seleccionadas después de haber aceptado el exclude. En caso de que exista un problema de dependencias ya que una librería elegida necesita de otra que hemos excluido, NB nos avisara de esta situación, con un mensaje de la forma:

  Module AAA in the cluster BBB depends on module CCC in cluster DDD but this is excluded.
  
  Esto significa que el modulo AAA dentro del cluster BBB que hemos incluido en el proyecto, depende el modulo CCC del cluster DDD, pero este ultimo ha sido excluido. Por ejemplo si NB nos indica:

  Module Platform in the cluster platform7 depends on module Favorites in cluster platform7 but this is excluded.
  
  Deberemos incluir al modulo Favorites dentro del cluster platform7 (es decir, debe estar chequeado dentro de la lista) porque el modulo Platform dentro del cluster pltform7 lo necesita (depende de él).
  Solucionamos todos los problemas de referencias que NB nos comunique (normalmente solo debe ser el del ejemplo anterior)

  • Hacemos click en OK.

• Probamos la aplicación:
  • Hacemos click en Run, o pulsamos F5 para compilar y correr el programa.
  • En caso de que todo haya funcionado bien veremos la pantalla de inicio que configuramos y la aplicación vacía.

Ya tenemos el Suite Module configurado para ser utilizado como base para nuestra aplicación. En otros post veremos como incluirle funcionalidad mediante nuevos módulos.
Mas Info:

• NetBeans API Index
• Introduction to Rich-Client Applications Development
  
• NetBeans Modules and Rich-Client Applications Learning Trail