Saludos a todos. En esta ocasión les traigo información sobre el uso del JInternalFrame, que se utiliza cuando queremos crear una aplicación con múltiples ventanas, antes conocida como multidocumento.

Contenedores Swing

Como ya lo mencioné en la entrada “Interfaz Gráfica de Usuario con Netbeans” cada aplicación Swing debe tener al menos un contenedor de alto nivel, que puede ser JFrame, JDialog o JApplet.  Como se especifica en los tutoriales oficiales de Java, para aparecer en pantalla, cada componente GUI debe ser parte de una jerarquía de componentes, la cual se puede ver como un árbol de componentes que tiene un contenedor de alto nivel como su raíz.

A la vez cada contenedor de alto nivel tiene un panel de contenido llamado content pane, al cual se “cuelgan” los componentes visibles de la GUI del contenedor de alto nivel. Es decir, si se crea un JFrame y se añade una lista combinada, la lista está colgada del panel de contenido del JFrame.  El panel de contenido es un objeto de la clase Container, un elemento de peso ligero.

JDesktopPane

Un objeto tipo JDesktopPane es un contenedor  que funciona como un escritorio virtual y que es utilizado para crear interfaces multi-documentos. La jerarquía de clases de JDesktopPane se muestra a continuación:

     java.lang.Object
        java.awt.Component
            java.awt.Container
                javax.swing.JComponent
                    javax.swing.JLayeredPane
                        javax.swing.JDesktopPane

JDesktopPane extiende a JLayeredPane lo que le permite que los componentes puedan solaparse, esto es enviarse al fondo o al frente cuando se requieran. Y en el caso específico de nuestro ejemplo, JDesktopPane funciona como la clase padre de los JInternalFrame que se crearán.

Inserción de un JDesktopPane

Empieza con tu aplicación tal y como se explicó en el post “Interfaz Gráfica de Usuario con Netbeans” y una vez que se ha creado el contenedor tipo JFrame, procede de la siguiente forma:

1. Inserta un control JDesktopPane desde la paleta, sección Swing Containers, tal y como se muestra en la figura 1.

Figura 1. La sección de contenedores Swing en la paleta de controles de Netbeans

2. El panel de escritorio insertado se muestra como un cuadro negro encima del JFrame (figura 2) Ajusta el tamaño del desktopPane hasta que cubra por completo el área del JFrame. Este paso no es obligatorio, pero sí deseable por la estética de tu aplicación.

Figura 2. El  JDesktopPane insertado en el JFrame.

3. Ahora configuraremos el nombre del objeto. Para ello, selecciona el escritorio, haciendo click sobre el cuadro negro insertado. En este punto puedes proceder de dos formas:
   1. Presiona click derecho sobre el escritorio y del menú contextual que se muestra, selecciona: Change Variable Name…
   2. Busca el panel Navigator, generalmente ubicado a la izquierda de la ventana de diseño, haz click derecho sobre el objeto JDesktopPane1 y selecciona Change Variable Name..
4.  Ahora escribe el nombre del objeto que representará a este control. Por comodidad, lo llamaremos simplemente escritorio (figura 3)

Figura 1. La sección de contenedores Swing en la paleta de controles de Netbeans

Es en este escritorio donde se “colgarán” las ventanas internas que se crearán en la siguiente etapa.

Creación de un JInternalFrame.

Los marcos internos o JInternalFrame es un contenedor que imita el comportamiento de un JFrame, pero no es un contenedor de alto nivel, por lo que requiere un contenedor de este tipo para crearse y mostrarse en la pantalla.

Para este proyecto lo que haré es crear nuestra propia clase de ventana interna que heredará de  JInternalFrame. Para ello:

1. Usando el panel de proyectos, haz click derecho sobre el nombre del paquete, y selecciona New ->  JInternalFrame Form. (figura 4)  Dado que esta clase aún no la hemos utilizado, puede que Netbeans te la “esconda”, es decir, no te la muestre por considerar que no es una clase básica. Si ese fuera tu caso, simplemente selecciona la opción New -> Other… Se abrirá un cuadro de diálogo como el que se aprecia en la figura 5. Como se aprecia, ahí seleccionarás la categoría Swing GUI Forms, para después seleccionar JInternalFrame Form. Presiona el botón Next.

Figura 4. Añadiendo un JInternalFrame a un proyecto

Figura 5. Añadiendo un JInternalFrame a través de la opción Otros…

2. Ahora escribe el nombre de la clase, en este caso yo la he llamado VentanaInterna1. Deja sin modificación las demás opciones, y presiona el botón Finish. Netbeans genera la ventana interna y te la muestra en la vista diseño. Puedes agregar los controles que consideres necesarios, así como también cambiar algunas propiedades de la ventana interna. En la figura 6 te muestro las propiedades comunes de JInternalFrame.

Figura 6. Propiedades comunes del contenedor JInternalFrame

3. Ahora puedes agregar los controles que necesitas en este frame interno. Para este ejemplo he agregado sólo una etiqueta.

Llamando a un JInternalFrame desde un menú.

Una vez que ya tenemos creada la clase para crear las ventanas internas, así como el escritorio en donde se abrirán, lo que sigue es un poco de código para lograr que las ventanas internas se muestren. En este ejemplo, se abrirá el frame interno desde un menú. Obviaré la parte de la creación del menú porque ya ha sido explicada en otro post anterior (Cómo crear un Menú en Java Swing con Netbeans), por lo que sólo indicaré que el JFrame creado (al que se le añadió el JDesktopPane) deberá tener una barra de menú muy sencilla. En la figura 7 te muestro como quedó preparado el JFrame para que el JInternalFrame se pueda abrir.

Figura 7. La vista diseño de la clase VentanaPrincipal.java

Ahora presionamos doble click sobre el JMenuItem Abrir para que se abra la ventana de código y escribimos:

    private void menuAbrirActionPerformed(java.awt.event.ActionEvent evt) {                                         
        // Crear un objeto tipo VentanaInterna1 y mostrarla en la pantalla
        VentanaInterna1 ventana1 = new VentanaInterna1();
         escritorio.add(ventana1);
        ventana1.setVisible(true);
    }

Como puedes ver, el código es muy sencillo. Simplemente se crea el objeto ventana1 tipo VentanaInterna1 que es la clase que extiende a JInternalFrame, añadimos el objeto creado al escritorio ( el JDesktopPane) y por último establecemos la propiedad visible del objeto ventana1 a verdadero, lo que permitirá que se muestre este frame.

La ventana1 tiene la opción de ser maximizada, minimizada y cerrada. Cada vez que le des click al menú, se creará otro objeto del tipo VentanaInterna1 el cual contiene sólo una etiqueta, como se muestra en la figura 8, en la cual se aprecian diversas ventanas tipo VentanaInterna1, y una de ellas está minimizada. Por supuesto que para realizar una aplicación más rica (y más útil ) deberás crear diversas ventanas que hereden de JInternalFrame y que tengan los controles que tu quieras agregar.

Figura 8. La ejecución del proyecto

Esto es todo por el momento. Les dejo el código de la VentanaPrincipal.java y de VentanaIterna1.java para que hagan sus pruebas. Si te gustó este post, no olvides darle “me gusta”, y compartirlo con quien lo necesite. Y si tienes dudas, escríbeme una línea y trataré de apoyarte (o aumentarte las dudas, jeje)

dCodinGames_JInternalFrame