Download universidad católica de cuenca unidad académica de ingeniería de
Document related concepts
no text concepts found
Transcript
UNIVERSIDAD CATÓLICA DE CUENCA UNIDAD ACADÉMICA DE INGENIERÍA DE SISTEMAS, ELÉCTRICA Y ELECTRÓNICA COMPONENTE SWING DE JAVA: ADMINISTRADORES DE DISEÑO Trabajo de Investigación previo a la obtención del Título de Ingeniero de Sistemas. Aspirante: TNLG. ANL. FREDDY E. QUEZADA B. Director: ING. ALÌ MÉNDEZ. Certifico que esta investigación ha sido desarrollada en su totalidad por el Tnlg. Freddy Edwin Quezada Bermeo bajo mi coordinación. F)………………………………………………………………. ING. ALI MÉNDEZ. La información de la presente investigación es de absoluta responsabilidad y propiedad del autor. F)………………………………………………………………. TNLG. ANL. FREDDY EDWIN QUEZADA BERMEO DEDICATORIA: Este trabajo investigativo tengo el honor de dedicar a mi esposa Adriana a mi hijo que son la razón de mi esfuerzo y por acompañarme incondicionalmente en los momentos de mi vida ; a mis queridos Padres que supieron educarme con valores y acercar cada vez más las metas propuestas en la vida profesional como en la vida cotidiana. AGRADECIMIENTO: A las personas que supieron ayudarme para que esta investigación fuera realizada, Mis queridos hermanos; y un agradecimiento especial al ING. ALI MÉNDEZ por guiarme en el proceso de elaboración de esta monografía. ÍNDICE UNIVERSIDAD CATÓLICA DE CUENCA .......................................................... 1 CAPÍTULO I ........................................................................................................ 2 1.1 Historia .......................................................................................................... 2 1.2 Ventajas y Características ............................................................................ 3 1.2.1 componentes ligeros .................................................................................. 3 1.2.2 Independencia de la plataforma ................................................................. 4 1.2.3 Paquete Swing ........................................................................................... 4 1.2 Eventos Swing .............................................................................................. 7 1.3 Modelos de componentes Swing .................................................................. 8 Swing llamando a métodos. .............................................................................. 10 1.4 Descripción de algunos componentes Swing.............................................. 10 CAPÍTULO II ..................................................................................................... 13 2.1. Layouts ...................................................................................................... 13 2.2. Look &Feel ................................................................................................. 13 2.3. Nuevas características ............................................................................... 15 2.3.1 Action Con objetos Action ........................................................................ 15 2.4. Modelos de datos y estados separados ..................................................... 15 2.5. Soporte para tecnologías asistivas ............................................................ 16 2.6. Applets ....................................................................................................... 16 Estructura De Un Applet ................................................................................... 17 2.6.1. Applets en Swing .................................................................................... 18 CAPITULO III .................................................................................................... 19 3.1. Herencia de Componentes y Contenedores .............................................. 19 3.2. Control de Distribución ............................................................................... 21 3.2.1. Seleccionar el Controlador de Distribución ............................................. 23 3.2.2. Proporcionar Consejos sobre un Componente ...................................... 24 3.2.3 Poner Espacio entre Componentes ......................................................... 25 3.2.3.1. El controlador de distribución. .............................................................. 25 3.2.3.3. Bordes vacíos ...................................................................................... 25 3.2.4. Cómo Ocurre el Control de Distribución ................................................. 26 3.3. Construcción de GUI en Swing .................................................................. 27 3.3.1 Ventanas .................................................................................................. 27 3.3.2. Menús ..................................................................................................... 28 3.3.3. Paneles ................................................................................................... 28 3.3.4. Diseños ................................................................................................... 28 3.3.5. Iconos ..................................................................................................... 29 1 3.3.6. Bordes..................................................................................................... 29 3.3.7. Información sobre herramientas ............................................................. 29 3.3.8. Barras de herramientas........................................................................... 29 3.3.9. Etiquetas y botones ................................................................................ 30 3.3.10. Componentes de texto .......................................................................... 30 3.3.11. Listas y cuadros combinados ................................................................ 30 3.3.12. Deslizadores y barras de progreso ....................................................... 31 3.3.13. Barras de desplazamiento .................................................................... 31 3.3.14. Tablas ................................................................................................... 31 3.3.15. Árboles .................................................................................................. 32 3.4. Manejo de eventos en Swing ..................................................................... 32 3.5. Swing: Cuadros de texto. Botones y casillas de activación ....................... 33 3.5. 1. Etiquetas y cuadros de texto .................................................................. 34 3.5. 2. Botones .................................................................................................. 34 3.5.3. Casillas de activación y botones de opción............................................. 35 3.5.4. Usar etiquetas ......................................................................................... 35 3.6. Swing: viewports. desplazamiento. deslizadores y listas ........................... 36 3.6.1. Viewports ................................................................................................ 37 3.6.2. Paneles de desplazamiento .................................................................... 37 3.6.3. Deslizadores ........................................................................................... 37 3.6.4. Barras de desplazamiento ...................................................................... 38 3.6.5. Listas....................................................................................................... 38 3.7. Swing: barras. Herramientas. Cuadros. Separadores y selectores ............ 39 3.7.1. Cuadros combinados .............................................................................. 39 3.7.2. Barras de progreso ................................................................................. 39 3.7.3. Selectores ............................................................................................... 40 3.7.4. Herramientas de ayuda ........................................................................... 41 3.7.5. Separadores ........................................................................................... 41 3.8. Swing: ventanas. Paneles. Marcos internos y cuadros de dialogo ............ 42 3.8.1. Ventanas ................................................................................................. 42 3.8.2. Cuadros de diálogo ................................................................................. 42 3.9. Creación de paquetes. Interfaces. archivos JAR y Java Beans ................. 43 3.9.1. Crear un paquete .................................................................................... 43 3.9.2. Crear paquetes que contienen paquetes ................................................ 45 3.9.3 Crear una interfaz .................................................................................... 45 3.9.4. Implementación parcial de una interfaz .................................................. 46 3.9.5. Crear un archivo JAR ............................................................................. 48 3.9.6. Obtener los contenidos del archivo JAR ................................................ 50 2 3.9.7. Extraer archivos desde un archivo JAR ................................................ 51 3.10. SwingUtilities ............................................................................................ 51 3.10.1. Métodos de cálculo .............................................................................. 52 3.10.2. Métodos de conversión ......................................................................... 52 3.10.3. Métodos de accesibilidad ...................................................................... 54 3.10.4 Métodos de recuperación....................................................................... 54 3.10.5.Métodos relacionados con la multitarea y los eventos ........................... 55 3.10.6. Métodos para los botones del ratón ...................................................... 56 3.10.7 Métodos de disposición/dibujo/UIString ................................................. 56 4. Conclusiones .............................................................................................. 58 5. Recomendaciones ....................................................................................... 59 6. Bibliografía .................................................................................................... 61 Anexos. ............................................................................................................. 62 INTRODUCCIÓN. ............................................................................................. 62 DATOS INFORMATIVOS. ................................................................................ 63 LUGARES DE CONSULTA. ............................................................................. 63 JUSTIFICACIÓN Y PROPUESTA. ................................................................... 63 4.1. ANÁLISIS DE LA SITUACIÓN ACTUAL ................................................ 64 4.2. PROPUESTA. ........................................................................................ 64 OBJETIVOS. ..................................................................................................... 65 5.1. Objetivo General. ................................................................................... 65 5.2 Objetivos Específicos: ............................................................................. 65 ALCANCE Y LIMITACIONES. .......................................................................... 65 6.1 Alcances. ................................................................................................. 65 6.2. Limitaciones. .......................................................................................... 65 MARCO REFERENCIAL Y CONCEPTUAL. ..................................................... 66 7.1. Marco Referencial. ................................................................................. 66 7.2. Marco Conceptual. ................................................................................. 66 TEMARIO.......................................................................................................... 67 ESTRATEGIAS METODOLÓGICAS. ............................................................... 69 RECURSOS...................................................................................................... 70 Recursos Humanos. ...................................................................................... 70 Recursos Tecnológicos. ................................................................................ 70 Recursos Materiales. ..................................................................................... 70 Recursos Económicos. .................................................................................. 71 BIBLIOGRAFÍA. ................................................................................................ 71 CRONOGRAMA ............................................................................................... 72 3 INTRODUCCIÓN Esta Investigación pretende ser una introducción a Swing, con la que se intenta mostrar una visión general sobre herramientas de interfaces gráficas de usuario, y más concretamente, sobre el desarrollo de éstas con Java y sus APIs, lo que se pretende mostrar las ventajas que ofrece éste tipo de programación. En primer lugar, se realiza una introducción a Swing, el AWT y las interfaces de usuario, tratando de ésta forma de centrar al lector en el tema a tratar. Una vez realizada dicha introducción, se describirá brevemente el paquete Swing, para dar una idea de la jerarquía de componentes que se puede utilizar con Swing y de sus utilidades. También se mencionará el manejo de eventos en Swing, así como los Applets, aunque de una forma muy superficial, ya que debido a la gran amplitud de variaciones que pueden darse, sería muy extenso hacer una descripción detallada. 1 CAPÍTULO I 1.1 Historia AWT era una herramienta poderosa que impulsó la popularidad de Java. Ahora Swing, que tiene aproximadamente cuatro veces el número de componentes de la interfaz de usuario de AWT, es parte de la distribución estándar de Java y está tan de moda que ha llegado a desplazar a AWT. Sin embargo, AWT tuvo un avance significativo durante su existencia, aunque es, para los estándares de hoy, una implementación limitada, no diseñada para proporcionar una UI seria y básica para las necesidades de millones de programadores.El conjunto de componentes AWT no fue diseñado para soportar la popularidadcon la que fue recibido y dentro de las necesidades de programación dehoy, está limitado en el rango, tiene muchos bugs y consume gran cantidad derecursos del sistema.Como se mencionó anteriormente en este libro, el AWT original se tardóen escribir sólo seis semanas, fue modelado con controles HTML y asignadauna ventana del sistema operativo por componente. Dado que los programadoresllegaban a utilizar gran cantidad de controles, los colaboradores empezarona producir sus propios conjuntos de controles, lo que hizo que en SunMicrosystems se pusieran nerviosos. Cuando Netscape introdujo su libreríade clases ZnternetFoundationClasses para usar con Java, éstas fueron muypopulares, Sun decidió actuar y la unión de los esfuerzos de Sun y Netscapedio lugar al conjunto de componentes Swing como parte de las ClasesFoundation de Java (JFC). 2 Muchos programadores creen que JFC y Swing son lo mismo, pero no esasí; JFC contiene Swing y otro gran número de elementos. Esto es lo que hayen JFC: Swing: El gran paquete UI. Cortar y pegar: Soporte de portapapeles. Accesibilidad: Ayuda a los usuarios con aquello que no es posible hacer. Colores del escritorio: Primero se introdujo en Java 1.1.Java 2D: Soporte mejorado del color, imagen y texto. Impresión: Originalmente disponible en Java 1.1. Swing introdujo tres avances significativos: Utiliza pocos recursos delsistema, añade gran cantidad de componentes más sofisticados y permiteconstruir la apariencia de los programas. 1.2 Ventajas y Características 1.2.1 componentes ligeros A los componentes Swing se les denomina ligeros mientras que a los componentes AWT se lesdenominados pesados. La diferencia entre componentes ligeros y pesados es su orden: la noción deprofundidad. Cada componente pesado ocupa su propia capa de orden Z. Todos los componentes ligerosse encuentran dentro de componentes pesados y mantienen su propio esquema de capas definido porSwing. Cuando colocamos un componente pesado dentro de un contenedor que también lo es, sesuperpondrá por definición a todos los componentes ligeros del contenedor.Lo que esto significa es que debemos intentar evitar el uso de componentes ligeros y pesados en unmismo contenedor siempre que sea posible. Esto no significa que no podamos mezclar nunca con éxitocomponentes AWT y Swing, sólo que tenemos que tener cuidado y saber qué situaciones son seguras ycuáles no. Puesto que probablemente 3 no seremos capaces de prescindir completamente del uso decomponentes pesados en un breve espacio de tiempo, debemos encontrar formas de que las dostecnologías trabajen juntas de manera aceptable. La regla más importante a seguir es que no deberíamos colocar componentes pesados dentro decontenedores ligeros, que comúnmente soportan hijos que se superponen. Algunos ejemplos de este tipode contenedores son JInternalFrame, JScrollPane, JLayeredPane, y JDesktopPane. Ensegundo lugar, si usamos un menú emergente en un contenedor que posee un componente pesado,tenemos que forzar a dicho menú a ser pesado. Para controlar esto en una instancia específica deJPopupMenu podemos usar su método setLightWeightPopupEnabled(). Alternativamente podemos llamar al método estático setDefaultLightWeightPopupEnabled()de JPopupMenu y pasarle un valor false para forzar a todos los menús emergentes de una sesión deJava a ser pesados. Tenga en cuenta que sólo afectará a los menús emergentes creados a partir de que seha hecho la llamada. Es por eso una buena idea llamar a este método durante la inicialización. 1.2.2 Independencia de la plataforma La característica más notable de los componentes Swing es que están escritos al 100% en Java y nodependen de componentes nativos, como sucede con casi todos los componentes AWT. Esto significaque un botón Swing y un área de texto se verán y funcionarán idénticamente en las plataformasMacintosh, Solaris, Linux y Windows. Este diseño elimina la necesidad de comprobar y depurar lasaplicaciones en cada plataforma destino. 1.2.3 Paquete Swing javax.swingContiene la mayor parte de los componentes básicos de Swing, modelos de componente pordefecto, e interfaces. javax.swing.borderClases e interfaces que se usan para definir estilos de bordes específicos. Observe que los bordespueden ser compartidos por 4 cualquier número de componentes Swing, ya que no soncomponentes por si mismos. javax.swing.colorchooserClases e interfaces que dan soporte al componente JColorChooser, usado para selección decolores. javax.swing.eventEl paquete contiene todos los oyentes y eventos específicos de Swing. Los componentes Swingtambién soportan eventos y oyentes definidos en java.awt.event y java.beans. javax.swing.filechooser Clases e interfaces que dan soporte al componente JFileChooser, usado para selección deficheros. javax.swing.plaf Contiene el API del comportamiento y aspecto conectable usado para definir componentes deinterfaz de usuario personalizados. La mayoría de las clases de este paquete son abstractas. Lasimplementaciones de look-and-feel, como metal, motif y basic, crean subclases e implementanlas clases de este paquete. Éstas están orientadas a desarrolladores que, por una razón u otra, nopueden usar uno de los look-and-feel existentes. javax.swing.plaf.basic Consiste en la implementación del Basic look-and-feel, encima del cual se construyen loslookand-feels que provee Swing. Normalmente deberemos usar las clases de este paquete siqueremos crear nuestro look-and-feel personal. javax.swing.plaf.metal Metal es el look-and-feel por defecto de los componentes Swing. Es el único look-and-feel queviene con Swing y que no está diseñado para ser consistente con una plataforma específica. 5 javax.swing.plaf.multi Este es el Multiplexing look-and-feel.No se trata de una implementación normal de look-andfeelya que no define ni el aspecto ni el comportamiento de ningún componente. Más bienofrece la capacidad de combinar varios look-and-feels para usarlos simultáneamente. Unejemplo típico podría ser un look-and-feel de audio combinado con metal o motif. ActualmenteJava 2 no viene con ninguna implementación de multiplexing look-and-feel. javax.swing.table Clases e interfaces para dar soporte al control de JTable. Este componente se usa para manejardatos en forma de hoja de cálculo. Soporta un alto grado de personalización sin requerir mejorasde look-and- feel.javax.swing.textClases e interfaces usadas por los componentes de texto, incluyendo soporte para documentoscon o sin estilo, las vistas de estos documentos, resaltado, acciones de editor y personalizacióndel teclado. javax.swing.text.html Esta extensión del paquete text contiene soporte para componentes de texto HTML. (El soportede HTML está siendo ampliado y reescrito completamente mientras escribimos este libro. Espor ello que la cobertura que le damos es muy limitada.) javax.swing.text.html.parser Soporte para analizar gramaticalmente HTML. javax.swing.text.rtf Contiene soporte para documents RTF. 6 javax.swing.tree Clases e interfaces que dan soporte al componente JTree. Este componente se usa para mostrary manejar datos que guardan alguna jerarquía. Soporta un alto grado de personalización sin requerir mejoras de look-and-feel. javax.swing.undo El paquete undo contiene soporte para implementar y manejar la funcionalidaddeshacer/rehacer. 1.2 Eventos Swing El modelo de eventos que utiliza Swing es el mismo que AWT, el de Java 1.1, añadiendoalgunos nuevos eventos para los nuevos componentes. Utilizando igualmente las interfacesListener, las clases Adapter o las clases anónimas para registrar los objetos que se encargaran de gestionar los eventos.Algunos de los nuevos eventos son: a.) Eventos de bajo nivel MenuKeyEventç MenuDragMouseEvent b.) Eventos de alto nivel AncestorEvent: Antecesor añadido desplazado o eliminado. CaretEvent: El signo de intercalación del texto ha cambiado. ChangeEvent: Un componente ha sufrido un cambio de estado. DocumentEvent: Un documento ha sufrido un cambio de estado. HyperlinkEvent: Algo relacionado con un vínculo hipermedia ha cambiado. 7 InternalFrameEvent: Un AWTEvent que añade soporte para objetosJInternalFrame. ListDataEvent: El contenido de una lista ha cambiado o se ha añadido o eliminadoun intervalo. ListSelectionEvent: La selección de una lista ha cambiado. MenuEvent: Un elemento de menú ha sido seleccionado o mostrado o bien noseleccionado o cancelado. PopupMenuEvent: Algo ha cambiado en JPopupMenu. TableColumnModelEvent: El modelo para una columna de tabla ha cambiando. TableModelEvent: El modelo de una tabla ha cambiado. TreeExpansionEvent: El nodo de un árbol se ha extendido o se ha colapsado. TreeModelEvent: El modelo de un árbol ha cambiado. TreeSelectionEvent: La selección de un árbol ha cambiado de estado. UndoableEditEvent: Ha ocurrido una operación que no se puede realizar. 1.3 Modelos de componentes Swing En principio implementa de nuevo todos los componentes gráficos existente en el AWT, pero en este caso con implementaciones ligeras, o lighweight, con todas las ventajas que esto implica. Además añade nuevas y útiles funcionalidades a estos componentes, tales como la posibilidad de presentar imágenes o animaciones en botones, etiquetas, listas o casi cualquier elemento gráfico. 8 Este paquete nuevo está enteramente basado en AWT y más específicamente en el soporte para interfaz de usuario ligero. Debido a ello y a ser puro Java, es posible hacer aplicaciones basadas en Swing desde la plataforma 1.1.5 y que funcione sin ningún problema con la JVM de dicha plataforma, así como con la incluida junto con los navegadores más actuales, lo que asegura que un applet realizado usando estos nuevos componentes funcionará sin problemas en dichos navegadores. Entre los componentes que se incorporan en Swing está la reimplementación de todos los componentes gráficos existentes en AWT y que, para no confundir con los antiguos, ahora empiezan todos por J. Así en vez de Button, tenemos JButton. La mayor diferencia entre los componentes AWT y los componentes Swing es que éstos últimos están implementados sin nada de código nativo. Esto significa que los componentes Swing pueden tener más funcionalidad que los componentes AWT, porque no están restringidos al denominador común, es decir las características presentes en cada plataforma. El no tener código nativo también permite que los componentes Swing sean vendidos como añadidos al JDK 1.1, en lugar de sólo formar parte del JDK 1.2. Incluso el más sencillo de los componentes Swing tiene capacidades que van más allá de lo que ofrecen los componentes AWT. Por ejemplo: Los botones y las etiquetas Swing pueden mostrar imágenes en lugar de o además deltexto. 9 Se pueden añadir o modificar fácilmente los bordes dibujados alrededor de casicualquier componente Swing. Por ejemplo, es fácil poner una caja alrededor de uncontenedor o una etiqueta. Se puede modificar fácilmente el comportamiento o la apariencia de un componente Swing llamando a métodos. Los componentes Swing no tienen porque ser rectangulares. Por ejemplo, los botonespueden ser redondos. Bordes complejos: Los componentes pueden presentar nuevos tipos de bordes. Ademásel usuario puede crear tipos de bordes personalizados. Otro mejora importante es que ahora todos los componentes pueden presentar una pequeñaleyenda de texto con una breve explicación, que es conocida como tooltip. 1.4 Descripción de algunos componentes Swing Se da una descripción breve de cada componente por la diversidad de métodos que contienen. Jframe: se trata de la implementación de la clase Frame añadiendo nuevas funcionalidades y una nueva filosofía, ya que ahora un Frame contiene varios tipos de paneles. Jpanel: es el nuevo contenedor básico de componentes gráficos. JscrollPane: esta nueva implementación de un panel con barra de desplazamiento no se limita sólo a proporcionar barras de desplazamiento en caso de que los componentes que contengan no entren en él área de 10 visualización, sino que también se encarga de proporcionar barras de desplazamiento a todo el resto de componentes gráficos existente. Japplet: Se trata de la reimplementación de la clase applet para que ésta pueda aprovechar todas las nuevas características existentes. Jbutton: botón que además de texto puede contener imágenes en cualquier posición en relación con el texto. JtoggleButton: se trata de una clase que no tiene equivalentes en AWT. Representa un botón que se mantiene presionado aunque dejemos de presionar connuestro ratón sobre él, pero visualmente no se difiere de un Jbutton cuando no está activado. Jlabel: etiqueta de texto que puede contener imágenes en cualquier posición en relación con el texto. JtextField: Componente que sirve para conseguir la entrada de texto por parte del usuario. JtextPane: se trata también de un panel para visualizar texto, con la salvedad de quetiene la capacidad de mutar en relación al tipo de texto que se desee mostrar para poder visualizarlo correctamente. Jlist: presenta una lista de elementos de entre los que se puede elegir uno o varios simultáneamente. JdesktopPane: se trata de un panel base para el desarrollo de aplicaciones MDI. JinternalFrame: este panel no es una ventana en sí, sino que simula una ventanainterior a un JdesktopPane. Como ventana interior puede ser movida, cerrada, organizada. Jtable: este componente presenta una rejilla en la que se puede colocar cualquiercomponente Swing. 11 JcheckBox: es similar al componente checkbox que encontramos en cualquierlenguaje y que permite mostrar al usuario si la opción está seleccionada o no. JpasswordField: se encuentra justo por debajo de Jtextfield en la jerarquía decomponentes, y permite la edición de texto sin realizar un eco de los caracterestecleados en pantalla, que son sustituidos por un carácter . JtextArea: hereda de JtextComponent, con la diferencia es que un área de texto permite la edición de múltiples líneas. Hay que tener en cuenta que si queremos tener la capacidad de desplazarnos a lo largo de un texto que no cabe en el componente tendremos que colocar el JtextArea en un JscrollPane. JprogressBar: las barras de progreso permiten ver de forma gráfica la evolución deuna tarea. Normalmente el avance se mide en porcentaje y la barra se acompaña de la visualización en texto del valor de dicho porcentaje. Java incorpora otra posibilidad para esta tarea: un monitor de progreso, que permite ver el avance de un proceso de forma más sencilla que las barras. Además al ser mostradas en un cuadro de dialogo, el usuario puede cerrarlas en cualquier momento e incluso llegar a cancelar el proceso. JcomboBox: es similar al Choice de AWT. Dispone de una lista desplegable deposibles valores, pero si no encontramos entre ellos el valor que buscamos, podemosteclearlo(si hemos habilitado la opción con setEditable(true)). Este control deSwing presenta una facilidad añadida: cuando pulsamos la inicial de la opción que buscamos, nos lleva directamente al primer término de la lista que empiece por dicha letra. 12 CAPÍTULO II 2.1. Layouts Swing incorpora nuevos gestores de impresión, ampliando los cinco que AWT incorporaba. Entre ellos conviene destacar los siguientes: BoxLayout: Es similar al FlowLayout de AWT, con la diferencia de que con él se pueden especificar los ejes (x o y). Viene incorporada en el componente Box, pero está disponible como una opción en otros componentes. OverlayLayout: Todos los componentes se añaden encima de cada componenteprevio. SpringLayout: El espacio se asigna en función de una serie de restriccionesasociadas con cada componente. ScrollPaneLayout. ViewportLayout. 2.2. Look &Feel Otra característica que introduce Swing es que se puede especificar el Aspecto y Comportamiento (Look &Feel o L&F) que utilice el GUI de nuestro programa. Por el contrario, los componentes AWT siempre tienen el aspecto y comportamiento de la plataforma nativa. Desde el código de la aplicación o applet Swing se puede exportar un Look &Feel diferente al nativo de la plataforma con el método UIManager.setLookAndFeel. En las siguientes figuras podremos observar tres de los L&F de Swing en la misma aplicación. 13 14 2.3. Nuevas características 2.3.1 Action Con objetos Action, el API Swing proporciona un soporte especial para compartir datos y estados entre dos o más componentes que pueden generar eventos Action. Por ejemplo, si tenemos un botón y un ítem de menú que realizan la misma función, podríamos considerar la Utilización de un objeto Action para coordinar el texto, el icono y el estado de activado de los dos componentes. 2.4. Modelos de datos y estados separados La mayoría de los componentes Swing no-contenedores tienen modelos. Por ejemplo, un botón (JButton) tiene un modelo (ButtonModel) que almacena el estado del botón - cuál es su mnemónico de teclado, si está activado, seleccionado o pulsado, etc. Algunos componentes tienen múltiples modelos. Por ejemplo, una lista (JList) usa un ListModel que almacenalos contenidos de la lista y un ListSelectionModel que sigue la pista de la selecciónactual de la lista. Normalmente no se necesita conocer los modelos que usa un componente. Por ejemplo,casi todos los programas que usan botones tratan directamente con el objeto JButton, y no lo hacen en absoluto con el objeto ButtonModel. Entonces ¿Por qué existen modelos separados? Porque ofrecen la posibilidad de trabajar con componentes más eficientemente y para compartir fácilmente datos y estados entre componentes. Un caso común es cuando un componente, como una lista o una tabla, contiene muchos datos. Puede ser mucho más rápido manejar los datos trabajando directamente con un modelo de datos que tener que esperar a cada petición de datos al 15 modelo. Se puede usar el modelo por defecto del componente o implementar uno propio. Las clases Model son una importante innovación que facilita la programación siguiendo la arquitectura MVC (modelo-vista-controlador) ya que separa para cada componente una clase de modelo de datos y otra de “interfaz”, aunque con la funcionalidad de la “interfaz” se podría controlar todo totalmente sin ayuda del modelo de datos de ese componente. 2.5. Soporte para tecnologías asistivas Las tecnologías asistivas para minusválidos como los lectores de pantallas pueden usar el API de accesibilidad para obtener información sobre los componentes Swing. Incluso sin hacer nada, un programa Swing probablemente funcionará correctamente con tecnologías asistivas, ya que el API de accesibilidad está construido internamente en los componentes Swing. Sin embargo, con un pequeño esfuerzo extra, se puede hacer que nuestro programa funcione todavía mejor con tecnologías asistivas, lo que podría expandir el mercado de nuestro programa. 2.6. Applets Los applets son pequeños programas Java que se incluyen en páginas Web y cuyo código se descarga desde el sevidor para ser ejecutado localmente por un navegador. Por tanto, para trabajar con applets es necesario conocer algunas de las características de las páginas Web y del lenguaje en que éstas están escritas, y el capítulo comienza exponiendo conocimientos básicos sobre HTML. También se explicará la estructura fundamental de un applet. Teniendo en cuenta que las applets trabajan con IGU y están guiadas 16 por eventos, el capítulo se apoya en los conocimientos aportados por otros anteriores para la creación de los primeros applets. Estructura De Un Applet La clase Applet extiende la clase Panel del AWT y Panel extiende Container que, a su vez, extiende Component, proporcionándose así a las upplets todas las herramientas necesarias en la programación IGU (Znterfuz Gráfica de Usuario) y, al igual que todos los programas que trabajan con IGU, las upplets están guiadas por eventos. Las upplets disponen de cinco métodos que pueden sobre escribir, aunque no es obligatorio que lo hagan, pues tienen implementaciones por defecto que se invocarán automáticamente durante la ejecución de la misma. Cuatro de estos métodos son proporcionados por la clase App 1 et : publicvoidinit ( ) Inicializa el applet y es invocado por elAppletviexlev o el navegador cuando se carga el applet.publicvoidstart ( ) Se ejecuta a continuación de init y también cada vez que el usuario del navegador regresa a lapágina HTML donde reside el upplet y debe contenerlas tareas que deban llevarse a cabo en estas ocasiones.publicvoid stop() Se ejecuta cuando el usuario abandona la páginaHTML en la que reside el applet.publicvoiddestroy ( ) Libera todos los recursos que el applet está utilizandoy se ejecuta antes de que el applet se descargue cuando el usuario sale de la sesión de navegación. 17 2.6.1. Applets en Swing La clase JApplet es el equivalente de Swing de la clase Applet. JApllet se parece aJFrame en que admite un panel de contenido separado. A este contenedor se accede a travésdel método getContentPane(). La barra de menús debe ser un objeto de la claseJMenuBar. 18 CAPITULO III 3.1. Herencia de Componentes y Contenedores Esta sección presenta algunos de los componentes más utilizados de Swing y explica como los componentes de un GUI entran juntos en un contenedor. Para ilustrarlo, usaremos el programa SwingApplication presentado en Una Ruta Rápida por el Código de una Aplicación Swing. Y aquí está su aspecto de nuevo. SwingApplication crea cuatro componentes Swing muy utilizados. un frame, o ventana principal (JFrame) un panel, algunas veces llamado pane (JPanel) un botón (JButton) una etiqueta (JLabel) El frame es un contenedor de alto nivel. Existe principalmente para proporcionar espacio para que se dibujen otros componentes Swing.Los otros contenedores de alto nivel más utilizados son los diálogos (JDialog) y los applets (JApplet). El panel es un contenedor intermedio. Su único propósito es simplificar el posicionamiento del botón y la etiqueta. Otros contenedores intermedios, como los paneles desplazables, (JScrollPane) y los paneles con pestañas (JTabbedPane), típicamente juegan un papelmás visible e interactivo en el GUI de un programa. 19 El botón y la etiqueta son componentes atómicos -- componentes que existen no para contener otros componentes Swing, sino como entidades auto-suficientes que representan bits de información para el usuario. Frecuentemente, los componentes atómicos también obtienen entrada del usuario. El API Swing proporciona muchos componentes atómicos, incluyendo combo boxes (JComboBox),campos de texto (JTextField), y tablas (JTable). Aquí podemos ver un diagrama con el árbol de contenidos de la ventana mostrada por Swing Application. Este diagrama muestra todos los contenedores creados o usados por el programa, junto con los componentes que contienen. Observa que si añadimos una ventana - por ejemplo, un diálogo - la nueva ventana tendría su propio árbol de contenidos, independiente del mostrado en esta figura Como muestra la figura, incluso el programa Swing más sencillo tiene múltiples niveles en su árbol de contenidos. La raíz del árbol de contenidos es siempre un contenedor de alto nivel. Este contenedor proporciona espacio para que sus componentes Swing descendentes se dibujen a sí mismo. 20 todo contenedor de alto nivel contiene indirectamente un contenedor intermedio conocido como panel de contenido. Para la mayoría de los programas no necesitas saber qué pasa entre el contenedor de alto nivel y su panel de contenido. (Si realmente quieres verlo, puedes ver Cómo usar Paneles Raíz.)Cómo regla general, el panel de contenido contiene, directamente o indirectamente, todos los componentes visibles en el GUI de la ventana. La gran excepción a esta regla es que si el contenedor de alto nivel tiene una barra de menú, entonces ésta se sitúa en un lugar especial fuera del panel de contenido. Para añadir componentes a un contenedor, se usa una de las distintas formas del método add. Este método tiene al menos una rgumento -- el componente a añadir. Algunas veces se requiere un argumento adicional para proporcionan información de distribución. Por ejemplo, la última línea del siguiente código de ejemplo especifica que el panel debería estar en el centro de su contenedor (el panel de contenido). 3.2. Control de Distribución Las siguientes figuras muestran los GUIs de cinco programas, cada uno de ellos muestra cinco botones. Los botones son idénticos, y el código de los programas es casi idéntico. ¿Entonces por qué parecen tan diferentes? Porque usan diferentes controladores de distribución para controlar el tamaño y posición de los botones. 21 Control de Distribución es el proceso de determinar el tamaño y posición de los componentes. Por defecto, cada contenedor tiene un controlador de distribución -- un objeto que realiza el control de la distribución de los componentes dentro del contenedor. Los componentes pueden proporcionarle al controlador de disposición sus preferencias en cuanto a tamaño y alineamiento, pero la última palabra la tiene el controlador de disposición. La plataforma comunmente Java suministra cinco utilizados: FlowLayout,GridBagLayout, y controladores BorderLayout, GridLayout. Estos de disposición BoxLayout, controladores de distribución están diseñados para mostrar múltiples componentes a la vez, y se han visto en la figura anterior. Una sexta clase proporcionada, CardLayout, es un controlador de disposición de propósito general usadoen combinación con otros controladores de distribución. Puedes encontrar detalles sobre cada uno de estos seis controladores, incluyendo claves para elegir el apropiado, en Usar Controladores de Distribución. Siempre que se use el método add para poner un componente en un contenedor, debemos tener en cuenta el controlador de distribución del contenedor. Algunos 22 controladores como BorderLayout requiere que especifiquemos la posición relativa del componente en el contenedor, usando un argumento extra para el método add. Ocasionalmente, un controlador de distribución comoGridBagLayout requiere elaborados procesos de configuración. Sin embargo, muchos controladores de distribución simplemente sitúan los componentes en el orden en que fueron añadidos a su contenedor. Todos esto probablemente suena más complicado de lo que es. Si quieres puedes copiar el código de nuestros ejemplos de Usar Componentes Swing o buscar el controlador de distribución individual en Usar Controladores de Distribución. Generalmente, sólo tendrás que seleccionar el controlador de distribución de dos tipos de contenedores: paneles de contenido (que usan BorderLayout por defecto) y JPanel (que usan FlowLayout por defecto). Esta sección describe algunas de las tareas más comunes de la distribución. 3.2.1. Seleccionar el Controlador de Distribución Podemos cambiar fácilmente el controlador de distribución que usa un contenedor. Sólo se debe llamar al método setLayout del contenedor. Por ejemplo, aquí está el código que hace que un panel use BorderLayout. JPanel pane = new JPanel(); pane.setLayout(new BorderLayout()); Aunque recomendamos que uses controladores de distribución, se puede realizar la distribución sin ellos. Seleccionando una propiedad de distribución del contenedor a nulo, podemos hacer que el contenedor no use ningún controlador de distribución. Con este esquema, llamado posicionamiento absoluto, podemos especificar el tamaño y posición de cada componente dentro del contenedor. Una desventaja del posicionamiento absoluto es que 23 no se ajusta bien cuando se redimensiona el contenedor de alto nivel. Tampoco se ajusta bien a las diferencias entres usuarios y sistemas, como los diferentes tamaños de fuente. 3.2.2. Proporcionar Consejos sobre un Componente Algunas veces necesitamos personalizar el tamaño que un componente proporciona al controlador de distribución del contenedor, para que el componente se vea bien. Se puede hacer esto proporcionando los tamaños mínimo, preferido y máximo del componente. También podemos llamar a los métodos de selección de tamaño del componente -- setMinimumSize, setPreferredSize, y setMaximumSize - o podemos crear una subclase del componente que sobreescriba los métodos apropiados -- getMinimumSize, getPreferredSize, y getMaximumSize. Actualmente, el único controlador de distribución en la plataforma Java que presta atención a la petición de tamaño máximo del componente es BoxLayout. Además de proporcionar preferencias de tamaño, podemos especificar preferencias de alineamiento. Por ejemplo, podemos especificar que los bordes superiores de dos componentes deberían estar alineados. Se seleccionan los consejos de alineamiento llamando a los métodos setAlignmentX y setAlignmentY del componente, o sobreescribiendo los métodos, getAlignmentX y getAlignmentY del componente. Realmente BoxLayout es el único controlador de distribución que presta atención a los consejos de alineamiento. 24 3.2.3 Poner Espacio entre Componentes Tres factores influyen en la cantidad de espacio entre los componentes visibles de un contenedor. 3.2.3.1. El controlador de distribución. Algunos controladores de distribución ponen automáticamente espacio entre los componentes; otros no. Algunos permiten incluso especificar la cantidad de espacio entre los componentes. Puedes ver Distribuir Componentes dentro de un contenedor sobre el soporte de espaciado de cada controlador de distribución. 3.2.3.2. Componentes invisibles. Se pueden crear componentes de peso ligero que no realicen dibujo, pero que ocupen espacio en el GUI. Frecuentemente se usan los componentes invisibles en contenedores controlados por BoxLayout. Puedes ver Cómo usar BoxLayout paraver ejemplos de uso de componentes invisibles. 3.2.3.3. Bordes vacíos No importa cuál sea el controlador de distribución, podemos afectar la aparente cantidad de espacio entre componentes añadiéndoles bordes. Los mejores candidatos para los bordes vacíos son los que típicamente no tienen bordes, como los paneles y las etiquetas. Algunos otros componentes, como paneles desplazables, no funcionan bien con bordes en algunas implementaciones del Aspecto y Comportamiento, debido a la forma en que implementan su código de dibujo. Para más información sobre los bordes puedes ver Cómo usar Bordes. 25 3.2.4. Cómo Ocurre el Control de Distribución Aquí hay un ejemplo de secuencia de control de distribución para un frame (JFrame). 1.- Después de que el GUI está construido, se llama al método pack sobre el JFrame. Esto especifica que el frame debería serde su tamaño preferido. 2.- Para encontrar el tamaño preferido del frame, el controlador de distribución añade el tamaño de los lados del frame al tamaño preferido del componente directamente contenido por el frame. Esto es la suma del tamaño preferido del panel decontenido, más el tamaño de la barra de menú del frame, si existe. 3.- El controlador de disposición del panel de contenido es responsable de imaginarse el tamaño preferido del panel de contenido. Por defecto, este controlador de disposición es un objeto BorderLayout. Sin embargo, asumamos que lo hemos reemplazado con un objeto GridLayout que se ha configurado para crear dos columnas. Lo interesante de gridlayout es que fuerza a que todos los componentes sean del mismo tamaño, e intenta hacerlos tan anchos como la anchura preferida del componente más ancho, y tan altos como la altura preferida del componente más alto. Primero, el controlador gridlayout pregunta el panel de contenido por su inserts - el tamaño del borde del panel de contenido, si existe. Luego, el controlador de gridlayout le pregunta a cada componente del panel de contenido sus tamaños preferidos, anotando la mayor anchura preferida y la mayor altura preferida. Luego calcula el tamaño preferido del panel de contenido. 26 4.- Cuando a cada botón se le pide su tamaño preferido, el botón primero comprueba si el usuario ha especificado un tamaño preferido. Si es así, reporta este tamaño. Si no es así, le pregunta a su Aspecto y Comportamiento el tamaño preferido. 3.3. Construcción de GUI en Swing La construcción de una GUI en Swing es muy similar a la construcción de GUI en el AWT, exceptuando que la primera tendrá muchas más clases de componentes con las que trabajar. A continuación se describen las clases que se usan para la construcción de GUI y se señalan las mejoras que Swing proporciona, comparando éstas clases con las de AWT. 3.3.1 Ventanas Swing, al igual que AWT, proporciona una jerarquía de clases Window. Las clases de laventana de Swing constituyen extensiones de la jerarquía de clases Window del AWT. Laclase JWindow amplía la clase Window. La clase JFrame amplía la clase JFrame delAWT y la clase JDialog amplía la clase Dialog del AWT.Las clases JWindow, JFrame y JDialog difieren de sus homólogos del AWT enque utilizan un panel de contenido separado para agregar y diseñar componentes GUI. Este panel es un objeto Container al que se accede a través del métodogetContentPane(). El panel de contenido es una parte de un objeto JRootPane quecontiene otros paneles que se usan para sobreponerse a componentes e interceptar eventos del ratón y del teclado. 27 3.3.2. Menús Los menús de Swing, al igual que las ventanas de Swing, son análogos a sus homólogos delAWT. Las clases JMenuBar, JMenu, JMenuItem, JCheckBoxMenuItem yJRadioButtonMenuItem se utilizan de la misma forma que las clases MenuBar,Menu, MenuItem y CheckboxMenuItem del AWT, sólo que con una diferenciafundamental. Las clases de menús de Swing son todas ellas subclases de la claseJComponent y, por tanto, de la clase Component. Esto implica que los menús de Swing, al contrario que sus homólogos del AWT, constituyen componentes de primera clase y se pueden usar con cualquiera de las clases Container. La clase JPopupMenu es equivalente a la clase PopupMenu del AWT. Otra atractiva característica de los menús de Swing es la posibilidad de utilizar imágenes de iconos en los menús. Se puede añadir una imagen a un elemento de menú por medio de su constructor. 3.3.3. Paneles La clase JPanel es el equivalente de Swing a la clase Panel del AWT. Esta clase, al igual que sucede en otras clases de JComponent, ofrece la posibilidad de agregar un borde. 3.3.4. Diseños Los contenedores de Swing admiten todos los diseños posibles del AWT, entre los que seincluye el diseño null, además de admitir otros diseños nuevos. 28 3.3.5. Iconos Una de las características más útiles que Swing ofrece es la posibilidad de agregar iconos a los componentes, como etiquetas, botones, elementos de menú, etc. La interfaz Icon define los métodos que las clases de iconos deben implementar. La clase ImageIcon proporciona una implementación predeterminada de esta interfaz. Los objetos ImageIcon se pueden construir a partir de archivos de imagen, URL que apuntan a archivos de imagenu objetos Image del AWT. 3.3.6. Bordes El paquete java.awt.swing.border proporciona la interfaz Border, la cual define los métodos que necesitan ser implementados por todas las clases de bordes. La claseAbstractBorder implementa la interfaz Border y es la superclase de las clases debordes de Swing. 3.3.7. Información sobre herramientas La clase JToolTip ofrece la posibilidad de agregar cuadros de texto emergentes queaparecen cuando se posa el ratón sobre un componente. Estos componentes, que admiteninformación sobre herramientas, permiten que éstas vengan especificadas en sus respectivosconstructores. El método setToolTipText() de la clase JComponent se puede usartambién para especificar la información sobre herramientas de un componente. 3.3.8. Barras de herramientas La clase JToolBar ofrece la posibilidad de utilizar barras de herramientas movibles y acoplables con Swing. Los objetos de esta clase son 29 contenedores de otros componentesSwing o del AWT. Los objetos JToolBar típicos contienen objetos JButton que se construyen por medio de iconos de imagen. 3.3.9. Etiquetas y botones Las clases JLabel y JButton proporcionan los equivalentes de Swing a las clasesLabel y Button del AWT. La implementación de Swing ofrece la ventaja de poder usariconos a la vez que texto. Los constructores JLabel() y JButton() permiten que se especifique un icono. Además, ambas clases admiten el método setIcon() para establecer un icono una vez que se ha construido el objeto. 3.3.10. Componentes de texto Las clases JTextComponent, JTextField y JTextArea son los equivalentes deSwing de las clases TextCompoenent, TextField y TextArea del AWT. Además,Swing proporciona la clase TextPane para trabajar con documentos de texto, que se pueden marcar con estilos de texto diferentes. 3.3.11. Listas y cuadros combinados Las clases JComboBox y JList ofrecen la posibilidad de presentarle al usuario una listade selecciones gráficas de texto. La clase JComboBox implementa una lista desplegable,parecida a una lista de opciones Motif. La clase JList es una lista de selecciones individuales o múltiples en las que se pueden ver muchos elementos. 30 3.3.12. Deslizadores y barras de progreso Las clases JSlider y JProgressBar carecen de equivalentes en el AWT. Ambasclases admiten orientaciones horizontales y verticales. La clase JProgressBar se utiliza típicamente para mostrar el progreso de una tarea, como la carga de una imagen. La claseJSlider se usa para ajustar o controlar el valor de una variable dentro del intervalo admisible. 3.3.13. Barras de desplazamiento El JScrollPane simplifica en gran medida el uso de las barras de desplazamiento. El método getViewport() devuelve un objeto JViewport en el que se pueden ir añadiendo componentes. En la mayoría de los casos, sólo necesita agregar componentes al objeto JViewport para que uno se pueda desplazar automáticamente por ellos. 3.3.14. Tablas La clase JTable es otro componente de Swing que carece de equivalente en AWT.JTable ofrece una posibilidad muy flexible para crear y mostrar tablas. Permite construir tablas a partir de arrays o vectores de objetos, o bien a partir de objetos que implementan lainterfaz TableModel.La interfaz JTableModel define métodos para los objetos que especifican el contenido de una tabla. La clase AbstractTableModel ofrece una implementaciónpredeterminada de la interfaz JTableModel. Esta clase se amplía típicamente para proporcionar una implementación personalizada de modelo de tabla. La clase JTable ofrece la posibilidad de editar tablas. El métodosetCellEditor() permite que un objeto de la interfaz TableCellEditor se ha identificado como el editor de celdas de una tabla. 31 3.3.15. Árboles Una de las clases nuevas más interesantes que ofrece Swing es la clase JTree. Esta clase implementa una estructura en forma de árbol que se puede usar para mostrar datos jerárquicos. La interfaz TreeNode define métodos que tienen que implementar los nodos de un objeto JTree. La clase DefaulMutableTreeNode proporciona una implementación predeterminada de la interfaz TreeNode. Los árboles se crean construyendo objetos de la interfaz TreeNode para luego añadirlos todos juntos (a través del método add()). Cuando todos los objetos TreeNode se hayan juntado, el objetoTreeNode resultante se pasa al constructor JTree.La presentación predeterminada de un objeto JTree utiliza un icono de carpeta con el fin de identificar los nodos de árbol que tienen nodos inferiores y un icono de archivo para identificar las ramificaciones del árbol. El método setCellRenderer() de la claseJTree se usa para identificar una prestación de árbol alternativa. 3.4. Manejo de eventos en Swing Cada vez que el usuario teclea un carácter o pulsa un botón del ratón, ocurre un evento. Cualquier componente puede ser notificado del evento. Todo lo que tiene que hacer es implementar el interface apropiado y ser registrado como un oyente de evento del evento fuente apropiado. Los componentes Swing pueden generar muchas clases de evento. El paquete java.awt.swing.event define una serie de interfaces auditoras de eventos y clases de eventos que se usan con los componentes Swing. Además, muchos de los componentes Swing también utilizan eventos del AWT. En la figura se muestra ejemplos de eventos: 32 Cada evento está representado por un objeto que ofrece información sobre el evento e identifica la fuente. Las fuentes de los eventos normalmente son componentes, pero otros tipos de objetos también pueden ser fuente de eventos. Como muestra la siguiente figura, cada fuente de evento puede tener varios oyentes registrados. Inversamente, un sólo oyente puede registrarse con varias fuentes de eventos. Figura relación evento - oyente 3.5. Swing: Cuadros de texto. Botones y casillas de activación Este literal se analiza las etiquetas, botones, cuadros de texto, botones toggle, casillas de activación y botones de opción en Swing. Todos ellos son controles esenciales que ocupan gran parte de los fundamentos de Swing. A excepción de los botones toggle, todos estos controles le deberían resultar familiares de la programación AWT. Gran parte de la funcionalidad de estos 33 controles Swing tiene su correspondencia en la de AWT, y aquí resaltaremos lo que es diferente. (Hay que tener en cuenta que todos los controles Swing aparecen de diferentes formas según las diversas apariencias; es importante recordar esto cuando se empiece a programar con ellos). 3.5. 1. Etiquetas y cuadros de texto Las etiquetas son controles básicos Swing que sólo visualizan una línea de texto. Sería razonable pensar que las etiquetas soportan varias líneas de texto en Swing, pero sólo soportan una. Por otro lado, soportan algo que no tienen las etiquetas AWT: imágenes. Veremos cómo utilizar la claselmagelcon para añadir imágenes a las etiquetas. La gestión del texto en los componentes Swing es uno de los apartados que veremos más tarde en este libro. Ahora, iniciaremos este tema con los cuadros de texto, viendo cómo funcionan en este capítulo y más adelante. 3.5. 2. Botones En Swing, cualquier botón se construye con la clase AbstractButton, y en este capítulo veremos esta clase. Como se podía esperar, los botones Swing tienen más capacidad que sus correspondientes en AWT, incluyendo la capacidad de visualizar imágenes, usar mnemónicos (combinación de teclas), diseñar un botón como botón por defecto de una ventana y fijar los márgenes y alineación del texto de un botón. Además, a un botón se le pueden asignar múltiples imágenes para gestionar el caso en que el ratón se mueva sobre el botón, y más cosas. Lo veremos a continuación. Botones toggle Swing introduce los botones toggle, que son botones que, cuando se hace clic sobre ellos, permanecen pulsados hasta que volvemos a hacer clic. 34 Los botones toggle son como las casillas de activación y botones de opción que parecen botones estándar; de hecho, la clase JToggleButton, es la clase base para las clases de estos controles en Swing, y además se pueden instanciar objetos de esta clase directamente. Al igual que ocurre con las casillas de activación y botones de opción, se pueden agrupar botones toggle y usar imágenes en ellos. 3.5.3. Casillas de activación y botones de opción AWT tiene casillas de activación y botones de opción, pero los gestiona de diferente forma que Swing. En Swing, los botones de opción tienen su propia clase (los botones de opción, son casillas de activación en AWT), y con ellos se pueden usar imágenes. De hecho, veremos que cuando se utilizan las imágenes con las casillas de activación y los botones de opción, hay algunos asuntos que considerar. 3.5.4. Usar etiquetas La clase de las etiquetas peso pesado en Swing es JLabel. Este es el diagrama de herencia de esta clase: java. 1ang.Object Ijava.awt.Component 1 j a v a .a w t . C o n t a i n e r Ijavax.swing.JComponent I j a v a x .s w i n g . J L a b e l Los constructores de la clase JLabel se encuentran en la tabla 1.1 y sus métodos en la tabla 1.2. 35 Constructor Descripción Construye un objeto JLabel Jlable sin imagen. Construye un objeto JLabelcon la JLabel(1con imagen) imagen indicada. Construye un objeto JLabelcon la JLabel(lconimagen, int alineación imagen y la alineaciónhorizontal horizontal) especificadas. Construye un objeto JLabelcon el JLabel(String texto) texto indicado. Construye un objeto JLabel con el JLabel(String texto, /con icono, int texto imagen y alineación horizontal alineación-horizontal) indicados. JLabel(Stringtext0, Construye un objeto JLabel con el intalineaciónhorizontal) texto y alineación horizontal indicado. Tabla 1.2 3.6. Swing: viewports. Desplazamiento. Deslizadores y listas En esta sección Viewport, paneles se indica algunos temas importantes de la Swing: de deslizadores, desplazamiento, barras de desplazamiento y cuadros de lista. Los controles de este capítulo tienen todos una cosa en común: el desplazamiento. El de lista, en concreto, es un control muy importante en la Swing, pero no procesa el desplazamiento por sí mismo, por lo que necesitamos comprender cómo funciona con desplazamiento antes de trabajar con vistas y muchos otros controles de la Swing. 36 3.6.1. Viewports La clase JViewport es el corazón del desplazamiento en la Swing. Un viewport es una ventana dentro de una vista, que visualizará una sección de nuestros datos. Podremos desplazar manualmente los Viewports. Utilizando Viewports, podemos desplazarnos por los datos visualizados, de forma similar a aquella en que realizamos nosotros mismos el desplazamiento. Examinaremos el uso de la clase JViewport para desplazar imágenes. 3.6.2. Paneles de desplazamiento Una forma común de implementar el desplazamiento en la Swing es utilizar paneles de desplazamiento, puesto que permiten desplazar componentes. Varios controles de la Swing, como el control JList, implementan la interfazScrollable para trabajar con paneles de desplazamiento. De hecho, éstos seutilizan habitualmente con controles JList para crear listas desplazables. 3.6.3. Deslizadores Otro control desplazable es el control deslizador de la Swing, soportado por la clase JSlider. Los deslizadores son similares a los controles que vemos en los dispositivos de audio que permiten deslizar un mando a lo largo de una pista. De hecho, los deslizadores son como barras de desplazamiento, excepto porque explícitamente utilizamos deslizadores para permitir al usuario seleccionar un valor dentro de un rango continuo. Puede hacer lo mismo, por supuesto, con barras de desplazamiento, pero 37 los deslizadores se introducen aquí debido a que los usuarios actualmente esperan que las barras de desplazamiento se utilicen para desplazar otros controles, como las áreas de texto. 3.6.4. Barras de desplazamiento Cada usuario de una UI conoce las barras de desplazamiento, por supuesto, y la Swing las soporta al igual que hacía el AWT. Utilizaremos la claseJScrollBar en esta sección desplazando texto en un applet. Cuando el cuadro de desplazamiento (también llamado burbuja o marcador) se mueva, el valor de la barra de desplazamiento cambiará. Puede hacer clic sobre los botones de flecha en los extremos de la barra de desplazamiento para cambiar el valor de la barra de desplazamiento en el incremento de bloque, y también puede hacer clic sobre la pista de la barra de desplazamiento para cambiar su valor en su incremento unitario. 3.6.5. Listas Las listas, soportadas por la clase JList en la Swing, son unos controles muy populares, debido a que permiten presentar una lista de elementos sencilla de manejar, ocultando una larga lista de elementos al hacer que el cuadro de lista sea desplazable. Mostraremos cómo desplazar largas listas y veremos diversos temas de la Swing. Por ejemplo, puede realizar selecciones múltiples de diversas formas en los cuadros de lista de la Swing. También puede visualizar imágenes, manejar eventos de clics de ratón dobles y triples e incluso aún más. 38 3.7. Swing: barras. Herramientas. Cuadros. Separadores y selectores 3.7.1. Cuadros combinados Los cuadros combinados son uno de los controles más importantes en la programación de la UI, pero el AWT no tiene un cuadro combinado. La Swing rectifica esto. Los cuadros combinados con combinaciones de campos de texto y listas desplazables. Son muy útiles, ya que permiten al usuario tanto seleccionar un elemento de la lista como introducir su propio valor en el campo de texto. Los cuadros combinados también son controles muy compactos, debido a que muestran únicamente un elemento y un botón que el usuario puede utilizar para desplegar la lista de otros elementos. Los cuadros combinados pueden funcionar como listas desplegables, proporcionando al usuario un mecanismo incluso aún más compacto para visualizar los elementos de una lista que el que proporciona un cuadro de lista, y han pasado a ser muy populares por esa razón. De hecho, la Swing tiene como valor predeterminado del cuadro combinado que muestre únicamente una lista desplegable, ya que el valor predeterminado para los cuadros combinados sería hacerlos no editables, lo que los convierte en listas desplegables. 3.7.2. Barras de progreso Las barras de progresos son controles relativamente nuevos, que se han hecho populares como mecanismo para proporcionar al usuario la indicación del progreso de una operación larga. Las barras de progreso, originalmente introducidas como mecanismo para mostrar el progreso de un programa de instalación, se utilizan ahora para todo tipo de operaciones de consumo de 39 tiempo, como descargas de archivos desde la red Internet. Las barras de progreso muestran una barra coloreada dentro de ellas que crece (o se reduce), de forma similar a como lo hace el mercurio en un termómetro, para mostrar visualmente cómo progresa una operación. Puede orientar las barras de progreso tanto horizontal como verticalmente, seleccionar los colores y etiquetas que use en ellas y manejar sus eventos. Y aún más, las barras de progreso siguen siendo controles sencillos, ya que tienen únicamente una función: mostrar el progreso de una tarea. 3.7.3. Selectores Como en la AWT, la Swing soporta cuadros de diálogo. Al contrario que la AWT, la Swing también soporta adicionalmente varios cuadros de diálogo que no tenemos que crear o personalizar nosotros mismos: selectores de archivos y selectores de color. Los selectores de archivos permiten al usuario seleccionar un archivo para abrir o guardar algo, muy similar a cualquier cuadro de diálogo de archivos estándar. Los selectores de color permiten al usuario seleccionar un color entre muchos. Ambos selectores representan cuadros de diálogo estándar y Sun únicamente nos ahorra tiempo al crearlos. Trabajaremos con ambos selectores en este capítulo. Podemos utilizar inmediatamente en los programas el selector de color, pero para utilizar los archivos que devuelve el selector de archivos, tendremos 40 3.7.4. Herramientas de ayuda Las herramientas de ayuda son esas ventanas pequeñas que aparecen y muestran un texto de explicación (como por ejemplo Descargar ahora o Abrir nueva carpeta) cuando se detiene el ratón sobre un control. Las herramientas de ayuda pueden ser muy útiles debido a que los usuarios de la UI tienen una gran resistencia a leer los manuales. Lo único que tiene que hacer el usuario es dejar el ratón sobre su programa para ver qué es lo que hacen los distintos controles. Por otro lado, tenga en cuenta que muchas herramientas de ayuda (conectadas con muchos elementos de texto en un control de texto, por ejemplo) pueden ser contraproducentes y dar una apariencia de dificultad a un programa. 3.7.5. Separadores Los separadores son barras horizontales o verticales que le permiten organizar sus controles en grupos. Aunque se utilizan mayoritariamente en los menús para dividir elementos de menú en agrupaciones lógicas, podrá utilizar separadores en componentes JApplet y JFrame como cualquier otro control. 41 3.8. Swing: ventanas. Paneles. Marcos internos y cuadros de dialogo 3.8.1. Ventanas Las clases JWindow y JFrame son el equivalente de las clases Window yFrame en AWT y sirven para el mismo propósito. Puede utilizar la claseJWindow para crear una ventana simple; de hecho, no es más que un rectángulo blanco. Aunque puede añadir bordes y controles a los objetos JWindow, normalmente utilizará la clase JFrame para crear ventanas que presente al usuario.Las clases JDesktopPane y JInternalFrame son nuevas en Swing, aunquejuntas representan algo que ha llegado a ser muy común en las IU: una interfaz de documentos múltiple. Los objetos de la clase JDesktopPane presentan un espacio en el que puede visualizar múltiples marcos internos de la clase JInternalFrame. Por ejemplo, una aplicación de procesamiento de textos podría permitir al usuario abrir varias vistas del mismo documento, o de múltiples documentos, utilizando un escritorio con varias ventanas de marcos internos. Los marcos internos son de poco peso, y dibujan ventanas que aparecen dentro de otras ventanas. De hecho, los paneles de escritorio también son componentes de poco peso, derivados de JLayeredPane. Puede añadir ventanas de marcos internos a las capas seleccionadas de un panel de escritorio. 3.8.2. Cuadros de diálogo La Swing proporciona bastante soporte para cuadros de diálogo con la clase JOptionPane. Mediante el uso de métodos de esta clase, puede visualizar toda clase de cuadros de diálogo (cuadros de diálogo de mensaje, cuadros de diálogo de confirmación, cuadros de diálogo de entrada y muchos 42 más).Como verá aquí, es sencillo crear cuadros de diálogo utilizando JOptionPane. Además de JOption Pane, la Swing también posee la clase JDialog, que puede utilizar como base para sus propias clases de cuadro de diálogo personalizadas. 3.9. Creación de paquetes. Interfaces. Archivos JAR y Java Beans 3.9.1. Crear un paquete La creación de los paquete es debido que la instauración de las clases se las coloca de forma desordenada. ¿Cómo se puede resolver este desorden? La solución está en la división de las clases en paquetes? Eso permitirá distribuirlos archivos de clase en una estructura de directorios de forma similar acuando distribuye los archivos porque tiene demasiados. Cuando se tiene varios archivos de clase, es buena idea distribuirlos en el disco utilizando una jerarquía de directorios. De hecho, los paquetes Javaf ueron diseñados originalmente para reflejar esa organización de archivos. Puede distribuir archivos de clase en una jerarquía de directorios y permitirque Java sepa lo que sucede con los paquetes. Por ejemplo, si se tiene un paquete llamado package, que contiene una claseapp.class, el archivo de clase iría en un directorio llamado package, como sigue: package -app Múltiples archivos de clase en el mismo paquete irán en el mismo directorio: packagel -app -app3 43 Como el directorio package se encuentra en una localización que Java Buscará, Java buscará los archivos de clase que utilice como parte del paquete en ese directorio. Tiene que indicarle a qué paquete pertenece un archivo de clase, utilizando la sentencia packagel en su código. Aquí tiene un ejemplo donde creamos app.class e indicamos que forma parte de packagel utilizando la sentencia package: packagepackagel; publicclasc app public static void main (String args) System.out.println ("Hola desde Java!"); Una vez compilada app.class y almacenada en el directorio packagel, podemos entonces importar la clase app en el código con sentencias como lasiguiente, como haríamos con cualquier otro paquete Java: importpackagel.*; importpackagel.app; La herramienta de tiempo de ejecución de Java también conoce los paquetes; por tanto, debido a que la clase app.class es una aplicación en sí, podemos ejecutar esta clase con una línea de comando que especifique el paquete de la clase app y utilizando un punto (.) para el separador de directorios: c:\> java packagel.app De hecho, el separador de paquetes punto es útil cuando creamos paquetes dentro de paquetes; examine el siguiente tema para más detalles. 44 3.9.2. Crear paquetes que contienen paquetes Cuando tenemos gran cantidad de archivos de clase, podemos organizarlos en una estructura de paquetes bastante compleja, y lo hacemos creando la estructura de directorios correspondiente en el disco, incluyendo las estructuras de subdirectorios dadas. Por ejemplo, si quiere que la clase app esté en el paquete package2, que asu vez está dentro del paquete package 1, ésta será la estructura de directorios:Para crear esta estructura de paquetes en el código, basta utilizar el separador de paquetes punto. ejemplo: package packagel.package2; public class app I public static void rnain (String[l args) { Systern.out.println ("iHola desde Java! " ) ; Ahora puede importar la clase app en su código con sentencias como éstas: import packagel.package2.*; irnport packagel.package2.app; Debido a que en este caso app ya es una aplicación clase, también puede ejecutarla como sigue, especificando la estructura de directorios de paquete: c:\> java packagel.package2.app ;Hola desde Java! 3.9.3 Crear una interfaz Cuando creamos una interfaz, especificamos los métodos de la interfaz y cuando la implementamos, proporcionamos el código de estosmétodos.Aquí tiene un ejemplo en el que creamos una interfaz llamada Printem quetiene 45 un método: printText. Implementamos esta interfaz en la clase llamada class. Para crear una interfaz, utilizamos simplemente la sentencia interfacey listamos los prototipos (declaraciones sin cuerpo) de los métodos que queremos en la interfaz, como sigue: interfacePrintem I voidprintText ( ) ; } Ahora podemos implementar esta interfaz en class 1: interfacePrintem { voidprintText ( ) ; 1 public class interfaces ( public static void main(Stringr1 args) I classlobjectl = new classl0; objectl.printText0; 1 } classclassl implements Printem I public void printText0 ( ystam.out.println(HoladesdeJavaln); 3.9.4. Implementación parcial de una interfaz Puede crear clases que implementen parcialmente una interfaz, pero estas clases deben declararse abstractas debido a que son únicamente implementaciones parciales y, por tanto, no pueden instanciarse en objetos. Aquí tiene un ejemplo en el que creamos una interfaz con dos métodos, printText 1 y printText2: interfacePrintem voidprintTextl(1; void printText2 ( ) ; A continuación, se crea una nueva clase, class1, que implementa la interfaz pero únicamente define un método, printText2 (observe que debido a que 46 estaclase no es una implementación completa de la interfaz, debemos declararlaabstracta): interfacePrintem ( voidprintTextl ( ) ; void printText2 ( ) ; abstract class classl implements Printem { public void printTextl0 I system.out.println("~Hola desde Java!"); Finalmente, podemos crear una nueva clase, class2, que extienda class1 e implemente printText2, lo que significa que podemos instanciar objetos de la clase class2 como se muestra aquí: interfacePrintem void printText1 ( ) ; void printText2 ( ) ; public class interfaces2 { public static void main(String[l args) ( class2 object2 = new class2 O ; object2.~rintText2(); abstract class classl implements Printem ( public void printTextl0 System.out.println(" ¡Holadesde Java!"); class class2 extends classl f public void printText20 System.out.println(~ola desde los interfaces Java!"); 47 3.9.5. Crear un archivo JAR El uso de los archivos JAR es por el aumento archivos de clase están aumentando de tamaño y hay muchos los archivos JAR comprimen sus contenidos utilizando el formato ZIP, por lo que si su applet necesita una gran cantidad de archivos grandes, es conveniente crear un archivo JAR. Los navegadores de la red Internet únicamente necesitan una conexión en vez de nuevas conexiones para cada nuevo archivo, lo que puede mejorar los tiempos de descarga. También puede firmar digitalmente los archivos de un archivo JAR para probar su origen. Crear archivos JAR con la herramienta jar. Esta herramienta viene con Java ya quí tiene su forma de uso: jar [optionsl [manifest] destination input-file[additional input filesl Aquí, options son las opciones que puede utilizar con la herramienta JAR y son parecidas a las opciones que se utilizan con la herramienta UNIX tar. El argumento opcional manifest consiste en el nombre de un archivo manifest, que soporta la firma digital y muestra los contenidos del archivo Java. Cuando cree un JavaBean, utilice un archivo manifest para indicar qué clases sonBeans Aquí se observa las opciones posibles que puede utilizar cuando use la herramienta jar: c. Crea un archivo nuevo o vacío en la salida estándar. t. Muestra la tabla de contenidos en la salida estándar. x file. Extrae todos los archivos o sólo los nombres de archivos. caso, únicamente se extraen los archivos especificados. 48 f. El segundo argumento especifica un archivo JAR para trabajar. v. Genera una salida "duplicada" en stderr. m. Incluye información manifiesta de un archivo manifest especificado. O. Indica "sólo almacenar", sin utilizar compresión ZIP M. Especifica que un archivo manifest no debería crearse por las entradas. u. Actualiza un archivo JAR existente añadiendo o cambiando los archivos del manifest. -C. Cambia los directorios durante la ejecución del comando jar. Por Ejemplo, jar añadiría todos los archivos dentro del directorio clases, pero no el propio directorio clases, al archivo jarfile.jar. Truco: Puede utilizar un argumento comenzando por el carácter para especificar un archivo que contiene argumentos adicionales Estos argumentos se insertan en la líneas en la posición del argumento @filen:"@" S, con Aquí se tiene el uso típico de la herramienta jar: c: \> jar cf j a r f i l e . jar * .class En este caso, todos los archivos de clase del directorio actual se sitúan en el archivo llamado jarfile.jar. La herramienta JAR genera automáticamente un archivo manifest predeterminado y es siempre la primera entrada del archivo Java (por defecto, se llama META-INF/MANIFEST.MF). Si tiene un archivo manifest y quiere que utilice la herramienta jar para un nuevo archivo JAR, se puede utilizar la opción -m y especificarlo como sigue: c:\>jar cm£ manifest.m£t jarfile.jar *.class 49 Observe que cuando especifica las opciones cfm en lugar de cmf, necesita especificar el nombre del archivo JAR primero, seguido del nombre del archivo manifest: c:\>jarcfmjarfile. jarmanifest.mft *.class Observe también que los archivos JAR no son únicamente para archivos de clase; pueden almacenar cualquier tipo de archivo. Aquí tiene la forma de empaquetar todos los archivos de un directorio en un archivo JAR: c:\>jarcfm jarfile.jar manifest.mft * . * Si los nombres de archivo que quiere empaquetar incluían directorios, los directorios se buscan de forma recursiva y se almacenan en el JAR los archivos. Cuando el archivo JAR se desempaqueta, se recrea de nuevo la estructura de directorios. 3.9.6. Obtener los contenidos del archivo JAR Los archivos JAR guardar información empaquetada para la visualización del contenido. De esta manera se puede determinar el contenido de un archivo JAR con las opciones tf, como en este caso, donde el archivo JAR contiene un manifest predeterminado en el directorio interno META-INF y varios archivos de clase: c: \>jartfjarfile. jar META- INF / META-INF/MANIFEST.MF applet.class jpanel.class newButton.class testPanel.class 50 3.9.7. Extraer archivos desde un archivo JAR Cuando se programa se utiliza los archivos JAR paraarchivar los archivos; pero, ¿cómo se extrae los archivos de un JAR?", "Con las opciones xf". Podemos extraer archivos desde un archivo JAR utilizando las opciones xf. Por ejemplo, aquí tiene la forma de extraer todos los archivos del archivo jarfile-jar introducido en el tema previo: c: \>jarxfjarfile. jar Al desempaquetar todos los archivos del archivo JAR de esta forma,también creamos su estructura original de directorio. En este caso, la herramientajar desempaqueta los archivos de clase y también crea un directoriollamado META-INF donde coloca el archivo predeterminado manifest MANIFEST.MF. También podemos extraer archivos especificando sus nombres. Aquí tieneun ejemplo en el que extraemos applet.class: c: \> jar xfjarfile. jarapplet.class 3.10. Swing Utilities clasajavax.swing.SwingUtilities Estos son sólo 2 de los 36 métodos de utilidad genérica definidos en SwingUtilities, que se dividen en siete grupos: métodos de cálculo, métodos de conversión, métodos de accesibilidad, métodos de recuperación, métodos relacionados con la multitarea y los eventos, métodos para los botones del ratón, y métodos de disposición/dibujo/UI. Todos estos métodos son estáticos y se describen muy brevemente en esta sección (para una comprensión más avanzada vea el código fuente de SwingUtilities.java). 51 3.10.1. Métodos de cálculo Rectangle[] computeDifference(RectanglerectA, RectanglerectB): devuelvelas regiones rectangulares que representan la porción de rectA que no intersecciona con rectB.RectanglecomputeIntersection(int x, int y, intwidth, intheight,Rectangledest): devuelve la intersección de dos áreas rectangulares. La primera región sedefine con los parámetros de tipo int y la segunda por con el parámetro de tipo Rectangle. Elparámetro de tipo Rectangle se modifica y se devuelve como resultado del cálculo de forma queno se tiene que instanciar un nuevo Rectangle. RectanglecomputeUnion(int x, inty, intwidth, intheight, Rectangledest): devuelve la unión de dos áreas rectangulares. La primera región se define con losparámetros de tipo int y la segunda por con el parámetro de tipo Rectangle. El parámetro detipo Rectangle se modifica y se devuelve como resultado del cálculo de forma que no se tieneque instanciar un nuevo Rectangle. isRectangleContainingRectangle(Rectangle a, Rectangle b): devuelve true si el Rectangle a contiene Rectangleb.computeStringWidth(FontMetricsfm, completamente Stringstr): devuelve al la achura del String de acuerdo al objeto FontMetrics. 3.10.2. Métodos de conversión MouseEventconvertMouseEvent(Componentsource, MouseEventsourceEvent, Componentdestination): devuelve un MouseEvent nuevo con destination como fuentey las coordenadas x e y convertidas al sistema de coordenadas de destination (asumiendo enambos casos que destination no sea null). Si destination es null las coordenadas se convierten 52 al sistema de coordenadas de source, y se pone source como fuente del evento. Siambos son null el MouseEvent devuelto es idéntico al evento que se pasa.Point convertPoint (Componentsource, Point aPoint, Componentdestination): devuelve un Point que representa aPoint convertido al sistema de coordenadas del componente destination como si se hubiese generado en el componente source. Si uno de los componentes es null se usa el sistema de coordenadas del otro, y si ambosson null el Point devuelto es idéntico al Point pasado. Point convertPoint(Componentsource, int x, int y, Componentdestination): este método funciona igual que el anterior método convertPoint() exceptoque recibe parámetros de tipo int que representan las coordenadas del Point a convertir en lugar de una instancia de Point.RectangleconvertRectangle(Componentsource, RectangleaRectangle, Componentdestination): devuelve un Rectangle convertido del sistema de coordenadasdel componente source al sistema de coordenadas del componente destination. Este métodose comporta de forma similar a convertPoint().voidconvertPointFromScreen(Point p, Component c): convierte el Point dado encoordenadas de la pantalla al sistema de coordenadas del Component dado.voidconvertPointToScreen(Point p, Component c): convierte el Point dado en el sistema de coordenadas del Component dado al sistema de coordenadas de la pantalla. 53 3.10.3. Métodos de accesibilidad AccessiblegetAccessibleAt(Component c, Point p): devuelve el componenteAccessible en el determinado Point del sistema de coordenadas del Component dado (sedevolverá null si no se encuentra ninguno). Observe que un componente Accessible es aquelque implementa el interface javax.accessibility.Accessible.AccessiblegetAccessibleChild(Component int i): devuelve el décimo hijoAccessible getAccessibleChildrenCount(Component hijosAccessible que c): contiene c, del Component dado.int devuelve el el número Component de dado. IntgetAccessibleIndexInParent(Component c): devuelve el índice en su padre delComponent dado descartando todos los componentes contenidos que no implementen el interfaceAccessible. Se devolverá -1 si el padre es null o no implementa Accessible, o si el Component dado Accessible.AccessibleStateSetgetAccessibleStateSet no implementa (Component c): devuelve el conjunto de A ccessibleStates que no están activos para el Component dado. 3.10.4 Métodos de recuperación ComponentfindFocusOwner(Component c): devuelve el componente contenido dentro del Component dado (o el Component dado) que tiene el foco. Si no hay tal componente se devuelve null. ContainergetAncestorNamed(Stringname, Componentcomp): devuelve el ancestormás cercano del Component dado con el nombre que le pasamos. En otro caso se devuelve null.(Observe que cada Component tiene una propiedad name que se puede asignar y recuperar usando los métodos setName() y getName 54 ()respectivamente.) ContainergetAncestorOfClass(Class c, Componentcomp): devuelve el ancestro máscercano del Component dado que es una instancia de c. En otro caso se devuelve null.ComponentgetDeepestComponentAt (Componentparent, int x, int y): devuelve elhijo más profundo del Component dado que contiene el punto (x,y) en términos del sistema decoordenadas del Component dado. Si el Component no es un Container este método terminainmediatamente. RectanglegetLocalBounds(Component c): devuelve un Rectagle que representa los límites de un Component determinado en su propio sistema de coordenadas (de este modo siempre empieza en 0,0).ComponentgetRoot(Component c): devuelve el primer ancestro de c que es una Window. Enotro caso este método devuelve el último ancestro que es un Applet.JRootPanegetRootPane(Component JRootPane que es padre de JRootPane.WindowwindowForComponent c, c): devuelve o (Component c si c): el primer es devuelve un el primer ancestro de c que es una Window. En otro caso devuelve null.booleanisDescendingFrom(ComponentallegedDescendent, ComponentallegedAncestor): devulve true si allegedAncestor contiene a allegedDescendent. 3.10.5. Métodos relacionados con la multitarea y los eventos voidinvokeAndWait(Runnableobj): envía el Runnable a la cola de despacho de eventos y bloquea el hilo actual.voidinvokeLater(Runnableobj): envía el Runnable a la cola de despacho de eventos y continúa. booleanisEventDispatchThread(): devuelve true si el hilo actual es el hilo de despacho de eventos. 55 3.10.6. Métodos para los botones del ratón booleanisLeftMouseButton(MouseEvent): devuelve true si el MouseEvent correspondea una pulsación del botón izquierdo del ratón. booleanisMiddleMouseButton(MouseEvent): devuelve true si el MouseEventcorresponde a una pulsación del botón de en medio del ratón. booleanisRightMouseButton(MouseEvent): devuelve true si el MouseEventcorresponde a una pulsación del botón derecho del ratón. 3.10.7 Métodos de disposición/dibujo/UIString layoutCompoundLabel (FontMetricsfm, intverticalAlignment, Stringtext, inthorizontalAlignment, iconicon, intverticalTextPosition, inthorizontalTextPosition, RectangleviewR, RectangleiconR,RectangletextR, inttextIconGap): Este método se usa normalmente por el delegado UI de JLabel para posicionar texto y/o un icono usando el FontMetrics, las condiciones de alineamiento y las posiciones del texto dentro del RectangleviewR . Si se determina que el texto de la etiqueta no cabrá dentro de este Rectangle, se usan puntos suspensivos (“...”) en lugar del texto que no cabría. Los RectanglestextR e iconR se modifican para reflejar la nuevadisposición, y se devuelve disposición.StringlayoutCompoundLabel Stringtext,iconicon, intverticalTextPosition, el String resultante (JComponent intverticalAlignment, inthorizontalTextPosition, c, de esta FontMetricsfm, inthorizontalAlignment, RectangleviewR, RectangleiconR, RectangletextR, inttextIconGap): este método es idéntico al anterior, pero recibe el componente destino para comprobar si él la orientación del texto se debe tener en cuenta voidpaintComponent(Graphics g, Component c, Container p, int x, int y,int w, int h): pinta el Component 56 dado en el contexto gráfico dado, usando el rectángulo definido por los cuatro parámetros de tipo int como área de recorte. El Container se usa para que actúe como el padre del Component de forma que cualquier petición de validación sucedan en ese componente no se propaguen por el árbol de ancestros del componente al que pertenece el contexto gráfico dado. Esta es la misma metodología que usan los pintores decomponentes de JList, JTree, y JTable para mostrar correctamente el comportamiento de"sello de goma" (rubberstamp). Este comportamiento se logra mediante el uso de unCellRendererPanevoidpaintComponent(Graphics g, Component c, Container p, Rectangle r):funciona de forma idéntica al método anterior, pero recibe un Rectangle como parámetro ints.voidupdateComponentTreeUI(Component en c): lugar notifica de a cuatro todos los componentes que contiene c, y a c, que actualicen su delegado UI para que correspondan a los actuales UIManagery UIDefaults. 57 4. Conclusiones A lo largo de este trabajo investigativo se han comprobado las similitudes y diferencias entre ambosAPI’s para la creación de interfaces gráficas. Básicamente, Swing viene a ser una ampliación y revisión de AWT. Ambas bibliotecas de clases comparten aspectos como el manejo de eventos, jerarquías similares de componentes, la representación de gráficas básicas e imágenes... Además, Swing añade nuevas funcionalidades a los antiguos componentes, añade nuevos componentes, introduce el concepto de Look & Feel, da soporte a el paradigma MVC; en resumen, aprovecha el camino recorrido por AWT respondiendo a sus deficiencias y a las nuevas necesidades. Esto pone de manifiesto que las capacidades y respuestas que ofrece Swing son fruto de una suma de trabajos anteriores a él, lo que indica la importancia en la construcción de software de las buenas prácticas de la ingeniería del software, que facilitan conceptos tan útiles como la reutilización, la portabilidad entre plataformas, la escalabilidad... en resumen al software de calidad. En resumen, AWT y Swing son un gran ejemplo de la buena puesta en marcha de las prácticas de la ingeniería del software y de la orientación a objeto. 58 5. Recomendaciones En la aplicación sólo debe haber un único JFrame, correspondiente a la aplicación principal. Todas las ventanas secundarias deben ser JDialog. Todas las ventanas secundarias deben tener una ventana padre, que es a partir de la cual se despliega. Es decir, todos los JDialog secundarios deben tener como padre al JFrame principal. Si desde un JDialog se va a visualizar otro, este segundo debe tener como padre al primero, y así sucesivamente. Evitar en lo posible los JDialog modales, o tener muy en cuenta su jerarquía de padres. El primer JDialog modal no tiene problemas si le pones su padre adecuadamente. Si tienes un JDialog modal visible, no muestres otro JDialog secundario, salvo que también sea modal y sea hijo del anterior. Si pones visibles a la vez dos JDialog modales y no son el uno hijo del otro, tendrás problemas al intentar escribir en ellos o cerrarlos. Nunca hereda de JFrame o JDialog o JApplet para hacer las ventanas. Se puede hacer siempre de un componente que no sea ventana y que no limite. Si las ventanas heredan de JPanel, podrás ponerlas siempre que quieras dentro de un JFrame, un JDialog, un JInternalFrame, un JApplet o incluso incrustarlas en otro JPanel. Si tu ventana hereda de JFrame, está condenada a ser un JFrame toda su vida. Reaprovechar las ventanas, no dejar al recolector de basura. Si un botón, al apretarlo, visualiza un JDialog, no hagas un new de JDialog cada vez que pulsas el botón. Es mejor hacer sólo un new la primera vez y guardar. En las siguientes veces bastará con hacer setVisible(true) y setVisible(false). Para que el recolector de basura libere una ventana, además de lo habitual, hay como mínimo que llamar al método dispose() de dicha ventana -cosa que mucha gente no sabe- , para que el sistema de eventos de teclado y ratón 59 eliminen todas las referencias que tienen a ella. De todas formas, incluso así no tengo muy claro que los JDialog se liberen siempre y, desde luego, en versiones anteriores de Java, los JFrame NUNCA se liberaban. La excusa de SUN es que como sólo debía haber un JFrame principal, no tenía sentido liberarlo. Los layouts para situar componentes no son tan complicados, sólo hay que ponerse a ello. No usar el layoutnull, ya que la ventana no será redimensionable y puedes tener problemas si cambia la fuente de letra, si tu programa se ejecuta en otro sistema operativo, se cambia el look &feel, etc. 60 6. Bibliografía A. “Java Swing” http://jungla.dit.upm.es/~santiago/docencia/apuntes/Swing/ B. Sun “The Swing Tutorial” http://java.sun.com/docs/books/tutorial/uiswing C. Sun, Traductor : Juan Antonio Palos “Swing y JFC” http://programacion.com/java/tutorial/swing/ Universidad de Navarra “Aprenda Java como si estuviera en primero” San Sebastián,Marzo 1999 D. Universidad de Las Palmas de Gran Canaria “Tutorial de Java – AWT”http://www.ulpgc.es/otros/tutoriales/java/Cap4/awt.html 61 Anexos. Anteproyecto INTRODUCCIÓN. Esta Investigación pretende ser una introducción a Swing, con la que se intenta mostrar una visión general sobre herramientas de interfaces gráficas de usuario, y más concretamente, sobre el desarrollo de éstas con Java y sus APIs, lo que se pretende mostrar las ventajas que ofrece éste tipo de programación. En primer lugar, se realiza una introducción a Swing, el AWT y las interfaces de usuario, tratando de ésta forma de centrar al lector en el tema a tratar. Una vez realizada dicha introducción, se describirá brevemente el paquete Swing, para dar una idea de la jerarquía de componentes que se puede utilizar con Swing y de sus utilidades. También se mencionará el manejo de eventos en Swing, así como los Applets, aunque de una forma muy superficial, ya que debido a la gran amplitud de variaciones que pueden darse, sería muy extenso hacer una descripción detallada. 62 DATOS INFORMATIVOS. 2.1.1. Tema General ADMINISTRADOR DE DISEÑO DE JAVA 2.1.2. Tema Específico. COMPONENTE SWING Universidad. Universidad Católica de Cuenca Unidad Académica de Ingeniería de Sistemas, Eléctrica y Electrónica Facultad de Ingeniería de Sistemas. Investigador. Tnlg. Anl. Freddy E. Quezada B. Director. Ing. Ali Méndez. Lugar. Universidad Católica de Cuenca. Fecha. 10 de Octubre del 2011. LUGARES DE CONSULTA. http://zarza.usal.es/~fgarcia/docencia/poo/02-03/trabajos/S2T4.pdf http://www.programacion.com/articulo/swing_y_jfc_java_foundation_classes_94 http://jungla.dit.upm.es/~santiago/docencia/apuntes/Swing/ http://www.programacion.net/java/tutorial/swing/ http://www.programacionfacil.com/java/indice.htm JUSTIFICACIÓN Y PROPUESTA. 63 4.1. ANÁLISIS DE LA SITUACIÓN ACTUAL. La programación en Java ha comenzado a despegar simplemente debido a su capacidad de hacer programas en múltiples plataformas. Esto es no sólo cierto para computadoras portátiles pero Java también está presente en las PC de bolsillo e incluso en los teléfonos móviles estándar. Debido a esto, existe un gran interés en programar con Java y aprovechar este gran y creciente mercado. La programación en Java significa que tener las herramientas adecuadas a fin de terminar proyecto rápido y eficientemente. Una de las herramientas esenciales es el componente de GUI (interfaz gráfica de usuario). Esto permite agregar fácilmente el componente gráfico sin la mayor parte de la programación necesaria. En esta categoría, hay dos de las que puedes elegir. La primera es la AWT (AbstractWindowToolkit) y el segundo es el swing, que apareció más tarde. Estos kits de herramientas tienen sus propias ventajas y desventajas que los hacen adecuados para los distintos tipos de necesidades de programación. El AWT utiliza muchos de los comandos de la plataforma que le da una gran cantidad de velocidad. Pero a fin de convertirlo para su uso en otras plataformas, debe cambiar los comandos de la contraparte. Por otro lado, Swing utiliza código Java puro, haciéndolo muy portátil con el costo de velocidad y rendimiento a través de plataformas. 4.2. PROPUESTA. Dar a conocer a través de métodos investigativos la aplicación y uso de de las herramientas del lenguaje Java para un diseño y desarrollo de aplicaciones dedicadas al usuario. 64 OBJETIVOS. 5.1. Objetivo General. Analizar los componentes de Java swing 5.2 Objetivos Específicos: Lograr conocimiento de los paquetes de Swing de java. Ilustrar al usuario con guía de uso que se refiere a la aplicación de componentes dedicados a la interface de usuario Adquirir competencias para la aplicación del lenguaje java ALCANCE Y LIMITACIONES. 6.1 Alcances. Crea una alternativa para el desarrollo de aplicaciones dedicadas al usuario Establecer diferencias entre distintos lenguajes de desarrollo orientado a objetos Aplicar los componentes de Java. Swing 6.2. Limitaciones. Ya que Swing es un extenso conjunto de componentes el tiempo para el desarrollo de los mismos 65 MARCO REFERENCIAL Y CONCEPTUAL. 7.1. Marco Referencial. Swing es el nombre clave del proyecto que desarrolló los nuevos componentes que vienen a sustituir o complementar a los de AWT. Frecuentemente se usa para referirse a los nuevos componentes y al API relacionado. Está inmortalizado en losn ombres de paquete del API Swing, que empiezan con javax.swing. Esta versión de lasJFC fue publicada como JFC 1.1, que algunas veces es llamada 'Versión Swing'. El API delJFC 1.1 es conocido como el API Swing. Swing constituye la característica más importante que se ha añadido a la plataforma 1.2, como Sun ha preferido llamarla, Java2. Con esta última incorporación por fin se completa totalmente la parte gráfica de la programación en Java, ofreciendo al programador acceso a todas las características existentes en un entorno gráfico actual, así como un conjunto de componentes gráficos completo y fácilmente ampliable con el que construir la interfaz gráfica de usuario, o GUI, de nuestras aplicaciones y applets, de una forma totalmente transparente e independiente de la plataforma en la que ejecutemos nuestro código. 7.2. Marco Conceptual. Swing es una de las mejoras principales que ha experimentado el JDK en su versión 1.2 con respecto a la versión 1.1, y representa la nueva generación de AWT. También es una de las API de las Clases de Fundamentos de Java (JFC), lo cual es el resultado de un esfuerzo de colaboración muy grande entre Sun, Netscape, IBM y otras empresas. Lo que da a Swing su importancia es el poder que ofrece para desarrollar interfaces gráficas de usuario (GUI) para applets y aplicaciones. La cantidad y calidad de los controles GUI que ofrece Swing no tiene rival en ningún otro juego de herramientas GUI. 66 El origen de los controles GUI que presenta Swing lo encontramos en las Clases de Fundamentos de Internet de Netscape (IFC). Los componentes Swing van más allá de las IFC, hasta el punto de que no hay un parecido apreciable entre los componentes Swing y los de las IFC. Swing ofrece también la posibilidad de cambiar fácil y rápidamente el aspecto y sensación (L&F) de un único componente o grupo de componente. Esta posibilidad, que se conoce como aspecto y sensación conectables (PL&F), es un sello distintivo de Swing TEMARIO. I INTRODUCCIÓN CAPITULO I Swing 1.1 historia 1.2 Ventajas - Desventajas 1.2 Eventos Swing 1.3 Modelos de componentes Swing 1.4 Descripción de algunos componentes Swing CAPITULO II Layouts 2.1. Look &Feel 2.2. Otras nuevas características 2.3. Action 2.4. Modelos de datos y estados separados 2.5. Soporte para tecnologías asistivas 2.6. Applets en Swing CAPITULO III 3.1. Herencia de Componentes y Contenedores 3.2. Control de Distribución 3.3. Construcción de GUI en Swing 67 3.4. Manejo de eventos en Swing 3.5. Swing: Applets. aplicaciones y cambios de apariencia 3.6. Swing: Cuadros de texto. botones y casillas de activación 3.7. Swing: viewports. desplazamiento. deslizadores y listas 3.8. Swing: barras. herramientas. cuadros. Se paradores y selectores 3.9. Swing: ventanas. paneles. marcos internos y cuadros de dialogo 3.10. Creación de paquetes. interfaces. archivos JAR y Java Beans 4. Conclusiones 4.2 Recomendaciones I. Bibliografía II. Anexos. 68 ESTRATEGIAS METODOLÓGICAS. Métodos Etapa de investigación Empíricos ANÁLISIS DE LA SITUACIÓN ACTUAL PROPUESTA DE SOLUCIÓN Técnicas Resultados Revisión por Internet Bases teóricas de la Investigación. Teóricos Analítico – sintético. Histórico- Lógico Revisión Documental Recolección de Información Analítico – sintético. Observación Investigar los elementos del paquete swing de java Hipotético – Deductivo MARCO REFERENCIAL Y CONCEPTUAL Analítico – sintético Sistémico 69 Propuesta fundamentada Teóricamente. Instrumentos. Las Herramientas que se utilizarán en el Desarrollo de la Investigación son: El Internet, constituye la fuente y base fundamental de donde se extraerá la Información requerida. El programa Netbeans 7.0, el mismo que nos ofrecerá mayor soporte Técnico para el desarrollo del presente proyecto. RECURSOS. Recursos Humanos. Catedráticos del Plantel. Autor. Recursos Tecnológicos. Uno de los Recursos Tecnológicos importantes es la Red de Redes (el Internet), la cual ofrece la mayor parte de la Información acerca de estas herramientas Recursos Materiales. Computadora portátil Netbeas 7.0 (win - linux) Útiles de oficina Internet 70 Recursos Económicos. Para la realización del Presente Trabajo se destina los siguientes rubros: Detalle Rubro Equipo Portátil $ 600 Útiles de Oficina $ 35 Consumo de internet prepago $ 35 Impresiones y Empastado $ 60 TOTAL 730 BIBLIOGRAFÍA. “Java Swing” http://jungla.dit.upm.es/~santiago/docencia/apuntes/Swing/ Sun “The Swing Tutorial” http://java.sun.com/docs/books/tutorial/uiswing Sun, Traductor : Juan Antonio Palos “Swing y JFC” http://programacion.com/java/tutorial/swing/ Universidad de Navarra “Aprenda Java como si estuviera en primero” San Sebastián, Marzo 1999 Universidad de Las Palmas de Gran Canaria “Tutorial de Java - AWT” http://www.ulpgc.es/otros/tutoriales/java/Cap4/awt.html 71 CRONOGRAMA SEMANA 1 SEMANA 2 LUN 17 A LUN 24 A SEMANA 3 SEMANA 4 SEMANA 5 SEMANA 6 LUN 7 A LUN 14 A LUN 21 A LUN 31 VIE 28 DE VIE 11 DE OCT VIE18 DE VIE 25 DE X X NOV X VIE 09 DE VIE 2 DE NOV NOV NOV CAPITULO I LUN 05 A NOV A VIE 21 DE OCT SEMANA 8 LUN 28 OCT A VIE 21 DE SEMANA 7 DIC DIC X CAPITULO II X X X CAPITULO III X X X 72 X X