Obsługa zdarzeń - konkrety

1. Hierarchia klas zdarzeniowych

• Jeśli nie podano inaczej - klasy pochodzą z pakietu java.awt.event
• Większość zdarzeń Swingowych (z pakietu javax.swing.event) jest ściśle związana z architekturą "Model-View-Controller". Będziemy je zatem omawiać przy tej okazji.
• Zdarzenie PropertyChangeEvent związane jest z koncepcją JavaBeans. Oznacza ono zmianę właściwości "ziarna", dotyczy wszystkich komponentów wizualnych AWT i Swing (bo są ziarnami), ale ma również szersze znaczenie dla "niewizualnych" ziaren. O tym będzie traktował wykład o JavaBeans w przyszlym semestrze.
• Klasy HierarchyEvent i AncestorEvent określają zdarzenia polegające na dodaniu, usunięciu, uwidocznieniu itp. komponentu na wyższym (od żródła zdarzenia) poziomie hierarchii zawierania się komponentów. Generalnie zdarzenia te są obsługiwane przez JVM, a ich obsługę dla programistów udostępniono wyłącznie w celach informacyjnych.
• Klasa InvocationEvent służy do budowania zdarzeń, polegających na wykonaniu kodu (podanego w metodzie run() obiektu klasy implementującej Runnable i przekazanego przy tworzeniu zdarzenia jako argument konstruktora ). Zdarzenia te - po użyciu metody dispatch() z klasy InvocationEvent - są umieszczane w kolejce zdarzeń do późniejszego "wykonania". W ten sposób można "zastąpić" działanie metod invokeLater i invokeAndWait, które robią to samo i  są obowiązkowym sposobem na działanie na komponentach Swingu po ich realizacji (uwidocznieniu lub spakowaniu okna). Konieczność taka wynika z tego, że komponenty Swingu nie są wielowątkowo bezpieczne.

• ActionEvent - "akcja",
• ItemEvent - "zmiana zaznaczeń w obiekcie mogącym mieć 0 lub więcej zaznaczeń - stanów",
• AdjustmentEvent - "dostosowanie obiektu dostosowywalnego",
• TextEvent - "zmiana tekstu obiektu tekstowego" (dotyczy tylko AWT i obecnie praktycznie nie jest stosowane)

2. Obsługa zdarzeń - przegląd

3. Obsługa zdarzeń myszki

Zdarzenia myszki

Zdarzenia myszki (klasa MouseEvent) razem ze zdarzeniami przychodzącymi z klawiatury (klasa KeyEvent) należą do ogólnego typu zdarzeń wejściowych (klasa InputEvent bazowa dla obu klas MouseEvent i KeyEvent).

Od każdego zdarzenia klasy InputEvent (oprócz ogólnych informacji o źródle i identyfikatorze zdarzenia) możemy się dowiedzieć o następujących okolicznościach zdarzenia:

• kiedy zaszło - metoda getWhen() zwracająca czas zdarzenia w milisekundach
• czy towarzyszyło mu wciśnięcie specjalnych klawiszy: alt, altgraph (prawy alt), shift, ctrl, meta - metody isAltDown(), isAltGraphDown(), isShiftDown(), isControlDown(), isMetaDown(), zwracające true jeśli odpowiedni klawisz został wciśnięty i false w przeciwnym razie.

• Point getPoint(), int getX(), int getY() - lokalizacja kursora myszki (w momencie zajścia zdarzenia) względem lewego górnego rogu komponentu (lewy górny róg komponentu ma współrzędne (0,0); dostajemy odpowiednio punkt (x,y), współrzędną x , współrzędną y,
• Point getLocationOnScreen(), int getXOnScreen(), int getYOnScreen() - j.w. ale we współrzędnych całego ekranu,
• int getButton() - który klawisz myszki uzyty; możliwe wartości określają stałe statyczne z klasy MouseEvent: BUTTON1, BUTTON2, BUTTON3.
• int getClickCount() - zwraca liczbę kliknięć,
• boolean isPopupTrigger() - czy to zdarzenie myszki może dla danej platformy systemowej spowodować otwarcie menu kontekstowego,
• void translatePoint(int x, int y) - powoduje przekształcenie współrzędnych zdarzenia poprzez dodanie do nich odpowiednio liczb x i y.

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

class MousePlay extends JFrame implements MouseInputListener {

  private Container cp = getContentPane();
  private int currIndex = 0;              // do tworzenia kolejnych znaków
  private int diffX =0, diffY =0;         // używane przy wleczeniu
  private boolean isDragged;              // czy wleczenie

  // Ramki dla etykiet
  Border normal = BorderFactory.createLineBorder(Color.black),
        pointed = BorderFactory.createLineBorder(Color.red, 2),
        dragged = BorderFactory.createLineBorder(Color.blue, 4);

  public MousePlay() {

   cp.setLayout(null); // bez rozkładu!

   cp.addMouseListener(new MouseAdapter() {
     public void mouseReleased(MouseEvent e) {
       if (e.isMetaDown()) {                           // prawy klawisz  
         if (e.isControlDown()) removeAllComponents(); // z Ctrl - usunięcie wszystkich
         else  setVisibility();                        // bez - ukrycie
       }
       else addLabel(e.getX(), e.getY());              // lewe klawisz - dodanie etykiety
     }
   });
   setDefaultCloseOperation(DISPOSE_ON_CLOSE);
   setSize(300, 300);
   setLocationRelativeTo(null);
   setVisible(true);
  }

  // Utworzenie i dodanie etykiety w miejscu kursora myszki (x, y)
  private void addLabel(int x, int y) {
     JLabel l = new JLabel("" + (char) ('A' + currIndex++));
     l.setBounds(x, y, 50, 50);
     l.setBorder(normal);
     l.setFont(new Font("Dialog", Font.BOLD, 24));
     l.setHorizontalAlignment(JLabel.CENTER);
     l.setVerticalAlignment(JLabel.CENTER);
     l.addMouseListener(this);
     l.addMouseMotionListener(this);
     cp.add(l);
  }

  // zmiana widoczności komponentów w panelu
  private void setVisibility() {
    for (Component comp : cp.getComponents() ) comp.setVisible(!comp.isVisible());
  }

  // usunięcie wszystkich komponentów
  private void removeAllComponents() {
    cp.removeAll();
    cp.repaint();
  }

  // Metody obsługujące zdarzenia myszki dla etykiet

  // Przy wejściu kursora w obszar etykiety - zmiana ramki, ale tylko wtedy
  // gdy nie wleczemy jakiejś innej etykiety

  public void mouseEntered(MouseEvent e) {
    if (isDragged) return;
    ((JComponent) e.getSource()).setBorder(pointed);
  }

  // Przywrócenie ramki z uwagą j.w.
  public void mouseExited(MouseEvent e) {
    if (isDragged) return;
    ((JComponent) e.getSource()).setBorder(normal);
  }


  public void mousePressed(MouseEvent e) {
   isDragged = true; // być może zaczynamy wleczenie
   ((JComponent) e.getSource()).setBorder(dragged); // ramka dla wleczenia
   diffX = e.getX(); // w jakiej odległości kursor od górnego rogu komponentu
   diffY = e.getY(); // - potrzebne do korygowania zmian lokalizacji
  }                  //   przy wleczeniu

  public void mouseReleased(MouseEvent e) {
    isDragged = false;           // ew. koniec wleczenia
    if (e.isControlDown()) {     // usunięcie etykiety, jeśli wciśnięto Ctrl
      cp.remove(e.getComponent());
      cp.repaint();
      return;
    }
    ((JComponent) e.getSource()).setBorder(pointed);
  }

  // wleczenie polega na zmianie położenia
  public void mouseDragged(MouseEvent e) {
    Component c = e.getComponent();
    // nowe położenie musimy skorygować w zależności od tego
    // w jakim miejscu schwyciliśmy etykietę (diffX, diffY)
    c.setLocation(c.getX() + e.getX() - diffX, c.getY() + e.getY() - diffY);
  }

  public void mouseClicked(MouseEvent e) {}
  public void mouseMoved(MouseEvent e) {}

  public static void main(String[] a) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        new MousePlay();
      }
    });
  }

}

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;
import javax.swing.border.*;
import javax.swing.event.*;

public class StickyWin extends JFrame {
  
  private static Icon icon = new ImageIcon(StickyWin.class.getResource("images/close.gif"));
  private static boolean again = true;  // czy po zamknięciu okna mozna je pokazać z nowym tekstem?

  private int diffX, diffY;     // dostosowanie (nowe pozycje okna zależą od miejca jego uchwycenia)

  // Obsługa 
  MouseInputAdapter mover = new MouseInputAdapter() {

    @Override
    public void mousePressed(MouseEvent e) {
      diffX = e.getXOnScreen() - StickyWin.this.getX(); // wyraźne odwołanie do this klasy otaczającej!
      diffY = e.getYOnScreen() - StickyWin.this.getY();
    }

    @Override
    public void mouseDragged(MouseEvent e) {  // wleczenie myszki zmienia położenie okna na ekranie
      int x = e.getXOnScreen() - diffX;
      int y = e.getYOnScreen() - diffY;
      setLocation(x, y);
    }

  };

  public StickyWin(String txt) {
    // Zdejmiemy dekoracje z okna JFrame (ramki i tytuły)
    this.setUndecorated(true);
    // Niech będzie zawsze na wierzchu
    this.setAlwaysOnTop(true);
    // Ramki
    Border empty = new EmptyBorder(10, 20, 10, 5);
    Border line = new LineBorder(Color.BLUE, 2);
    ((JComponent) getContentPane()).setBorder(BorderFactory
        .createCompoundBorder(line, empty));
    // Box dla komponentów
    Box box = Box.createHorizontalBox();
    box.add(new JLabel(txt));
    box.add(Box.createHorizontalStrut(10));
    JLabel x = new JLabel(icon);
    x.setForeground(Color.RED);
    x.setFont(new Font("Dialog", Font.BOLD, 14));
    x.setToolTipText("Close");
    x.addMouseListener(new MouseAdapter() {  // 'x' zamyka okno

      @Override
      public void mouseReleased(MouseEvent e) {
        dispose();
        if (again) {
          String in = JOptionPane
              .showInputDialog("Teraz możesz podać swój tekst");
          again = false;
          new StickyWin(in);
        }

      }
    });
    box.add(x);
    add(box);
    addMouseListener(mover);
    addMouseMotionListener(mover);
    pack();
    setVisible(true);
  }

  public static void main(String[] args) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        new StickyWin("<html>Telefon:<br>111-111-222<html>");
      }
    });
    
  }
}

4. Obsługa menu

4.1. Menu kontekstowe

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

public class PopupTest extends JFrame {
  
  private Icon icon = new ImageIcon(getClass().getResource("images/green.gif"));

  public PopupTest() {
    setLayout(new FlowLayout());
    JPopupMenu pm = createPopup("Jeden", "Dwa", "Trzy");
    JButton[] btns =  { new JButton("Przycisk 1"), 
                        new JButton("Przycisk 2"),
                        };
    for (JButton b : btns) {
      b.setComponentPopupMenu(pm);
      add(b);
    }
    setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    pack();
    setLocationRelativeTo(null);
    setVisible(true);
  }
  
  JPopupMenu createPopup(String ... items ) {
    JPopupMenu pm = new JPopupMenu();
    for (String s : items) {
      pm.add(new JMenuItem(s, icon));  
    }
    return pm;
  }

  public static void main(String[] args) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        new PopupTest();
      }
    });
  }

}

    JPopupMenu pm = createPopup("Jeden", "Dwa", "Trzy");
    
    ((JComponent) getContentPane()).setComponentPopupMenu(pm);
    
    JButton[] btns =  { new JButton("Przycisk 1"), 
                        new JButton("Przycisk 2"),
                      };
    
    for (JButton b : btns) {
      b.setInheritsPopupMenu(true);
      add(b);
    }

• przyłączenie MouseListenera do komponentu,
• w obsłudze zdarzeń myszki sprawdzanie isPopupTrigger() i jeśli tak - otwieranie menu kontekstowego poprzez show.

4.2. Obsługa wyboru opcji menu kontekstowego i rozwijalnego

import java.awt.event.*;
import java.util.*;

import javax.swing.*;

public class TestMenu extends JFrame implements ActionListener {
  
  private JLabel statusBar = new JLabel(" ");
  
  public TestMenu() {
    List<JMenuItem> fileItems = createMenuItems("Open", "Save", "Save as", "Exit");
    List<JMenuItem> editItems = createMenuItems("Copy", "Cut", "Paste", "Select");
    JMenu pulldown = new JMenu("File");
    for(JMenuItem mi : fileItems) pulldown.add(mi);
    JPopupMenu popup = new JPopupMenu();
    for(JMenuItem mi : editItems) popup.add(mi);  
    
    JMenuBar mb = new JMenuBar();
    mb.add(pulldown);
    setJMenuBar(mb);
    
    JTextArea ta = new JTextArea(10,20);
    ta.setComponentPopupMenu(popup);
    add(new JScrollPane(ta));
    
    add(statusBar, "South");
    
    setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    pack();
    setLocationRelativeTo(null);
    setVisible(true);
  }
  
  private List<JMenuItem> createMenuItems(String ... items) {
    List<JMenuItem> list = new ArrayList<JMenuItem>();
    for(String s : items) {
      JMenuItem mi = new JMenuItem(s);
      mi.addActionListener(this);
      list.add(mi);
    }
    return list;
  }

  @Override
  public void actionPerformed(ActionEvent e) {
    statusBar.setText("Ostatnio wykonano: " + e.getActionCommand());
  }

  public static void main(String[] args) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        new TestMenu();
      }
    });
  }


}

4.3. Invoker menu kontekstowego. Menu kontekstowe i rozwijalne w jednym

• gdy jest ono zadeklarowane na poziomie klasy, to oczywiście w metodzie obsługi mamy dostęp do zmiennej oznaczającej menu i możemy łatwo uzyskać dostęp do komponentu na którym zostało ono otwarte:

JPopupMenu popup = new JPopupMenu();
// ...
ActionListener al = new ActionListener() {
    public void actionPerformed(ActionEvent e) {
      JMenuItem c = (JMenuItem) e.getSource(); // źródło zdarzenia wyboru elementu
      Component invoker = popup.getInvoker(); // komponent na którym otwarto menu
      // ...
    }
};  
// ...

• jeśli nie mamy dostępu do zmiennej oznaczającej menu kontekstowe, możemy je uzyskać odpytując wybrany element menu o jego rodzica. Będzie nim właśnie menu kontekstowe. A dalej w analogiczny jak wyżej sposób dowiadujemy się na jaki komponencie menu zostało otwarte:

 ActionListener al = new ActionListener() {
    public void actionPerformed(ActionEvent e) {
      Component c = (JComponent) e.getSource();
      JPopupMenu popup = (JPopupMenu) c.getParent();
      Component invoker = popup.getInvoker();
      // ...
    }
}; 

package popupinvoker;

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

import static java.awt.Color.*;

public class PopupInvoker extends JFrame {

  private JPopupMenu popup = new JPopupMenu();

  private ActionListener colorChanger = new ActionListener() {

    public void actionPerformed(ActionEvent e) {
      Component c = (Component) e.getSource();
      Color back = c.getBackground();
      Color fore = c.getForeground();
      JPopupMenu popup = (JPopupMenu) c.getParent();
      Component invoker = popup.getInvoker();
      invoker.setBackground(back);
      invoker.setForeground(fore);
    }
  };

  public PopupInvoker() {
    super("Invoker test");
    createPopupMenu();
    setLayout(new FlowLayout());
    JComponent cp = (JComponent) getContentPane();
    cp.setComponentPopupMenu(popup);
    for (int i = 1; i <= 3; i++) {
      JButton b = new JButton("Przycisk " + i);
      b.setInheritsPopupMenu(true);
      add(b);
    }
    setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    setSize(400,200);
    setLocationRelativeTo(null);
    setVisible(true);
  }

  private void createPopupMenu() {
    Color[] back = { YELLOW, BLUE, BLACK, WHITE };
    Color[] fore = { BLUE, YELLOW, WHITE, RED };
    for (int i = 0; i < back.length; i++) {
      JMenuItem mi = new JMenuItem("Color change");
      mi.setBackground(back[i]);
      mi.setForeground(fore[i]);
      mi.addActionListener(colorChanger);
      popup.add(mi);
    }
  }

  public static void main(String[] args) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        new PopupInvoker();
      }
    });
  }
}

    JMenu editMenu = createMenu( ... "Copy", "Cut", "Paste", "Select");
    
    JPopupMenu popup = editMenu.getPopupMenu();

    JMenuBar mb = new JMenuBar();
    mb.add(editMenu);

    JTextArea ta = new JTextArea(10,20);
    ta.setComponentPopupMenu(popup);

• popupMenuWillBecomeVisible(PopupMenuEvent e)  - wywolywana tuż przed otwarciem menu kontekstowego,
• popupMenuWillBecomeInvisible(PopupMenuEvent e) -  wywolywana tuż przed zamknięciem menu kontekstowego,
• popupMenuCanceled(PopupMenuEvent e) - wywoływana przy anulowaniu menu kontekstowego.

      public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
        popup.setInvoker(editMenu);
      }

package menu2;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.event.*;

public class TestMenu extends JFrame implements ActionListener {
  
  private JLabel statusBar = new JLabel(" ");
  
  public TestMenu() {
    JMenu fileMenu = createMenu("File", "Open", "Save", "Save as", "Exit");
    final JMenu editMenu = createMenu("Edit", "Copy", "Cut", "Paste", "Select");
    
    // uzyskanie "popupu" menu rozwijalnego editMenu
    final JPopupMenu popup = editMenu.getPopupMenu();
    
    // menus ida na pasek
    JMenuBar mb = new JMenuBar();
    mb.add(fileMenu);
    mb.add(editMenu);
    setJMenuBar(mb);
    
    // a za chwilę editMenu będzie też jako kontektstowe
    JTextArea ta = new JTextArea(10,20);
    ta.setText("Menu Edit dostępne jest jako rozwijalne i jako kontekstowe.\nSpróbuj!");
    ta.setComponentPopupMenu(popup);
    add(new JScrollPane(ta));
    
    // zapewniamy przywrócenie JMenu jako invokera
    popup.addPopupMenuListener( new PopupMenuListener() {

      public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
        popup.setInvoker(editMenu);
      }

      public void popupMenuCanceled(PopupMenuEvent e) { }
      public void popupMenuWillBecomeVisible(PopupMenuEvent e) { }
    });

    
    add(statusBar, "South");
    
    setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    pack();
    setLocationRelativeTo(null);
    setVisible(true);
  }
  
  private JMenu createMenu(String ... txt) {
    JMenu menu = new JMenu(txt[0]);
    for (int i = 1; i < txt.length; i++) {
      JMenuItem mi = new JMenuItem(txt[i]);
      mi.addActionListener(this);
      menu.add(mi);
    }
    return menu;
  }

  @Override
  public void actionPerformed(ActionEvent e) {
    statusBar.setText("Ostatnio wykonano: " + e.getActionCommand());
  }

  public static void main(String[] args) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        new TestMenu();
      }
    });
  }


}

5. Fokus

package fokus1;

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

public class Fokus1 extends JFrame implements FocusListener {

  final Border NORMAL = BorderFactory.createLineBorder(Color.black),
               FOCUS = BorderFactory.createLineBorder(Color.blue, 3),
               EMPTY = BorderFactory.createEmptyBorder(10,10,10,10);

  public Fokus1() {
    super("Fokus");
    setLayout(new GridLayout(0, 1, 5, 5));
    ((JComponent) getContentPane()).setBorder(EMPTY);
    for (int i = 0; i < 5; i++) {
      JTextField tf = new JTextField(20);
      tf.setFont(new Font("Dialog", Font.BOLD, 18));
      tf.setBorder(NORMAL);
      tf.addFocusListener(this);
      add(tf);
    }
    setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    pack();
    setLocationRelativeTo(null);
    setVisible(true);
  }

  public void focusGained(FocusEvent e) {
    ((JComponent) e.getSource()).setBorder(FOCUS);
  }

  public void focusLost(FocusEvent e) {
    ((JComponent) e.getSource()).setBorder(NORMAL);
  }

  public static void main(String args[]) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        new Fokus1();
      }
    });
  }

}

// ...
final Border ERROR = BorderFactory.createLineBorder(Color.red, 4);

JComponent inError = null; // pole tekstowe, które zawiera błąd

public void focusGained(FocusEvent e) {
  JComponent c = (JComponent) e.getSource();
  if (inError != null) {                               // jeżeli jest błędne pole
     inError.setBorder(ERROR);                         // dla niego: czerwona ramka
     if (c != inError) inError.requestFocusInWindow(); // i przywrocenie fokusu
  } else c.setBorder(FOCUS);
}

public void focusLost(FocusEvent e) {
  JTextField tf = (JTextField) e.getSource();
  if (inError != null && inError != tf) return;
  String txt = tf.getText();
  if (!txt.equals("")) {
    try {                   // Sprawdzenie poprawności tekstu
      Integer.parseInt(txt);
    } catch (NumberFormatException exc) {  // tekst wadliwy
        inError = tf;                      // zapamiętujemy błędne pole
        return;
    }
  }

  // Tu na pewno wiemy, że tekst jest poprawny
  inError = null;
  tf.setBorder(NORMAL);
}

package inputver;

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;
import javax.swing.border.*;

public class InpVer extends JFrame implements FocusListener {

  final Border NORMAL = BorderFactory.createLineBorder(Color.black),
               FOCUS = BorderFactory.createLineBorder(Color.blue, 4),
               ERROR = BorderFactory.createLineBorder(Color.red, 4);

  // Tworzymy obiekt typu InputVerifier
  InputVerifier inputVerifier = new InputVerifier() {

    public boolean verify(JComponent c) {         // zdefiniowanie metody verify
      String txt = ((JTextField) c).getText();    // jaki tekst w polu tekstowym
      if (txt.equals("")) return true;            // pusty jest OK
      try {                                       // sprawdzamy czy liczba
        Integer.parseInt(txt);
      } catch (NumberFormatException exc) {       // jeśli nie -
        c.setBorder(ERROR);                       // ramka czerwona!
        return false;                             // i nie wolno zmienić fokusu
      }
      return true;
    }
  };

  public InpVer() {
    super ("Input Verifier");
    setLayout(new GridLayout(0, 1, 5, 5));
    for (int i = 0; i < 5; i++) {
      JTextField tf = new JTextField(20);
      tf.setBorder(NORMAL);
      tf.addFocusListener(this);
      tf.setInputVerifier(inputVerifier);
      add(tf);
    }
    setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    pack();
    setLocationRelativeTo(null);
    setVisible(true);
  }

  // Poprzednie najprostze metody pokazywania gdzie fokus
  public void focusGained(FocusEvent e) {
    ((JComponent) e.getSource()).setBorder(FOCUS);
  }

  public void focusLost(FocusEvent e) {
    ((JComponent) e.getSource()).setBorder(NORMAL);
  }

  public static void main(String args[]) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        new InpVer();
      }
    });
  }
}

• możemy się teraz dowiedzieć w metodzie focusGained od jakiego komponentu dany komponent dostał fokus, a w metodzie focusLost - na rzecz jakiego komponentu dany komponent traci fokus. Informacji tej dostarcza metoda Component getOppositeComponent() z klasy FocusEvent,
• możemy przechwytywać zdarzenia z klawiatury przed ich dojściem do KeyboardFocusManagera za pomocą interfejsu KeyEventDispatcher, a także otrzymywać wszystkie zdarzenia z klawiatury do ew. obróbki za .pomcoą interfejsu KeyEventPostProcessor już po ich przetworzeniu przez właścicieli fokusu,
• możemy zmieniać/blokować/ustalać zestaw kluczy zmian fokusu dla każdego komponentu oraz politykę zmian fokusu w konenerach (interfejs FocusTravelsalPolicy - w jakiej kolejności komponenty otzrymują fokus), m.in możemy w ogóle zablokować  użycie kluczy zmian fokusu za pomocą metody, Component.setFocusTraversalKeysEnabled(false) , umożliwiając w ten sposób otrzymywanie tych kluczy do obsługi w metodach obsługi zdarzeń z klawiatury na dowolnych komponentach, co we wcześniejszych wersjach Javy nie było mozliwe.

6. Obsługa klawiatury

import java.awt.event.*;
import java.util.*;

import javax.swing.*;
import javax.swing.text.*;

public class KbShort extends KeyAdapter {

  private TreeMap<String, String> hm = new TreeMap<String, String>();

  public KbShort(String[] keys, String[] txt) {
    for (int i = 0; i < keys.length; i++)
      hm.put(keys[i], txt[i]);
  }

  public void keyReleased(KeyEvent key) {
    int k = key.getKeyCode();
    int m = key.getModifiers();
    String t = hm.get(KeyEvent.getKeyModifiersText(m) +
                      KeyEvent.getKeyText(k));
    if (t == null) return;
    Object o = key.getSource();
    if (o instanceof JLabel)
      ((JLabel) o).setText(t);
    else if (o instanceof AbstractButton)
      ((AbstractButton) o).setText(t);
    else if (o instanceof JTextComponent) ((JTextComponent) o).setText(t);
  }
}

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;
import javax.swing.border.*;

public class FocusLabel extends MouseAdapter implements FocusListener {

  private static final Border lbord = BorderFactory.createLineBorder(Color.red, 2);

  private JLabel lab;

  public FocusLabel(String txt) {
    lab = new JLabel(txt);
    lab.addMouseListener(this);
    lab.addFocusListener(this);
  }

  public JLabel getLabel() {
    return lab;
  }

  public void mousePressed(MouseEvent e) {
    lab.requestFocusInWindow();
  }

  public void focusGained(FocusEvent e) {
    lab.setBorder(lbord);
  }

  public void focusLost(FocusEvent e) {
    lab.setBorder(null);
  }
}

import java.awt.*;

import javax.swing.*;

public class Keys extends JFrame {

  String[] keys = { "AltW", "AltK", "AltP" };         // klucze i
  String[] txt = { "Warszawa", "Kraków", "Poznań" };  // związane z nimi teksty
  
  KbShort ks = new KbShort(keys, txt);                // słuchacz klawiatury

  public Keys() {
    setLayout(new FlowLayout());
    
    // dla zwięzłości kodu konfigurowanie i dodawanie komponentów
    // powierzamy metodzie addComponent(...)
    addComponent(new FocusLabel("Miasto1").getLabel());
    addComponent(new FocusLabel("Miasto2").getLabel());
    addComponent(new JTextField(10));
    addComponent(new JButton("Przycisk"));

    setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    pack();
    setLocationRelativeTo(null);
    setVisible(true);
  }

  void addComponent(JComponent c) {
    c.addKeyListener(ks);
    add(c);
  }

  public static void main(String[] args) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        new Keys();
      }
    });
  }

}

7. Obsługa okien

• zdefiniować Słuchacza zdarzeń okiennych (WindowListener) poprzez implementację interfejsu WindowListener lub wykorzystanie adaptora WindowAdapter,
• stworzyć Słuchacza (nowy obiekt).
• przyłączyć Słuchacza do głównego okna aplikacji.

mport java.awt.event.*;
import java.util.*;
import javax.swing.*;

public class Okna extends JFrame {

  // mapa: stan okna (stała int z klasy JFrame) -> opis stanu
  HashMap<Integer, String> wstat = new HashMap<Integer, String>();  

  // Sluchacz zmiany stanu okna
  WindowStateListener wsl = new  WindowStateListener() {

    { // blok inicjacyjny
       wstat.put(NORMAL, "Normal");
       wstat.put(ICONIFIED, "Minimized");
       wstat.put(MAXIMIZED_VERT, "Maximized vertically");
       wstat.put(MAXIMIZED_HORIZ,"Maximized horizontally");
       wstat.put(MAXIMIZED_BOTH,"Maximized");
    }

    public void windowStateChanged(WindowEvent e) {  // obsługa zdarzenia zmiany stanu
      String old = wstat.get(e.getOldState());
      String now =  wstat.get(e.getNewState());
      System.out.println("Zmiana stanu z " + old + " na " + now);
    }

  };

  public Okna() {
    addWindowStateListener(wsl);
    
    add(new JLabel("Przyciski poniżej zmieniają stan okna"));
    
    JPanel p = new JPanel();

    for (int k : wstat.keySet()) {
      String opis = wstat.get(k);              // opis stanu
      JButton b = new JButton(opis);
      b.setActionCommand(""+k);                // command = identyfikator stanu
      b.addActionListener( new ActionListener() {
       public void actionPerformed(ActionEvent e) { // ustalenie stanu okna
          setExtendedState(Integer.parseInt(e.getActionCommand()));
        }
      });
      p.add(b);
    }
    add(p, "South");
    setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    pack();
    setLocationRelativeTo(null);
    setVisible(true);
  }

  public static void main(String args[]) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        new Okna();
      }
    });
  }
}

8. Zdarzenia na komponentach wyboru

• Checkbox, CheckboxMenuItem, Choice, List (z AWT)
• JCheckBox, JRadioButton, JComboBox (ze Swingu)

• ItemSelectable getItemSelectable() - zwraca komponent wyboru jako ItemSelectable
•  int getStateChange()     - zwraca rodzaj zmiany jako stałą całkowitoliczbową ItemEvent.SELECTED lub ItemEvent.DESLECTED
• Object getItem()      - zwraca element podlegający zmianie

package itemsel;
import java.awt.*;
import java.awt.event.*;

import javax.swing.*;
import javax.swing.event.*;
import java.util.*;

public class ItemSel extends JFrame implements ItemListener {


  private String[] countries = { "Polska", "Rosja", "Hiszpania", };
  private String[][] towns = { { "Warszawa", "Poznań", "Kraków", },
                                   { "Moskwa", "Władywostok", },
                                   { "Madryt", "Barcelona", },   };

  private JComboBox cbCountry = new JComboBox(countries);
  private JComboBox cbTown = new JComboBox(towns[0]);

  private HashMap<String, Set<String>> countryTowns = new HashMap<String, Set<String>>();

  public ItemSel() {
    for (int i=0; i < countries.length; i++) {
      String key = countries[i];
      TreeSet<String> tSet = new TreeSet<String>();
      for (int j =0; j < towns[i].length; j++) {
        tSet.add(towns[i][j]);
      }
      countryTowns.put(key, tSet);
    }
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        setLayout(new FlowLayout());
        cbCountry.addItemListener(ItemSel.this);
        add(cbCountry);
        add(cbTown);
        setDefaultCloseOperation(DISPOSE_ON_CLOSE);
        pack();
        setLocationRelativeTo(null);
        setVisible(true);        
      }
    }); 
  }

  public void itemStateChanged(ItemEvent e) {
    if (e.getStateChange() == ItemEvent.SELECTED) {
       String country = (String) e.getItem();
       if (country == null) return;
       Set<String> towns =  countryTowns.get(country);
       if (towns == null) return;
       cbTown.removeAllItems();
       for(String t : towns) cbTown.addItem(t);
    }
  }

  public static void main(String args[]) {
    new ItemSel();
  }

}