Componentes Swing

üForman parte de las Java Foundation Classes y, constituyen

un conjunto de componentes de interfaz de usuario,
lightweight, construídas bajo la infraestructura del AWT.

üSon un reemplazo lightweigth de las componentes

heavyweight del AWT. Además Swing provee múltiples
componentes de GUI que no están presentes en el AWT
(tabbed pane, toolbar, color chooser, table, tree, dialog
boxes).

üProveen soporte para implementar interfaces de usuario

gráficas con look and feel pluggable (las componentes Swing
pueden conservar su apariencia en plataformas diferentes),
tienen incorporado un mecanismo de double buffering,
pueden ser transparentes.
 Componentes Swing
üSwing contiene alrededor de 250 clases. Para
distinguir las clases que son componentes de
interfaz de usuario de aquellas que son de soporte,
los nombres de las componentes Swing comienzan
con J.
üAlgunos de los paquetes que componen Swing son:
javax.swing Componentes Swing
javax.swing.border Bordes para componentes Swing

javax.swing.event Clases de eventos e interfaces listener

javax.swing.table Clases de soporte para JTable

javax.swing.tree Clases de soporte para JTree

 Componentes Swing y AWT
üSwing se construyó por encima del AWT. Swing usa la infraestructura
provista por el AWT: objetos gráficos, colores, fonts, layout managers, etc.
üTodas las componentes Swing son subclase de java.awt.Container (es
lightweight, no tiene peer), que a su vez es subclase de java.awt.Component.
üSwing NO usa las componentes de GUI del AWT, excepto Frame, Window y
Dialog, que son las superclases de las componentes Swing, JFrame, JWindow y
JDialog, respectivamente.

JFrame
JWindow Swing Heavyweight Swing Lightweight
JDialog
Components Components

Frame, Window,
AWT Dialog

Component, Container, Graphics, Color, Font, Toolkit,

Layout Managers, etc.
 Arquitectura de las Componentes
Swing
üSwing está basada en una versión especializada de la arquitectura
Model View Controller.

üLas componentes Swing lightweigth comprenden los siguientes objetos:

üUn modelo que mantiene los datos de la componente y provee
métodos para accederlos.
üUn UI delegate que es el responsable de pintar la componente
(look) y manejar sus eventos (feel).
üUna componente que es subclase de JComponent.
Los controllers en Java son los objetos listeners. Usualmente los
listeners Swing se implementan como clases internas de los objetos UI
delegate.

üSwing provee una API para manipular objetos de interfaz de usuario.

La creación de los objetos UI delegate y de los modelos es transparente
para el programador.
 Applets y Aplicaciones Swing
üLas applets y aplicaciones que usan componentes Swing deben
extender las clases JApplet (subclase de java.applet.Applet) y JFrame
(subclase de java.awt.Frame), respectivamente. JApplet y JFrame
soportan Swing. Se recomienda extender estas clases para implementar
applets y aplicaciones que usan Swing.
üTodos los contenedores Swing de nivel de ventana contienen una
instancia de de la clase JRootPane (JApplet, JDialog, JFrame,
JInternalFrame y JWindow). Esta instancia incluye un contenedor
llamado content pane (instancia de JPanel), donde estarán contenidas
todas las componentes.
üSwing define la interface, RootPaneContainer que implementan todos
los contenedores Swing mencionados.
üPor lo tanto, tanto JApplet como JFrame son contenedores que tienen
asociado una instancia de la clase JRootPane. En el content pane del
JRootPane residen todas las componentes del applet o aplicación.
 La Clase JApplet
üLas componentes de GUI deben ser agregadas al content pane en vez
de ser agregadas directamente al applet (como en AWT). Adicionalmente,
el layout manager se establece sobre el content pane y no
directamente sobre el applet Swing.

üEl manejador de layout para JApplet es el BorderLayout. JFrame usa el

mismo y de esta manera se facilita la migración de applets a aplicaciones y
viceversa.

üUn applet obtiene una referencia a su content pane, invocando al método

getContentPane() de Japplet.

üLas instancias de JApplet pueden tener una barra de menúes (no era
posible en las applets AWT) que se especifica mediante el método
setJMenuBar(JMenuBar) de JApplet. También es posible agregar una
barra de menú al applet, instanciando JMenu y agregando dicho objeto al
content pane.
 Ejemplo de un Applet Swing
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class Test extends JApplet {

public void init() {
Container contentPane = getContentPane();
Icon icon = new ImageIcon("swing.gif", ”Una animación");
JLabel label = new JLabel("Swing!", icon, JLabel.CENTER);
contentPane.add(label, BorderLayout.CENTER);
}
}

Se agrega el label al content Ubica el label en el centro del

pane del applet content pane

üA diferencia de Applet, las JApplet usan como layout manager de default al

BorderLayout.
 La Clase JComponent

üLa clase JComponent es la clase base de todas las componentes Swing

(lightweigth). Es la superclase de todas las componentes Swing lightweight.
üJComponent es subclase de java.awt.Container, que a su vez es subclase de
java.awt.Component, por lo tanto todas las componentes Swing son
contenedores AWT.
üJComponent provee a todas sus subclases de una amplia funcionalidad.
ü Bordes
ü Soporte de Accesibilidad
ü Double buffering
ü Debug graphics
ü Autoscrolling
ü Tooltips
ü Manejo de abreviaturas
 Bordes
üTodas las subclases de JComponent puede tener un borde (excepto JViewPort).
üLos bordes de la componentes se establecen, creando el borde deseado y luego
invocando al método setBorder(Border) pasando como parámetro el borde
previamente creado.
üLos bordes se dibujan adentro de la componente, pero los bordes no son
componentes.
import java.awt.BorderLayout;
import javax.swing.*;
import javax.swing.border.*;

public class Test extends JApplet {

public void init() {
JPanel panel = new JPanel();
panel.setBorder(new TitledBorder("JPanel Border"));
getContentPane().add(panel, BorderLayout.CENTER);
}
}

El applet crea un titled border que es pasado como

parámetro al setBorder.
Estilos de Bordes provistos por
Swing
 Bordes
üExisten distintos estilos de bordes y cada uno de ellos se corresponde con una clase en
el paquete javax.swing.border. Por ejemplo: javax.swing.border.TitledBorder,
javax.swing.border.BevelBorder, etc.
üUn mismo borde puede ser usado para decorar diferentes componentes. Para ello Swing
provee la clase BorderFactory que permite construir instancias de bordes compartidos.
La clase BorderFactory provee métodos de clase que retornan instancias de todos los
bordes.
..........................................................................
Border border =BorderFactory.createRaisedBevelBorder();
Border border2 =BorderFactory.createRaisedBevelBorder();
JPanel panel.setBorder(border);
JPanel panel2.setBorder(border2);
.....................................
üUsar la clase BorderFactory evita importar el paquete javax.swing.border y hace más
eficiente el uso de bordes ya que la fábrica devuelve instancias compartidas (para los
bordes simples). Para los bordes que tienen propiedades como títulos, las instancias son
únicas.
üEs posible crear bordes customizados, subclaseando la clase AbstractBorder y
sobreescribiendo los métodos necesarios. Usualmente se sobreescriben los métodos:
paintBorder, getBorderInsets e isOpaque (retornando true, si la componente pinta todos
los pixels del borde, ya que default retorna false).
 Double buffering
üEl double buffering, es una técnica, que elimina el parpadeo producido
cada vez que parte de ó toda una componente se actualiza en la pantalla.
üLas componentes Swing son double buffering, esto significa que el
background se limpia y la componente se vuelve a pintar en un buffer
offscreen y, luego este buffer se copia en la pantalla.
üEl buffer offscreen es lo suficientemente grande como para poder
contener todas las componentes Swing del contenedor. Las componentes se
dibujan en el buffer offscreen y subsecuentemente se copian en la
pantalla.
üLa propiedad de double buffering puede ser establecida sobre una
componente particular. Sin embargo, prevalece la configuración realizada
por el contenedor, esto es, toda componente es automáticamente double
buffer si su contenedor lo es.

üLas componentes Swing JRootPane y JPanel son double buffer por

default.
 Double buffering

üLa propiedad de double buffer se hace disponible mediante

los siguientes métodos de la clase javax.swing.JComponent:
ü public void setDoubleBuffered(boolean o)
ü public boolean isDoubleBuffered()
üLos programas que usan componentes Swing, no necesitan
hacer nada especial para soportar double buffering. Swing
asegura que el tipo apropiado de objeto Graphics (imagen
offscreen en caso de double buffer ó una imagen normal) será
pasado como parámetro al método paint(). Por lo tanto, la
componente solamente debe ocuparse de dibujar en él.
 Componentes Opacas ó
Transparentes
üLas componentes Swing pueden ser opacas ó parcialmente
transparentes.

Componente Opaca Componente Transparente

üUna componente que NO pinta TODOS sus bits asociados es

parcialmente transparente. En otro caso, es opaca. Una
componente transparente cada vez que es repintada primero debe
repintar la porción del contenedor que intercepta.
 Componentes Opacas ó
Transparentes
üLa javax.swing.JComponent provee los métodos:
ü public void setOpaque()
ü True, la componente pinta todos sus bits
ü False, la componente no garantiza que se pinten todos sus bits
ü public boolean isOpaque()

üEl sistema de pintado de Swing usa la propiedad de no

transparente ú opaco de una componente para determinar si
es necesario repintar ó no a sus ancestros (ante un pedido de
actualización de la componente).
üLa mayoría de las componentes Swing por default son opacas.
üEj: A los Pushbuttons, ser transparentes les permite tener
apariencia no-rectangular.
 El método paint() en Swing

üDe la misma forma que las componentes AWT, las Swing son
mostradas en la pantalla invocando el método paint(Graphics g)
de la clase javax.swing.JComponent.
üEl método paint(Graphics g) de JComponent considera que la
componente puede ser double buffer, puede tener borde y que
puede contener otras componentes.
protected void paintComponent(Graphisc g) Estructura del
método
protected void paintBorder(Graphisc g) paint(Graphics g)

protected void paintChildren(Graphisc g)

üEl programador que usa Swing, NO debe sobreescribir el
método paint(), solamente se debe sobreescribir el método
paintComponent().
 El método paint() en Swing

üComo ya hemos visto, las componentes Swing tienen asociado

un objeto UI delegate, que es el responsable del look and feel
de la componente. Por lo tanto, el pintado de las componentes
estándares se delega en este objeto. Esto ocurre en el método
paintComponent().

paint() paintComponent()
Si la componente es opaca,
se limpia el background y
ui.update() luego se invoca al paint()
de la componente

ui.paint()
 Pintar Componentes Swing
Originado por el ancestro heavyweigth

1 Se invoca al método Container.paint()

Para cada una de las componentes lightweigth

Se convierte el objeto Graphics en un objeto Graphics offscreen
2 apropiado (si double buffer está habilitado).

3 Se invoca al paintComponent() sobre la componente (usando la imagen

offscreen si double buffer está habilitado)
4 Se invoca al paintBorder() sobre la componente (usando la imagen
offscreen si double buffer está habilitado)

5 Se invoca al paintChildren() sobre la componente (usando la imagen

offscreen si double buffer está habilitado). Este método usa el
rectángulo de dibujo de la componente, la propiedad de transparencia
para determinar sobre que descendientes invocar al paint()
6 Si double buffer está habilitado, se copia la imagen offscreen sobre la
pantalla
 Pintar Componentes Swing

Originado por una invocación al JComponent.repaint()

Usa el rectángulo de dibujo de la componente y la propiedad de
transparencia para determinar la componente raíz a partir de donde
comienza la operación de pintado
Se convierte el objeto Graphics en un objeto Graphics offscreen
apropiado (si double buffer está habilitado en la componente raíz)

Se invoca al paint () sobre la componente raíz (luego se realizan los pasos

3, 4 y 5)
Si double buffer está habilitado sobre componente raíz, se copia la
imagen offscreen sobre la pantalla
 Pluggable Look and Feel
üLa clase javax.swing.UIManager maneja información
acerca del look and feel de las applets y aplicaciones Swing.
Provee acceso a la siguiente información y servicios,
mediante métodos de clase:
üEstablece el look and feel de applets ó aplicaciones
üProvee acceso a los valores del look anf feel actual
üCarga propiedades para Swing de un archivo de
propiedades
üEl método UIManager.setLookAndFeel() establece el valor
actual del look and feel. Los valores posibles son:
javax.swing.plaf.motif.MotifLookAndFeel,
javax.swing.plaf.motif.WindowsLookAndFeel
javax.swing.plaf.motif.MetalLookAndFeel
javax.swing.plaf.motif.MacLookAndFeel
 Soporte de Accesibilidad
üEl objetivo del soporte de accesibilidad es hacer que el software sea
accesible para todas las personas.
üJFC soporta accesibilidad de tres formas diferentes:
ü Look and Feel Pluggable
ü API de Accesibilidad
ü Servicios de Accesibilidad

üSwing fue diseñado para soportar look & feel “pluggable”. De esta forma
es posible implementar look and feels alternativos para las componentes.
Por ejemplo, reemplazar el look and feel visual de las componentes por uno
basado en voz, para usuarios con problemas de visión ó adaptar las
componentes que tienen aspectos de audio con un look and feel que muestre
subtítulos cada vez que se reproduce el audio (para usuarios con
dificultades auditivas).
üLa API de Accesibilidad, permite que las componentes de interfaz de
usuario le brinden información a las tecnologías que ayudan a usuarios
discapacitados. La clase AccesibleContext define un conjunto básico de
información que la componente debe proveer.
 Soporte de Accesibilidad
üLa clase AccesibilityContext provee métodos como:
ü getAccesibleRole(): identifica el rol de la componente de interfaz de
usuario que a su vez identifica el tipo de componente.
ü getAccesibleName(), getAccesibleDescription(): obtiene información
específica sobre una componente (acerca de la funcionalidad
específica de una instancia de una componente).

üJComponent tiene incorporado el soporte para brindar

información de accesibilidad. Todas las componentes Swing
tienen la capacidad de obtener su información de accesibilidad.
......................
JTextField unTexto = new JTextField();
AccesibleContext unContextodeTexto = unTexto.getAccesibleContext();
unContextodeTexto.setAccesibleName(“Apellido”);
unContextodeTexto.setAccesibleDescription(“Tipee su Apellido”);
 Tooltips
üLos tooltips son una línea de texto que se despliegan en una ventana
cuando el cursor permanece apoyado sobre una componente por un período
de tiempo específico. Ese tiempo se llama retardo inicial y el valor por
defecto es 750 milisegundos.
üUn tooltip se asocia a una componente invocando el método
setToolTipText(string) de la clase JComponent. El parámetro string
representa el texto que será desplegado en la ventana del tooltip.
üLos tooltips no soportan múltiples líneas de texto. Las reglas de buen
diseño de GUI establecen que los tooltips tienen que ser cortos y precisos.
üLos tooltips finalizan debido a: a) el curso abandona la componente, b) se
presiona el mouse ó c) expira el retardo final (4 segundos). Cuando el
cursor deja una componente que mostraba un tooltip, comienza a funcionar
otro retardo (0.5 seg.). Si el cursor entra a otra componente equipada con
un tooltip, este se muestra inmediatamente. Es posible personalizar los
tooltips fijando los valores de estos tiempos invocando métodos de clase
de la clase ToolTipManager.
 Tooltips

import java.awt.*;
import javax.swing.*;

public class ToolTipTest extends JApplet {

public void init() {
Container contentPane=getContentPane();
JButton botoncito = new JButton(”Tengo un tooltip”);
botoncito.setToolTipText(“Soy un Botoncito");
contentPane().setLayout(new FlowLayout());
contentPane().add(botoncito);
}
}

üLa clase JComponent provee múltiples opciones para setear tooltips y para
personalizar su comportamiento, como por ejemplo establecer la posición del
tooltip (de acuerdo a la posición es el texto que se muestra).
 Debug graphic
üEl debug graphic permite a los programadores entender exactamente
cómo las componentes se dibujan sobre la pantalla. Esto es especialmente
útil cuando se implementan componentes de UI ”customizadas”.

üSwing provee la clase javax.swing.DebugGraphics, subclase de

java.awt.Graphics que disminuye la velocidad con que las operaciones
gráficas son realizadas. Invocando métodos de clase de la clase
DebugGraphics, es posible establecer el número de ”flashes” por operación,
el color del flash, etc.

üInvocando al método setDebugGraphicsOptions(int) de JComponent es

posible obtener información de debug, como por ejemplo que se abra una
ventana que muestre el buffer offscreen de una componente double
buffer. El argumento int indica la opción de debug.
 Autoscrolling

üJComponent soporta autoscrolling. De esta manera, las componentes

tienen la capacidad de rolar cuando el mouse es arrastrado afuera de las
cotas de la componente.

üEl autoscrolling se activa y desactiva invocando al método

setAutoScrolls(boolean) de la clase JComponent. Además es posible
consultar el estado del autoscrolling de una componente mediante el
método getAutoScrolls().

üPor default, el autoscrolling está habilitado solamente para listas y tablas.

Por ejemplo, si tenemos una componente JLIST de seis elementos y se
fijan como visibles solamente tres, entonces como por defecto está
habilitado el scrooling en listas, la lista se mostrará en un srollpane.

üImplementar el autoscrolling en una componente “customizada” requiere

que la componente maneje el evento “mouse dragged” (especificado por la
interfaz MouseMotionListener) que ocurre afuera de las cotas de la
componente.
 Manejo de abreviaturas
üLa clase JComponent provee una facilidad para manejo de abreviaturas.
De ésta forma, se evita a los programadores que filtren las abreviaturas.
Las componentes Swing pueden disparar eventos y delegar su manejo a
un listener específico cuando una abreviatura es tipeada.
üEl método registerKeyboardAction(ActionListener, KeyStroke, int)
de la clase JComponent registra una abreviatura sobre la componente.
Cuando la abreviatura es tipeada, el método actionPerformed() es
invocado si la condición dada por el parámtero int se cumple (por ej.
cuando la componente tiene el focus); el método
getRegisteredKeyStrokes() devuelve todas las abreviaturas asociadas a
una componente.
üLas condiciones bajo las cuales son manejadas las abreviaturas se
especifican mediante constantes enteras de la clase JComponent:
ü WHEN_FOCUSED
ü WHEN_ANCESTOR_OF_FOCUSED_COMPONENT
ü WHEN_IN_FOCUSED_WINDOWS