SWT contiene molte funzioni sofisticate, ma per implementare applicazioni utili e potenti è sufficiente possedere una conoscenza di base delle funzioni fondamentali del sistema: widget, layout ed eventi.
Se si forniscono elementi UI mediante estensioni del workbench della piattaforma, i meccanismi di avvio di SWT vengono gestiti dal workbench.
Per scrivere un'applicazione SWT partendo da zero (fuori dal workbench), è necessario comprendere meglio la struttura applicativa di SWT.
Una tipica applicazione SWT autonoma possiede la seguente struttura:
Creare una visualizzazione che rappresenti una sessione SWT.
Creare una o più Shell che fungono da finestre principali dell'applicazione.
Creare qualsiasi altro widget necessario all'interno della shell.
Inizializzare le dimensioni e gli altri stati necessari per i widget. Registrare i listener degli eventi widget da gestire.
Aprire la finestra shell.
Eseguire il ciclo distributivo dell'evento finché non si verifica una condizione di uscita (generalmente quando la finestra shell principale viene chiusa dall'utente).
Organizzare la visualizzazione.
Il seguente frammento di codice è stato adattato dall'applicazione org.eclipse.swt.examples.helloworld.HelloWorld2. Poiché l'applicazione visualizza soltanto la stringa "Hello World," non è necessario registrare tutti gli eventi widget.
public static void main(String[] args) {
Display display = new Display ();
Shell shell = new Shell (display);
Label label = new Label (shell, SWT.CENTER);
label.setText ("Hello_world");
label.setBounds (shell.getClientArea ());
shell.open ();
while (!shell.isDisposed ()) {
if (!display.readAndDispatch ()) display.sleep ();
}
display.dispose ();
}
La visualizzazione rappresenta la connessione tra SWT e il sistema GUI della piattaforma sottostante. Le visualizzazioni sono utilizzate principalmente per gestire il ciclo di eventi della piattaforma e controllare la comunicazione tra il thread dell'interfaccia utente e altri thread. Per una trattazione completa del thread dell'interfaccia utente, consultare la sezione Problemi relativi ai thread per i client.
Per la maggior parte delle applicazioni è possibile seguire il modello utilizzato in precedenza. Prima di creare qualsiasi finestra, è necessario creare una visualizzazione e organizzarla quando la shell è chiusa. Non è necessario dedicare molto tempo alla visualizzazione, a meno che non si stia progettando un'applicazione a più thread.
Una shell è una "finestra" gestita dal gestore della finestra nella piattaforma del sistema operativo. Le shell di livello superiore sono create come elementi secondari della visualizzazione. Sono queste le finestre che gli utenti spostano, ridimensionano, riducono a icona e ingrandiscono quando utilizzano l'applicazione. Le shell secondarie sono quelle create come elemento secondario di un'altra shell. Queste finestre vengono in genere utilizzate come finestre di dialogo o altre finestre transitorie che possono esistere solo all'interno di un'altra finestra.
Tutti i widget che non sono di livello superiore hanno un elemento principale. Le shell di livello superiore non hanno un elemento principale ma sono tutte create in combinazione con una particolare visualizzazione , a cui è possibile accedere mediante getDisplay(). Tutti gli altri widget discendono (direttamente o indirettamente) da shell di livello superiore.
I widget composti sono widget che possiedono elementi secondari.
La finestra di un'applicazione può essere considerata una struttura widget o una gerarchia, che ha come radice la shell. A seconda della complessità dell'applicazione, la shell può avere uno o più elementi secondari o layer nidificati di widget composti con elementi secondari.
Nel momento in cui l'applicazione crea un widget, SWT crea immediatamente il widget piattaforma sottostante. In questo modo, non è necessario avere un codice che operi differentemente a seconda della presenza o meno del widget del sistema operativo sottostante. In questo modo, è possibile tenere la maggioranza dei widget nel livello della piattaforma senza doverli replicare nel toolkit. Ciò significa che il modo in cui il toolkit considera il ciclo di vita di un widget deve essere conforme alle regole del sistema GUI sottostante.
La maggior parte delle piattaforme GUI richiede che venga specificato un elemento principale durante la creazione di un widget. Poiché SWT crea un widget della piattaforma non appena viene creato un widget del toolkit, occorre specificare il widget principale nel corrispondente costruttore.
Alcune proprietà di widget devono essere impostate dal sistema operativo al momento della creazione di un widget e non possono essere modificate in seguito. Ad esempio, un elenco può essere a selezione singola o multipla ed essere dotato o meno di barre di scorrimento.
Queste proprietà, denominate stili, devono essere impostate nel costruttore. Tutti i costruttori di widget utilizzano un argomento int che specifica l'operatore OR bit per bit di tutti gli stili desiderati. A volte uno stile particolare viene considerato un suggerimento, nel senso che può non essere disponibile su tutte le piattaforme, ma sarà correttamente ignorato sulle piattaforme su cui non è supportato.
Le costanti di stile sono posizionate nella classe SWT in qualità di campi statici pubblici. Un elenco delle costanti applicabili a ciascuna classe di widget è contenuto nel Riferimento API per SWT.
Le piattaforme del sistema operativo su cui sui basa SWT richiedono un'esplicita assegnazione e liberazione delle risorse del sistema operativo. La filosofia di progettazione di SWT, in base alla quale la struttura di applicazione della piattaforma deve essere riflessa nel toolkit di widget, rende necessario liberare esplicitamente tutte le risorse del sistema operativo che sono state allocate. In SWT, le risorse associate a un particolare oggetto toolkit vengono liberate mediante il metodo dispose() .
La regola generale è che qualsiasi oggetto creato deve essere eliminato. Di seguito, sono riportate alcune regole base specifiche che spiegano ulteriormente questa filosofia.
Se si crea un widget o un oggetto grafico mediante un costruttore, è necessario provvedere alla sua eliminazione manuale una volta che si è finito di utilizzarlo.
In presenza di un widget o un oggetto grafico ottenuto senza l'utilizzo di un costruttore, non è necessario provvedere alla sua eliminazione manuale poiché non è stato allocato.
Se un riferimento al widget o all'oggetto grafico viene passato a un altro oggetto, bisogna fare attenzione a non eliminare il widget o l'oggetto grafico mentre sono ancora in uso (questa regola è stata osservata precedentemente in Modelli di plug-in per l'utilizzo di immagini).
Quando un utente chiude una shell, essa viene eliminata in modo ricorsivo con tutti i relativi widget secondari. In tal caso, non è necessario eliminare i widget; è necessario, però, liberare le risorse grafiche allocate insieme ai widget.
Se un oggetto grafico viene creato per essere utilizzato durante il ciclo di vita di uno dei widget, è necessario eliminarlo quando si elimina il widget. L'operazione può essere effettuata registrando un listener di eliminazione per il widget e liberando l'oggetto grafico al ricevimento dell'evento dispose.
Le regole elencate presentano un'eccezione: gli oggetti dati semplici, ad esempio, un rettangolo e un punto, non utilizzano risorse del sistema operativo. Non possiedono un metodo dispose() e non è necessario liberarli. In caso di dubbi, controllare la classe in Javadoc.