Eventos de Usuario: FocusListener

FocusListener

El foco describe el componente que esta activo para entradas de teclado. Este puede ser ganado o perdido, y esto representa también un evento de usuario. La idea se me hace similar a el reflector llamado vector que recibe a un presentador y como si fuera un componente que recibe esa atención.
java.awt.event

Interface FocusListener


Métodos:

  • void focusGained(FocusEvent e)
    • Se invoca cuando un componente gana el foco del teclado.
  • void focusLost(FocusEvent e)
    • Se invoca cuando un componente pierde el foco del teclado.
Pequeño ejemplo: al seleccionar(ganar el foco) un campo de texto aparece un mensaje con una sugerencia y al perderlo este se borra:
  1. import java.awt.*;
  2. import java.awt.event.FocusEvent;
  3. import java.awt.event.FocusListener;
  4. import javax.swing.*;
  6. public class EjemploFoco extends JFrame implements FocusListener{
  7.     JPanel panel = new JPanel();
  8.     FlowLayout flujo = new FlowLayout();
  9.     JLabel nombre = new JLabel("Nombre:", JLabel.LEFT);
  10.     JTextField campo = new JTextField(20);
  11.     JLabel mensaje = new JLabel("                                         ");
  12.     JPanel panel2 = new JPanel();
  13.     JLabel apellido = new JLabel("Apellido:", JLabel.LEFT);
  14.     JTextField campo2 = new JTextField(20);
  15.     JLabel mensaje2 = new JLabel("                                         ");
  16.     public EjemploFoco(){
  17.         super("EJemplo de FocusListener");
  18.         setSize(470,140);
  19.         setLocationRelativeTo(null);
  20.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  21.        
  22.         panel.setLayout(flujo);
  23.         panel.setBorder(BorderFactory.createEmptyBorder(20, 20, 0, 20));
  24.         panel.add(nombre);
  25.         campo.addFocusListener(this);
  26.         panel.add(campo);
  27.         panel.add(mensaje);
  28.        
  29.         panel2.setLayout(flujo);
  30.         panel2.setBorder(BorderFactory.createEmptyBorder(0, 20, 20, 20));
  31.         panel2.add(apellido);
  32.         campo2.addFocusListener(this);
  33.         panel2.add(campo2);
  34.         panel2.add(mensaje2);
  35.        
  36.         GridLayout grilla = new GridLayout(2,1);
  37.         setLayout(grilla);
  38.         add(panel);add(panel2);
  39.         //pack();
  40.         setVisible(true);
  41.     }
  43.     @Override
  44.     public void focusGained(FocusEvent e) {
  45.         if(e.getSource() == campo){
  46.             mensaje.setText("<--Escribe tu monbre.");
  47.         }
  48.         if(e.getSource() == campo2){
  49.             mensaje2.setText("<--Escribe tu Apellido.");
  50.         }
  51.        
  52.     }
  54.     @Override
  55.     public void focusLost(FocusEvent e) {
  56.         if(e.getSource() == campo){
  57.             mensaje.setText("                                         ");
  58.         }
  59.         if(e.getSource() == campo2){
  60.             mensaje2.setText("                                         ");
  61.         }
  62.        
  63.     }
  64.     public static void main(String[] dario){
  65.         new EjemploFoco();
  66.     }
  67. }

ComponentEvent, FocusEvent y métodos propios

Class ComponentEvent

java.lang.Object
java.util.EventObject
java.awt.AWTEvent
javax.swing.JComponent
java.awt.event.ComponentEvent

Class FocusEvent

java.lang.Object
java.util.EventObject
java.awt.AWTEvent
javax.swing.JComponent
java.awt.event.ComponentEvent
java.awt.event.FocusEvent
Lo que nos interesa de estas clases es el objeto FocusEvent e que indicamos como parametro en los métodos implementados por la interface FocusListener.
  • public void focusGained(FocusEvent e) {}
  • public void focusGLost(FocusEvent e) {}
Y en particular sus métodos:
  • Class ComponentEvent
    • getComponent()
      • Devuelve el componente que generó el evento.
  • Class FocusEvent
    • getOppositeComponent()
      • Devuelve el componente implicado en este cambio de enfoque, que perdio el foco.
  • isTemporary()
    • Devuelve un parámetro String, que identifica a este evento.

  • Class JComponent
    • requestFocus()
      • Podemos pedir que tenga el foco un componente como JButton.

    • Segundo Ejemplo

    1. import java.awt.*;
    2. import java.awt.event.FocusEvent;
    3. import java.awt.event.FocusListener;
    4. import javax.swing.*;
    6. public class CalculadoraFoco extends JFrame implements FocusListener {
    7.     FlowLayout flujo = new FlowLayout();
    8.     JTextField num1 = new JTextField(10);
    9.     JLabel mas = new JLabel(" + ");
    10.     JTextField num2 = new JTextField(10);
    11.     JLabel igual = new JLabel(" = ");
    12.     JTextField resultado = new JTextField("0", 8);
    13.     public CalculadoraFoco(){
    14.         super("Calculadora a través de FocusListener");
    15.         setLocationRelativeTo(null);
    16.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    17.        
    18.         setLayout(flujo);
    19.         num1.addFocusListener(this);
    20.         add(num1); add(mas);
    21.         num2.addFocusListener(this);
    22.         add(num2); add(igual);
    23.         resultado.setEnabled(false);
    24.         add(resultado);
    25.        
    26.         pack();
    27.         setVisible(true);
    28.     }
    29.     @Override
    30.     public void focusGained(FocusEvent e) {
    31.         try{
    32.             float total = Float.parseFloat( num1.getText() )
    33.                     Float.parseFloat( num2.getText() );
    34.             resultado.setText(" " total);
    35.         }catch(NumberFormatException em){
    36.             num1.setText("0");
    37.             num2.setText("0");
    38.             resultado.setText("0");
    39.         }
    41.     }
    42.     @Override
    43.     public void focusLost(FocusEvent e) {
    44.         focusGained(e);
    46.     }
    47.     public static void main(String[] args) {
    48.         new CalculadoraFoco();
    50.     }
    51. }
    Una pequeña calculadora que al ganar o perder el foco en nuestros JtextField se calcula el resultado de la suma automaticamente al pasar por otro campo de texto. Tambien podemos usar "tab" para pasar al siguiente y "shift+tab" para regresar.
    Nuestros campos de textos regresan un String que lo pasamos a Float con el método parseFloat y como parametro recuperamos el texto ingresado. Como también podemos escribir una letra u otro caracter incorrecto se puede producir una excepción maneja por NumberFormatException y en ese caso reseteamos todos los valores a "0".

    Ejemplo de The Java™ Tutorials

    El desafio recrear algo similar a lo propuesto en los tutoriales oficiales de Java
    El código es el siguiente:

    1. package eventos;
    2. import java.util.Vector;
    3. import java.awt.*;
    4. import java.awt.event.*;
    6. import javax.swing.*;
    8. public class FocusEventDemo extends JFrame implements FocusListener {
    9.     final static String newline = "\n";
    10.     final int numItems = 15;
    11.     JTextArea mostrar;
    12.    
    13.     //Constructor que configura el titulo cuando lo llamen.
    14.     public FocusEventDemo(String nombreTitulo) {
    15.         super(nombreTitulo);
    16.     }
    17.      
    18.     public void agregarComponentesPanel(final Container pane) {
    19.         GridBagLayout grilla = new GridBagLayout();
    20.         pane.setLayout(grilla);
    21.          
    22.         GridBagConstraints c = new GridBagConstraints();
    23.          
    24.         c.fill = GridBagConstraints.HORIZONTAL;
    25.         c.weightx = 1.0;  //Hace la columna lo más ancho posible.
    26.         JTextField campoTexto = new JTextField("Un Campo de Texto");
    27.         campoTexto.setMargin(new Insets(0,2,0,2));
    28.         campoTexto.addFocusListener(this);
    29.         grilla.setConstraints(campoTexto, c);
    30.         add(campoTexto);
    31.        
    32.         c.fill = GridBagConstraints.NONE;
    33.         c.weightx = 0.1;  //Ensancha un poco cualquier otra columna.
    34.         JLabel etiqueta = new JLabel("Una Etiqueta:");
    35.         etiqueta.setBorder(BorderFactory.createEmptyBorder(0,5,0,5));
    36.         etiqueta.addFocusListener(this);
    37.         grilla.setConstraints(etiqueta, c);
    38.         add(etiqueta);
    39.          
    40.         String prefijoCombo = "Item de ComboBox #";
    41.         Vector<String> vector = new Vector<String>(numItems);
    42.         for (int i = 0; i < numItems; i++)
    43.             vector.addElement(prefijoCombo i);
    44.         JComboBox<String> comboBox = new JComboBox<String>(vector);
    45.         comboBox.addFocusListener(this);
    46.         grilla.setConstraints(comboBox, c);
    47.         add(comboBox);
    48.          
    49.         c.gridwidth = GridBagConstraints.REMAINDER;
    50.         JButton boton = new JButton("Un Botón");
    51.         boton.addFocusListener(this);
    52.         grilla.setConstraints(boton, c);
    53.         add(boton);
    54.          
    55.         c.weightx = 0.0;
    56.         c.weighty = 0.1;
    57.         c.fill = GridBagConstraints.BOTH;
    58.         String prefijoLista = "Item de la Lista #";
    59.         Vector<String> listaVector = new Vector<String>(numItems);
    60.         for (int i = 0; i < numItems; i++) {
    61.             listaVector.addElement(prefijoLista i);
    62.         }
    63.         JList<String> lista = new JList<String>(listaVector);
    64.         lista.setSelectedIndex(1); //Es más fácil ver el cambio de enfoque, si se selecciona un elemento.
    65.         lista.addFocusListener(this);
    66.         JScrollPane scrollPaneLista = new JScrollPane(lista);
    67.          
    68.         grilla.setConstraints(scrollPaneLista, c);
    69.         add(scrollPaneLista);
    70.          
    71.         c.weighty = 1.0; //Hace esta fila tan alto como sea posible.
    72.         c.gridheight = GridBagConstraints.REMAINDER;
    73.         mostrar = new JTextArea();
    74.         mostrar.setEditable(false);
    75.         //El método setRequestFocusEnabled impide que un componente de ser seleccionable
    76.         //pero todavía puede obtener el enfoque a través del teclado, probar con "tab"
    77.         mostrar.setRequestFocusEnabled(false);
    78.         mostrar.addFocusListener(this);
    79.         JScrollPane scrollPaneArea = new JScrollPane(mostrar);
    80.          
    81.         grilla.setConstraints(scrollPaneArea, c);
    82.         add(scrollPaneArea);
    83.         setPreferredSize(new Dimension(450, 450));
    84.         ((JPanel)pane).setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
    85.     }
    86.     //Métodos de la interface FocusListener
    87.     public void focusGained(FocusEvent e) {
    88.         mostrarMensaje("Foco ganado", e);
    89.     }
    90.      
    91.     public void focusLost(FocusEvent e) {
    92.         mostrarMensaje("Foco perdido", e);
    93.     }
    94.    
    95.    
    96.     void mostrarMensaje(String prefijo, FocusEvent e) {
    97.         mostrar.append(prefijo (e.isTemporary() ? " (temporary):" : ":") );
    98.         mostrar.append(e.getComponent().getClass().getName() );
    99.         mostrar.append("; Componente Anterior: " (e.getOppositeComponent() != null ? e.getOppositeComponent().getClass().getName() : "ninguno") );
    100.         mostrar.append( newline);
    101.         mostrar.setCaretPosition(mostrar.getDocument().getLength());
    102.     }
    103.      
    104.     // Crear la GUI y la muestra. Para la seguridad del hilo, este método debe ser invocado desde el
    105.     // el hilo de distribución de eventos.
    106.     private static void crearYMostrarGUI() {
    107.         //Crear y da la configuracion básica de la ventana.
    108.         FocusEventDemo marco = new FocusEventDemo("Demostración de FocusListener");
    109.         marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    110.         //Configura el contenido del panel con el método "agregarComponentesPanel(final Container pane).
    111.         marco.agregarComponentesPanel(marco.getContentPane());
    112.          
    113.         //Enpaquetamos y hacemos visible la ventana.
    114.         marco.pack();
    115.         marco.setVisible(true);
    116.     }
    117.      
    118.     public static void main(String[] args) {
    119.         /* Podemos elegir alguno de los Look and Feel comentando el otro. */
    120.         try {
    121.             UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
    122.             //UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
    123.         } catch (UnsupportedLookAndFeelException ex) {
    124.             ex.printStackTrace();
    125.         } catch (IllegalAccessException ex) {
    126.             ex.printStackTrace();
    127.         } catch (InstantiationException ex) {
    128.             ex.printStackTrace();
    129.         } catch (ClassNotFoundException ex) {
    130.             ex.printStackTrace();
    131.         }
    132.        
    133.         //Programa una tarea para el hilo de distribución de eventos:
    134.         //La interfaz Runnable y el método run que llama a nuestro método.
    135.         javax.swing.SwingUtilities.invokeLater(new Runnable() {
    136.             public void run() {
    137.                 crearYMostrarGUI();
    138.             }
    139.         });
    140.     }
    141. }

    Mi resultado:
    en
    Etiquetas:

    No hay comentarios:

    Publicar un comentario

    Suscribirse a: Enviar comentarios (Atom)
    • [MySQL] Sentencia WHERE, BETWEEN, LIKE y IN
      WHERE La sentencia WHERE se utiliza en conjunto con la declaración SELECT nombre_columna FROM nombre_tabla (en DML) para especificar que...
    • Look and Feel
      El look and feel(Aspecto y comportamiento) es la forma en que los JComponent de swing (JLabel, JButton, JTextField, JTextArea, JCheck...