Programowanie GUI: komponenty wizualne i kontenery

1. Ogólne reguły działania z komponentami GUI.

• Komponenty tworzymy za pomocą wyrażenia new wywołującego odpowiedni konstruktor klasy komponentu, któremu podajemy argumenty, określające niektóre właściwości komponentu (np. tekst/ikonę na przycisku).
• Komponenty mają właściwości (np. kolory, pismo tekstu na przycisku), które możemy ustalać (lub pobierać) za pomocą metod z odpowiednich klas komponentów (metody setNNN(...), getNNN(...), isNNN(...), gdzie NNN nazwa właściwości).
• Większość właściwości komponentów jest reprezentowane przez obiekty odpowiednich klas (np. pismo – klasa Font, kolor – klasa Color)
• Komponenty, które mogą zawierać inne komponenty nazywają się kontenerami.
• Do kontenerów dodajemy inne komponenty (w tym inne kontenery)
• Z każdym kontenerem związany jest określony zarządca rozkładu, który określa układ komponentów w kontenerze i ich zachowanie (zmiany rozmiarów i położenia) przy zmianie rozmiarów kontenera. Inaczej: rozkład jest jedną z właściwości kontenera.
• Zarządcy rozkładu są obiektami odpowiednich klas
• Dla każdego kontenera możemy ustalić wybranego zarządcę rozkładu
• Aplikacja komunikuje się z użytkownikiem za pomocą okna lub wielu okien
• Okna AWT są kontenerami, do których dodajemy komponenty wizualnej interakcji z użytkownikiem (w tym inne kontenery)
• Okna Swingu zawierają tzw. contentPane, który jest kontenerem do którego domyślnie dodajemy komponenty wizualnej interakcji (w tym inne kontenery).
• Okna (w tym "okno" apletu) są zawsze kontenerami najwyższego poziomu w hierarchii zawierania się komponentów
• Współdziałanie użytkownika z aplikacją odbywa się na zasadzie obsługi zdarzeń (np. zdarzenia kliknięcia w przycisk). Obsługą zdarzeń zarządza specjalny, równolegle z naszym programem wykonujący się kod w JVM – wątek obsługi zdarzeń. O obsłudze zdarzeń – w następnym wykładzie.

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

class Intro  {

public static void main(String[] args)  {
  
  // ta klasa (potrzebne do niezależnego pobierania zasobów, takich jak obrazki)
  Class<Intro> klas = Intro.class;

  // Ikony z plików graficznych zawartych w katalogu images aplikacji 
  Icon[] icon = { new ImageIcon(klas.getResource("images/ocean.jpg")),  
                  new ImageIcon(klas.getResource("images/pool.jpg")),
                  new ImageIcon(klas.getResource("images/town.jpg")),
                };
  
  String[] opis = { "Ocean", "Pool", "Town" }; // tekst na przyciskach

  JFrame frame = new JFrame("First Swing");    // utworzenie okna ramowego z podanym tytułem
  frame.setLayout(new FlowLayout());           // ustalenie rozkładu jego contentPane

  for (int i=0; i<icon.length; i++) {

     // tworzenie kolejnych przycisków
     JButton b = new JButton(opis[i], icon[i]);

     // Ustalenie pisma i koloru napisu na przyciskach
     b.setFont( new Font("Dialog", Font.BOLD | Font.ITALIC, 18));
     b.setForeground(Color.blue);

    //  Ustalenie pozycji tekstu na przycisku względem ikony
     b.setVerticalTextPosition(SwingConstants.BOTTOM);
     b.setHorizontalTextPosition(SwingConstants.CENTER);

     frame.add(b);   // dodanie przycisku do contentPane okna
     }

  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frame.pack();           // spakowanie okna
                          // (wymiary okna takie by dokładnie zmieścić komponenty)
  
  frame.setLocationRelativeTo(null);  // centrowanie okna w obszarze pulpitu 
  frame.setVisible(true);             // pokazanie okna
  }

}

2. Komponenty AWT a komponenty Swingu

• ubogie możliwości graficzne i interakcyjne komponentów,
• brak komponentów istotnych dla oprogramowania nowoczesnych GUI (np. tabel)
• zależny od platformy systemowej wygląd komponentów

• komponenty lekkie mogą być przezroczyste, a zatem mogą przybierać wizualnie dowolne kształty
• komponenty lekkie mają wygląd niezależny od platformy.

Wnioski, które wynikają z tej hierarchii :

• podstawowe właściwości wszystkich komponentów (i AWT i Swingu, i komponentów terminalnych i kontenerów) określa klasa Component z pakietu java.awt; w klasie tej znajdziemy mnóstwo użytecznych metod do ustalania i pobierania właściwości dla każdego z możliwych komponentów,

• podstawowe właściwości i użyteczne metody dla wszystkich kontenerów określa klasa Container,

• szczególne dla lekkich komponentów Swingu, ale wspólne dla nich wszystkich, właściwości określa klasa JComponent

• specyficzne właściwości i funkcjonalność poszczególnych rodzajów komponentów zdefiniowane są w klasach tych komponentów

3. Krótki przegląd komponentów Swingu

4. Wspólne właściwości komponentów (AWT i Swing)

5. Własne komponenty i rysowanie

• komponent staje sie widoczny na ekranie,
• zmieniają się rozmiary komponentu,
• coś innego zasłoniło komponent, a potem został odsłonięty.

• uzyskiwanie i ustalanie właściwości kontekstu graficznego,
• rysowanie linii i figur,
• wypisywanie tekstów,
• rysowanie obrazów (obiektów klasy Image).

• rysowanie jest realizowane przez pióro, które zostawia ślad o szerokości i wysokości  jednego piksela,
• pióro zostawia ślad PONIŻEJ i Z PRAWEJ strony ścieżki współrzędnych określonych w danej operacji rysowania.

public void paintComponent(Graphics g) {
  g.drawRect(0, 0, getWidth()-1, getHeight()-1);
}

public void paint(Graphics g) {
  g.fillRect(0,0,getWidth(),getHeight());
}

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

class CustButton extends JButton {

  public CustButton(String txt) {
    super(txt);
    setFont(new Font("Dialog", Font.PLAIN, 24)); 
  }

  public void paintComponent(Graphics g) {
    super.paintComponent(g);
    int w = getWidth();       // aktualna szerokość ...
    int h = getHeight();      // i wysokość komponentu
    g.setColor(Color.red);    // ustalenie koloru rysunku
    // rysowanie kwadracików
    g.fillRect(0, 0, 10, 10);
    g.fillRect(w-10, 0, 10, 10);
    g.fillRect(0, h-10, 10, 10);
    g.fillRect(w-10, h-10, 10, 10);
  }
}

public class ButtonTest extends JFrame {
	
	public ButtonTest() {
	  CustButton mb = new CustButton("To jest przycisk");
	  add(mb);
	  setDefaultCloseOperation(EXIT_ON_CLOSE);  // domyślna operacja zamknięcia okna: koniec pracy
	  pack();
	  setLocationRelativeTo(null);
	  setVisible(true);
	}

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

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

class ObszarRysunku extends JComponent {

  public ObszarRysunku(int w, int h) {
    Dimension d = new Dimension(w, h);
    setMinimumSize(d);
    setPreferredSize(new Dimension(d));
    setMaximumSize(d);
  }

  public void paintComponent(Graphics g) {
    super.paintComponent(g);
    int w = getWidth();
    int h = getHeight();
    g.setColor(Color.blue);
    g.drawRect(0,0,w-1,h-1);
    int hor = 10, vert = 10;
    while (hor < h) {
       g.drawLine(1, hor, w-1, hor);
       hor += 10;
    }

    while (vert < w) {
       g.drawLine(vert, 1 , vert, h-1);
       vert += 10;
    }
  }
}

public class Siatka extends JFrame {

  public Siatka() {
    super("Siatka");
    add(new  ObszarRysunku(200, 100));
    setDefaultCloseOperation(EXIT_ON_CLOSE);  
    pack();
    setLocationRelativeTo(null);
    setVisible(true);
  }

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

}

    public void paintComponent(Graphics g) {
        String s = "jakis tekst";
        int y = ... ; // położenie w pionie
        int w = getWidth();
        int h = getHeight();
        g.drawString(s, (w - g.getFontMetrics().stringWidth(s))/2, y);
        ...
        }

• getHeight(),
• getAscent(), 
• getDescent(),
• getLeading()

 MediaTracker mt = new MediaTracker(this);
 Toolkit tk = Toolkit.getDefaultToolkit();
 Image img = tk.getImage(nazwaPliku);
 mt.addImage(img, 1);         // drugi argument - identyfikaor, pozwalający dzielić
                              // obrazy na grupy z różnymi priorytetami ładowania

 try {
      mt.waitForAll();
 } catch(InterruptedException e) { System.exit(1); }

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

class ImagePanel extends JPanel {

  Image img;
  boolean loaded = false; // czy obrazek został załadowany?

  public ImagePanel(String imgFileName) {
    loadImage(imgFileName);
  }

  public void paintComponent(Graphics g) {
    super.paintComponent(g);
    if (img != null && loaded)
      g.drawImage(img, 0, 0, getWidth(), getHeight(), this);
    else
      g.drawString("Bez obrazka", 10, getHeight() - 10);
  }

  private void loadImage(String imgFileName) {
    img = Toolkit.getDefaultToolkit().getImage(imgFileName);
    MediaTracker mt = new MediaTracker(this);
    mt.addImage(img, 1);
    try {
      mt.waitForID(1);
    } catch (InterruptedException exc) {
    }
    int w = img.getWidth(this); // szerokość obrazka
    int h = img.getHeight(this); // wysokość obrazka
    if (w != -1 && w != 0 && h != -1 && h != 0) {
      loaded = true;
      setPreferredSize(new Dimension(w, h));
    } else
      setPreferredSize(new Dimension(200, 200));
  }

}

public class ImagePanelTest extends JFrame {

  public ImagePanelTest(String fname) {
    ImagePanel p = new ImagePanel(fname);
    p.add(new JButton("Jakiś przycisk"));
    add(p);
    pack();
    setLocationRelativeTo(null);
    setVisible(true);
  }

  public static void main(String args[]) {
    new ImagePanelTest("pool2.jpg"); // argument - nazwa pliku graficznego (z
                                     // roboczego katalogu aplikacji)
  }
}

• W metodzie loadImage ładujemy obrazek i uzyskujemy jego wymiary. Służą temu metody getWidth(...) i getHeight(...) z klasy Image. Ich argumentem jest ImageObserver, możemy podać this, bo klasy wszystkich komponentów implementują interfejs ImageObserver. Zgodnie z tymi wymiarami ustalamy preferowane rozmiary kontenera, Jeśli obrazek (z jakichś przyczyn) nie jest gotowy do wyświetlenia (-1 jako wynik metod getWidth lub getHeight) - ustalamy domyślne rozmiary kontenera, a w metodzie paintComponent - wykreślimy u jego dołu napis "Bez obrazka".
• Zauważmy też, że wykreślając obrazek metodą drawImage jako jego szerokośc i wysokość podajemy aktualne rozmiary kontenera. Rozmiary te mogą się zmieniać i zgodnie z tymi zmianami obrazek będzie reskalowany.
• Nieco prostszy program uzyskamy używając klasy ImageIcon, która przy konstrukcji obiektów automatycznie  używa MediaTrackera i synchronicznie ładuje obraz. Nie będziemy więc musieli zapisywać kodu związanego z MediaTrackerem, ale za to będziemy musieli od obiektu klasy ImageIcon uzyskać obraz klasy Image (więcej o tym w za chwilę).
  

6. Kontenery

7. Okna

• okno bez ramki, menu i tytułu.
• ma właściciela - inne okno.
• nie podlega przesunięciom wraz z właścicielem.
• nie jest modalne.

• niezależny od platformy wygląd
• muszą być dodawane do innych kontenerów
• dodatkowe możliwości programistyczne (np. dynamicznych zmian właściwości takich jak możliwość zmiany rozmiaru, możliwość maksymalizacji itp.)

• DO_NOTHING_ON_CLOSE
• HIDE_ON_CLOSE  - operacja domyślna (chowa okno, ale nie likwiduje go)
• DISPOSE_ON_CLOSE - usunięcie okna
• EXIT_ON_CLOSE - powoduje zamknięcie aplikacji

8. Rozkłady

8.1. Zarządcy rozkładów - zasady ogólne

• stworzyć obiekt-zarządce rozkładu,
• ustalić ten rozkład dla konetnera.

8.2. Proste rozkłady - FlowLayout, BorderLayot i GreedLayout

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

public class LayShow {

  public static void main(String[] args) {

    final int CNUM = 5; // liczba komponentów w panelach

    String lmNames[] = {
        "Flow Layout", // opisy rozkładów
        "Flow (left aligned)", "Border Layout", "Grid Layout(1,num)",
        "Grid Layout(num, 1)", "Grid Layout(n,m)", };

    LayoutManager lm[] = {
        new FlowLayout(), // rozkłady
        new FlowLayout(FlowLayout.LEFT), new BorderLayout(),
        new GridLayout(1, 0), new GridLayout(0, 1), new GridLayout(2, 0), };
    
    // argumenty dla rozkladu BorderLayout
    String gborders[] = { "West", "North", "East", "South", "Center" };
    
    // Kolory paneli
    Color colors[] = { new Color(191, 225, 255), new Color(255, 255, 200),
        new Color(201, 245, 245), new Color(255, 255, 140),
        new Color(161, 224, 224), new Color(255, 255, 200), };

    Icon redDot = new ImageIcon("red.gif"); // ikonka na przycisku

    JFrame frame = new JFrame("Layouts show"); // okno i contentPane

    frame.setLayout(new GridLayout(0, 2));

    for (int i = 0; i < lmNames.length; i++) {
      JPanel p = new JPanel();
      p.setBackground(colors[i]); // kolor tła panelu
      p.setBorder(BorderFactory.createTitledBorder(lmNames[i])); // ramka
      p.setLayout(lm[i]); // ustalenie rozkładu
      Icon icon = null;

      // Możemy sprawdzić z jakim rozkładem mamy do czynienia
      // i odpowiednio do tego coś zrobić (tu: ikonka na przyciskach)
      if (lm[i] instanceof BorderLayout) icon = redDot;
      for (int j = 0; j < CNUM; j++) { // dodajemy przyciski do paneli
        JButton b = new JButton("P " + (j + 1), icon);
        p.add(b, gborders[j]);
      }
      frame.add(p);
    }
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.pack();
    frame.setVisible(true);
  }
}

8.3. Rozkład BoxLayout

• klej (glue)
• sztywny obszar (rigid area) oraz
• wypełniacz (box-filler).

	Trzy komponenty dodane do pionowego BoxLayout. Ich maksymalne rozmiary  są ograniczone, wolne miejsce pojawia się u dołu kontenera. Domyślne wyrównanie - do lewej
	Zmiana wyrównania komponentów po osi X: setAlignmentX(Component.CENTER_ALIGNMENT)
	Pomiędzy komponentami dodano sztywne obszary stworzone metodą Box.createRigidArea(new Dimension(0,10); Wolne miejsce nadal jest lokowane u dołu kontenera, a odstępy między komponentami są stałe
	Tym razem pomiędzy komponentami dodano dwa komponenty-kleje (Box.createGlue()). Przy zmianie rozmiarów kontenera ew. wolne miejsce jest lokowane pomiędzy komponentami. Jeśli nie ma nadmiarowego miejsca komponenty stykają się ze sobą.
	Tu komponenty nie mają ograniczonych maksymalnych rozmiarów lub rozmiary te są odpowiednio duże.  Wolne miejsce jest wypełniane przez BoxLayout poprzez zmianę rozmiaru komponentów. Maksymalne rozmiary komponentów możemy zmieniać dynamicznie za pomocą metody setMaximumSize.

8.4. Rozkłady TableLayout i MigLayout

• ściągnąć  odpowiedni JAR ze strony https://tablelayout.dev.java.net/
• dodać ten JAR do BuildPath naszego projektu (w Eclipse opcja Configure BuildPath, Libraries, Add External JARs).

• jako rozmiary absolutne - w pikselach (wartości  od 1.0 w górę),
• jako rozmiary relatywne - w procentach wolnej przestrzeni (wartości z przedziału 0-0.99, np. 0.5 oznacza 50% wolnego miejsca),
• jako stałą TableLayout.PREFERRED (oznacza rozmiar wiersza lub kolumny równy maksymalnemu z preferowanych rozmiarów umieszczonych w komórkach komponentów),
• jako stałą TableLayout.FILL, co oznacza, że rozmiar kolumny lub wiersza będzie wypełniał całą dostępną po alokacji innych szerokości (absolutnych i relatywnych) przestrzeń,

import info.clearthought.layout.*;
import javax.swing.*;

public class TabLay1 extends JFrame {
  
  public TabLay1(String[] labs, int[] fwidth) {
    
    final int N = labs.length,  // liczba dynamicznych elementów: etykieta - pole tekstowe
              GAP = 10;         // odstęp
    
    // Kolumny rozkładu
    double[] cols = { GAP, TableLayout.PREFERRED, TableLayout.FILL, TableLayout.PREFERRED, GAP};
    
    // Wiersze rozkładu
    double[] rows = new double[N + 5];
    
    rows[0] = GAP;  // odstęp górny
    
    for (int i=0; i < N; i++) rows[i+1] = TableLayout.PREFERRED; // etykiety-pola txt
    
    int rhead = N+1;                   // wiersz nagłówków (etykiet wyjasniajacych)  
    rows[rhead] = TableLayout.PREFERRED;
    
    int rcomm = N+2;                    // wiersz dodatk. komentarzy (JTextArea)
    rows[rcomm] = TableLayout.FILL;
    
    int rbutt = N+3;                   // wiersz przycisków
    rows[rbutt] = TableLayout.PREFERRED;                            
    
    rows[N+4] = GAP; // odstęp końcowy
    
    // Utworzenie i ustalenie rozkładu
    TableLayout lay = new TableLayout(cols, rows);
    lay.setHGap(7);  // odstępy pomiędzy komórkami
    lay.setVGap(5);
    setLayout(lay);
    
    
    // Dodanie elementów dynamicznych
    for (int i=0; i < N; i++) {
      int r = i + 1;
      add(new JLabel(labs[i]), "1 " + r + " right center" );
      add(new JTextField(fwidth[i]), "2 " + r + " left center");
      add(new JCheckBox(), "3 " + r + " left center");
    }
    
    add(new JLabel("Dodatkowe komentarze"),"2 " + rhead + " 3 " + rhead + " center center");
    add(new JLabel("<html><i>Wybór<br>miasta</i></html>"), "1 " + rhead  + " center center");
    JList list = new JList(new String[] { "Warszawa", "Poznań", "Wrocław", "Gdańsk", 
        "Lublin", "Katowice", "Szczecin", "Białystok", "Bielsko-Biała"  });
    add(new JScrollPane(list), "1 " + rcomm + " 1 " + rbutt + " full full ");
    add(new JScrollPane(new JTextArea(10, 50)), "2 " + rcomm + " 3 " + rcomm);
    add(new JButton("Dodaj"), "2 " + rbutt + " 3 " + rbutt + " left full");
    add(new JButton("Znajdź"), "2 " + rbutt + " 3 " + rbutt + " center full");
    add(new JButton("Wyślij"), "2 " + rbutt + " 3 " + rbutt + " right full");
    setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    pack();
    setVisible(true);   
  }

  public static void main(String[] args) {
    new TabLay1(new String[] {"Imię", "Nazwisko", "Pesel", "Rok urodzenia", "Adres"},
                new int[] { 20, 30, 12, 8, 45 });
  }

}

• komponenty dodawane bez żadnych ograniczeń trafiają do bieżącego wiersza,
• gdy zastosujemy ograniczenie "wrap", następne komponenty będą dodawane w następnym wierszu,
• gdy zastosujemy ograniczenie "span", komponent zajmuje więcej niż jedną komórkę,
• możemy ustalać bardzo precyzyjnie sposób reagowania na zmiany rozmiarów kontenera, tu proste ograniczenie "grow" powoduje zwiększanie rozmiarów komponentu, a "shrink" określa dopuszczalne granice jego zmniejszania się,
• możemy też za pomocą słówka "gap" określać odstępy.
• wyrównania komponentów w komórkach określane są typowymi słowami: "left", "right" itp.
• można modyfikować minimalne, preferowane i maksymalne rozmiary komponentów przy ich dodawaniu metodą add.

import javax.swing.*;

import net.miginfocom.swing.*;

public class MigTest extends JFrame {

  public MigTest() {
    
    // Ustalenie rozkładu
    // drugi argument kosntruktora dotyczy ograniczeń kolumn rozkładu
    // tu: komponenty w pierwszej kolumnie będą równane do prawej
    //     trzecia koleumna może zwiększac swoje rozmiary
    
    setLayout(new MigLayout("", "[right][][grow]"));
    
    add(new JLabel("Imię"));  
    add(new JTextField(10));
    add(new JLabel("Nazwisko"), "right align, gapleft 10"); // równanie do prawej, odstęp 10
    add(new JTextField(20), "growx, wrap"); // może rosnąć, przejście do nowego wiersza
    add(new JLabel("Adres"));
    add(new JTextField(), "growx, span, wrap");   // może rosnąć, zajmuje cały wiersz,
                                                  // i zaczynamy nowy wiersz
    add(new JCheckBox("Podlega zniżce?"), 
                       "skip 3, right align");   // przeskocz 3 kolumny, wyrównaj do prawej
    
    setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    pack();
    setVisible(true);
  }

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

}

Zobacz zaawansowaną demonstrację możlwości MigLayout

9. Działania na kontenerach

• getLayout - zwraca referencję do aktualnie ustalonego zarządcy rozkładu
• getComponents  - zwraca tablicę komponentów (obiektów typu Component), które znajdują  się w kontenerze
• validate  - uaktualnia położenie i rozmiary komponetów w kontenerze

1. rozjaśnia tło tego komponentu (metoda brighter z klasy Color)
2. przyciemnia tło wszystkich innych zawartych w kontenerze komponentów (metoda darker z klasy Color)
3. jesli kontener ma rozkład FlowLayout - dodaje do niego przycisk z napisem "Nowy przycisk"

void  chgCont(Component comp) {
  Container cont = comp.getParent(); // rodzic komponentu
                                     // w hierarchii zawierania się komponentów

  Component[] c = cont.getComponents();  // uzyskanie wszystkich komponentów

  for (int i=0; i<c.length; i++) {         // przyciemnianie i rozjaśnianie
    Color back = c[i].getBackground();
    if (c[i] == comp)   c[i].setBackground(back.brighter());
    else c[i].setBackground(back.darker());
  }

  LayoutManager lm = cont.getLayout();

  if (lm instanceof FlowLayout) {  // jeżeli rozkład Flow - dodaj nowy przycisk
     cont.add(new JButton("Nowy przycisk"));
  }
  cont.validate(); // musi być użyte po dodaniu komponentu:
                   // znak, ze kontener ma byc odswieżony
}

10. Komponenty Swingu a wielowątkowość. Schemat aplikacji Swing

    SwingUtilities.invokeLater( new Runnable() {
       public void run() {
         // tu działania na komponentach Swingu
       }
    });

• Typowe aplikacje GUI konstruowane są jako okna, zatem klasa aplikacji dziedziczy klasę okna.
• W kontrsuktorze dokonujemy ew. incjacji pól klasy niezwiązanych z komponentami GUI, anastępnie w wątku obsługi zdarzeń  budujemy GUI
• A zatem ustalany jest (jeśli trzeba) rozkład komponentów i ich właściwości.
• Komponenty dodawane są do okna
• Ustala się rozmiary okna i pokazuje okno.
• Dzialania te można dla lepszej strukturyzacji kodu wyodrębnić jako metodę o nazwie np. createGui i wywołac ją przez invokeLater.

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

public class GuiSwing extends JFrame {

  public GuiSwing() {
    // jakieś dzialania inicjacyjne, nie związane z komponentami Swing
    // ...

    // budujemy okno;
    // ponieważ jest to działanie na komponentach wizualnych
    // - zrobimy to w wątku obsługi zdarzeń
    SwingUtilities.invokeLater(new Runnable() {

      @Override
      public void run() {
        createGui();
      }
    });
  }

  protected void createGui() {
    // ustalenie tytułu okna
    setTitle("Okno aplikacji");

    // ustalenie rozkładu - jeśli trzeba, np:
    setLayout(new FlowLayout());

    // tworzenie komponentów np.
    JLabel lab = new JLabel("Etykieta");
    JButton b = new JButton("Przycisk");

    // Ustalenie własciwości komponentów,
    // np:
    lab.setForeground(Color.red);
    b.setForeground(Color.blue);

    // Dodanie komponentów do okna np.
    add(lab);
    add(b);

    // Ustalenie domyślnej operacji zamknięcia okna
    setDefaultCloseOperation(EXIT_ON_CLOSE);

    // ustalenie rozmiarów okna, np.:
    pack();

    // ustalenie położenia okna np. wycentrowanie

    setLocationRelativeTo(null);

    // pokazanie okna
    setVisible(true);
  }

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

11. J-komponenty (wspólne właściwości lekkich komponentów Swingu)

• są komponentami lekkimi o niezależnym od platformy systemowej wyglądzie (ale zależnym od dobieranych przez programistę ustaleń - "Look and Feel")
• możemy ustalać czy mają być przezroczyste, czy nie,
• istnieje możliwość zewnętrznego ustalania ich preferowanych, maksymalnych i minimalnych rozmiarów (metody setPreferredSize,   setMaximumSize, setMinimumSize), oraz ich wyrównania względem innych komponentów (metody setAlignmentX, setAlignmentY)
• mogą mieć ramki o dowolnie ustalanej formie,
• mogą mieć podpowiedzi  ( "dymki" pomocy - fly-over help, tooltips)
• mogą być uaktywniane z klawiatury (operowanie na GUI za pomocą klawiatury, nie tylko myszki)
• mogą mieć przypisaną dodatkową informację (w postaci tablicy asocjacyjnej, kojarzącej obiekty-klucze i obiekty-wartości)

• ustalenie ramki za jej pomocą nie wymaga importu klas ramkowych (z pakietu javax.swing.border)
• nazwy (statycznych) metod tej klasy są łatwe do zapamiętania
• obiekty-ramki, dostarczane przez BorderFactory mogą być  dzielone (shared) pomiędzy komponentami, dla których ustalamy ramki (jedna i ta sama ramka stworzona przez BorderFactory może być używana przez wiele komponentów równocześnie).

comp.setBorder( BorderFactory.createCompoundBorder(
                            BorderFactory.createLineBorder(Color.blue),
                            comp.getBorder());

• stworzyć nową klasę, dziedziczącą klasę AbstractBorder  (która abstrakcyjnie implementuje interfejs Border)
• dostarczyć implementacji metod interfejsu Border:
• paintBorder - rysującej ramkę
• getBorderInsets - zapewniającej odpowiednie rozmiary dla ramki

import javax.swing.border.*;
//...
private Border
   empty = BorderFactory.createEmptyBorder(),
   blackLine = BorderFactory.createLineBorder(Color.black),
   redLine = BorderFactory.createLineBorder(Color.red),
   titled1 = BorderFactory.createTitledBorder("Tytuł"),
   titled2 = BorderFactory.createTitledBorder(redLine,"Tytuł"),
   etched = BorderFactory.createEtchedBorder(),
   etchedC = BorderFactory.createEtchedBorder(Color.red, Color.yellow),
   raisedBevel = BorderFactory.createRaisedBevelBorder(),
   loweredBevel = BorderFactory.createLoweredBevelBorder(),
   matteColor = BorderFactory.createMatteBorder(5, 10, 5, 15, Color.blue),
   matteIcon = BorderFactory.createMatteBorder(24,24,24,24,
               new ImageIcon("Volume24.gif")),
   softBevR = new SoftBevelBorder(SoftBevelBorder.RAISED),
   softBevL = new SoftBevelBorder(SoftBevelBorder.LOWERED),
   compound1 = BorderFactory.createCompoundBorder(softBevR, softBevL),
   compound2 = BorderFactory.createCompoundBorder(redLine, compound1),
   compound3 = BorderFactory.createCompoundBorder(
                 BorderFactory.createLineBorder(Color.blue), matteIcon);

• ustalaniu lokalizacji napisu
• ustalaniu różnych napisów dla różnych obszarów komponentu

int getIconWidth()
int getIconHeigh()
void paintIcon(Component c,  int x, int y)

JFrame f = new JFrame(...);
...
Jlabel l = new JLabel(new ImageIcon("Obraz.jpg"));
f.getContentPane.add(l);

12. Etykiety i przyciski

• możliwe jest umieszczania ikon obok (lub zamiast) tekstu etykiety (tekst lub ikonę podajemy jako argument konstruktora, możemy je też pobrać za pomoca metod getText() i getIcon() oraz ustalić za pomocą metod setText(String), setIcon(Icon),
• możliwe jest kontrolowanie położenia ikony i/lub tekstu w obszarze etykiety w pionie i poziomie (metody setHorizontalAlignment(int), setVerticalAlignment(int))
• mozliwe jest kontrolowanie położenia tekstu wobec ikony (setHorizontalTextPosition(int), setVerticalTextPosition(int))
• możliwe jest wyświetlanie tekstów HTML na etykiecie (dzięki czemu, na przykład, można w prosty sposób zrealizować wielowierszowe etykiety z fragmentami tekstu w różnych stylach),
• z każdą etykietę za pomocą metody labelFor(Component) można skojarzyć komponent ("oznaczany" przez tę etykietę). Jeśli dodatkowo ustalimy skrót klawiaturowy za pomocą metody setDisplayedMnemonic(char), to podany znak będzie w etykiecie  podkreślony, a naciśnięcie klawiszy alt-znak spowoduje przejście fokusu do komponentu oznaczanego przez etykietę.

import java.awt.*;
import javax.swing.*;
import static java.awt.Color.*;
import static javax.swing.SwingConstants.*;

class Labels extends JFrame {

  public Labels() {
    setLayout(new GridLayout(0, 2));
    Icon i = new ImageIcon("red.gif");
    add(creLab("Lab 1", i, BLACK, YELLOW, LEFT, TOP, LEFT, CENTER));
    add(creLab("Lab 2", i, WHITE, BLUE, CENTER, CENTER, CENTER, BOTTOM));
    add(creLab("Lab 3", i, RED, WHITE, RIGHT, BOTTOM, RIGHT, CENTER));
    add(creLab("Lab 4", i, YELLOW, BLACK, LEFT, CENTER, CENTER, TOP));
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    pack();
    setVisible(true);
  }

  JLabel creLab(String txt, Icon icon, Color fc, Color bc, int halign,
      int valign, int htxtpos, int vtxtpos) {
    JLabel l = new JLabel(txt);
    l.setFont(new Font("Dialog", Font.BOLD, 24));
    l.setOpaque(true);
    l.setIcon(icon);
    l.setBackground(bc);
    l.setForeground(fc);
    l.setHorizontalAlignment(halign);
    l.setVerticalAlignment(valign);
    l.setHorizontalTextPosition(htxtpos);
    l.setVerticalTextPosition(vtxtpos);
    return l;
  }

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

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

class Labels2 extends JFrame {

  JPanel panel = new JPanel(new GridLayout(0, 2));

  Labels2() {

    String html = "<html><center>Proszę<br>"
        + "<b><font color=red>wpisywać</font></b><br>"
        + "<font color=blue>swoje <b>prywatne</b> dane"
        + "</font></center><br></html>";
    JLabel head = new JLabel(html);
    head.setHorizontalAlignment(JLabel.CENTER);
    add(head, BorderLayout.NORTH);
    addLabAndTxtFld("Nazwisko", 'n');
    addLabAndTxtFld("Rok urodzenia", 'r');
    addLabAndTxtFld("Adres", 'a');
    add(panel);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    pack();
    setVisible(true);
  }

  void addLabAndTxtFld(String txt, char mnemonic) {
    JLabel l = new JLabel(txt);
    l.setHorizontalAlignment(JLabel.RIGHT);
    JTextField tf = new JTextField(20);
    l.setLabelFor(tf);
    l.setDisplayedMnemonic(mnemonic);
    panel.add(l);
    panel.add(tf);
  }

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

• zwykły : JButton 
• podstawowy przełącznik : JToggleButton (przycisk dwustanowy o wyglądzie normalnego przycisku)
• znacznik : JCheckBox 
• radio-przycisk: JRadioButton - jak JCheckBox, ale z kropką; służy głownie od prezentacji wyłaczających się opcji.

• ustalanie różnych ikon (normalnej, w stanie wciśniętego przycisku, w stanie zaznaczonego przycisku, w stanie wskazania myszką przycisku itp.).
• ustalanie położenia tekstu względem ikony (w pionie i poziomie; stałe interfejsu SwingConstants: TOP, BOTTOM, CENTER, LEFT, RIGHT),
  
• symulacja kliknięcia (metoda doClick()...),
• ustalanie czy przycisk ma być przyciskiem domyślnym w oknie,
• ustalenie mnemoniki dla przycisku (litery w tekście na przycisku; wciśnięcie alt-litera będzie równoznaczne z kliknięciem w przycisk).
  

package buttons;

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

class IconA implements Icon {

  private Color color;
  private int w = 40;
  private boolean frame;

  IconA(Color c, boolean frame) {
    color = c;
    this.frame = frame;
  }

  public void paintIcon(Component c, Graphics g, int x, int y) {
    Color old = g.getColor();
    g.setColor(color);
    w = ((JComponent) c).getHeight() / 2;
    int p = w / 4, d = w / 2;
    g.fillOval(x + p, y + p, d, d);
    if (frame) g.drawRect(x, y, w - 1, w - 1);
    g.setColor(old);
  }

  public int getIconWidth() {
    return w;
  }

  public int getIconHeight() {
    return w;
  }

}

public class Butt1 extends JFrame {

  private Icon[] icons = { new IconA(Color.yellow, false), // normal
      new IconA(Color.blue, false), // over
      new IconA(Color.red, true), // pressed
      new IconA(Color.black, false), // selected
  };
  
  // przycisk, który bedzie programistycznie wciśnięty
  private JButton bpre = new JButton("Button - pressed");  

  Butt1() {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        setLayout(new GridLayout(0, 1, 10, 10));
        JButton b = new JButton("Button");
        setButt(b, icons, RIGHT, CENTER);
        JButton bmov = new JButton("Button - mouse over"); 
        setButt(bmov, icons, LEFT, TOP);
        setButt(bpre, icons, CENTER, TOP);

        JToggleButton tb = new JToggleButton("ToggleButton - selected");
        setButt(tb, icons, CENTER, BOTTOM);

        setDefaultCloseOperation(DISPOSE_ON_CLOSE);
        pack();
        setLocationRelativeTo(null);
        setVisible(true);
      }
    });    
    bpre.doClick(5000);
  }

  void setButt(AbstractButton b, Icon[] i, int horPos, int vertPos) {
    b.setFocusPainted(false);
    b.setIcon(i[0]);
    b.setRolloverIcon(i[1]);
    b.setPressedIcon(i[2]);
    b.setSelectedIcon(i[3]);
    b.setHorizontalTextPosition(horPos);
    b.setVerticalTextPosition(vertPos);
    add(b);
  }

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

}

13. Menu rozwijalne

JMenuItem mi(String t, Icon i, int mnemo, String accel) {
  JMenuItem mi = new JMenuItem(t, i);  // element menu z tekstem t oraz ikoną i
  mi.setMnemonic(mnemo);               // ustalenie mnemoniki
  mi.setAccelerator(KeyStroke.getKeyStroke(accel)); // ustalenie akceleratora
  return mi;
}

JMenu menu = new JMenu("File");
JMenuItem mi = mi("New", newIcon, 'n', "control N");
menu.add(mi);                                      // dodanie opcji do menu
menu.add(mi("Open", openIcon, 'o', "control O" ));
menu.addSeparator();                               // dodaje separator
menu.add(mi("Exit", null, 'x', "control X"));
  

JMenu  menu1 = new JMenu("Run");
menu1.setIcon( new ImageIcon("red.gif"));
menu1.setMnemonic('r');
menu1.setHorizontalTextPosition(SwingConstants.LEFT);

 JMenuBar mb = new JMenuBar();
 mb.add(menu);      // menu "File"
 mb.add(menu1);     // menu "Run"
 f.setJMenuBar(mb); // f - oznacza obiekt typu JFrame

 JSeparator sep = new JSeparator(SwingConstants.VERTICAL);
 sep.setMaximumSize(new Dimension(100,100));
 mb.add(sep);
 JMenu  menu2 = new JMenu("View");
 menu2.setIcon(new ImageIcon("green.gif"));
 mb.add(menu2);
 mb.add(Box.createHorizontalGlue());
 JMenu menu3 = new JMenu("Help");
 mb.add(menu);

14. Dialogi

  String msg = "<html><center><b>Proszę<br>"+
             "<font color=blue>WYŁĄCZYĆ KOMPUTER</font><br>" +
             "bo się<font color=red> przegrzał</font></b></center></html>";
  ImageIcon ikona = new ImageIcon("monitor.jpg");
  JOptionPane.showMessageDialog(null,                        // okno-własciciel
                                msg,                         // komunikat
                                "Uwaga! uwaga!",             // tytuł
                                JOptionPane.WARNING_MESSAGE, // rodzaj komnunikatu
                                ikona                        // ikona
                                );

  String val = "",
         msg = "Podaj dwie liczby całkowite";
   
  while ((val = JOptionPane.showInputDialog(msg, val)) != null) {

    StringTokenizer st = new StringTokenizer(val);
    boolean error = false;
    if (st.countTokens() != 2) error = true;
    try {
      int a = Integer.parseInt(st.nextToken());
      int b = Integer.parseInt(st.nextToken());
    } catch (Exception exc) { error = true; }
    if (error) msg = "<html>Wadliwe dane. " +
                     "Podaj <font color=red>DWIE liczby CAŁKOWITE</font></html>";
    else break;
  }

String[] mozliwosci = { "Polska", "Czechy", "Hiszpania", "Tunezja" };
String ans = (String) JOptionPane.showInputDialog(
                         null,                         // okno-rodzic
                         null,                         // komunikat
                         "Wybierz kraj",               // tytuł
                         JOptionPane.QUESTION_MESSAGE, // typ komunikatu
                         new ImageIcon("cross.gif"),   // ikona
                         mozliwosci,                  // mozliwosci do wyboru
                         mozliwosci[0]                // inicjalnie wybrana
                       );

String[] opcje =  { "Przywróć", "Zapisz", "Kompiluj"};
int rc = JOptionPane.showOptionDialog(
           null,                      // okno
           "Co mam zrobić?",          // komunikat
           "Program zmodyfikowany",   // tytuł
           JOptionPane.DEFAULT_OPTION, // rodzaj przycisków u dołu (tu nieważny)
           JOptionPane.QUESTION_MESSAGE,// typ komunikatu (standardowa ikona)
           null,                        // własna ikona (tu: brak)
           opcje,                       // własne opcje - przyciski
           opcje[1]);                   // domyślny przycisk

System.out.println("Wybrałeś " + rc + " " + opcje[rc]);

JTextArea list = new JTextArea(10,20);   // edytor
list.setBorder(BorderFactory.createLineBorder(Color.blue));
JTextField adres = new JTextField(10);   // pole tekstowe

// tablica opcji
Object[] opcje =  { new JLabel("Adres"), // etykieta
                    adres,               // pole tekstowe
                    "Wyślij"             // z "Wyślij" powstanie przycisk
                   };

int rc = JOptionPane.showOptionDialog(
           null,
           list,                     // komunikatem może być dowolny obiekt!
           "Treść listu",            // tytuł
           JOptionPane.DEFAULT_OPTION,
           JOptionPane.PLAIN_MESSAGE,
           null,
           opcje,                   // opcje - to też dowolne obiekty!
           opcje[2]                 // domyślnie - przycisk "Wyślij"
         );

if (rc == 2) {
  String tekstListu = list.getText();
  String adr = adres.getText();
  System.out.println("wysyłam na adres " + adr + " :");
  System.out.println(tekstListu);
}

    String choiceMsg(String title,        // tytuł
                     String[] normalMsg,  // normalne wiersze komunikatów
                     String[] radioMsg,   // radio-przyciski (opcje do wyboru)
                     Icon icon            // ikona
                     ) // metoda zwraca tekst wybranego radio-przycisku
    {
      Object[] msg = new Object[normalMsg.length + radioMsg.length];
      for (int i = 0; i < normalMsg.length; i++) msg[i] = normalMsg[i];
      JRadioButton rb[] = new JRadioButton[radioMsg.length];
      ButtonGroup bg = new ButtonGroup();
      for (int i = 0; i < radioMsg.length; i++)  {
         rb[i] = new JRadioButton(radioMsg[i]);
         bg.add(rb[i]);
         msg[normalMsg.length +i] = rb[i];
      }
      JOptionPane.showMessageDialog(null, msg, title, 0, icon);
      for (int i =0; i < rb.length; i++)
        if (rb[i].isSelected()) return rb[i].getText();
      return null;
    }

// ... poniższy fragment pokazuje wywołanie metody choiceMsg

      String s = choiceMsg( "Wyjazd nad morze",
                 new String[] { "Wybierz środek transportu,",
                                "zaznaczając jedną z opcji",
                                " "
                              },
                 new String[] { "Autokar", "Pociąg", "Samolot"  },
                 new ImageIcon("bview2.jpg")
                 );
     System.out.println("Wybrałeś: " + s);

• utworzyć obiekt (new JFileChooser(...))
• wywołać odpowiednią metodę pokazującą odpowiedni dialog: (showOpenDialog dla otwarcia pliku lub showSaveDialog - zapis pliku). Można też użyć metody showDialog , podając typ dialogu (otwarcie czy zapis), co znajdzie odzwierciedlenie w jego tytule oraz tekście na przycisku. Wyniki tych metod (typu int) mówią nam o tym czy użytkownik wybrał jakiś plik, czy w ogóle zrezygnował z wyboru. Dalsze informacje (np. plik, nazwa etc.) , możemy uzyskać odpytując dany obiekt typu JFileChooser

• wywołanie metody JColorChooser.showDialog(...) jest synchroniczne (wstrzymuje działanie aplikacji)
• metoda zwraca referencję do wybranego obiektu typu Color.

    String[] opcje = { "Otwarcie pliku", "Zapis pliku", "Wybór koloru" };

    JLabel msgLabel = new JLabel("Wybierz dialog"); // etykieta dialogu
    msgLabel.setHorizontalAlignment(JLabel.CENTER);
    msgLabel.setOpaque(true);
    msgLabel.setBackground(Color.yellow);
    msgLabel.setBorder(BorderFactory.createLineBorder(Color.red));

    JFileChooser fc = new JFileChooser(new File(".")); // dialog plikowy
                                                       // z bieżącym katalogiem
    String approveButt = ""; // tekst na przycisku dialogu plikowego
    int rc = 0;
    while (rc != -1) {
      rc = JOptionPane.showOptionDialog(null,
                       msgLabel,
                       "Test chooserów",
                       JOptionPane.DEFAULT_OPTION,
                       JOptionPane.QUESTION_MESSAGE,
                       null,
                       opcje,
                       opcje[0]
            );

      switch (rc) {
        case 0 :
        case 1 : approveButt = opcje[rc];
                 int retVal = fc.showDialog(null, approveButt);
                 if (retVal == JFileChooser.APPROVE_OPTION)
                   System.out.println(approveButt + " " + fc.getSelectedFile());
                 break;

        case 2 : Color nc = JColorChooser.showDialog(null,
                                          "Wybierz kolor",
                                  msgLabel.getBackground() // inicjalny kolor
                            );
                 if (nc != null) {
                   System.out.println("Wybrany kolor: " + nc);
                   msgLabel.setBackground(nc);   // zmiana koloru etykiety
                 }
                 break;

        default: break;
      }
    }

• JOptionPane zawiera proste metody tworzenia dialogów informacyjnych, ostrzegawczych, informacji o błędach. Ponadto może dawać dialogi dostosowane do naszych ustaleń (np. teksty i ikony na przyciskach). 
• Obiekty typu JFileChooser oraz JColorChooser:
• są komponentami lekkimi
• mogą być wbudowane w dowolne GUI (niekoniecznie muszą być prostymi dialogami)
• są konfigurowalne