Topicos GUI Avanzados

Transcripción

1 Topicos GUI Avanzados H. Tejeda Mayo 2016 Índice 1. Panel de contenido 1 2. Clase Color 4 3. Manejadores de diseño 5 4. JPanel JScrollPane Eventos y su manejo Métodos de la clase AWTEvent Manejo de eventos del ratón Uso de menús Panel de contenido La clase JFrame es una clase Java Swing contenedora de nivel superior. Las otras dos clases contenedoras de nivel superior son JDialog y JApplet. Cada componente GUI (Graphical User Interface) que aparece en la pantalla deberá ser parte de una jerarquía de contención. Una jerarquía de contención es un árbol de componentes que tienen un contenedor de nivel superior como su raíz. Cada contenedor de nivel superior tiene un panel de contenido que contiene todos los componentes visibles en la interfaz de usuario del contenedor. El panel de contenido puede contener directamente componentes como JButton, u otros contenedores, como JPanel, que a su vez puede contener componentes. 1

2 Un contenedor de nivel superior puede tener una barra de menú. Una barra de menú es una tira horizontal que convencionalmente está puesta en la cima de un contenedor y tiene opciones para el usuario. La barra de menú está encima del panel de contenido. Un panel de cristal está encima del panel de contenido. En la siguiente figura se muestra la relación entre un JFrame y su páneles raíz, de contenido y de cristal JFrame Panel raíz Barra de menú Panel de contenido Panel de cristal Nota. En el panel de cristal residen los tool tips. Se pueden dibujar sus propios gráficos en este panel en la cima de los componentes en un JFrame o JApplet. Si se agrega un MouseListener al panel de cristal, este previene que el ratón dispare eventos en los componentes debajo del panel de cristal en el JFrame. Existe un panel adicional encima del panel raíz, pero este no es usado frecuentemente por los programadores. Para obtener una referencia al panel de contenido de un JFrame, u otro contenedor de nivel superior, se usa el método getcontentpane(). Los métodos add() y remove() usados para agregar y quitar componentes de objetos JFrame y el método setlayoutmanager() usado para poner el manejador de diseño tienen esas habilidades porque Java los convierte en versiones más completas. Por ejemplo, las siguientes tres sentencias son equivalentes dentro de una clase que descienda de JFrame: this.getcontentpane().add(unboton); getcontentpane().add(unboton); add(unboton); En la primera sentencia, this se refiere a la clase JFrame en el cual la sentencia aparece, y getcontentpane() da una referencia al panel de contenido. En la segunda sentencia, la referencia this está implicada. En la tercera sentencia, la referencia this y la llamada al método getcontentpane() están implicados. 2

3 No se requiere preocuparse por el panel de contenido si sólo se agregan componentes, se quitan o se pone el manejador de diseño de un JFrame, pero se deberá referir al panel de contenido para todas las otras acciones, tales como poner el color del fondo. Cuando se escribe una aplicación en la cual se tenga que estar usando el panel de contenido, es más eficiente declarar un objeto que represente el panel de contenido que estar llamando al método getcontentpane(), como se muestra en el siguiente ejemplo, donde la llamada al método getcontentpane() es hecha una vez, su referencia se guarda en una variable, y luego el nombre de referencia es usada con la llamada al método add(): Container con = getcontentpane(); con.add(boton1); con.add(boton2); con.add(boton3); En la clase JFrameConContentPane, código 1, se crea un JFrame donde la operación de cierre por defecto no fue puesta y al botón no se le asignó alguna funcionalidad, para que el ejemplo sea sencillo. 1 import java. awt. ; 2 import javax. swing. ; 3 public c l a s s JFrameConContentPane extends JFrame { 4 private f i n a l int TAM = 180; 5 private Container con = getcontentpane ( ) ; 6 private JButton boton = new JButton ( Pulsa aquí ) ; 7 public JFrameConContentPane ( ) { 8 super ( Ventana ) ; 9 s e t S i z e (TAM, TAM) ; 10 con. setlayout (new FlowLayout ( ) ) ; 11 con. add ( boton ) ; 12 } 13 public static void main ( S t r i n g [ ] args ) { 14 JFrameConContentPane marco = 15 new JFrameConContentPane ( ) ; 16 marco. s e t V i s i b l e ( true ) ; 17 } 18 } Código 1: La clase JFrameConContentPane. En el código 1 en la línea 5 la llamada del método getcontentpane() se asigna una referencia a un Container llamado con, y luego es usada con los métodos setlayout() y add() en las líneas 10 y 11 respectivamente. Cuando se quieren usar otros métodos en vez de add(), remove(), o setlayout() con un JFrame, se debe usar un panel de contenido, como cuando se emplea el método setbackground() usado para cambiar el color del fondo. Si este método se usa con un JFrame el usuario no verá los resultados. 3

4 2. Clase Color La clase Color define colores para ser usados en aplicaciones, por ejemplo con los métodos setbackground() y setforeground() de la clase Component. Cuando se usa la clase Color, se debe incluir la sentencia import java.awt.color; al inicio del archivo de la clase. La clase Color define constantes con nombre que representan trece colores, como se muestra en el cuadro 1. Las constantes en Java son escritas usualmente con todas las letras en mayúsculas. Sin embargo, los creadores de Java declararon dos constantes para cada color en la clase Color una versión con mayúsculas, y la otra con minúsculas. Las primeras versiones de Java contenían sólo las constantes con minúsculas. Constante Constante minúsculas mayúsculas Color BLACK black negro BLUE blue azul CYAN cyan cian DARK GRAY darkgray gris obscuro GRAY gray gris GREEN green verde LIGHT GRAY lightgray gris claro MAGENTA magenta magenta ORANGE orange naranja PINK pink rosa RED red rojo WHITE white blanco YELLOW yellow amarillo Cuadro 1: Constantes de la clase Color. Para crear un objeto Color propio se haría de la siguiente forma: Color alguncolor = new Color(r, g, b); En la sentencia previa, r, g, y b son números que representan las intensidades de rojo, verde, y azul que se quieren en el color. El rango de los números está entre 0 y 255. Para crear el color negro se requiere que los valores de r, g, y b sean cero, y para el color blanco es con 255. En la siguiente sentencia se genera el color púrpura obscuro que tiene componentes para el rojo y el azul, pero carece de verde. Color purpuraobscuro = new Color(100, 0, 100); Se pueden crear más de 16 millones, 2 24, de colores personalizados de la forma anterior. Algunos computadoras no pueden mostrar cada uno de los 16 millones de colores posibles; cada computadora muestra el color más cercano que puede al color solicitado. 4

5 Para determinar la cantidad de los componentes rojo, verde, o azul de algún objeto Color se usan los métodos getred(), getgreen(), o getblue() respectivamente. Cada uno de los métodos devuelve un entero. Por ejemplo, para saber la cantidad de rojo en MAGENTA se usa Color.MAGENTA.getRed(). La aplicación JFrameConColor, código 2, pone el color del fondo de un panel de contenido JFrame y los colores del frente y el fondo de un JButton. 1 import java. awt. ; 2 import javax. swing. ; 3 public c l a s s JFrameConColor extends JFrame { 4 private f i n a l int TAM = 180; 5 private Container con = getcontentpane ( ) ; 6 private JButton boton = new JButton ( Pulsa aquí ) ; 7 public JFrameConColor ( ) { 8 super ( Marco ) ; 9 s e t S i z e (TAM, TAM) ; 10 con. setlayout (new FlowLayout ( ) ) ; 11 con. add ( boton ) ; 12 con. setbackground ( Color.YELLOW) ; 13 boton. setbackground ( Color.RED) ; 14 boton. setforeground ( Color.BLUE) ; 15 } 16 public static void main ( S t r i n g [ ] args ) { 17 JFrameConColor marco = 18 new JFrameConColor ( ) ; 19 marco. s e t V i s i b l e ( true ) ; 20 } 21 } Código 2: La aplicación JFrameConColor. 3. Manejadores de diseño Un manejador de diseño es un objeto que controla el tamaño y la posición (que es, el diseño) de componentes dentro de un objeto Container. Dependiendo del manejador de diseño que se asigne a un Container este determina como sus componentes son dimensionados y posicionados. Los manejadores de diseño son clases interfaz que son parte del JDK; estos alinean los componentes para que ni se amontonen, ni se traslapen. Por ejemplo, el manejador de diseño FlowLayout coloca los componentes en renglones de izquierda a derecha a través de su contenedor. Otros manejadores de diseño ponen los componentes en columnas y renglones de tamaño igual o centran los componentes dentro de su contenedor. Cada componente que se pone dentro de un Container puede también ser un Container por sí mismo, así que se pueden asignar manejadores de diseño dentro de otros. Java proporciona manejadores de diseño que van desde los muy simples, como FlowLayout y GridLayout, los de propósito especial, como BorderLayout y CardLayout, a los muy flexibles, como GridBagLayout y BoxLayout. En el cuadro 2 se listan cada uno de los manejadores de diseño y las situaciones en las cuales son comúnmente empleados. 5

6 Manejador BorderLayout FlowLayout GridLayout CardLayout GridBagLayout Descripción Usar para agregar hasta cinco componentes. Usar para agregar componentes de izquierda a derecha; cuando el renglón se llena se pasa automáticamente al siguiente renglón, y cada componente toma su tamaño preferente. Usar para agregar componentes en una malla de renglones y columnas; cada componente es del mismo tamaño. Usar para agregar componentes que sean mostrados uno a la vez. Usar cuando se necesite fijar tamaño, lugar, y restricciones de alineación para cada componente que sea agregado. Cuadro 2: Manejadores de diseño. Clase BorderLayout El manejador BorderLayout es la clase manejadora por defecto para todos los páneles de contenido. Se puede usar la clase BorderLayout con cualquier contenedor que tenga 5 componentes o menos. Cualquiera de los componentes podría ser un contenedor que tenga más componentes. Con el manejador BorderLayout los componentes llenan la pantalla en cinco regiones: norte, sur, este, oeste y centro. Cuando se agrega un componente a un contenedor que usa BorderLayout, el método add() usa dos argumentos: el componente y la región a la cual este es agregado. La clase BorderLayout proporciona cinco constantes con nombre para las regiones BorderLayout.NORTH,.SOUTH,.EAST,.WEST, y.center o se pueden usar los String que estas constantes representan: North, South, East, West, o Center. La aplicación DemoJBorderLayout, código 3, muestra una salida donde han sido puestos cinco botones. 1 import java. awt. ; 2 import javax. swing. ; 3 public c l a s s DemoJBorderLayout extends JFrame { 4 private JButton bn = new JButton ( Botón Norte ) ; 5 private JButton bs = new JButton ( Botón Sur ) ; 6 private JButton be = new JButton ( Botón Este ) ; 7 private JButton bo = new JButton ( Botón Oeste ) ; 8 private JButton bc = new JButton ( Botón Centro ) ; 9 private Container con = getcontentpane ( ) ; 10 public DemoJBorderLayout ( ) { 11 con. setlayout (new BorderLayout ( ) ) ; 12 con. add ( bn, BorderLayout.NORTH) ; 13 con. add ( bs, BorderLayout.SOUTH) ; 14 con. add ( be, BorderLayout.EAST) ; 15 con. add ( bo, BorderLayout.WEST) ; 16 con. add ( bc, Center ) ; 17 s e t S i z e (400, ) ; 18 } 19 public static void main ( S t r i n g [ ] args ) { 20 DemoJBorderLayout ventana = 6

7 21 new DemoJBorderLayout ( ) ; 22 ventana. s e t V i s i b l e ( true ) ; 23 } 24 } Código 3: Aplicación DemoJBorderLayout. Nota. Cuando se usa BorderLayout, se pueden usar las constantes PAGE START, PAGE END, LINE START, LINE END, y CENTER en vez NORTH, SOUTH, EAST, WEST, y CENTER. Las constantes dadas corresponden a posiciones que se podrían tener en una hoja impresa. Si se agrega la siguiente sentencia import, se puede referir a CENTER en vez de BorderLayout.CENTER: import static java.awt.borderlayout.*; Cuando se colocan cinco componentes en un contenedor y se usa BorderLayout, cada componente llena una región entera, como se observa al ejecutar la aplicación DemoJBorderLayout. Cuando la aplicación se ejecuta, Java determina el tamaño exacto de cada componente basado en el contenido del componente. Cuando se redimensiona un Container que use BorderLayout, las regiones también cambian en tamaño. Si el contenedor se hace más ancho las regiones norte, sur, y centro se hacen más anchas, pero las otras restantes no cambian. Si se incrementa la altura, las regiones este, oeste, y centro se hacen más altas, pero las otras permanecen sin cambio. Cuando se usa BorderLayout, no se requiere agregar componentes en cada una de las cinco regiones. Si se agregan menos componentes, cualquier región vacía desaparece, y las restantes se expanden para llenar el espacio disponible. Si cualquiera de las regiones norte, sur, este, u oeste fueron dejadas vacías, el área central se expande en las áreas vacías. Sin embargo, si el área central es dejada, ni la área norte, sur, este, u oeste cambia. Un error común cuando se usa BorderLayout es agregar un componente a un panel de contenido o marco sin nombrar una región. Esto puede resultar que algunos de los componentes no sea visible. Clase FlowLayout Se puede usar el manejador FlowLayout para arreglar los componentes en renglones a lo ancho de un Container. Con un FlowLayout, cada componente que sea agregado es colocado a la derecha de los componentes previamente agregados en un renglón; o, si el renglón actual está lleno, el componente es puesto al inicio de un nuevo renglón. Cuando se usa BorderLayout, los componentes que se agregan llenan sus regiones. Sin embargo, cuando se usa FlowLayout, cada Component retiene su tamaño por defecto o tamaño preferente. Por ejemplo, el tamaño preferente de un JButton es el tamaño que es lo suficientemente grande para tener el texto del JButton. Cuando se usa un BorderLayout y luego se redimensiona la ventana, los componentes cambian su tamaño porque sus regiones cambian. Cuando se usa FlowLayout y luego se redimensiona la ventana, cada componente retiene su tamaño, pero este podría obscurecerse parcialmente o cambiar de posición. La clase FlowLayout contiene tres constantes que se pueden usar para alinear Componentes en un Container: FlowLayout.LEFT 7

8 FlowLayout.CENTER FlowLayout.RIGHT Si no se indica la alineación, los componentes son alineados al centro en un Container con FlowLayout por defecto. En la aplicación DemoJFlowLayout, código 4, un objeto FlowLayout llamado manejador es usado para poner el diseño del panel de contenido. Cuando el usuario pulsa un botón, en las líneas el método actionperformed() cambia la alineación a la izquierda o a la derecha usando el método setalignment(). Al ejecutar la DemoJFlowLayout se debe observar como los componentes JButton son reposicionados después de que se pulsa en el botón izquierdo, y después de hacerlo en el botón derecho. 1 import java. awt. ; 2 import java. awt. event. ; 3 import javax. swing. ; 4 public class DemoJFlowLayout extends JFrame implements A c t i o n L i s t e n e r { 5 private JButton bi = new JButton ( Botón I z q u i e r d o ) ; 6 private JButton bd = new JButton ( Botón Derecho ) ; 7 private Container con = getcontentpane ( ) ; 8 private FlowLayout manejador = new FlowLayout ( ) ; 9 public DemoJFlowLayout ( ) { 10 con. setlayout ( manejador ) ; 11 con. add ( bi ) ; 12 con. add ( bd ) ; 13 bi. addactionlistener ( this ) ; 14 bd. addactionlistener ( this ) ; 15 s e t S i z e (500, ) ; 16 } 17 public void actionperformed ( ActionEvent event ) { 18 Object source = event. getsource ( ) ; 19 i f ( source == bi ) 20 manejador. setalignment ( FlowLayout.LEFT) ; 21 else 22 manejador. setalignment ( FlowLayout.RIGHT) ; 23 con. i n v a l i d a t e ( ) ; 24 con. v a l i d a t e ( ) ; 25 } 26 public static void main ( S t r i n g [ ] args ) { 27 DemoJFlowLayout ventana = new DemoJFlowLayout ( ) ; 28 ventana. s e t V i s i b l e ( true ) ; 29 } 30 } Código 4: Aplicación DemoJFlowLayout. Nota. Las sentencias de las ĺıneas 23 y 24 en el método actionperformed() del código 4 llaman a los métodos invalidate() y validate(), respectivamente. La llamada invalidate() marca el contenedor, y cualquiera de sus padres, como necesitado de ser arreglado. La llamada validate() causa que los componentes sean redispuestos de acuerdo al manejador nuevo asignado. 8

9 Clase GridLayout Si quiere acomodar componentes en renglones y columnas del mismo tamaño, se puede usar la clase manejador GridLayout. Cuando se crea un objeto GridLayout se indica la cantidad de renglones y columnas deseadas, y entonces la superficie es dividida en una cuadrícula. Con la siguiente sentencia se crea un GridLayout anónimo con cuatro renglones y cinco columnas en un Container llamado con: con.setlayout(new GridLayout(4, 5)); Cuando se agregan componentes a un GridLayout, estos son posicionados en secuencia de izquierda a derecha a través de cada renglón. No se puede saltar una posición o indicar una posición exacta para un componente. Sin embargo, se podría agregar una etiqueta blanca para simular el salto de una posición. Se puede también indicar una separación vertical y horizontal medida en píxeles, con dos argumentos adicionales. La aplicación DemoJGridLayout, código 5, en la línea 9 establece un GridLayout con tres renglones y dos columnas, e intervalos horizontal y vertical de cinco píxeles cada uno. Cinco componentes JButton son agregadas al panel de contenido recuperado del JFrame. 1 import java. awt. ; 2 import javax. swing. ; 3 public c l a s s DemoJGridLayout extends JFrame { 4 private JButton b1 = new JButton ( Botón 1 ) ; 5 private JButton b2 = new JButton ( Botón 2 ) ; 6 private JButton b3 = new JButton ( Botón 3 ) ; 7 private JButton b4 = new JButton ( Botón 4 ) ; 8 private JButton b5 = new JButton ( Botón 5 ) ; 9 private GridLayout d i seno = new GridLayout ( 3, 2, 5, 2 ) ; 10 private Container con = getcontentpane ( ) ; 11 public DemoJGridLayout ( ) { 12 con. setlayout ( d iseno ) ; 13 con. add ( b1 ) ; 14 con. add ( b2 ) ; 15 con. add ( b3 ) ; 16 con. add ( b4 ) ; 17 con. add ( b5 ) ; 18 s e t S i z e (200, ) ; 19 } 20 public static void main ( S t r i n g [ ] args ) { 21 DemoJGridLayout ventana = new DemoJGridLayout ( ) ; 22 ventana. s e t V i s i b l e ( true ) ; 23 } 24 } Código 5: Aplicación DemoJGridLayout. Cuando se ejecuta la aplicación DemoJGridLayout, los componentes son puestos en el panel a través de los tres renglones. Como hay seis posiciones pero sólo cinco componentes, un lugar está sin usar. Con GridLayout, se puede indicar la cantidad de renglones y usar cero para la cantidad de columnas para permitir que el manejador de diseño determine la cantidad de columnas, de igual forma se 9

10 puede indicar la cantidad de columnas y usar cero para la cantidad de renglones, para que el manejador calcula la cantidad de renglones. Cuando se intenta decidir entre usar un GridLayout o un FlowLayout, considerar lo siguiente: Usar GridLayout cuando se quiere a los componentes en renglones y columnas fijas, y se quiere que el tamaño de los componentes llene el espacio disponible. Usar FlowLayout si se quiere que Java determine los renglones y las columnas, en vez de algo fijo, para que los componentes retengan su tamaño natural para que sus contenidos sean completamente visibles. Clase CardLayout El manejador CardLayout genera una pila de contenedores o componentes. Cada componente en el grupo es referido como una carta, y cada carta puede ser cualquier tipo de componente, como un JButton, un JLabel, o un JPanel. Se emplea un CardLayout cuando se quiere que componentes múltiples compartan el mismo espacio de presentación. Un manejador de cartas es creado de la clase CardLayout usando uno de dos constructores: CardLayout() crea un diseño de cartas sin un intervalo horizontal o vertical. CardLayout(int hint, int vint) crea un diseño de cartas con los intervalos horizontales y verticales especificados. Los intervalos horizontales son colocados en las aristas izquierda y derecha. Los intervalos verticales son colocados en las aristas de la cima y el fondo. La aplicación DemoJCardLayout, código 6, usa un manejador CardLayout para crear una pila de JButton que contienen las etiquetas As de Corazones, Tres de Espadas, Reina de Tréboles. En el constructor de la clase, se ocupa una versión ligeramente diferente del método add() para agregar componentes a un panel de contenido cuyo manejador de diseño es CardLayout. El formato es: add(unstring, uncontenedor); En esta sentencia, unstring representa el nombre que se quiere usar para identificar la carta componente que es agregada. 1 import java. awt. ; 2 import java. awt. event. ; 3 import javax. swing. ; 4 public class DemoJCardLayout extends JFrame implements A c t i o n L i s t e n e r { 5 private CardLayout c a r t a s = new CardLayout ( ) ; 6 private JButton b1 = new JButton ( As de Corazones ) ; 7 private JButton b2 = new JButton ( Tres de Espadas ) ; 8 private JButton b3 = new JButton ( Reina de Tré b o l e s ) ; 9 private Container con = getcontentpane ( ) ; 10 public DemoJCardLayout ( ) { 10

11 11 con. setlayout ( c a r t a s ) ; 12 con. add ( as, b1 ) ; 13 b1. addactionlistener ( this ) ; 14 con. add ( t r e s, b2 ) ; 15 b2. addactionlistener ( this ) ; 16 con. add ( r e i n a, b3 ) ; 17 b3. addactionlistener ( this ) ; 18 s e t S i z e (200, ) ; 19 } 20 public void actionperformed ( ActionEvent e ) { 21 c a r t a s. next ( getcontentpane ( ) ) ; 22 } 23 public static void main ( S t r i n g [ ] args ) { 24 DemoJCardLayout ventana = new DemoJCardLayout ( ) ; 25 ventana. s e t V i s i b l e ( true ) ; 26 } 27 } Código 6: Aplicación DemoJCardLayout. En un programa que tenga un manejador CardLayout, un cambio de carta es disparado por la acción del usuario. En el programa DemoJCardLayout, cada JButton dispara el método actionperformed(). Dentro de este método, la sentencia next(getcontentpane()) cambia a la siguiente carta del contenedor. El orden de las cartas depende del orden en cual fueron agregadas al contenedor. Se puede también usar previous(getcontentpane());, first(getcontentpane());, y last(getcontentpane()); para cambiar a la carta previa, primera, y última, respectivamente. Se puede ir a una carta específica usando el nombre String asignado en la llamada al método add(). Para la aplicación del código 6, la siguiente sentencia deberá mostrar Tres de Espadas porque tres es usado como el primer argumento cuando el objeto b2 es agregado al panel de contenido en el constructor DemoJCardLayout: cards.show(getcontentpane(), "tres"); Al ejecutar la aplicación DemoJCardLayout se muestra la primera carta, As de Corazones, y luego que el usuario pulsa una vez, aparece Tres de Espadas, y en la segunda pulsación Reina de Tréboles. Como cada JButton es una carta, cada JButton usa el área de visualización completamente en el contenedor. Si el usuario continúa pulsando los botones carta, las cartas se ciclan en orden. Manejadores de diseño avanzado El manejador GridBagLayout permite agregar componentes en lugares específicos en una cuadrícula, al igual que se puede indicar que los componentes se expandan en múltiples renglones y columnas. Por ejemplo, si se quiere crear un JPanel con seis JButton, en el cual dos de los JButton sean el doble de anchos que los otros, se puede usar GridBagLayout. Esta clase es difícil de usar porque se debe poner la posición y el tamaño para cada componente, y más de veinte métodos están asociados con la clase. 11

12 Otra opción de manejador de diseño es el manejador BoxLayout, el cual permite que varios componentes estén puestos verticalmente u horizontalmente. Los componentes no se reacomodan cuando el marco es redimensionado, por ejemplo un arreglo vertical de componentes permanece vertical a pesar del redimensionado. Actividad 1. Crear un JFrame que use los diferentes manejadores de diseño vistos en esta sección. 4. JPanel Los manejadores BorderLayout, FlowLayout, GridLayout, y Cardlayout proporcionan una cantidad limitada de arreglos de pantalla si solo se pudiera colocar un solo Component en una sección del diseño. Pero, se puede incrementar la cantidad de arreglos de componentes posibles usando la clase JPanel. Un JPanel es un plano, superficie sin borde que puede tener componentes UI de peso ligero. Enseguida se muestra la jerarquía de herencia de la clase JPanel. java.lang.object +--java.awt.component +---java.awt.container +---javax.swing.jcomponent +---javax.swing.jpanel De la figura previa, se ve que cada JPanel es un Container; así que se puede usar un JPanel para tener otros componentes UI, tales como JButton, JCheckBox, o incluso otros JPanel. Usando un JPanel dentro de otro, se puede crear una variedad infinita de diseños de pantalla. El manejador de diseño por defecto para cada JPanel es FlowLayout. Para agregar un componente a un JPanel, se llama al método add() del contenedor, usando el componente como el argumento. La aplicación JFrameConJPanels, código 7, extiende la clase JFrame. Un JButton es agregado a un JPanel llamado panel1, y dos JButton más son agregados a otro JPanel llamado panel2. Luego panel1 y panel2 son agregados a panel de contenido de un JFrame. 1 import java. awt. ; 2 import javax. swing. ; 3 import static java. awt. Color. ; 4 public c l a s s JFrameConJPanels extends JFrame { 5 private f i n a l int ANCHO = 250; 6 private f i n a l int ALTO = 120; 7 private JButton boton1 = new JButton ( Uno ) ; 8 private JButton boton2 = new JButton ( Dos ) ; 9 private JButton boton3 = new JButton ( Tres ) ; 10 public JFrameConJPanels ( ) { 11 super ( JFrame con JPanels ) ; 12 s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame. EXIT ON CLOSE ) ; 12

13 13 JPanel panel1 = new JPanel ( ) ; 14 JPanel panel2 = new JPanel ( ) ; 15 Container con = getcontentpane ( ) ; 16 con. setlayout (new FlowLayout ( ) ) ; 17 con. add ( panel1 ) ; 18 con. add ( panel2 ) ; 19 panel1. add ( boton1 ) ; 20 panel1. setbackground (BLUE) ; 21 panel2. add ( boton2 ) ; 22 panel2. add ( boton3 ) ; 23 panel2. setbackground (RED) ; 24 s e t S i z e (ANCHO, ALTO) ; 25 } 26 public static void main ( S t r i n g [ ] args ) { 27 JFrameConJPanels ventana = new JFrameConJPanels ( ) ; 28 ventana. s e t V i s i b l e ( true ) ; 29 } 30 } Código 7: Aplicación JFrameConJPanels. Al ejecutar la aplicación JFrameConJPanels se deben mostrar los dos JPanel que fueron agregados al JFrame, el primero con un botón y color azul de fondo, y el otro con dos botones y color rojo de fondo. Cuando se crea un objeto JPanel, se puede usar uno de cuatro constructores disponibles. Los diferentes constructores permiten usar valores por defecto o indicar un manejador de diseño y si el JPanel es doble búfer. Si se indica doble búfer, la cual es la estrategia de búfer por defecto, se indica que el espacio de memoria adicional será usado para dibujar el JPanel fuera de pantalla cuando sea actualizado. Con doble búfer, un JPanel redibujado es mostrado sólo cuando este está completo; esto proporciona al usuario con pantallas actualizadas que no parpadeen mientras son redibujadas. Los cuatro constructores son los siguientes: JPanel() crea un JPanel con doble búfer y un diseño de flujo. JPanel(boolean esdoblebúfer) crea un JPanel con un diseño de flujo y la estrategia de doble búfer indicada. JPanel(LayoutManager dise~no) crea un JPanel con el manejador de diseño indicado y doble búfer. JPanel(LayoutManager dise~no, boolean esdoblebúfer) crea un JPanel con el manejador de diseño y la estrategia de búfer indicados. Nota. Cuando se emplea doble búfer, el área de pantalla visible es llamada el área primaria, y la imagen fuera de pantalla es llamada el búfer de respaldo. El acto de copiar los contenidos de una área a otra es frecuentemente referida como una transferencia lineal de bloques, o blitting. El doble búfer previene la despedazadera, el efecto visual que ocurre cuando se ven partes de imágenes diferentes porque el redibujado no es lo suficientemente rápido. Como la mayoría de las prestaciones, doble búfer tiene un costo de requerimientos adicionales de memoria. 13

14 Hay varias formas para crear un JPanel que use un manejador BorderLayout: Se crea un diseño con nombre y se usa este como un argumento en un constructor JPanel: BorderLayout borde = new BorderLayout(); JPanel mipanel = new JPanel(borde); Se usa un manejador de diseño anónimo con el constructor JPanel: JPanel mipanel = new JPanel(new BorderLayout()); Se crea un JPanel y luego se pone su manejador de diseño usando el método setlayout(): JPanel mipanel = new JPanel(); mipanel.setlayout(new BorderLayout()); Cuando un JPanel tendrá un manejador diferente de FlowLayout, es preferible especificar el manejador de diseño cuando se crea el JPanel por cuestiones de rendimiento. Si se crea el JPanel primero y luego se cambia su manejador, se crea un objeto FlowLayout innecesario para la instanciación original. Se agregan componentes a un JPanel con el método add(). La aplicación JDemoMuchosPaneles, código 8, es un JFrame que contiene cuatro JPanel y doce JButton donde cada uno muestra un número con letras. Al panel de contenido de un JFrame automáticamente se le asigna un BorderLayout, y a cada JPanel se le asigna un GridLayout o un FlowLayout y son colocados en una de las regiones, dejando la región norte vacía. Uno o más JButton son luego colocados en cada JPanel. 1 import java. awt. ; 2 import javax. swing. ; 3 public c l a s s JDemoMuchosPaneles extends JFrame { 4 // Doce botones 5 private JButton boton01 = new JButton ( Uno ) ; 6 private JButton boton02 = new JButton ( Dos ) ; 7 private JButton boton03 = new JButton ( Tres ) ; 8 private JButton boton04 = new JButton ( Cuatro ) ; 9 private JButton boton05 = new JButton ( Cinco ) ; 10 private JButton boton06 = new JButton ( S e i s ) ; 11 private JButton boton07 = new JButton ( S i e t e ) ; 12 private JButton boton08 = new JButton ( Ocho ) ; 13 private JButton boton09 = new JButton ( Nueve ) ; 14 private JButton boton10 = new JButton ( Diez ) ; 15 private JButton boton11 = new JButton ( Once ) ; 16 private JButton boton12 = new JButton ( Doce ) ; 17 // Cuatro p a n e l e s 18 private JPanel panel01 = new JPanel (new GridLayout ( 2, 0 ) ) ; 19 private JPanel panel02 = new JPanel (new FlowLayout ( ) ) ; 20 private JPanel panel03 = new JPanel (new FlowLayout ( ) ) ; 21 private JPanel panel04 = new JPanel (new GridLayout ( 2, 0 ) ) ; 22 public JDemoMuchosPaneles ( ) { 23 setlayout (new BorderLayout ( ) ) ; 14

15 24 add ( panel01, BorderLayout.WEST) ; 25 add ( panel02, BorderLayout.CENTER) ; 26 add ( panel03, BorderLayout.SOUTH) ; 27 add ( panel04, BorderLayout. EAST) ; 28 panel01. add ( boton01 ) ; 29 panel01. add ( boton02 ) ; 30 panel01. add ( boton03 ) ; 31 panel02. add ( boton04 ) ; 32 panel02. add ( boton05 ) ; 33 panel02. add ( boton06 ) ; 34 panel03. add ( boton07 ) ; 35 panel04. add ( boton08 ) ; 36 panel04. add ( boton09 ) ; 37 panel04. add ( boton10 ) ; 38 panel04. add ( boton11 ) ; 39 panel04. add ( boton12 ) ; 40 s e t S i z e (500, ) ; 41 } 42 public static void main ( S t r i n g [ ] args ) { 43 JDemoMuchosPaneles ventana = new JDemoMuchosPaneles ( ) ; 44 ventana. s e t V i s i b l e ( true ) ; 45 } 46 } Código 8: La aplicación JDemoMuchosPaneles. Cuando se ejecuta la aplicación JDemoMuchosPaneles el usuario puede hacer la ventana horizontalmente más grande para observar como algunos botones aparecen y se reacomodan, en particular los que están en el JPanel que ocupa la región central. Nota. Si se crea un programa con muchos botones y páneles como los del código 8, se debería preferir crear arreglos de los componentes en vez de manejar muchos nombres individualmente. Nota. Los contenedores Swing, excepto JPanel, y los páneles de contenido proporcionan métodos interfaz de programación de aplicaciones (API) que se deberían usar en vez del método add(). GridLayout proporciona renglones y columnas que son similares a los arreglos bidimensionales. Por lo tanto, este se usa para mostrar arreglos de objetos. La aplicación Tablero, código 9, muestra un patrón de ocho renglones y ocho columnas en colores alternantes. El JPanel colocado en el panel de contenido tiene un GridLayout de ocho por ocho. 64 JPanel son declarados, y en un ciclo, uno por uno, son instanciados y asignados a una sección de la cuadrícula, líneas Después de que cada conjunto de ocho JPanel es asignado a la cuadrícula, cuando x es divisible por 8, el color1 y el color2 son intercambiados, para que el primer renglón inicie con un cuadro azul, el segundo inicie con un cuadro blanco, etc. Dentro de cada renglón, todos los cuadros con posición par son llenados con un color, y los otros cuadros con otro color. Ejecutar la aplicación Tablero para ver la salida. 1 import java. awt. ; 2 import javax. swing. ; 3 public class Tablero extends JFrame { 15

16 4 private f i n a l int RENS = 8 ; 5 private f i n a l int COLS = 8 ; 6 private f i n a l int SEP = 2 ; 7 private f i n a l int NUM = RENS COLS; 8 private int x ; 9 private JPanel pane = new JPanel ( 10 new GridLayout (RENS, COLS, SEP, SEP ) ) ; 11 private JPanel [ ] panel = new JPanel [NUM] ; 12 private Color c o l o r 1 = Color.WHITE; 13 private Color c o l o r 2 = Color.BLUE; 14 private Color tempcolor ; 15 public Tablero ( ) { 16 super ( Tablero ) ; 17 s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame. EXIT ON CLOSE ) ; 18 add ( pane ) ; 19 for ( x = 0 ; x < NUM; ++x ) { 20 panel [ x ] = new JPanel ( ) ; 21 pane. add ( panel [ x ] ) ; 22 i f ( x % COLS == 0) { 23 tempcolor = c o l o r 1 ; 24 c o l o r 1 = c o l o r 2 ; 25 c o l o r 2 = tempcolor ; 26 } 27 i f ( x % 2 == 0) 28 panel [ x ]. setbackground ( c o l o r 1 ) ; 29 else 30 panel [ x ]. setbackground ( c o l o r 2 ) ; 31 } 32 } 33 public static void main ( S t r i n g [ ] args ) { 34 Tablero ventana = new Tablero ( ) ; 35 f i n a l int TAM = 300; 36 ventana. s e t S i z e (TAM, TAM) ; 37 ventana. s e t V i s i b l e ( true ) ; 38 } 39 } Código 9: Aplicación Tablero. Cuando se crea la clase Tablero, se podría estar tentado a crear sólo dos JPanel, uno azul y uno blanco, y agregarlo al panel de contenido varias veces. Sin embargo, cada componente GUI puede ser contenido una sola vez. Si un componente ya está en un contenedor y se intenta agregar otro contenedor, el componente será quitado del primer contenedo y luego agregado al segundo. 5. JScrollPane Cuando componentes en una UI Swing requieren más área de visualización que la les ha sido asignada, se puede usar un contenedor JScrollPane para tener los componentes en una forma que permitan al usuario desplazar partes no visibles inicialmente del panel en la vista. Un JScrollPane tiene barras de desplazamiento a un lado o en el fondo, o en ambos, con una área de visualización 16

17 llamada una ventana (viewport). La siguiente figura muestra la jerarquía de herencia de la clase JScrollPane. java.lang.object +--java.awt.component +---java.awt.container +---javax.swing.jcomponent +---javax.swing.jscrollpanel Hay cuatro constructores JScrollPane que son: JScrollPane() crea un JScrollPane vacío en el cual las barras de desplazamiento horizontal y vertical aparecen cuando se ocupan. JScrollPane(Component) crea un JScrollPane que muestra el contenido del componente indicado. JScrollPane(Component, int, int) crea un JScrollPane que muestra el componente especificado e incluye especificaciones de las barras de desplazamiento horizontal y vertical. JScrollPane(int, int) crea un JScrollPane con ambas especificaciones de las barras de desplazamiento horizontal y vertical. Cuando se crea un panel de desplazamiento simple usando el constructor sin argumentos, como en el siguiente ejemplo, las barras de desplazamiento horizontal y vertical aparecen solo si se ocupan, es decir, si el contenido del panel no puede ser mostrado completamente: JScrollPane unscrollpane = new JScrollPane(); Para forzar la aparición de una barra de desplazamiento, se pueden usar las constantes definidas en la interfaz JScrollPaneConstants: ScrollPaneConstants.HORIZONTAL SCROLLBAR AS NEEDED ScrollPaneConstants.HORIZONTAL SCROLLBAR ALWAYS ScrollPaneConstants.HORIZONTAL SCROLLBAR NEVER ScrollPaneConstants.VERTICAL SCROLLBAR AS NEEDED ScrollPaneConstants.VERTICAL SCROLLBAR ALWAYS ScrollPaneConstants.VERTICAL SCROLLBAR NEVER El siguiente código crea un panel de desplazamiento que muestra una imagen llamada dibujo, una barra de desplamiento vertical, y sin barra de desplazamiento horizontal: 17

18 JScrollPane desplaza = new JScrollPane(dibujo, ScrollPaneConstants.VERTICAL SCROLLBAR ALWAYS, ScrollPaneConstants.HORIZONTAL SCROLLBAR NEVER); La aplicación DemoJScroll, código 10, tiene una etiqueta con una fuente grande que se agregó a un panel. El panel de desplazamiento llamado desplaza incluye el panel y dos barras de desplazamiento. 1 import java. awt. ; 2 import javax. swing. ; 3 public c l a s s DemoJScroll extends JFrame { 4 private JPanel panel = new JPanel ( ) ; 5 private JScrollPane d e s p l a z a = new JScrollPane ( panel, 6 ScrollPaneConstants.VERTICAL SCROLLBAR ALWAYS, 7 ScrollPaneConstants.HORIZONTAL SCROLLBAR ALWAYS) ; 8 private JLabel label = new JLabel ( Hace ochenta y s i e t e ) ; 9 private Font fontgrande = new Font ( A r i a l, Font. PLAIN, 3 0 ) ; 10 private Container con ; 11 public DemoJScroll ( ) { 12 super ( DemoJScroll ) ; 13 s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame. EXIT ON CLOSE ) ; 14 con = getcontentpane ( ) ; 15 label. setfont ( fontgrande ) ; 16 con. add ( d e s p l aza ) ; 17 panel. add ( label ) ; 18 } 19 public static void main ( S t r i n g [ ] args ) { 20 f i n a l int ANCHO = 180; 21 f i n a l int ALTO = 100; 22 DemoJScroll unaventana = new DemoJScroll ( ) ; 23 unaventana. s e t S i z e (ANCHO, ALTO) ; 24 unaventana. s e t V i s i b l e ( true ) ; 25 } 26 } Código 10: Aplicación DemoJScroll. El objeto DemoJScroll en el programa del código 10 es puesto a propósito con un tamaño suficientemente pequeño (180x100) así una sola parte de la etiqueta que contiene es visible a la vez. Un usuario puede deslizar las barras de desplazamiento para ver la etiqueta completa. Al ejecutar la aplicación DemoJScroll muestra la ventana con barras de desplazamiento en dos lugares. 6. Eventos y su manejo La clase padre de todos los eventos es EventObject, la cual desciende de la clase Object. EventObject es el padre de AWTEvent, la cual a su vez es el padre de clases de eventos específicos como ActionEvent e ItemEvent. La clase abstracta AWTEvent está contenida en el paquete java.awt.event. La siguiente figura ilustra la jerarquía de herencia de estas relaciones. 18

19 java.lang.object +--java.util.eventobject +---java.awt.awtevent +---java.awt.event.actionevent +---java.awt.event.adjustmentevent +---java.awt.event.itemevent +---java.awt.event.textevent +---java.awt.event.componentevent +---java.awt.event.containerevent +---java.awt.event.focusevent +---java.awt.event.paintevent +---java.awt.event.windowevent +---java.awt.event.inputevent +---java.awt.event.keyevent +---java.awt.event.mouseevent En la figura previa, ComponentEvent es padre de varias clases de evento, incluyendo a InputEvent, la cual es padre de KeyEvent y MouseEvent. El árbol para eventos tiene descendencia que va lejos, pero los nombres de las clases son simples, y comparten tareas básicas dentro de los programas. Por ejemplo, ActionEvent son generados por componentes donde los usuarios pueden pulsar, como JButton y JCheckBox; TextEvent son generados por componentes en los cuales el usuario ingresa texto, tales como JTextField. MouseEvent incluyen determinar la posición del apuntador del ratón y la distinción entre una pulsación simple y una doble. El cuadro 3 lista algunas acciones comunes del usuario y los eventos que son generados por ellos. Acción del usuario Pulsar un botón Pulsar un componente Pulsar un elemento en un cuadro de lista Pulsar un elemento en una casilla de verificación Cambiar texto en un campo de texto Abrir una ventana Iconificar una ventana Presionar una tecla Tipo de evento resultante ActionEvent MouseEvent ItemEvent ItemEvent TextEvent WindowEvent WindowEvent KeyEvent Cuadro 3: Ejemplos de acciones del usuario y sus tipos de eventos resultantes. Como ActionEvent involucra al ratón, es fácil confundirlo con MouseEvent. Si se está interesado en ActionEvent, la atención está en los cambios de un componente, por ejemplo, un JButton en un JFrame siendo presionado; si se está interesado en MouseEvent, el foco está en lo que el usuario hace manualmente con el ratón, por ejemplo, pulsar el botón izquierdo del ratón. 19

20 Cuando se escriben programas con GUI, siempre se están manejando eventos que se originan con el ratón o teclas en componentes o contenedores específicos. El sistema operativo notifica al usuario cuando un AWTEvent ocurre, por ejemplo, cuando el ratón es pulsado. Se pueden ignorar los AWTEvent, y por lo tanto no producirán algún efecto. Para tener cuidado de los eventos se puede implementar una interfaz apropiada para la clase. Cada clase evento mostrada en el cuadro 3 tiene una interfaz receptora asociada con este, así para cada clase evento, <nombre>evento, hay una interfaz similar llamada <nombre>listener. Por ejemplo, ActionEvent tiene una interfaz ActionListener. La clase MouseEvent tiene un receptor adicional además de MouseListener que es MouseMotionListener. Cada método de la interfaz <nombre>listener tiene el tipo de regreso void, y cada uno toma un argumento: un objeto que es una instancia de la correspondiente clase <nombre>evento. Así, la interfaz ActionListener tiene un método manejador de evento llamado actionperformed(), y su cabecera es void actionperformed(actionevent e). Cuando una acción sucede, el método actionperformed() se ejecuta, y e representa una instancia de aquel evento. En vez de implementar una clase receptora, se puede extender una clase adaptadora. Una clase adaptadora implementa todos los métodos en una interfaz, con un cuerpo vacío para cada método. Por ejemplo, la clase MouseAdapter da un método vacío para todos los métodos contenidos en MouseListener. La ventaja de extender una clase adaptadora en vez de implementar una interfaz receptora es que sólo se necesita escribir los métodos que se quieren usar. Si un receptor tiene un sólo método, no hay necesidad de un adaptador, como con ActionListener. Si se usa un receptor o un adaptador, se crea un manejador de evento cuando se escribe código para los métodos receptores; es decir, se le dice a la clase como manejar el evento. Después de crear el manejador, se debe registrar una instancia de la clase con el componente que se quiere que el evento afecte. Para cualquier <name>listener, se debe usar la forma object.add<nombre>listener(component) para registrar un objeto con el Component que escuchará objetos. Los métodos add<nombre>listener(), tales como addactionlistener() y additemlistener(), todos trabajan de la misma forma. Ellos registran un receptor con un Component, regresan void, y toman un objeto <nombre>listener como un argumento. Por ejemplo, si un JFrame es un ActionListener y contiene un JButton llamado presióname, entonces la siguiente sentencia registra este JFrame como un receptor para el JButton presióname: presióname.addactionlistener(this); El cuadro 4 lista los eventos con sus receptores y manejadores. Ejemplo de manejo-evento KeyListener Se usa la interfaz KeyListener cuando se está interesado en acciones que el usuario inicia desde el teclado. La interfaz KeyListener contiene tres métodos: keypressed(), keytyped(), y keyreleased(). Para la mayoría de las aplicaciones de teclado, no es importante si se realiza la acción cuando el usuario primero presiona una tecla, durante la presión de la tecla, o hasta que la tecla sea soltada; probablemente estos eventos ocurren en secuencia rápida. Sin embargo, en aquellas ocasiones que no se quiere tomar acción mientras el usuario mantiene presionada la 20

21 Evento Receptor(es) Manejador(es) ActionEvent ActionListener actionperformed(actionevent) ItemEvent ItemListener itemstatechanged(itemevent) TextEvent TextListener textvaluechanged(textevent) AdjustmentEvent AdjustmentListener adjustmentvaluechanged- (AdjustmentEvent) ContainerEvent ContainerListener componentadded(containerevent) componentremoved(containerevent) ComponentEvent ComponentListener componentmoved(componentevent) componenthidden(componentevent) componentresized(componentevent) componentshown(componentevent) FocusEvent FocusListener focusgained(focusevent) focuslost(focusevent) MouseEvent MouseListener mousepressed(mouseevent) MouseMotionListener mousereleased(mouseevent) mouseentered(mouseevent) mouseexited(mouseevent) mouseclicked(mouseevent) mousedragged(mouseevent) mousemoved(mouseevent) KeyListener KeyEvent keypressed(keyevent) keytyped(keyevent) keyreleased(keyevent) WindowEvent WindowListener windowactivated(windowevent) windowclosing(windowevent) windowclosed(windowevent) windowdeiconified(windowevent) windowiconified(windowevent) windowopened(windowevent) MouseWheelEvent MouseWheelListener mousewheelmoved(mousewheelevent) Cuadro 4: Ejemplos de acciones del usuario y sus tipos de eventos resultantes. 21

22 tecla, se pueden colocar las acciones en el método keyreleased(). Lo mejor es usar el método keytyped() cuando se quiere descubrir que carácter fue tecleado. Cuando el usuario presiona una tecla que no genera un carácter, tal como una tecla función, llamadas a veces una tecla acción, keytyped() no es ejecutada. Los métodos keypressed() y keyreleased() dan las únicas formas para obtener información acerca de las teclas que no generan caracteres. La clase KeyEvent tiene constantes conocidas como códigos de teclas virtuales que representan las teclas que han sido presionadas. Por ejemplo, cuando se teclea A, dos códigos de teclas virtuales son generados: Cambio y a. Las constantes de códigos de teclas virtuales tienen nombres como VK SHIFT y VK ALT. La aplicación DemoJKeyFrame, código 11 usa el método keytyped() para saber cual fue la última tecla presionada por el usuario. 1 import java. awt. ; 2 import java. awt. event. ; 3 import javax. swing. ; 4 public class DemoJKeyFrame extends JFrame implements KeyListener { 5 private JLabel a v i s o = new JLabel ( P r e s i o n a r t e c l a s en e l campo de texto : ) ; 6 private JLabel e t i q u e t a S a l i d a = new JLabel ( ) ; 7 private JTextField t e x t F i e l d = new JTextField ( 1 0 ) ; 8 public DemoJKeyFrame ( ) { 9 s e t T i t l e ( Marco DemoJKeyFrame ) ; 10 s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame. EXIT ON CLOSE ) ; 11 add ( aviso, BorderLayout.NORTH) ; 12 add ( t e x t F i e l d, BorderLayout.CENTER) ; 13 add ( e t i q u e t a S a l i d a, BorderLayout.SOUTH) ; 14 t e x t F i e l d. addkeylistener ( this ) ; 15 } 16 public void keytyped ( KeyEvent e ) { 17 char c = e. getkeychar ( ) ; 18 e t i q u e t a S a l i d a. settext ( Última t e c l a presionada : + c ) ; 19 } 20 public void keypressed ( KeyEvent e ) { } 21 public void keyreleased ( KeyEvent e ) { } 22 public static void main ( S t r i n g [ ] args ) { 23 DemoJKeyFrame ventanakey = new DemoJKeyFrame ( ) ; 24 f i n a l int ANCHO = 250; 25 f i n a l int ALTO = 100; 26 ventanakey. s e t S i z e (ANCHO, ALTO) ; 27 ventanakey. s e t V i s i b l e ( true ) ; 28 } 29 } Código 11: Aplicación DemoJKeyFrame. Nota. Los programadores Java llaman a los eventos keytyped() eventos de nivel alto porque no dependen de la plataforma o el diseño del teclado. En cambio, los eventos keypressed() y keyreleased() son eventos nivel bajo y dependen de la plataforma y el diseño del teclado Al ejecutar la aplicación DemoJKeyFrame se muestra un indicador en el área del borde norte que pide al usuario teclear en el campo de texto del área central. Con cada tecla presionada, el método keytyped() cambia la etiqueta en el área de borde sur del marco para mostrar la tecla que fue generada por el KeyEvent más reciente. 22

23 7. Métodos de la clase AWTEvent Además de los métodos manejadores incluidos con las interfaces receptoras de eventos, las clases AWTEvent por sí mismas contienen otros métodos que devuelven información acerca de un evento. Por ejemplo, la clase ComponentEvent tiene el método getcomponent() que permite determinar cual de los múltiples Component generó el evento. La clase WindowEvent tiene un método similar, getwindow(), que devuelve la Window que es la fuente de un evento. El cuadro 5 lista algunos métodos útiles para varias clases de eventos. Todos los Component tienen estos métodos: addcomponentlistener() addfocuslistener() addmouselistener() addmousemotionlistener() Se puede llamar cualquiera de los métodos listados en el cuadro 5 usando el formato objeto-puntométodo que se usa con todos los métodos de instancia. Por ejemplo, si se tiene un KeyEvent llamado eventoentrada y un entero llamado valorunicode, la siguiente sentencia es válida: valorunicode = eventoentrada.getkeychar(); Cuando se usa un evento, se puede usar cualquiera de los métodos de evento, y por la herencia, se pueden también usar métodos que pertenezcan a cualquier superclase del evento. Por ejemplo, cualquier KeyEvent tiene acceso a los métodos InputEvent, ComponentEvent, AWTEvent, EventObject, y Object, al igual que los métodos KeyEvent. Coordenadas x e y El cuadro 5 refiere las coordenadas x-y de un apuntador de ratón. Una ventana o marco consiste de una cantidad de píxeles horizontales y verticales en la pantalla. Cualquier componente que se ponga en la pantalla tiene un posición horizontal, o eje x al igual que una posición vertical, eje y en la ventana. La esquina superior izquierda de cualquier pantalla es la posición 0,0. El primer valor, o coordenada x, se incrementa conforme se viaja de izquierda a derecha a través de la ventana. El segundo valor, coordenada y, se incrementa conforme se va de arriba hacia abajo. 8. Manejo de eventos del ratón La interfaz MouseMotionListener proporciona los métodos llamados mousedragged() y mouse- Moved() que detectan el ratón siendo movido o arrastrando a través de una superficie componente. La interfaz MouseListener da los métodos mousepressed(), mouseclicked(), y mousereleased() que son análogos a los métodos evento teclado keypressed(), keytyped(), y keyreleased() 23

24 boolean isshiftdown() Clase Método Propósito EventObject Object getsource() Regresa la referencia Object involucrada en el evento. ComponentEvent Component getcomponent() Regresa la referencia Component involucrada en el evento. WindowEvent Window getwindow() Regresa la referencia Window involucrada en el evento. ItemEvent Object getitem() Regresa la referencia Object que fue seleccionada o deseleccionada. int getstatechange() Regresa un entero llamado ItemEvent.SELECTED o ItemEvent.DESELECTED. InputEvent int getmodifiers() Regresa un entero para indicar cual botón del ratón fue pulsado. int getwhen() Regresa un tiempo indicando cuando el evento ocurrió. boolean isaltdown() Regresa si la tecla Alt fue presionada cuando el evento ocurrió. boolean iscontroldown() Regresa si la tecla Ctrl fue presionada cuando el evento ocurrió. Regresa si la tecla Shift fue presionada cuando el evento ocurrió. KeyEvent getkeychar() Regresa el carácter Unicode ingresado del teclado. MouseEvent getbutton() Regresa cual, si hay alguno, de los botones del ratón ha cambido, usa los campos NOBUTTON, BUTTON1, BUTTON2, y BUTTON3. getclickcount() int getx() int gety() Point getpoint() Cuadro 5: Métodos útiles de clases de eventos. Regresa el número de pulsaciones del ratón; permite identificar las dobles pulsaciones del usuario. Regresal la coordenada x del apuntador del ratón. Regresal la coordenada y del apuntador del ratón. Regresa el objeto Point que contiene las coordenadas x e y del lugar del ratón. 24

25 respectivamente. Sin embargo, con un ratón se está más interesado que sólo el botón presionado; en ocasiones se quiere saber a dónde el ratón apunta. Los métodos adicionales de la interfaz mouseentered() y mouseexited() informan cuando el usuario posiciona el ratón encima de un componente o mueve el ratón fuera de un componente. La interfaz MouseInputListener implementa todos los métodos de las interfaces MouseListener y MouseMotionListener; sin embargo no tiene métodos propios, pero es conveniente cuando se quiere manejar muchos tipos diferentes de eventos de ratón. Los cuadros 6 y 7 muestran los métodos de las clases MouseListener y MouseMotionListener, respectivamente. Método void mouseclicked(mouseevent e) void mouseentered(mouseevent e) void mouseexited(mouseevent e) void mousepressed(mouseevent e) void mousereleased(mouseevent e) Descripción Invocado cuando el botón del ratón ha sido pulsado (presionado y soltado) en un componente. Invocado cuando el apuntador del ratón ingresa en un componente. Invocado cuando el apuntador del ratón sale de un componente. Invocado cuando un botón del ratón ha sido presionado en un componente. Invocado cuando un botón del ratón ha sido soltado en un componente. Cuadro 6: Métodos MouseListener. Método void mousedragged(mouseevent e) void mousemoved(mouseevent e) Descripción Invocado cuando el apuntador del ratón es presionado en un componente y luego arrastrado. Invocado cuando el apuntador del ratón ha sido movido en un componente pero sin algún botón presionado. Cuadro 7: Métodos MouseMotionListener. Nota. La interfaz MouseWheelListener tiene sólo un método llamado mousewheelmoved(), y este acepta un argumento MouseWheelEvent. Cada uno de los métodos de los cuadros 6 y 7 aceptan un argumento MouseEvent. Un MouseEvent es el tipo de evento generado por la manipulación del ratón. En la siguiente figura se muestra la jerarquía de herencia de la clase MouseEvent. De ese diagrama, se puede ver que un MouseEvent es un tipo de InputEvent, el cual es un tipo de ComponentEvent. La clase MouseEvent contiene muchos métodos de instancia y campos que son útiles en describir eventos generados por el ratón. El cuadro 8 lista algunos de los métodos más útiles de la clase MouseEvent, y el cuadro 9 lista algunos campos. 25

26 java.lang.object +--java.util.eventobject +---java.awt.awtevent +---java.awt.event.componentevent +---java.awt.event.inputevent +---java.awt.event.mouseevent Método int getbutton() int getclickcount() int getx() int gety() Descripción Regresa cual, si hay, de los botones del ratón ha cambiado su estado; usa los campos NOBUTTON, BUTTON1, BUTTON2, y BUTTON3. Regresa la cantidad de pulsaciones del ratón asociado con el evento actual. Regresa la posición-x horizontal del evento relativa al componente fuente. Regresa la posición-y vertical del evento relativa al componente fuente. Cuadro 8: Métodos útiles de la clase MouseEvent. Campo static int BUTTON1 static int BUTTON2 static int BUTTON3 static int NOBUTTON static int MOUSE CLICKED static int MOUSE DRAGGED static int MOUSE ENTERED static int MOUSE EXITED Descripción Indica botón de ratón #1; usado por getbutton(). Indica botón de ratón #2; usado por getbutton(). Indica botón de ratón #3; usado por getbutton(). Indica ningún botón de ratón; usado por getbutton(). El evento ratón pulsado. El evento ratón arrastrado. El evento ratón ingresado. El evento ratón salido. Cuadro 9: Algunos campos útiles de la clase MouseEvent. La aplicación JFrameMouseAction, código 12, muestra varios de los métodos receptores y de eventos del ratón. JFrameMouseAction extiende JFrame, y como implementa la interfaz MouseListener, debe incluir todos los cinco métodos mouseclicked(), mouseentered(), mouseexited(), mouse- Pressed(), y mousereleased() a pesar de que no hay acciones incluidas en los métodos mouse- Pressed() y mousereleased(). 26

27 1 import java. awt. ; 2 import java. awt. event. ; 3 import javax. swing. ; 4 import static java. awt. event. MouseEvent. ; 5 public class JFrameMouseAction extends JFrame implements MouseListener { 6 private int x, y ; 7 private JLabel e t i q u e t a = new JLabel ( Haciendo algo con e l r a t ón ) ; 8 S t r i n g mensj = ; 9 public JFrameMouseAction ( ) { 10 s e t T i t l e ( Acciones d e l Ratón ) ; 11 s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame. EXIT ON CLOSE ) ; 12 setlayout (new FlowLayout ( ) ) ; 13 addmouselistener ( this ) ; 14 add ( e t i q u e t a ) ; 15 } 16 public void mouseclicked ( MouseEvent e ) { 17 int cualboton = e. getbutton ( ) ; 18 mensj = Se p r e s i o n ó e l ; 19 i f ( cualboton == BUTTON1) 20 mensj += botón 1. ; 21 else i f ( cualboton == BUTTON2) 22 mensj += botón 2. ; 23 else 24 mensj += botón 3. ; 25 mensj += Se e s t á en l a p o s i c i ón + 26 e. getx ( ) +, + e. gety ( ) +. ; 27 i f ( e. getclickcount ( ) == 2) 28 mensj += Hizo una doble p u l s a c i ón. ; 29 else 30 mensj += Hizo una p u l s a c i ón simple. ; 31 e t i q u e t a. settext ( mensj ) ; 32 } 33 public void mouseentered ( MouseEvent e ) { 34 mensj = Se entró a l marco. ; 35 e t i q u e t a. settext ( mensj ) ; 36 } 37 public void mouseexited ( MouseEvent e ) { 38 mensj = Se s a l i ó d e l marco. ; 39 e t i q u e t a. settext ( mensj ) ; 40 } 41 public void mousepressed ( MouseEvent e ) { } 42 public void mousereleased ( MouseEvent e ) { } 43 public static void main ( S t r i n g [ ] args ) { 44 JFrameMouseAction ventana = new JFrameMouseAction ( ) ; 45 f i n a l int ANCHO = 750; 46 f i n a l int ALTO = 300; 47 ventana. s e t S i z e (ANCHO, ALTO) ; 48 ventana. s e t V i s i b l e ( true ) ; 49 } 50 } Código 12: La aplicación JFrameMouseAction. Al ejecutar la aplicación JFrameMouseAction muestra mensaje conforme el usuario genera acciones 27

28 del ratón. Al inicio de la clase, en la línea 6, dos enteros son declarados para guardar las coordenadas x-y de la posición del ratón. Un JLabel y un String son también declarados, en las líneas 7 y 8, para guardar mensajes que informan al usuario de las acciones hechas con el ratón. El constructor, líneas 9 15, pone el título del JFrameMouseAction, pone la operación de cierra, pone el manejador de diseño, habilita al marco para escuchar los eventos del ratón, y agrega el JLabel al JFrame. La mayoría de las acciones ocurren en el método mouseclicked(). En este método se construye un String que al final es asignado al JLabel. Las mismas acciones podrían haber sido colocadas en el método mousepressed() o mousereleased(). Dentro del método mouseclicked(), el objeto MouseEvent llamado e es usado varios veces. Se usa con el método getbutton() para determinar cual botón del ratón el usuario ha pulsado, con getx() y gety() para recuperar la posición del ratón donde se pulsó, y con getclickcount() para distinguir entre una pulsación simple y una doble. El usuario es notificado cuando el apuntador del ratón ha entrado al JFrame, y también cuando ha salido mediante mensajes diferentes generados por los métodos mouseentered() y mouseexited() respectivamente. El método main() al final de la clase crea una instancia de la clase JFrameMouseAction y fija su tamaño y visibilidad. 9. Uso de menús Los menús son listas de opciones; estas son características agregadas en programas GUI. Las aplicaciones de usuario son usadas para ver una barra de menú horizontal a lo largo de la parte superior del marco, y se espera que se puedan pulsar estas opciones para producir listas descendentes que muestran más opciones. La lista horizontal de varias JMenu es una JMenuBar. Cada JMenu puede contener opciones, llamadas JMenuItems, o puede contener submenús que también son JMenu. La aplicación JFrameMenu, código 13, muestra un JFrame que muestra el uso de los siguientes componentes: Un JMenuBar que contiene dos JMenu llamados archivo y colores. Tres elementos dentro del JMenu colores: claro, oscuro, blanco. oscuro y blanco son JMenuItems. claro es un JMenu que tiene un submenu. Se puede decir que claro es un submenú porque una flecha está a la derecha de su nombre, y cuando el ratón se pone encima de claro, dos JMenuItem adicionales aparecen: rosa y amarillo. Para generar la salida dada por la ejecución de la aplicación JFrameMenu, un conjunto de objetos JMenuBar, JMenu, y JMenuItem fueron creados y puestos juntos en etapas. Se crean cada uno de los componentes como sigue: 1. Crear un JMenuBar: JMenuBar BarraPrinc = new JMenuBar(); 2. Crear los dos JMenu que son parte del JMenuBar: 28

29 JMenu archivo = new JMenu("Archivo"); JMenu colores = new JMenu("Colores"); 3. Los tres componentes dentro del JMenu colores son creados como sigue: JMenu claro = new JMenu("Claro"); JMenuItem oscuro = new JMenuItem("Oscuro"); JMenuItem blanco = new JMenuItem("Blanco"); 4. Los dos JMenuItem que son partes del JMenu Claro son creados así: JMenuItem rosa = new JMenuItem("Rosa"); JMenuItem amarillo = new JMenuItem("Amarillo"); 5. Después de que los componentes son creados, se ensamblan. Se agrega el JMenuBar a un JFrame usando el método setjmenubar() como sigue: setjmenubar(barraprinc); Usando el método setjmenubar() asegura que la barra de menú es anclada a la cima del marco y parece una barra de menú convencional. Observar que el JMenuBar no es agregado al panel de contenido del JFrame; este es agregado al JFrame por sí mismo. 6. Los JMenu son agregados al JMenuBar usando el método add(). Por ejemplo: BarraPrinc.add(archivo); BarraPrinc.add(colores); 7. Un submenú y dos JMenuItem son agregados al menú colores como se muestra enseguida: colores.add(claro); colores.add(oscuro); colores.add(blanco); 8. Un submenú puede contener sus propios JMenuItem. Por ejemplo, el JMenu claro que es parte del menú colores contiene sus dos objetos propios JMenuItem: claro.add(rosa); claro.add(amarillo); El código 13 muestra un programa completo que crea un marco con un saludo y el JMenu descrito previamente. 29

30 1 import java. awt. ; 2 import java. awt. event. ; 3 import javax. swing. ; 4 public class JFrameMenu extends JFrame implements A c t i o n L i s t e n e r { 5 private JMenuBar BarraPrinc = new JMenuBar ( ) ; 6 private JMenu a r c h i v o = new JMenu( Archivo ) ; 7 private JMenu c o l o r e s = new JMenu( Colores ) ; 8 private JMenuItem s a l i r = new JMenuItem ( S a l i r ) ; 9 private JMenu c l a r o = new JMenu( Claro ) ; 10 private JMenuItem oscuro = new JMenuItem ( Oscuro ) ; 11 private JMenuItem blanco = new JMenuItem ( Blanco ) ; 12 private JMenuItem rosa = new JMenuItem ( Rosa ) ; 13 private JMenuItem a m a r i l l o = new JMenuItem ( Amarillo ) ; 14 private JLabel e t i q u e t a = new JLabel ( Hola ) ; 15 public JFrameMenu ( ) { 16 s e t T i t l e ( Demostración de Menú ) ; 17 s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame. EXIT ON CLOSE ) ; 18 setlayout (new FlowLayout ( ) ) ; 19 setjmenubar ( BarraPrinc ) ; 20 BarraPrinc. add ( a rchivo ) ; 21 BarraPrinc. add ( c o l o r e s ) ; 22 archivo. add ( s a l i r ) ; 23 c o l o r e s. add ( c l a r o ) ; 24 c o l o r e s. add ( oscuro ) ; 25 c o l o r e s. add ( blanco ) ; 26 c l a r o. add ( rosa ) ; 27 c l a r o. add ( a m a r i l l o ) ; 28 s a l i r. addactionlistener ( this ) ; 29 oscuro. addactionlistener ( this ) ; 30 blanco. addactionlistener ( this ) ; 31 rosa. addactionlistener ( this ) ; 32 a m a r i l l o. addactionlistener ( this ) ; 33 add ( e t i q u e t a ) ; 34 e t i q u e t a. setfont (new Font ( A r i a l, Font.BOLD, 2 6 ) ) ; 35 } 36 public void actionperformed ( ActionEvent e ) { 37 Object source = e. getsource ( ) ; 38 Container con = getcontentpane ( ) ; 39 i f ( source == s a l i r ) 40 System. e x i t ( 0 ) ; 41 else i f ( source == oscuro ) 42 con. setbackground ( Color.BLACK) ; 43 else i f ( source == blanco ) 44 con. setbackground ( Color.WHITE) ; 45 else i f ( source == rosa ) 46 con. setbackground ( Color. PINK ) ; 47 else 48 con. setbackground ( Color.YELLOW) ; 49 } 50 public static void main ( S t r i n g [ ] args ) { 51 JFrameMenu ventana = new JFrameMenu ( ) ; 52 f i n a l int ANCHO = 250; 53 f i n a l int ALTURA = 2 00; 54 ventana. s e t S i z e (ANCHO, ALTURA) ; 55 ventana. s e t V i s i b l e ( true ) ; 56 } 57 } 30 Código 13: La aplicación JFrameMenu.

31 En la aplicación JFrameMenu, cada JMenuItem se convierte en una fuente para una ActionEvent, y al JFrame se le asigna el papel de receptor para cada uno. El método actionperformed() determina la fuente de cualquier evento generado. Si el usuario selecciona la opción Salir del menú Archivo, la aplicación termina. Si el usuario selecciona cualquiera de los colores del menú Colores, el color del fondo del JFrame es modificado en consecuencia. Uso de objetos JCheckBoxMenuItem y JRadioButtonMenuItem Las clases JCheckBoxMenuItem y JRadioButtonMenuItem derivan de la clase JMenuItem. Cada una proporciona elementos de menú más específicos como sigue: Los objetos JCheckBoxMenuItem aparecen seguido de una casilla de verificación. Un elemento puede ser seleccionado, mostrando una marca de verificación en la casilla, o no. Se usan los elementos de casilla de verificación para apagar o encender opciones. Los objetos JRadioButtonMenuItem aparecen seguidos de un botón circular de radio. Se espera que los botones de radio sean mutuamente excluyentes, así que se hacen parte de un ButtonGroup. Luego, cuando cualquiera de los botones de radio es seleccionado, todos los otros no quedan seleccionados. El estado de un JCheckBoxMenuItem o un JRadioButtonMenuItem puede ser determinado con el método isselected(), y se puede modificar el estado de la casilla de verificación con el método setselected(). La aplicación JFrameMenu2, código 14, muestra dos JCheckBoxMenuItem y tres JRadioButtonMenuItem han sido agregados a un JMenu. A los controles no se les ha asignado todavía alguna tarea. 31

32 1 import java. awt. ; 2 import java. awt. event. ; 3 import javax. swing. ; 4 public c l a s s JFrameMenu2 extends JFrame { 5 private JMenuBar BarraPrinc = new JMenuBar ( ) ; 6 private JMenu menu1 = new JMenu( Archivo ) ; 7 private JCheckBoxMenuItem v e r i f i c a 1 = new 8 JCheckBoxMenuItem ( Marcar c a j a A, true ) ; 9 private JCheckBoxMenuItem v e r i f i c a 2 = new 10 JCheckBoxMenuItem ( Marcar c a j a B ) ; 11 private JRadioButtonMenuItem r a d i o 1 = new 12 JRadioButtonMenuItem ( Radio opción 1, true ) ; 13 private JRadioButtonMenuItem r a d i o 2 = new 14 JRadioButtonMenuItem ( Radio opción 2 ) ; 15 private JRadioButtonMenuItem r a d i o 3 = new 16 JRadioButtonMenuItem ( Radio opción 3 ) ; 17 private ButtonGroup grupo = new ButtonGroup ( ) ; public JFrameMenu2 ( ) { 20 s e t T i t l e ( Demostración de Menús 2 ) ; 21 s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame. EXIT ON CLOSE ) ; 22 setlayout (new FlowLayout ( ) ) ; 23 setjmenubar ( BarraPrinc ) ; 24 BarraPrinc. add (menu1 ) ; 25 menu1. add ( v e r i f i c a 1 ) ; 26 menu1. add ( v e r i f i c a 2 ) ; 27 menu1. addseparator ( ) ; 28 menu1. add ( r a d i o 1 ) ; 29 menu1. add ( r a d i o 2 ) ; 30 menu1. add ( r a d i o 3 ) ; 31 grupo. add ( r a d i o 1 ) ; 32 grupo. add ( r a d i o 2 ) ; 33 grupo. add ( r a d i o 3 ) ; 34 } public static void main ( S t r i n g [ ] args ) { 37 JFrameMenu2 ventana = new JFrameMenu2 ( ) ; 38 f i n a l int ANCHO = 300; 39 f i n a l int ALTO = 200; 40 ventana. s e t S i z e (ANCHO, ALTO) ; 41 ventana. s e t V i s i b l e ( true ) ; 42 } 43 } Código 14: Aplicación JFrameMenu2. Uso de addseparator() Al ejecutar la aplicación JFrameMenu2 y pulsar en la opción Archivo del menú, se observa una línea horizontal que separa en grupos las opciones. Este separador es agregado usando el método addseparator() en la línea 27 del código 14. El separador no cambia la funcionalidad del menú; simplemente hace el ménu más organizado visualmente para el usuario. 32

33 Uso de setmnemonic() Un mnemónico ó nemónico es una tecla que causa que un elemento de menú pueda ser escogido por esta. Se puede usar el método setmnemonic() para dar una tecla de menú breve para cualquier elemento visible del menú. Por ejemplo, cuando se agrega la siguiente sentencia al constructor JFrameMenu2, en el código 14, se permite usar una combinación de teclas para acceder la opción: menu1.setmnemonic( A ); El nemónico para el menú Archivo es puesta a A, así la A en Archivo está subrayada. Cuando un usuario presiona Alt+A en el teclado, el resultado es el mismo si el usuario hubiera pulsado Archivo en el menú: la lista de menú es abierta y mostrada. Se deberán usar diferentes nemónicos para cada elemento del menú que tengan una; si se usa el mismo nemónico varias veces, sólo la primera asignación trabaja. Generalmente, se usa la primera letra de la opción. Si varios elementos del menú inician con la misma letra, la convención es escoger la siguiente letra más prominente en el nombre. Un acelerador es similar a un nemónico. Este es una combinación de teclas que cause que un elemento del menú sea escogido si está o no visible. Por ejemplo, varios programas permiten presionar CTRL+P para imprimir desde cualquier lugar en el programa. Solo elementos menú hoja menús que no despliegan otros menús pueden tener aceleradores. Por ejemplo, para asociar el acelerador CTRL+A para la opción del menú Marcar caja A, se deberá poner en el constructor de JFrameMenu2 del código 14 lo siguiente: radio1.setaccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_A, Event.CTRL_MASK)); Actividad 2. Crear una aplicación para una empresa de eventos sociales la cual usa una barra de menús con opciones múltples, y que usa varios JPanel separados con diferentes manejadores de diseño para organizar los componentes. 33