• Inicio
• Artículos
  • Por categoría
  • Los últimos publicados
  • Los más leidos
  • Leer formato en RSS
• Foros
  • Ir a los foros
  • Últimos publicados
  • Los que estan sin responder
• Enlaces
  • Por categoría
  • Los últimos publicados
  • Los más visitados
• Colaboradores
  • Colaboradores destacados
  • Colaboradores registrados
  • Con más inicios de sesión
• Manuales
  • Por categoría
  • Los últimos publicados
  • Los más descargados
  • Leer formato en RSS
• Códigos fuentes
  • Por lenguaje de programación
  • Los últimos publicados
  • Los más descargados
  • Leer formato en RSS
• Notas de interes
  • Notas por temas
  • Las últimas publicadas
  • Las más leidas
  • Leer formato en RSS

Inicio | Artículos | Java | Ventanas internashijas

[titulo]INTERNAL FRAME[/titulo]

A través de la clase JInternalFrame, podremos mostrar ventanas dentro de otras ventanas. Esto es típico de determinados programas, como por ejemplo, el procesador de textos de la empresa MicroSoft: Word. En este programa se permite al usuario tener abiertos varios documentos a la vez, de manera que cada uno de ellos aparecerá en una ventana distinta, y dentro de la ventana principal del programa.

El aspecto de una ventana principal con varias ventanas internas sería el siguiente:

---

NOTA: el código fuente de la aplicación anterior, aparece explicado en su totalidad a continuación.
Pero no obstante, si usted quiere ejecutarlo, a fin de ver el comportamiento de la aplicación, podrá encontrarlo en el archivo InternaFrameTest.java. Para ejecutarlo, no tendrá más que teclear java CerrarInternalFrameTest.

---

Las ventanas internas tienen una determinadas características propias que las hacen diferentes a las ventanas instanciadas a partir de la clase JFrame:

• Un frame interno debe añadirse a un contenedor, normalmente un JDesktopPane (que es una subclase de LayeredPane o panel por capas). De no hacerlo, la ventana interna no aparecerá.

• Debemos seleccionar el tamaño de un frame interno, ya que si no realizamos esta operación, la ventana interna tendrá tamaño 0, por lo que no aparecerá.

• Es conveniente seleccionar la posición del frame interno, ya que sino su localización comenzará en la posición (0,0) de su contenedor.

• Para mostrar una ventana interna no será necesario llamar al método show() o setVisible() ya que los frames internos se muestran automáticamente cuando se añaden a un contenedor.

• Las ventanas internas no provocan eventos de ventana, sino eventos internal frame.

METODOS PRINCIPALES

Los métodos principales usados con ventanas internas son los siguientes:

MÉTODOS CONSTRUCTORES

Método	Descripción
JInternalFrame()	Crea un internal frame o ventana interna.
JInternalFrame(String)	Crea un internal frame con el título indicado.
JInternalFrame(String, boolean)	Crea un internal frame con el título indicado. El argumento boolean, se refiere a si se permite al usuario que redimensione la ventana (el valor por defecto es false).
JInternalFrame(String, boolean, boolean)	Es idéntico al caso anterior, con la salvedad de que aparece un tercer argumento boolean que se refiere a si se permite al usuario que cierre la ventana (el valor por defecto es false).
JInternalFrame(String, boolean, boolean, boolean)	Es idéntico al caso anterior, con la salvedad de que aparece un cuarto argumento boolean que se refiere a si se permite al usuario que maximice la ventana (el valor por defecto es false).
JInternalFrame(String, boolean, boolean, boolean, boolean)	Es idéntico al caso anterior, con la salvedad de que aparece un quinto argumento boolean que se refiere a si se permite al usuario que minimice la ventana (el valor por defecto es false).

MÉTODOS NO CONSTRUCTORES

Método	Descripción
void setLocation(Point) void setLocation(int,int)	Establece la posición del frame interno.
void setSize(Dimension) void setSize(int,int)	Establece el tamaño del frame interno.
void setBounds(Rectangle) void setBounds(int,int,int,int)	Establece el tamaño y la posición del frame interno.
void pack()	Empaqueta el frame interno.
void moveToFront() void moveToBack()	Si el frame interno está contenido en un LayeredPane, a través de estos métodos, podremos mover el frame interno, adelante y atrás, respectivamente.
void setDefaultCloseOperation(int) int getDefaultCloseOperation()	Establece y obtiene, respectivamente, lo que ocurre cuando se intenta cerrar el frame interno. Los posibles valores son HIDE_ON_CLOSE (por defecto), DO_NOTHING_ON_CLOSE, DISPOSE_ON_CLOSE.
void setClosed(boolean) boolean isClosed()	Estable y obtiene, respectivamente, si el frame interno está cerrado actualmente.
void setIcon(boolean) boolean isIcon()	Establece y obtiene, respectivamente, si el frame interno está minimizado actualmente.
void setMaximum(boolean) boolean isMaximum()	Establece y obtiene, respectivamente, si el frame interno esta maximizado actualmente.
void setSelected(boolean) boolean isSelected()	Establece y obtiene, respectivamente, si el frame interno está seleccionado actualmente.
void setFrameIcon(Icon) Icon getFrameIcon()	Estable y obtiene, respectivamente, el icono mostrado en el título del frame interno.
void setResizable(boolean) boolean isResizable()	Establece y obtiene, respectivamente, si el usuario puede redimensionar el frame interno.
void setClosable(boolean) boolean isClosable()	Establece y obtiene, respectivamente, si el usuario puede cerrar el frame interno.
void setIconifiable(boolean) boolean isIconifiable()	Establece y obtiene, respectivamente, si el usuario puede minimizar el frame interno.
void setMaximizable(boolean) boolean isMaximizable()	Establece y obtiene, respectivamente, si el usuario puede maximizar el frame interno.

MANEJO DE EVENTOS

Antes de leer este apartado deberías acudir al apartado de la gestión de eventos en el AWT 1.1 , si todavía no estás familiarizado con los aspectos generales para capturar los eventos producidos por cualquier componente de Java.

JInternalFrame, tiene su propia clase de escucha que recibe el nombre de InternalFrameListener; de manera que los eventos internal frame son a los JInternalFrame, lo que los eventos window son a los JFrame o Frame. Los eventos internal frame, al igual que los window, permiten a sus oyentes saber cuándo la ventana o frame se ha mostrado por primera vez, cuándo se ha eliminado, iconificado, agrandado, activado o desactivado.

La interface InternalFrameListener tiene varios métodos, lo que propicia el que tenga una clase adaptadora, InternalFrameAdapter. Estos métodos son los siguientes:

Método	Descripción
void internalFrameOpened(InternalFrameEvent)	es llamado justo después de que el frame interno se muestre por primera vez
void internalFrameClosing(InternalFrameEvent)	se llama después de que el usuario pida cerrar el frame interno. Por defecto JInternalFrame oculta la ventana cuando el usuario la cierra. Para cambiar esta última acción se puede utilizar el método setDefaultCloseOperation de JinternalFrame, que podrá recibir como parámetros las constantes definidas en WindowConstants DISPOSE_ON_CLOSE y DO_NOTHING_ON_CLOSE
void internalFrameClosed(InternalFrameEvent)	llamado por el AWT justo después de que se haya ocultado el frame interno escuchado
void internalFrameIconified(InternalFrameEvent)	llamado inmediatamente después de que el frame interno escuchado sea iconificado
void internalFrameDeiconified(InternalFrameEvent)	llamado inmediatamente después de que el frame interno escuchado sea desiconificado
void internalFrameActivated(InternalFrameEvent)	se llama justo después de que el frame interno escuchado sea activado
void internalFrameDeactivated(InternalFrameEvent)	se llama justo después de que el frame interno escuchado sea desactivado

Dentro de estos métodos, para conocer cuál fue el frame interno que generó el evento se usa getSource( ), este es un método de la clase InternalFrameEvent que nos devuelve el frame interno mencionado. CODIGO FUENTE DEL EJEMPLO

A continuación se va a explicar el código fuente del ejemplo:

1. Importamos los paquetes que vamos a necesitar:
import javax.swing.*; import java.awt.*; import java.awt.event.*;

2. Declaramos la clase InternalFrameTest como subclase de JFrame: public class InternalFrameTest extends JFrame implements ActionListener{

3. Declaramos un JDesktopPane, descendiente de LayeredPane, que será el contenedor de nuestras ventanas internas: JDesktopPane desktop;

4. A cotinuación declaramos una variable para llevar la cuenta del número de ventanas internas abiertas, así como dos constantes con el valor del desplazamiento que tendrán las ventanas internas dentro de la principal: static int numDeInternos=0; static final int xOffset=20; static final int yOffset=20;

5. Definimos el método constructor: public InternalFrameTest() {

que realiza las siguientes acciones:

- establece el título de la ventana principal y la queda sangrada 100 pixeles desde los bordes de la pantalla:
super("Ejemplo de Internal Frames"); Dimension tamPantalla=Toolkit.getDefaultToolkit().getScreenSize(); setBounds(100,100, tamPantalla.width-200, tamPantalla.height-200);

- la añadimos a la clase de escucha de ventanas: addWindowListener(new CerrarInternalFrameTest());

- creamos el contenedor de la ventana principal donde irán las ventanas secundarias o internas y llamamos al método que crea la primera ventana interna: desktop=new JDesktopPane(); crearFrame();

- establecemos el JDesktop como contenedor de nuestra ventana principal:
setContentPane(desktop);

- creamos una barra de menus, pulsando sobre la opción "Nuevo" del menú de Archivo, el usuario puede crear una nueva ventana interna:
JMenuBar menuBar=new JMenuBar(); JMenu menu=new JMenu("Archivo"); JMenuItem menuItem=new JMenuItem("Nuevo"); // añadimos item al menu y el menu a la barra menu.add(menuItem); menuBar.add(menu); setJMenuBar(menuBar); // controlamos la eleccion por el usuario de la opcion "Nuevo" menuItem.addActionListener(this); }

6. Implementamos el método que nos crea ventanas internas y nos las añade al JDesktopPane
protected void crearFrame() { JInternalFrame frame= new JInternalFrame("Archivo #"+(++numDeInternos), true, // resizable true, // cerrable true, // maximizable true); // iconificable // hay que establecer siempre el tamano frame.setSize(290,290); // hay que establecer siempre la localizacion frame.setLocation( xOffset*numDeInternos,yOffset*numDeInternos); try { frame.setSelected(true); // activamos el actual frame } catch(java.beans.PropertyVetoException e) { } desktop.add(frame); // al no especificar un segundo argumento // al metodo add, se esta indicando que el // frame se incluya en la capa por defecto, // esto es, DEFAULT_LAYER }

7. Cada vez que se elige la opción "Nuevo" del menu de Archivo se crea una nueva ventana interna, de ahí que capturemos dicha pulsación mediante el método actionPerformed de la clase ActionListener: public void actionPerformed(ActionEvent e) { crearFrame(); } }

8. Definimos la clase CerrarInternalFrameTest, que es una extensión de WindowAdapter.
Simplemente se encarga de cerrar la ventana e inicializar la aplicación: class CerrarInternalFrameTest extends WindowAdapter { public static void main(String args[]) { InternalFrameTestframe=new InternalFrameTest(); frame.show(); } public void WindowClosing(WindowEvent e) { System.exit(0); } }