|
[[File:Gui-widgets.png|thumb|upright=1.4|Esempio di interfaccia grafica Swing. La renderizzazione dei font potrebbe variare a seconda della piattaforma utilizzata.]]
{{W|informatica|gennaio 2007|'''[[Utente:Piracmone|Piracmone]]'''. <small>[[Discussioni utente:Piracmone|(Dimmi)]]</small> 15:40, 29 gen 2007 (CET)}}
'''Swing''' è un [[framework]] per [[Java (linguaggio di programmazione)|Java]], appartenente alle [[Java Foundation Classes]] (JFC) e orientato allo sviluppo di [[GUI|interfacce grafiche]]. Parte delle [[classe (informatica)|classi]] del framework Swing sono implementazioni di [[widget (informatica)|widget]] (oggetti grafici) come caselle di testo, pulsanti, pannelli e tabelle.
[[Immagine:Gui-widgets.png|thumb|right|Esempio di widget in Java 5.0+ per il [[X Window System]]. La renderizzazione dei font potrebbe variare a seconda della piattaforma utilizzata.]]
'''Swing''' è un [[Framework]] per [[Java_(linguaggio)|Java]]. È una parte di [[Java Foundation Classes]] (JFC). Swing include una [[GUI|Interfaccia grafica]] (GUI), dei [[widget]] come le caselle di testo, pulsanti, pannelli e tabelle.
La libreria Swing viene utilizzata come libreria ufficiale per la realizzazione di interfacce grafiche in Java. È un'estensione del precedente [[Abstract Window Toolkit]]. La differenza principale tra i due è che i componenti Swing sono scritti completamente in codice [[Java (linguaggio di programmazione)|Java]].
I widget Swing forniscono una GUI più sofisticata rispetto alla precedente [[Abstract Window Toolkit]]. Essendo scritti in puro [[Java_(linguaggio)|Java]], funzionano allo stesso modo su tutte le piattaforme (su cui java gira), al contrario delle AWT le quali sono legate al sistema grafico nativo del [[Sistema_operativo|sistema operativo]]. Swing supporta il [[look and feel]] non tramite quello che viene fornito nativamente dal gestore delle finestre, ma tramite una sua emulazione. Questo significa che si può ottenere un qualsiasi L&F supportato su qualsiasi piattaforma. Lo svantaggio di questi componenti pesanti è quello di una più lenta esecuzione. Il vantaggio è una uniformità di visualizzazione tra svariate piattaforme.
== Storia ==
La ''Internet Foundation Classes'' (IFC) era una [[GL (grafica 3d)|libreria grafica]] per Java sviluppata originalmente dalla [[Netscape Communications Corporation]] e rilasciatadistribuita per la prima volta nel [[16 dicembre]] [[1996]].
Il [[2 aprile]] [[1997]], [[Sun Microsystems]] e [[Netscape Communications Corporation]] annunciarono la loro intenzione di combinare IFC con altre tecnologie per creare la [[Java Foundation Classes]]. Oltre ai componenti originalmente forniti da IFC, Swing introdusse un meccanismo che permetteva il [[look and feel]] di ogni componente di una applicazione di essere alterato senza dover fare cambiamenti significativi al [[codice sorgente]]. L'introduzione del supporto al [[look and feel]] a [[plugin (informatica)|plug-in]] permise ai componenti Swing di emulare l'apparenza dei componenti nativi mantenendo comunque il beneficio di essere indipendenti dalla piattaforma. Questa caratteristica rende molto semplice l'avere un look di una applicazione individuale che appare significativamente differente da tutti gli altri programmi nativi.
Originalmente distribuito come una libreria scaricabile separatamente, Swing fu inclusa come parte della [[Java 2 Platform, Standard Edition|Java Standard Edition]] fin dalla versione 1.2. Le classi Swing sono contenutocontenute nella gerarchia [[Java package (Java)|package]].
== Architettura ==
Swing è una libreria
Swing è un modello di programmazione per il Java:
* indipendente dalla [[piattaforma (informatica)|piattaforma]]
* orientatoorientata ai componenti
* estendibile
* modificabile
* configurabile
* ''loosely-coupled'' (ad accoppiamento debole)
* leggeroleggera
* a spedizione di eventi
* un framework GUI [[Model-View-Controller|MVC]]
* con un [[thread (informatica)|thread]] unico
* Indipendente dalla piattaforma: Swing è indipendente dalla piattaforma sia in termini di linguaggio (Java) sia della sua implementazione (una renderizzazione universale e non nativa dei widget).
* Estendibile: Swing è una architettura molto suddivisa la quale permette l'aggancio di varie implementazioni modificate di specifiche interfacce: Gli utenti possono creare le loro personali implementazioni dei componenti per modificare le implementazioni di default. In generale, gli utenti Swing possono estendere il framework con: estensione delle classi esistenti; fornitura di implementazioni native dei componenti base.
* Orientato ai componenti: Swing è un framework basato a componenti. La differenza tra oggetti e componenti è leggera: concisamente, un componente è un oggetto con determinate caratteristiche di comportamento conosciute e specificate. Gli oggetti Swing emettono eventi in modo asincrono, hanno caratteristiche legate ad essi stessi, e rispondono da un ben preciso set di comandi (Specifico per componente). Specialmente i componenti Swing Java Beans, seguono le specifiche dell'architettura Java Bean.
* Modificabile: Dato il modello di renderizzazione programmatico del framework di Swing, è possibile ottenere un preciso controllo del dettaglio sulla renderizzazione dei suoi componenti. Come discorso generale, la rappresentazione grafica di un componente swing è una combinazione di un set standard di elementi, come i bordi, le rientranze, decorazioni, etc. Solitamente, gli utenti modificheranno un componente standard di Swing (come una JTable) assegnando bordi, colori, sfondi specifici come proprietà del componente. Il componente base, userà queste proprietà (o settaggi) per determinare la modalità più appropriata per disegnarsi. Comunque, è anche possibile creare controlli GUI completamente nuovi, con un livello di rappresentazione visuale molto dettagliato (Per esempio, i componenti Swing supportano le trasparenze.)
* Configurabile: Swing, facendo un uso pesante dei meccanismi di runtime e dei percorsi di renderizzazione indiretta, ha la possibilità di modificare a runtime cambiamenti anche fondamentali nei suoi settaggi. Per esempio, una applicazione basata su Swing può cambiare il suo look and feel a runtime (per esempio, dal look and feel di MacOS a quello di Windows XP). Inoltre, gli utenti possono fornire le loro proprie implementazioni di look and feel, il che permette di ottenere cambiamenti uniformi nei look and feel di applicazioni Swing esistenti, senza un continuo ritocco al codice sorgente dell'applicazione.
* Leggero: La magia della configurabilità di Swing è anche dovuta al fatto che non necessita di usare i controlli della GUI dell'OS nativi per la ''rappresentazione'', ma piuttosto 'disegna' i suoi controlli costantemente, attraverso l'uso delle api 2D di Java. Inoltre, un componente Swing non ha un corrispettivo nell'insieme dei componenti nativi dell'OS, ed è quindi libero di renderizzare se stesso in ogni modo possibile con le librerie grafiche di Java 2D.
;Indipendente dalla piattaforma: Swing è indipendente dalla piattaforma sia in termini di linguaggio (Java) sia della sua implementazione (una renderizzazione universale e non nativa dei [[widget (informatica)|widget]]).
Comunque, alla base, ogni componente Swing si basa su di un contenitore AWT, dato che i JComponent di Swing estendono quelli di AWT. Questo permette a Swing di innestarsi al framework di controllo della GUI dell'OS nativo, compresi la cruciale mappatura device/screen e le interazioni dell'utente (come le pressioni dei tasti, i movimenti del mouse, etc.) Swing semplicemente 'traduce' la sua (OS agnostico) semantica su quella sottostante dei componenti dell'OS. Così, per esempio, ogni componente di Swing si disegna sul dispositivo grafico in risposta alla chiamata component.paint(), la quale è definita nel container AWT. Ma, differentemente dai componenti AWT, i quali delegano il disegno ai widget nativi dell'OS, i componenti di Swing sono responsabili della loro stessa renderizzazione.
;Estendibile: le diverse parti della libreria Swing sono basate su determinate interfacce e sono collegate in modo da consentire facilmente l'aggancio di implementazioni diverse di queste interfacce. Il programmatore può creare un'implementazione personalizzata di queste interfacce o utilizzare le versioni di default.
;Orientata ai componenti: Swing è un framework basato su componenti. Un componente è un oggetto con determinate caratteristiche di comportamento conosciute e specificate. Gli oggetti Swing emettono [[evento (informatica)|eventi]] in modo asincrono, hanno caratteristiche legate ad essi stessi, e rispondono da un ben preciso set di comandi (specifico per componente). In particolare i componenti ''Swing Java Beans'' seguono le specifiche dell'architettura [[JavaBean]].
;Modificabile: l'applicazione ha modo di ottenere un preciso controllo della renderizzazione dei componenti con i quali è realizzata l'interfaccia grafica. La rappresentazione grafica di un componente swing è data da una combinazione di un set standard di elementi; in particolare, ad ogni componente è affidato il disegno dei bordi, delle rientranze, delle decorazioni, ecc. Solitamente, gli utenti modificano un componente standard di Swing (come una ''JTable'') assegnando bordi, colori, sfondi specifici come proprietà del componente. Il componente userà queste proprietà all'atto del disegnarsi.
;Configurabile: Swing, facendo un uso pesante dei meccanismi di runtime e dei percorsi di renderizzazione indiretta, ha la possibilità di modificare a runtime cambiamenti anche fondamentali nei suoi settaggi. Per esempio, una applicazione basata su Swing può cambiare il suo look and feel a [[runtime]] (per esempio, dal look and feel di [[MacOS]] a quello di [[Windows XP]]). Inoltre, gli utenti possono fornire le loro proprie implementazioni di look and feel, il che permette di ottenere cambiamenti uniformi nei look and feel di applicazioni Swing esistenti, senza dover modificare in profondità il codice sorgente dell'applicazione.
;Leggera: La configurabilità di Swing è anche dovuta al fatto che non necessita di usare i controlli della GUI del [[sistema operativo|SO]] nativi per la ''rappresentazione'', ma piuttosto "disegna" i suoi controlli costantemente, attraverso l'uso delle [[Application programming interface|API]] 2D di Java. Inoltre, un componente Swing non deve necessariamente un corrispettivo nell'insieme dei componenti nativi del SO, e questo significa che è possibile realizzare componenti con la massima libertà, sfruttando a propria discrezione le potenzialità messe a disposizione dalle [[Libreria (software)|librerie]] grafiche di Java 2D.
;Loosely-Coupled/MVC: La libreria Swing fa un forte uso del ''design pattern'' [[Model-view-controller|Model/View/Controller]], il quale concettualmente disaccoppia i dati mostrati ed i controlli dell'interfaccia utente attraverso i quali sono mostrati. Grazie a questo, la maggior parte dei componenti Swing hanno associati ''modelli'' (specificati in termini di Java [[interfaccia (informatica)|interfaces]]), il programmatore può usare varie implementazioni di default o crearne di proprie. Il framework fornisce implementazioni di default di modelli per le interfacce per tutti i suoi componenti.
<!-- HELP
Tipicamente, gli oggetti dei modelli dei componenti Swing sono responsabili di provvedere ad una concisa interfaccia per la definizione degli eventi che vengono emessi, nonché proprietà accessibili per il [[modello dei dati]] da usare con i JComponent associati. Dato questo il modello di sviluppo MVC è un percorso loosely-coupled di oggetti in relazione collaborativamente, il modello provvede i consueti modi per creare ''event listeners'' agli oggetti del ''data model''. Tipicamente, questi eventi sono ''model centric'' (ad esempio: l'inserimento di righe in un modello di tabella) e sono mappati dalla specializzazione del JComponent in un ben preciso evento per il componente GUI.
Inoltre, questa traduzione e disaccoppiamento, non è puramente visuale, si estende alla gestione dei widget and extends to the Swing's management of, and application of its own OS-indepenent semantics for, events fired within its component containment hierarchies.
-->
Per esempio, il JTable ha un modello chiamato ''TableModel'' che descrive una interfaccia per come una tabella dovrebbe accedere ai dati. Una implementazione di default di questo opera su di un [[array]] bidimensionale.
Sopratutto, l'architettura di Swing delega il compito del mappaggio di tutte le sfacettature della semantica della GUI dell'OS in un semplice, ma generalizzato percorso al contenitore AWT. Poi, costruito su di una piattaforma generale, crea le sue proprie ricche e complesse semantiche della GUI, sotto forma della classe JComponent.
La componente visiva di un JComponent Swing è l'oggetto usato per "rappresentare" graficamente il controllo GUI concettuale. Una distinzione di Swing, come framework GUI, è il suo utilizzo sulla continua rappresentazione di controlli GUI (al contrario dell'uso dei componenti nativi della gui del SO). Questa distinzione è fonte di complicazione quando si mischiano controlli AWT, che usano controlli nativi, con controlli Swing in una GUI.
(Il lettore interessato è incoraggiato a dare uno sguardo al codice sorgente delle classi Container.java e JComponent.java per ulteriori approfondimenti sull'interfacciamento tra i componenti Swing, più leggeri, e quelli AWT, più pesanti).
* Loosely-Coupled/MVC: La libreria Swing fa un forte uso del [[design pattern (computer science)|design pattern]] [[Model-view-controller|Model/View/Controller]], il quale concettualmente disaccoppia i dati mostrati ed i controlli dell'interfaccia utente attraverso i quali sono mostrati. Grazie a questo, la maggior parte dei componenti Swing hanno associati ''modelli'' (specificati in termini di Java [[interfaccia_(informatica)|interfaces]]), il programmatore può usare varie implementazioni di default o crearne di proprie. Il framework provvede implementazioni di default di modelli per le interfacce per tutti i suoi componenti.
Deve essere notato che il tipico uso del framework Swing non richiede la creazione di modelli modificati, siccome il framework fornisce un insieme di implementazioni di default che sono trasparentemente, per default, associati con le corrispondenti figlie della classe JComponent nella libreria Swing. In generale, solo componenti complessi come le tabelle e le viste di collezioni ''potrebbero'' aver bisogno di modifiche ai loro modelli di default<ref>Comunque, per capire bene il potenziale che l'architettura Swing rende possibile, considerate l'ipotetica situazione in cui i modelli modificati delle tabelle e le liste sono creati al di sopra di servizi DAO e/o EJB</ref>.
Tipicamente, gli oggetti dei modelli dei componenti Swing sono responsabili di provvedere ad una concisa intrfaccia per la definizione degli eventi che vengono emessi, nonché proprietà accessibili per il modello dei dati da usare con i JComponent associati. Dato questo il modello di sviluppo MVC è un loosely-coupled percorso di oggetti in relazione collaborativamente, il modello provvede i consueti modi per creare event listeners aigli oggetti del data model. Tipicamente, questi eventi sono model centric (ad esempio: l'inserimento di righe in un modello di tabella) e sono mappati dalla specializzazione del JComponent in un ben preciso evento per il componente GUI.
== Legami con AWT ==
Per esempio, il {{Javadoc:SE|javax/swing|JTable}} ha un modello chiamato {{Javadoc:SE|javax/swing/table|TableModel}} che descrive una interfaccia per come una tabella dovrebbe accedere ai dati. Una implementazione di default di questo opera su di un [[array]] bidimensionale.
[[File:AWTSwingClassHierarchy.png|thumb|Schema che illustra l'organizzazione dei componenti grafici AWT e dei componenti grafici Swing.]]
La libreria Swing è un'estensione di AWT, più che un suo sostituto. Infatti ogni interfaccia grafica Swing ''lightweight'' è basata su un componente AWT ''heavyweight'', perché tutti i componenti top-level in Swing estendono i container top-level AWT. La funzionalità di renderizzazione usata da Swing per disegnare i suoi componenti è fornita da Java2D, un'altra parte di AWT. La disposizione dei componenti viene affidata ai <kbd>java.awt.LayoutManager</kbd>. ecc.
=== Differenze con AWT: il meccanismo di funzionamento ===
La componente visiva di un JComponent Swing è l'oggetto usato per 'rappresentare' graficamente il controllo GUI concettuale. Una distinzione di Swing, come framework GUI, è il suo utilizzo sulla continua rappresentazione di controlli gui (al contrario dell'uso dei componenti nativi della gui dell'OS). (Questa distinzione è fonte di complicazione quando si mischiano controlli AWT, che usano controlli nativi, con controlli Swing in una GUI.)
Fin dalle prime versioni di Java, una porzione del [[Abstract Window Toolkit]] (AWT) ha fornito API indipendenti dalla piattaforma per la realizzazione delle GUI. In AWT, di fatto l'applicazione si serve di oggetti Java per controllare i componenti nativi specifici per il sistema operativo in utilizzo e che compongono l'interfaccia grafica. Questo significa che il comportamento dei componenti (la reazione agli eventi, il rendering, ecc.) sono affidati alla loro implementazione ''system-dependent''. Per questo motivo, i componenti AWT vengono detti ''heavyweight components'' ("componenti pesanti"): a ciò che l'applicazione "vede" come la creazione di un componente AWT, di fatto corrisponde l'allocazione di risorse ad opera del sistema operativo. Al contrario, i componenti Swing sono spesso descritti come ''lightweight'' ("leggeri"), perché non necessitano l'allocazione di risorse native nel toolkit della GUI del sistema operativo.
=== Elementi di AWT utilizzati in Swing ===
Deve essere notato che il tipico uso del framework Swing, non richiede la creazione di modelli modificati, siccome il framework fornisce un insieme di implementazioni di default che sono trasparentemente, per default, associati con le corrispondenti figlie della classe JComponent nella libreria Swing. In generale, solo componenti complessi come le tabelle e le viste di collezioni ''potrebbero'' aver bisogno di modifiche ai loro modelli di default.
; Layout managers
Alla fine, in termini di composizione visuale e gestione, Swing possiede layout relativi (i quali specificano la posizione reciproca tra i componenti) che operano in maniera opposta rispetto al layout assoluto (nel quale è necessario specificare apposta la esatta posizione e le dimensioni di ogni componente). Questa direzione verso visualizzazioni "fluide" è una diretta politica dello sviluppo di Swing che riemerge dalle ceneri del framework AWT e l'associata assunzione sulle [[applet]] dell'ambiente operativo che ha tracciato il disegno e sviluppo dell'originale toolkit GUI di Java.
Concettualmente, questa visualizzazione della gestione del layout è abbastanza simile a quella che gestisce la renderizzazione del contenuto [[HTML]] nei [[browser]], ed indirizza lo stesso insieme di concetti che hanno motivato i suoi creatori.
; Container top-level
(Comunque, per capire bene il potenziale che l'architettura Swing rende possibile, considerate l'ipotetica situazione in cui i modelli modificati delle tabelle e le liste sono creati al di sopra di servizi DAO e/o EJB).
Se è vero che i singoli componenti sono realizzati completamente in codice Java, i container ''top-level'' (finestre di dialogo e applet) sono parzialmente implementati in codice nativo.
=== Vantaggi rispetto ad AWT ===
Alla fine, in termini di composizione visuale e gestione, Swing possiede layouts relativi (i quali specificano la posizione reciproca tra i componenti) che operano in maniera opposta rispetto ai layout assoluti (i quali specificano le esatte posizioni e dimensioni dei componenti). Questa direzione verso visualizzazioni 'fluide' è una diretta politica dello sviluppo di Swing che riemerge dalle ceneri del framework AWT e l'associata assunzione sulle Applet dell'ambiente operativo che ha tracciato il disegno e sviluppo dell'originale toolkit GUI di Java.
I principali vantaggi di Swing rispetto ad AWT sono conseguenza del fatto stesso che i componenti Swing sono realizzati in puro codice Java. Infatti, questo significa che i componenti funzionano allo stesso modo su tutte le piattaforme per le quali esiste una [[macchina virtuale]]. I bug rilevati durante l'esecuzione del sistema grafico (almeno per la parte che riguarda l'interfaccia grafica) sono gli stessi su tutte le piattaforme, il che permette di risolverli con un semplice aggiornamento delle librerie.
; Look and feel
(Concettualmente, questa visualizzazione della gestione del layout è abbastanza simile a quella che gestisce la renderizzazione del contenuto dell'HTML nei browsers, ed indirizza lo stesso insieme di concetti che hanno motivato i creatori).
Poiché i componenti sono sviluppati in Java, il sistema Swing ha controllo sul [[render]]ing grafico dei componenti, e questo ha consentito lo sviluppo di un'API tramite la quale un'applicazione può personalizzare il ''[[look and feel]]'' della propria interfaccia grafica. In poche parole, il disegno e lo stile grafico dei componenti non vengono richiesti al toolkit grafico nativo del sistema operativo, ma vengono riprodotti tramite una loro emulazione. Questo significa che si può ottenere un nuovo L&F semplicemente implementando le classi Java necessarie (oppure configurando il look and feel Synth, introdotto a partire dal J2SE 5.0).
; Libertà nel rendering
==Look and feel==
Il principale vantaggio della libreria Swing è che essa permette al programmatore di astrarsi dai vincoli imposti dall'architettura del sistema grafico adottato dal sistema operativo in uso. Il sistema grafico AWT risente di queste limitazioni, in quanto l'insieme dei componenti e le caratteristiche che questi ultimi offrono all'applicazione sono ristretti ad uno standard comune, un minimo insieme che possa essere supportato da tutti i sistemi operativi sui quali AWT deve funzionare.
Swing permette di specializzare il [[Look_and_feel#Look and Feel in Widget Toolkits|look and feel]] dei suoi [[Widget|widget]], modificando quello di default (con parametri a runtime), basandosi su di uno esistente, creandone uno da zero, o, iniziando con '''J2SE 5.0''', usando lo [[skinnable]] {{Javadoc:SE|package=Synth Look and Feel|javax/swing/plaf/synth}}, il quale viene configurato con un file di proprietà [[XML]]. Il look and feel può essere modificato a can be changed at runtime, una prossima dimostrazione di Swing mostrerà spesso come fare.
I componenti Swing gestiscono in modo autonomo la propria grafica e il proprio comportamento; è pur vero che il rendering finale deve essere affidato al sistema operativo, in quanto è quest'ultimo che ha in mano la gestione delle periferiche video e delle periferiche che segnalano l'input utente (tastiera, mouse, rotellina del mouse, ecc.), ma è anche vero che Swing "traduce" la sua [[semantica]] su quella sottostante dei componenti del SO con un legame molto più debole rispetto a quanto l'architettura stessa dell'AWT consentiva di ottenere.<br />
==Legami con AWT==
Così, per esempio, di fatto ogni componente di Swing si disegna sul dispositivo grafico del sistema operativo servendosi di un [[wrapper]] opportunamente implementato in Java (realizzato tramite un oggetto <kbd>java.awt.Graphics</kbd>). Ma, differentemente dai componenti AWT, i quali delegano il disegno ai widget nativi del SO, i componenti di Swing sono responsabili della loro stessa renderizzazione.
Fin dalle prime versioni di Java, una porzione del [[Abstract Windowing Toolkit]] (AWT) ha fornito API indipendenti dalla piattaforma per i componenti della GUI. In AWT, ogni componente è renderizzato e controllato da uno nativo specifico per il sottostante sistema operativo.
Al contrario, i componenti Swing sono spesso descritti come ''lightweight'' perché non necessitano l'allocazione di risorse native nel toolkit della GUI del sistema operativo. I componenti AWT vengono detti come ''heavyweight components''.
=== Svantaggi rispetto ad AWT ===
La maggior parte delle API Swing è generalmente una estensione complementare di AWT piuttosto che un diretto rimpiazzo. Infatti, ogni interfaccia Swing lightweight è basata su un componente AWT heavyweight perché tutti i componenti top-level in Swing ({{Javadoc:SE|javax/swing|JApplet}}, {{Javadoc:SE|javax/swing|JDialog}}, {{Javadoc:SE|javax/swing|JFrame}} e {{Javadoc:SE|javax/swing|JWindow}}) estendono i container top-level AWT. La funzionalità di renderizzazione usata da Swing per disegnare i suoi componenti è fornita da [[Java2D]], una altra parte di JFC. Comunque l'uso contemporaneo di componenti lightweight ed heavyweight nella stessa finestra è generalmente scoraggiato per incompatibilità di [[Z-order]].
Il principale svantaggio rispetto ad AWT è quello di una più lenta esecuzione.
== Legami con SWT ==
Lo [[Standard Widget Toolkit]] (SWT) è un toolkit concorrente originalmente sviluppato dalla [[IBM]] ed ora mantenuto dalla [[Eclipse Foundation]]. Le implementazioni SWT sono più in comune con i componenti AWT heavyweight. Questo conferisce benefici come una più accurata fedeltà con il sottostante toolkit window nativo, al costo di una maggior esposizione ad una programmazione più nativa nel modello di programmazione.
L'avvento di SWT ha dato origine ad una grande divisione tra gli sviluppatori del Java desktop con molti fortemente favorevoli a SWT e altri a Swing. Lo sviluppo di Sun su Swing continua a concentrarsi sulla fedeltà del look and feel (PLAF, Pluggable look and feel) in ogni toolkit window. Nel frattempo non vi sono altre risorse di PLAFs fedeli, molti dei quali sono nel sito [http://www.javootoo.com/ javootoo] {{Webarchive|url=https://web.archive.org/web/20050715034602/http://www.javootoo.com/ |date=15 luglio 2005 }}.
C'è stato un dibattito significativo sulle prestazioni di SWT rispetto a quelle di Swing; La dipendenza di SWT da JNI lo rende lento quando i componenti GUI e Java necessitano di scambiarsi i dati, ma più veloce a disegnarsi quando il modello dei dati è stato caricato nella GUI.
SWT serve alla piattaforma delle finestre molto bene ma<!-- èCHE considerataSIGNIFICA daL'INIZIO DI QUESTA FRASE??--> ma alcuni dila essereconsiderano meno efficace come tecnologia per lo sviluppo multipiattaforma. Usando le funzionalità di alto livello dei window toolkit nativi, SWT riporta alla situazione vista negli anni '90 (con toolkit come zApp, Zinc, XVT e IBM/[[Smalltalk]]) dove i toolkit cercavano di mascherare le differenze nel comportamento e gestione del focus, della gestione degli eventi e dei layout grafici. Il fallimento di avere eguali comportamenti su ogni piattaforma può causare errori di programmazione subdoli e difficili da risolvere, checon effetti impattanonegativi sull'interazione dell'utente e sull'aspetto grafico della GUI.
== Esempio ==
Il seguente è un programma [[Hello worldWorld]] di esempio che usa Swing.
<sourcesyntaxhighlight lang="java">
import javax.swing.JFrame*;
import javax.swing.JLabel;
import java.awt.EventQueue;
public final class HelloWorld {
public static void main(String[] args) {
// Swing has its own dispatch thread, which is
// distinct from the main JVM (launcher) thread.
// This means that even if the (launcher) thread exited
// (this) main method, the Swing GUI thread would
// still be running, waiting to respond to user input, etc.
// and if the user closes the window, then the program would
// continue to run (due to the live gui thread). As of Java 1.4, the
// GUI thread will automatically stop if all Components are hidden and
// disposed.
/* Questo fa sì che tutto il codice che crea e mostra a schermo la GUI venga eseguito sul thread
// Execute all GUI code on the event dispatch thread, even initialization:
che gestisce la coda degli eventi di Swing (e di AWT). */
EventQueue.invokeLater(new Runnable() {
publicSwingUtilities.invokeLater(new void runRunnable() {
public void run() {
mainOnEventDispatchThread();
} });
}
// Questo metodo viene sempre invocato sul thread che gestisce la coda degli eventi ↓
private static void mainOnEventDispatchThread() {
// Create frame with title "Hello, World!"
JFrame f = new JFrame("Hello, World!");
// Dimensione della finestra
f.setSize(200, 100);
// PreviouslyFa wesì typicallyche attachedil aframe windowrichieda listeneralla toJVM ourdi mainterminare JFrameil programma
// andquando onla windowClosing()finestra eventviene notification callback, we wouldchiusa.
f.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
// explicitly call System.exit(stat) or some other such nastiness.
// The following is the new (clean) way of defining default close behavior
// for a JFrame. The following will merely dispose the JFrame but it will not
// stop the application unless *all* Windows are disposed.
f.setDefaultCloseOperationadd(new JLabel(JFrame.DISPOSE_ON_CLOSE"Hello, World!"));
// this stops the app on window close
// (it is commented out.)
// f.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
// JFrame, which is the 'window' component of Swing, has an interesting feature:
// it has a layered content architecture which (conceptually) allows for placement
// of a component of the JFrame in a designated layer. The layers can be conceptually
// viewed as a series of transparencies placed one above another in a overhead projector
// Swing typically places user components (such as buttons, etc.) in what it calls its
// 'content pane'. This pane is layer that is below most of the other (transparent)
// layers.
// What are the layers for? Think of when you right-click on a control and it 'pops' a
// contextual menu 'over' the original control; or, when you press 'help' for a control
// or hover the mouse for a 'tool tip' and the information is 'placed over the control'.
// How is that done? By rendering the information in a layer 'above' the lower level
// 'content' pane. So:
// The standard way of adding a component to a 'multi-pane' container such as JFrame
// is by first establishing a reference to its 'content pane' (which is, by default
// just aJPanel with BorderLayout and adding the components the JFrame to the content
// pane and NOT directly to the JFrame. (The latest Swing releasehowever alters the
// semantics of the JFrame.add(..) to assume convenient addition to the content pane).
f.getContentPane().add(new JLabel("Hello, World!"));
// Remember the relative layouts of Swing?
// pack() tells the receiving container (here 'this' JFrame)
// for it to optimally pack its components according to its layout.
f.pack();
f.setVisible(true);
} });
}
}
</syntaxhighlight>
</source>
== Note ==
<references/>
== Bibliografia ==
* Matthew Robinson, ''Swing'', Manning, ISBN 1-930110-88-X
* David M. Geary, ''Graphic Java 2, Volume 2: Swing'', Prentice Hall, ISBN 0-13-079667-0
* James Elliott, Robert Eckstein, Marc Loy, David Wood, Brian Cole, ''Java Swing'', [[O'Reilly Media|O'Reilly]], ISBN 0-596-00408-7
* Kathy Walrath, Mary Campione, Alison Huml, Sharon Zakhour, ''The JFC Swing Tutorial: A Guide to Constructing GUIs'', Addison-Wesley Professional, ISBN 0-201-91467-0
* Joshua Marinacci, Chris Adamson, ''Swing Hacks'', O'Reilly, ISBN 0-596-00907-0
== Voci correlate ==
* [[Project Looking Glass]]
*[[JavaFX]]
* [[Event dispatching thread]]
* [[SwingWorker]]
* [[CookSwing]]
* [[Widget toolkit]]
== Altri progetti ==
==Bibliografia==
{{interprogetto}}
* [[Matthew Robinson]]: ''Swing'', Manning, ISBN 1-930110-88-X
* [[David M. Geary]]: ''Graphic Java 2, Volume 2: Swing'', Prentice Hall, ISBN 0-13-079667-0
* [[James Elliott]], [[Robert Eckstein]], [[Marc Loy]], [[David Wood]], [[Brian Cole]]: ''Java Swing'', O'Reilly, ISBN 0-596-00408-7
* [[Kathy Walrath]], [[Mary Campione]], [[Alison Huml]], [[Sharon Zakhour]]: ''The JFC Swing Tutorial: A Guide to Constructing GUIs'', Addison-Wesley Professional, ISBN 0-201-91467-0
* [[Joshua Marinacci]], [[Chris Adamson]]: ''Swing Hacks'', O'Reilly, ISBN 0-596-00907-0
== Collegamenti esterni ==
Link dai siti ufficiali:
* [http://www.java-swing-tutorial.com Java Swing Tutorial] di [[Hemanth Balaji]]
* [{{cita web|http://java.sun.com/docsproducts/booksjfc/tutorialtsc/uiswingarticles/index.html Thearchitecture/|A Swing Tutorial]architecture overview}}
* [{{cita web|http://java.sun.com/productsdocs/jfcbooks/tsctutorial/uiswing/index.html |The Swing Connection]Tutorial}}
* {{cita web |1=http://community.java.net/javadesktop/ |2=JavaDesktop |accesso=1º ottobre 2006 |urlarchivio=https://web.archive.org/web/20050729002040/http://community.java.net/javadesktop/# |dataarchivio=29 luglio 2005 |urlmorto=sì }}
* {{Javadoc:SE-guide|swing|The Swing API documentation}}
* [http://java.sun.com/products/jfc/tsc/articles/architecture/ The Swing architecture]
* [http://community.java.net/javadesktop/ JavaDesktop]
* [http://www.javootoo.com/ Java Look And Feel]
* [http://www.clientjava.com/ ClientJava.com]
* Presentation "[http://javalobby.org/eps/galbraith-swing-1/ Professional Swing: Creating Polished Apps, Part 1/2]" by [[Ben Galbraith]]
* Presentation "[http://www.javalobby.org/eps/galbraith-swing-2/ Professional Swing: Creating Polished Apps, Part 2/2]" by [[Ben Galbraith]]
* Article "[http://javalobby.org/articles/swing_slow/index.jsp What does "Swing is Slow" mean?]" by [[Sermet Yucel]]
* Article "[http://www.onjava.com/pub/a/onjava/2004/02/18/desktop.html Java Desktop Development]" by [[Andrei Cioroianu]]
* Article "[http://www.onjava.com/pub/a/onjava/2004/03/10/blackmamba.html BlackMamba: A Swing Case Study]" by [[Ashwin Jayaprakash]]
* [http://www.javaworld.com/channel_content/jw-awt-index.shtml Articles on AWT/Swing]
* [http://citeseer.ist.psu.edu/cis?q=Java+Swing Citations from CiteSeer]
* [http://www.swingwiki.org Swing wiki] containing best practices, tips, tricks and howto tutorials
* [http://www.jgoodies.com JGoodies ]
* Free trial "[http://www.java-library.com/java-library.html Java SWING Components]" - extended Java SWING components.
Altri link:
[[Categoria:Sun]]
* Articolo ''[http://www.onjava.com/pub/a/onjava/2004/02/18/desktop.html Java Desktop Development]'' di Andrei Cioroianu
[[Categoria:Java]]
* Articolo ''[http://www.onjava.com/pub/a/onjava/2004/03/10/blackmamba.html BlackMamba: A Swing Case Study]'' di Ashwin Jayaprakash
[[Categoria:Strumenti di sviluppo]]
*{{cita web | 1 = http://www.swingwiki.org/ | 2 = Swing wiki | accesso = 17 aprile 2011 | urlarchivio = https://web.archive.org/web/20110526164920/http://www.swingwiki.org/ | dataarchivio = 26 maggio 2011 | urlmorto = sì }}
[[Categoria:Piattaforma Java]]
[[bn:সুইং (জাভা)]]
[[de:Swing (Java)]]
[[en:Swing (Java)]]
[[es:Swing (biblioteca gráfica)]]
[[fi:Swing (Java)]]
[[fr:Swing (Java)]]
[[ja:Swing]]
[[ko:스윙 (자바)]]
[[lt:Swing]]
[[nl:Swing (Java)]]
[[pl:Swing (Java)]]
[[pt:Swing (api)]]
[[ru:Swing]]
[[zh:Swing]]
| 