Sistemi di elaborazione - Appunti

CHECK BOX MENU ITEM:

Questo componente si differenzia dal normale MenuItem per il fatto che assume uno stato selezionato/non

selezionato, allo stesso modo di un Checkbox, e che il click sul componente genera un ItemEvent. Un

CheckboxMenuItem viene visualizzato con un simbolo a fianco quando è selezionato.

Lo stato può essere modificato o rilevato dal codice con i metodi void setState(boolean selected) e

boolean getState().

MENU:

Il componente Menu è un MenuItem utilizzato come contenitore di altri MenuItem. A tal fine implementa

l’interfaccia MenuContainer. La classe Menu rappresenta un menu pulldown ossia a discesa, mentre la

sottoclasse PopupMenu rappresenta i menu popup, usati soprattutto come menu di contesto.

Un menu può contenere semplici MEnuItem oppure altri menu, dando origine a una struttura ad albero a più

livelli (menu gerarchico).

Abbiamo riassunto, fin quì, le classi che ci consentono di creare gui. LA cosa più importante da tenere a

mente è che la capostipite di tutte queste classi è la classe Container, infatti in tutte le applicazione grafiche

bisogna sempre istanziare un top-level container (di solito la classe Frame) e all’interno di questo verranno

inseriti tutti i componenti grafici, l’inserimento di questi componenti all’interno della top-levelc container lo si

fa con il metodo add, definito nella classe base Container.

I layout manager

La posizione di un componente aggiunto a un container dipende essenzialmente dall’oggetto che è

associato al container, detto “layout manager”. In ogni container infatti, esiste un layout manager associato di

default. Un layout manager è un’istanza di una sottoclasse di LayoutManager. Esistono decine di sottoclassi

di LayoutManager, ma tutto sommato le più importanti sono solo cinque:

- FlowLayout

- BorderLayout

- GridLayout

- CardLayout

- GridBagLayout

In questo modulo introdurremo le prime quattro, accennando solo al GridBagLayout. Anche la dimensione

dei componenti aggiunti dipenderà dal layout manager. La Figura, mostra come tutte le sottoclassi di

Window (quindi anche Frame), abbiano associato per default il BorderLayout, mentre tutta la gerarchia di

Panel utilizzi il FlowLayout per il posizionamento dei componenti.

In realtà è anche possibile non utilizzare layout manager per gestire interfacce grafiche. Tale tecnica però

comprometterebbe la consistenza e la portabilità della GUI stessa. Il lettore interessato può provare per

esempio ad annullare il layout di un container (per esempio un Frame) con l’istruzione setLayout(null), per

poi usare i metodi setLocation(), setBounds() e setSize() per gestire il posizionamento dei componenti.

- Il Flow Layout:

Il FlowLayout è il layout manager di default di Panel, come vedremo una delle classi principali del package

AWT. FlowLayout dispone i componenti aggiunti in un flusso ordinato che va da sinistra a destra con un

allineamento centrato verso l’alto. Per esempio il codice seguente (da inserire all’interno di un metodo main):

Frame f = new Frame("FlowLayout");

Panel p = new Panel();

Button button1 = new Button("Java");

Button button2 = new Button("Windows");

Button button3 = new Button("Motif");

p.add(button1);

p.add(button2);

p.add(button3);

f.add(p);

f.pack();

f.setVisible(true);

Produrrebbe come output quanto mostrato in figura 15.4. Notare che il metodo pack(), semplicemente

ridimensiona il frame in modo tale da mostrarsi abbastanza grande da visualizzare il suo contenuto.

In particolare, le figura 15.5 e 15.6 mostrano anche come si dispongono i bottoni dopo avere ridimensionato

la finestra che contiene il Panel. Nella figura 15.5 è possibile vedere come l’allargamento della finestra non

alteri la posizione dei bottoni sul Panel.

Mentre nella figura 15.6, è possibile vedere come i bottoni si posizionino in maniera coerente con la filosofia

del FlowLayout, in posizioni diverse dopo aver ristretto molto il frame.

Il FlowLayout utilizza per i componenti aggiunti la loro “dimensione preferita”. Infatti, tutti i componenti

ereditano dalla classe Component il metodo getPreferredSize() (in italiano “dammi la dimensione preferita”).

Il Flowlayout chiama questo metodo per ridimensionare i componenti prima di aggiungerli al container. Per

esempio il metodo getPreferredSize() della classe Button, dipende dall’etichetta che gli viene settata. Un

bottone con etichetta “OK”, avrà dimensioni molto più piccole rispetto ad un bottone con etichetta “Ciao io

sono un bottone AWT”.

- Il Border Layout:

Il BorderLayout è il layout manager di default per i Frame, il top level container per eccellenza. I componenti

sono disposti solamente in cinque posizioni specifiche che si ridimensionano automaticamente:

- NORTH, SOUTH che si ridimensionano orizzontalmente

- EAST, WEST che si ridimensionano verticalmente

- CENTER che si ridimensiona orizzontalmente e verticalmente

Questo significa che un componente aggiunto in una certa area, si deformerà per occupare l’intera area.

Segue un esempio:

import java.awt.*;

public class BorderExample

{ private Frame f;

private Button b[]={new Button("b1"),new Button("b2"), new Button("b3"), new Button("b4"),

new Button("b5")};

public BorderExample()

{ f = new Frame("Border Layout Example");

}

public void setup()

{ f.add(b[0], BorderLayout.NORTH);

f.add(b[1], BorderLayout.SOUTH);

f.add(b[2], BorderLayout.WEST);

f.add(b[3], BorderLayout.EAST);

f.add(b[4], BorderLayout.CENTER);

f.setSize(200,200);

f.setVisible(true);

}

public static void main(String args[])

{ new BorderExample().setup();

}

}

L’output di questa applicazione è il seguente:

Quando si aggiungono componenti con il BorderLayout quindi, si utilizzano il metodo add(Component c, int

position) o add(Component c, String position). Se si utilizza il metodo add(Component c), il componente

verrà aggiunto al centro dal BorderLayout.

- Il GridLayout:

Il GridLayout dispone i componenti da sinistra verso destra e dall'alto verso il basso all’interno di una griglia.

Tutte le regioni della griglia hanno sempre la stessa dimensione, e i componenti occuperanno tutto lo spazio

possibile all’interno delle varie regioni. Il costruttore del GridLayout permette di specificare righe e colonne

della griglia. Il seguente codice mostra come può essere utilizzato il GridLayout:

import java.awt.*;

public class GridExample

{ private Frame f;

private Button b[]={new Button("b1"),new Button("b2"), new Button("b3"), new Button("b4"),

new Button("b5"), new Button("b6")};

public GridExample()

{ f = new Frame("Grid Layout Example");

}

public void setup()

{ f.setLayout(new GridLayout(3,2));

for (int i=0; i<6;++i)

f.add(b[i]);

f.setSize(200,200);

f.setVisible(true);

}

public static void main(String args[])

{ new GridExample().setup();

}

}

L’output di questa applicazione è il seguente:

- Creazione di interfacce grafiche complesse

Cerchiamo ora di capire come creare GUI con layout più complessi. È possibile infatti sfruttare i vari layout in

un'unica GUI, creando così un layout composito, complesso e stratificato. In un Frame per esempio,

possiamo inserire molti container (come i Panel), che a loro volta possono disporre i componenti mediante il

proprio layout manager.

Il seguente codice mostra come creare una semplice interfaccia per uno “strano” editor:

import java.awt.*;

public class CompositionExample

{ private Frame f;

private TextArea ta;

private Panel p;

private Button b[]={new Button("Open"),new Button("Save"), new Button("Load"),

new Button("Exit")};

public CompositionExample()

{ f = new Frame("Composition Layout Example");

p = new Panel();

ta = new TextArea();

}

public void setup()

{ for (int i=0; i<4;++i)

p.add(b[i]);

f.add(p,BorderLayout.NORTH);

f.add(ta,BorderLayout.CENTER);

f.setSize(350,200);

f.setVisible(true);

}

public static void main(String args[])

{ new CompositionExample().setup();

}

}

L’output di questa applicazione è:

In pratica, componendo i layout tramite questa tecnica, è possibile creare un qualsiasi tipo di interfaccia.

Il consiglio in questo caso è di progettare con degli schizzi su di un foglio di carta, tutti gli strati che dovranno

comporre l’interfaccia grafica. È difficile creare una GUI senza utilizzare questa tecnica, che tra l’altro,

suggerisce anche eventuali container riutilizzabili.

- Il GridBagLayout:

Il GridBagLayout può organizzare interfacce grafiche complesse da solo. Infatti, anch’esso è capace di

dividere il container in una griglia, ma, a differenza del GridLayout, può disporre i suoi componenti in modo

tale che si estendano anche oltre un’unica cella. Quindi, anche nella più complicata dell’interfacce, è

idealmente possibile dividere in tante celle il container quanto sono i pixel dello schermo e piazzare

i componenti a proprio piacimento. Anche se quella appena descritta non è una soluzione praticabile, rende

l’idea della potenza del GridBagLayout. Si può tranquillamente affermare che da solo il GridBagLayout può

sosituire i tre precedenti layout manager di cui abbiamo parlato. In compenso però, la difficoltà di

utilizzo è notevole (vedi documentazione).

- Il CardLayout:

Il CardLayout, è un layout manager particolare che permetterà di posizionare i vari componenti uno sopra

l’altro, come le carte in un mazzo. Il seguente esempio mostra come è possibile disporre i componenti

utilizzando un CardLayout:

import java.awt.*;

public class CardTest

{ private Panel p1, p2, p3;

private Label lb1, lb2, lb3;

private CardLayout cardLayout;

private Frame f;

public CardTest()

{ f = new Frame ("CardLayout");

cardLayout = new CardLayout();

p1 = new Panel();

p2 = new Panel();

p3 = new Panel();

lb1 = new Label("Primo pannello rosso");

p1.setBackground(Color.red);

lb2 = new Label("Secondo pannello verde");

p2.setBackground(Color.green);

lb3 = new Label("Terzo pannello blue");

p3.setBackground(Color.blue);

}

public void setup()

{ f.setLayout(cardLayout);

p1.add(lb1);

p2.add(lb2);

p3.add(lb3);

f.add(p1, "uno");

f.add(p2, "due");

f.add(p3, "tre");

cardLayout.show(f, "uno");

f.set