Swing
zarządcy układu (ang. layout managers)
dr inż. Juliusz Mikoda
wtorek, 29 marca 2011
Zarządca układu (ang. Layout Manager)
" Zarządca układu to obiekt implementujący interfejs LayoutManager.
" Zarządca układu decyduje o rozmiarze i pozycji komponentów w kontenerze.
Komponenty mogą posiadać podpowiedzi, jaka pozycja i rozmiar są dla nich
preferowane, ale ostatecznie decyduje o tym zarządca układu.
" W praktyce zarządcę układu definiuje się dla:
" powierzchni zawartości - domyślnie BorderLayout,
" komponentów JPanel - domyślnie FlowLayout.
wtorek, 29 marca 2011
Określanie zarządcy układu
" Ustawienie zarządcy układu:
public void setLayout(LayoutManager mgr);
metoda ta jest zdefiniowana w klasie java.awt.Container
JPanel p = new JPanel();
p.setLayout(new BorderLayout());
" Zarządca układu może również zostać określony podczas wywołania
konstruktora kontenera, np:
JPanel p = new JPanel(new BorderLayout());
" Możliwe, aczkolwiek nie zalecane!, jest wyłączenie zarządcy układu poprzez
przekazanie do metody setLayout() wartości null. W takim wypadku pozycja i
rozmiary wszystkich komponentów muszą zostać jawnie zdefiniowane.
wtorek, 29 marca 2011
Dodawanie komponentów do kontenerów
" Dodając komponent do kontenera za pomocą metody add możemy określić,
w którym miejscu ma się znalez
ć dany komponent.
" Sposób w jaki określamy pozycję komponentu zależy od zastosowanego
zarządcy układu.
Na przykład BorderLayout wymaga określenia w której części kontenera ma
się znalez
ć komponent:
p.add(new JButton("OK"),BorderLayout.PAGE_START);
" Niektórzy zarządcy układu umieszczają komponenty w takiej kolejności, w
jakiej są one dodawane do kontenera.
wtorek, 29 marca 2011
Wskazówki rozmieszczenia i rozmiaru
" Jeśli zależy nam na tym, aby dany komponent miał określone rozmiary możliwe jest
zdefiniowanie minimalnej, preferowanej i maksymalnej wielkości komponentu za pomocą
metod:
void setMinimumSize(Dimension minimumSize);
void setPreferredSize(Dimension preferredSize);
void setMaximumSize(Dimension maximumSize);
Metody zdefiniowane w klasie javax.swing.JComponent. Konstruktor klasy Dimension: Dimension(int width, int height);
" Możliwe jest również wskazanie preferowanego wyrównania komponentów w pionie i
poziomie za pomocą metod:
void setAlignmentX(float alignmentX);
float alignmentX: Component.LEFT_ALIGNMENT (0.0), Component.RIGHT_ALIGNMENT(1.0),
Component.CENTER_ALIGNMENT (0.5)
void setAlignmentY(float alignmentY);
float alignmentY: Component.BOTTOM_ALIGNMENT, Component.TOP_ALIGNMENT
" Należy pamiętać o tym, że są to jedynie wskazówki dla zarządcy układu i mogą zostać przez
niego zignorowane.
wtorek, 29 marca 2011
Orientacja komponentu
" Ustalenie orientacji komponentu pozwala na wskazanie w jaki sposób powinny
być rozmieszczane komponenty: od lewej do prawej czy od prawej do lewej.
" Orientację komponentu można zdefiniować za pomocą metody:
void setComponentOrientation(ComponentOrientation o);
ComponentOrientation o: ComponentOrientation.LEFT_TO_RIGHT,
ComponentOrientation.RIGHT_TO_LEFT, ComponentOrientation.UNKNOWN
" Orientację można odczytać z domyślnej lokalizacji:
Locale loc = cpane.getLocale();
cpane.applyComponentOrientation(ComponentOrientation.getOrientation(loc));
" Standardowymi zarządcami układu, którzy wspierają orientację komponentów
są FlowLayout, BorderLayout, BoxLayout, GridBagLayout i GridLayout.
wtorek, 29 marca 2011
Odległości pomiędzy komponentami
" Niektórzy zarządcy układu pozwalają na definiowanie odległości pomiędzy
komponentami (w poziomie i w pionie).
" Odległości można definiować przekazując w kostruktorze zarządcy układu
dwie wartości: odległość w pionie i odległość w poziomie, np.:
# BorderLayout(int hgap, int vgap)
lub za pomocą metod:
# void setHgap(int hgap)
# void setVgap(int vgap)
wtorek, 29 marca 2011
FlowLayout
" Jeden z najprostszych układów, domyślny dla komponentu JPanel.
" FlowLayout umieszcza komponenty w wierszu, zachowując preferowaną szerokość
komponentów.
" Jeśli komponenty nie mieszczą się w jednym wierszu, tworzone są kolejne wiersze,
w których umieszczane są komponenty.
Container p = frame.getContentPane();
p.setLayout(new FlowLayout());
p.add(new JButton("But. 1"));
p.add(new JButton("Przycisk numer 2 (długa nazwa)"));
JButton b = new JButton("Button 3");
b.setPreferredSize(new Dimension(100,200));
p.add(b);
p.add(new JButton("B 4"));
p.add(new JButton("Button 5"));
wtorek, 29 marca 2011
FlowLayout
wyrównanie komponentów
" FlowLayout pozwala na zdefiniowanie wyrównania elementów oraz odległości
pomiędzy komponentami w pionie i w poziomie.
" Domyślne wartości to:
# odległość pomiędzy komponentami: 5px w poziomie i 5px w pionie,
# wyrównanie: CENTER
" Wyrównanie komponentów można definiować w konstruktorze:
# FlowLayout(int align);
# FlowLayout(int align, int hgap, int vgap);
int align: FlowLayout.LEADING, FlowLayout.LEFT, FlowLayout.RIGHT, FlowLayout.CENTER
lub FlowLayout.TRAILING
wtorek, 29 marca 2011
FlowLayout
wyrównanie komponentów
" Jeśli wyrównanie komponentów zostanie ustawione na LEADING lub TRAILING, na to, do której
strony (prawej czy lewej) zostaną wyrównane komponenty ma wpływ również orientacja kontenera.
" W przypadku zastosowania wyrównania LEFT, RIGHT lub CENTER orientacja wpływa jedynie na
kolejność komponentów, a nie na ich wyrównanie.
wtorek, 29 marca 2011
BorderLayout
" Układ BorderLayout składa się z pięciu obszarów określonych poprzez stałe
zdefiniowane w klasie BorderLayout:
#
BorderLayout.PAGE_START
#
BorderLayout.PAGE_END
#
BorderLayout.LINE_START
#
BorderLayout.LINE_END
#
BorderLayout.CENTER
" Dodając komponenty do kontenera, dla którego jako zarządcę układu ustawiono
BorderLayout, jako drugi parametr metody add należy podać położenie
komponentu.
p.setLayout(new BorderLayout());
p.add(new JButton("Page start"),BorderLayout.PAGE_START);
p.add(new JButton("Page end"),BorderLayout.PAGE_END);
p.add(new JButton("Line start"),BorderLayout.LINE_START);
p.add(new JButton("Line end"),BorderLayout.LINE_END);
p.add(new JButton("Center"),BorderLayout.CENTER);
wtorek, 29 marca 2011
BorderLayout
preferowane wielkości komponentów
" Definiując preferowaną wielkość komponentów można wpływać na ich układ:
p.setLayout(new BorderLayout());
JButton b = new JButton("Page start");
b.setPreferredSize(new Dimension(20, 50));
p.add(b,BorderLayout.PAGE_START);
b = new JButton("Page end");
b.setPreferredSize(new Dimension(1000, 30));
p.add(b,BorderLayout.PAGE_END);
b = new JButton("Line start");
b.setPreferredSize(new Dimension(180, 30));
p.add(b,BorderLayout.LINE_START);
b = new JButton("Line end");
b.setPreferredSize(new Dimension(40, 30));
p.add(b,BorderLayout.LINE_END);
b = new JButton("Center");
b.setPreferredSize(new Dimension(0, 2000));
p.add(b,BorderLayout.CENTER);
" Nie wszystkie  sugestie są brane pod uwagę przez zarządcę układu, np.:
# nie można wskazać wielkości komponentu umieszczonego w lokalizacji CENTER,
# dla PAGE_TOP i PAGE_END można definiować jedynie wysokość.
wtorek, 29 marca 2011
BorderLayout
odległości pomiędzy komponentami
" BorderLayout pozwala na zdefiniowanie odległości w pionie i w poziomie
pomiędzy komponentami.
" Odległości można definiować przekazując w konstruktorze zarządcy układu
dwie wartości: odległość w pionie i odległość w poziomie:
BorderLayout(int hgap, int vgap)
#
lub za pomocą metod:
void setHgap(int hgap)
#
void setVgap(int vgap)
#
" np:
p.setLayout(new BorderLayout(10,40));
wtorek, 29 marca 2011
BoxLayout
" BoxLayout umieszcza komponenty jeden pod drugim (w kolumnie) lub jeden
obok drugiego (w wierszu).
" Konstruktor BoxLayout przyjmuje dwa parametry:
BoxLayout(Container target, int axis);
Container target: komponent kontrolowany przez zarządce układu,
int axis: oś, według której będą układane elementy; możliwe wartości: BoxLayout.PAGE_AXIS,
BoxLayout.LINE_AXIS, BoxLayout.X_AXIS lub BoxLayout.Y_AXIS
" Ustawienie osi jako BoxLayout.X_AXIS lub BoxLayout.Y_AXIS sprawia,
że układ elementów (również ich kolejność) jest niezależny od orientacji
kontenera. W przypadku osi BoxLayout.PAGE_AXIS lub
BoxLayout.LINE_AXIS zarówno kolejność komponentów jak i ich
wyrównanie są zależne od orientacji kontenera.
wtorek, 29 marca 2011
BoxLayout
oś układu elementów
wtorek, 29 marca 2011
BoxLayout
wyrównanie elementów
" BoxLayout pozwala na rozmieszczenie komponentów zgodnie z
preferowanym wyrównaniem zdefiniowanym dla poszczególnych
komponentów.
p.setLayout(new BoxLayout(p,BoxLayout.PAGE_AXIS));
JButton b = new JButton("B 1"); b.setAlignmentX(Component.LEFT_ALIGNMENT); p.add(b);
b = new JButton("B 2"); b.setAlignmentX(Component.RIGHT_ALIGNMENT); p.add(b);
b = new JButton("B 3"); b.setAlignmentX((float)0.75); p.add(b);
b = new JButton("B 4"); b.setAlignmentX(Component.CENTER_ALIGNMENT); p.add(b);
p.setLayout(new BoxLayout(p,BoxLayout.LINE_AXIS));
JButton b = new JButton("B 1"); b.setAlignmentY(Component.TOP_ALIGNMENT); p.add(b);
b = new JButton("B 2"); b.setAlignmentY((float)0.25); p.add(b);
b = new JButton("B 3"); b.setAlignmentY((float)0.5); p.add(b);
b = new JButton("B 4"); b.setAlignmentY((float)0.75); p.add(b);
b = new JButton("B 5"); b.setAlignmentY(Component.BOTTOM_ALIGNMENT); p.add(b);
wtorek, 29 marca 2011
BoxLayout
wielkość komponentów
" Wielkość komponentów dopasowywana jest tak, aby dopasować łączną wysokość i szerokość
komponentów do kontenera.
" Komponenty są skalowane do maksymalnej wielkości zdefiniowanej dla komponentu.
" Wielkość komponentów jest modyfikowana podczas zmiany wielkości okna.
Jest dostosowywana do nowych rozmiarów okna, np.:
p.setLayout(new BoxLayout(p,BoxLayout.PAGE_AXIS));
JButton b = new JButton("B 1");
b.setMaximumSize(new Dimension(100, 300));
p.add(b);
b = new JButton("B 2");
b.setMaximumSize(new Dimension(200, 100));
p.add(b);
b = new JButton("B 3");
b.setMaximumSize(new Dimension(300, 200));
p.add(b);
b = new JButton("B 4");
b.setMaximumSize(new Dimension(100, 100));
p.add(b);
" Minimalna wielkość komponentu jest brana pod uwagę podczas proporcjonalnego skalowania
komponentów, ale nie zawsze jest rygorystycznie przestrzegana (komponent może być mniejszy
niż zdefiniowana dla niego wielkość minimalna).
wtorek, 29 marca 2011
BoxLayout
przestrzenie między komponentami
" Aby utworzyć pustą przestrzeń pomiędzy komponentami należy wstawić (pomiędzy te
komponenty) przeznaczone do tego celu niewidoczne komponenty dostępne dzięki
klasie Box.
" Dostępne są trzy metody wstawiania pustej przestrzeni:
# Sztywny obszar (ang. rigid area) - pozwala na wstawienie przestrzeni o dokładnie określonej
wielkości.
# Klej (ang. glue) - rozszerzalny obszar przestrzeni między komponentami.
# Dowolny komponent Box.Filler - niewidoczny komponent o minimalnej, preferowanej
i maksymalnej wielkości.
" Filler to klasa wewnętrzna klasy Box. Wstawienie sztywnego obszaru oraz kleju to
wstawienie odpowiednio skonfigurowanego obiektu klasy Box.Filler.
wtorek, 29 marca 2011
Sztywny obszar
przestrzenie między komponentami
" Tworzenie sztywnego obszaru umożliwia metoda:
Component createRigidArea(Dimension d);
Dimension d: wielkość wstawianego sztywnego obszaru.
" Utworzony w ten sposób komponent należy dodać do kontenera.
p.setLayout(new BoxLayout(p,BoxLayout.LINE_AXIS));
p.add(new JButton("B 1"));
Component c = Box.createRigidArea(new Dimension(50,0));
p.add(c);
p.add(new JButton("B 2"));
p.add(Box.createRigidArea(new Dimension(15,0)));
p.add(new JButton("B 3"));
wtorek, 29 marca 2011
Sztywny obszar
przestrzenie między komponentami
" Tworzenie poziomego i pionowego kleju umożliwiają metody:
" Component createHorizontalGlue();
" Component createVerticalGlue();
" Utworzony w ten sposób komponent należy dodać do kontenera.
p.setLayout(new BoxLayout(p,BoxLayout.LINE_AXIS));
p.add(new JButton("B 1"));
Component c = Box.createHorizontalGlue();
p.add(c);
p.add(new JButton("B 2"));
p.add(new JButton("B 3"));
wtorek, 29 marca 2011
Dowolny Box.Filler
przestrzenie między komponentami
" Obiekt Box.Filler tworzony jest za pomocą konstruktora przyjmującego
minimalne, preferowane i maksymalne rozmiary komponentu:
Box.Filler(Dimension min, Dimension pref, Dimension max)
" Utworzenie komponentu o minimalnej szerokości 5px oraz wysokości 100px.
p.setLayout(new BoxLayout(p,BoxLayout.LINE_AXIS));
p.add(new JButton("B 1"));
Dimension minSize = new Dimension(5, 100);
Dimension prefSize = new Dimension(5, 100);
Dimension maxSize = new Dimension(Short.MAX_VALUE, 100);
p.add(new Box.Filler(minSize, prefSize, maxSize));
p.add(new JButton("B 2"));
p.add(new JButton("B 3"));
wtorek, 29 marca 2011
CardLayout
" CardLayout pozwala na zarządzanie dwoma lub więcej komponentami (najczęściej
panelami JPanel) wyświetlanymi w tym samym miejscu.
" Komponentom dodawanym do CardLayout nadawane są nazwy wykorzystywane do
przełączania pomiędzy widocznymi komponentami. Nazwę (typu String) przekazuje się
jako drugi parametr, podczas dodawania komponentu za pomocą metody add.
p.setLayout(new CardLayout());
JPanel p1 = new JPanel();
p1.add(new JLabel("Panel1"));
p.add(p1, "P1");
JPanel p2 = new JPanel();
p2.add(new JLabel("Panel2"));
p.add(p2, "P2");
" Domyślnie widoczny jest komponent dodany jako pierwszy.
wtorek, 29 marca 2011
CardLayout
przełączanie pomiędzy kartami
" Aby przełączyć  karty dodane do zarządcy widoku CardLayout należy:
# za pomocą metody getLayout() pobrać z kontenera zarządcę widoku i rzutować
go do typu CardLayout,
# z obiektu CardLayout wywołać metodę show, przekazując jako pierwszy
parametr kontener, a jako drugi nazwę komponentu należącego do kontenera,
który ma zostać wyświetlony.
CardLayout cl = (CardLayout)p.getLayout();
cl.show(p, "P2");
wtorek, 29 marca 2011
GridLayout
" GridLayout umieszcza komponenty w komórkach tabeli.
" Każdy komponent dodany do tego układu zajmuje całą przestrzeń wewnątrz komórki tabeli.
" Wszystkie komórki tabeli są dokładnie tej samej wielkości. Jeśli kontener, dla którego ustawiono
GridLayout jest skalowany, komórki tabeli są skalowane tak, żeby wypełnić cały obszar
kontenera.
" Konstruktor GridLayout przyjmuje liczbę wierszy oraz liczbę kolumn. Jedna (ale nie obie) z tych
wartości może być równa 0. Oznacza to dowolną liczbę elementów.
p.setLayout(new GridLayout(0,2));
p.add(new JButton("Button 1"));
p.add(new JButton("Button 2"));
p.add(new JButton("Button 3"));
p.add(new JButton("Button 4"));
p.add(new JButton("Button 5"));
p.add(new JButton("Button 6"));
wtorek, 29 marca 2011
GridLayout
odległości pomiędzy komórkami tabeli
" Ustawienie odległości pomiędzy komórkami tabeli jest możliwe w
konstruktorze GridLayout
GridLayout(int rows, int cols, int hgap, int vgap);
int hgap, int vgap: odległość w poziomie i w pionie (w pikselach)
lub za pomocą metod:
void setHgap(int hgap)
void setVgap(int vgap)
" Domyślnie odległości pomiędzy komórkami ustawione są na 0px.
p.setLayout(new GridLayout(0,2,10,20));
wtorek, 29 marca 2011
GridBagLayout
" GridBagLayout pozwala na rozmieszczenie komponentów w komórkach tabeli, pozwalając
jednocześnie na połączenie kilku komórek w wierszu lub kolumnie.
" Wiersze nie muszą mieć takiej samej wysokości, a kolumny takiej samej szerokości. Do
określenia rozmiarów komórki wykorzystywana jest preferowana wielkość komponentu
umieszczonego w komórce tabeli.
" Do określenia wielkości i pozycji komponentu w tabeli wykorzystywane są ograniczenia (ang.
constraints). Dodając komponent do kontenera za pomocą metody add, jako drugi parametr
tej metody przekazywany jest odpowiednio skonfigurowany obiekt klasy GridBagConstraints.
" Ograniczenia GridBagConstraints są konfigurowane poprzez ustawienie odpowiednich
wartości pól składowych obiektu.
wtorek, 29 marca 2011
GridBagConstraints
właściwości
" int gridx, int gridy
Wiersz i kolumna dla górnego lewego narożnika komponentu. Pierwszy wiersz od góry to
gridy=0, pierwsza kolumna pd lewej gridx=0. Ustawienie wartości na
GridBagConstraints.RELATIVE powoduje umieszczenie komponentu bezpośrednio pod
poprzednio dodanym komponentem lub bezpośrednio obok niego (po prawej stronie).
" int gridwidth, int gridheight
Liczba kolumn (gridwidth) lub wierszy (gridheight) przeznaczonych do wyświetlenia
komponentu. Określana jest liczba kolum i wierszy, a nie liczba pikseli. Domyślna wartość to 1.
" int fill
Wykorzystywane, gdy wielkość komponentu jest mniejsza niż obszar przeznaczony do
wyświetlenia tego komponentu. Parametr ten określa czy komponent powinien być skalowany,
a jeśli nie to w jaki sposób powinien być wyrównany. Możliwe wartości to: NONE (domyślne, nie
skaluje komponentu), HORIZONTAL (skaluje komponent w poziomie, ale nie zmienia jego
wysokości), VERTICAL (skaluje komponent w pionie, ale nie zmienia jego szerokości), and BOTH
(skaluje kompnent w pionie i poziomie).
wtorek, 29 marca 2011