Newsgroup: it.comp.java
Titolo: [NEWBIE] Layout manager + disponibilità componenti

Ciao,
sono un programmatore esperto nei linguaggi Delphi e Visual Basic 6.0.
Da poco ho iniziato a studiare Java.
Quando ho iniziato ad affrontare il tema della realizzazione delle interfacce 
grafiche in Java, mi sono quasi subito scontrato col concetto di layout manager.
Dopo molti tentativi e non poche difficolta' sto finalmente iniziando a capire 
come maneggiarli anche se, nella pratica, sono ancora molto incerto quando si 
tratta di decidere se utilizzarli o meno e soprattutto QUALI utilizzare.
Il problema piu' grave ed il motivo principale per cui sto scrivendo sta pero' a 
monte: non ho capito perche' si debba ricorrere ad una tecnologia a mio parere 
tanto ostica, complessa nonche' scomoda solo per garantire una disposizione ed 
un ridimensionamento dinamico degli oggetti grafici.
Invece in Delphi, e credo anche in tutti i linguaggi della famiglia .NET, questa 
problematica viene risolta in modo molto piu' semplice ed intuitivo utilizzando 
concetti come l'allineamento e gli anchors. In particolare questi ultimi 
consentono di rendere fissa la distanza del controllo rispetto ad uno o piu' 
bordi (top, bottom, left, right) del suo contenitore; quando il contenitore 
viene ridimensionato le distanze "anchorate" restano fisse mentre, se 
necessario, le dimensioni del controllo vengono adeguate automaticamente.
Inoltre i layout manager, rispetto alle soluzioni alternative di cui sopra, a 
mio avviso hanno anche lo svantaggio di imporre una eccessiva rigidita'. Infatti 
puo' accadere che la stessa interfaccia subisca nel tempo diverse modifiche. 
Cosa accadrebbe allora se mi accorgessi che, a seguito dell'ennesima modifica, 
il layout manager scelto all'inizio non fosse piu' adeguato alla nuova 
situazione? Cambiare layout manager in corso d'opera non comporterebbe quasi 
sempre di dover ricominciare da zero con la disposizione di TUTTI i componenti 
dell'interfaccia? Questo non accade invece con gli anchors e l'allineamento 
poiche' sono proprieta' che si definiscono per ogni singolo componente.
Il problema e' ancora piu' serio se si considera che, nel mio lavoro di tutti i 
giorni, con i linguaggi che padroneggio mi ritrovo spesso a dover realizzare 
interfacce molto complesse con svariate decine di controlli diversi tanto che, 
pur senza la scomodita' dei layout manager, solo questo aspetto dello sviluppo 
richiede tempo e sforzo considerevoli. Quindi non posso assolutamente 
permettermi di sposare una tecnologia che ne aumenti ulteriormente la 
complessita' senza offrirmi in cambio nessun vantaggio evidente.
Francamente tutte queste considerazioni hanno molto raffreddato il mio 
entusiasmo iniziale per questo linguaggio e mi stanno costringendo a mettere 
seriamente in discussione l'opportunita' di proseguire in questo mio percorso di 
apprendimento.
E, nel rivalutare la mia scelta di "convertirmi" a Java, il dubbio e lo 
sconforto (ho gia' speso un bel po' di soldini per procurami due voluminosi 
manuali sull'argomento) anno aperto la strada ad altre domande che prima, prorio 
sull'onda di quell'entusiasmo iniziale, avevo trascurato. Una di queste e' la 
seguente: similmente a quanto accade per altri linguaggi come quelli sopra 
citati, esiste anche per Java una ricca offerta di componenti grafici sviluppati 
da terze parti, magari dal look piu' intrigante e con piu' funzionalita' 
rispetto a quelli canonici di Swing?
In sintesi, i punti fondamentali su cui gradirei una vostra risposta sono i 
seguenti:
1) l'uso dei layout manager offre dei vantaggi rispetto ad altre tecniche, 
apparentemente piu' intuitive e funzionali, utilizzate da altri linguaggi per 
conseguire il medesimo obiettivo? Se si, quali sono questi vantaggi?
2) nella pratica utilizzate spesso i layout manager? in base a quali criteri li 
scegliete? avete dei suggerimenti da darmi per un loro utilizzo ottimale? Per 
esempio, applicate il layout manager prima o dopo di aver disposto tutti gli 
elementi dell'interfaccia?
3) potete sottopormi qualche esempio di libreria di componenti grafici 
alternativa a Swing e possibilmente (ma non necessariamente) gratuita?
Mi scuso per la lunghezza del mio intervento e ringrazio sin d'ora chi vorra' 
rispondermi.
Grazie per l'attenzione,
Andrea Barbagallo



 
Se ti può consolare, sto seguendo il tuo stesso percorso (delphi->java) e
condivido in pieno le tue osservazioni.
Non ho ancora fatto una scelta definitiva fra i vari tipi di layout e sto
ancora valutando di volta in volta la strada migliore.
Ciao
Angelo Ravagli


Rispondo ad entrambi:
non c'e' un layout migliore di altri, bisogna scegliere di volta in
volta quello piu' adatto. Inoltre il layout si possono impacchettare
uno nell'altro.
Infine se proprio devi fare roba molto complessa potrebbe valere la
pena di non fare la finestra ridimensionabile e inserire i vari
elementi fissi (questo IMHO)
Ciao Jack


Sì, SWT, la libreria grafica con cui hanno sviluppato Eclipse.

 alternativa a Swing e possibilmente (ma non necessariamente) gratuita?
una alternativa potrebbe essere SWT (che non conosco) ma sinceramente ci
penserei due volte ad abbandonare Swing perchè è la libreria ufficiale di
Java e gode di un buon supporto, non vorrei cadere dalla padella nelle
brace.
ciao

 ciao
Ciao, e grazie per il tuo contributo.

 elementi fissi (questo IMHO)
E' quello che ho pensato anch'io. Del resto, nella pratica di tutti i giorni, la 
stragrande maggioranza delle finestre che implemento (con Delphi o Vb) non sono 
ridimensionabili. Quindi vale la pena di fare una prova.
Apro il mio JBuilder (ver. 2006 enterprise per windows) e creo, con l'apposito 
wizard, un nuovo progetto di tipo "Application". Nel progetto viene incluso un 
JFrame che a sua volta contiene un JPanel. Utilizzando l'editor visuale, setto a 
FALSE la proprieta' "resizable" del JFrame e a null la proprieta' layout del 
JPanel (in modo da non utilizzare nessun layout manager). Poi dispongo un 
JButton vicino all'angolo inferiore destro del JPanel. Mando il tutto in 
esecuzione e mi viene mostrata la finestra a runtime.
Con mio grande stupore e sconforto noto che, per qualche strano e oscuro motivo, 
il JButton adesso mi compare piu' in basso rispetto a dove lo avevo messo io, 
tanto che ne rimane visibile solo una strisciolina nella parte superiore: il 
resto del componente sta oltre il bordo inferiore della finestra.
Evidentemente si tratta di un test semplicissimo e banale. Se, da neofita, 
avessi fatto qualcosa del genere con Delphi o con Vb avrei ottenuto esattamente 
cio' che mi aspettavo. Con Java non e' cosi', pur volendo evitare la 
complicazione dei layout manager.
Allora mi chiedo: ho ragione o no a pensare che la gestione delle interfacce 
grafiche in Java sia un po' un delirio?
Comunque, se qualcuno di voi potesse dirmi dove ho sbagliato aiutandomi a far 
comparire quell'unico pulsante esattamente dove voglio io, gliene saro' molto grato.


 comparire quell'unico pulsante esattamente dove voglio io, gliene saro' molto grato.
1) non ho idea di come funzioni JBuilder, non lo uso
2) se quello che fai tu visualmente poi non funziona come pensi,
magari poterbbe essere un idea andare a dare un occhiata nel codice
che viene creato automaticamente.
3) la gestione della GUI in java non e' un delirio, bisogna solo
capire come funziona, evidentemente non funziona allo stesso modo di
vb e delphi (fortunatamente aggiungo). Si vede che non hai mai avuto a
che fare con le GTK in C, li si che c'e' da spararsi...
4) se posti il codice ti possiamo dire cosa fai di sbagliato.
5) prima di usare le cose visuali per far finestre,pannelli e altro e'
meglio se cominci a scrivere tu il codice a mano, si capisce meglio
come funzionano le cose.
Ciao Jack

 utilizzavi di solito?
Salti mortali col BorderLayout e pannelli innestati con altri BorderLayout
o altri Layout a seconda dei casi.

 4) se posti il codice ti possiamo dire cosa fai di sbagliato.
Ti riporto di seguito il codice generato automaticamente dall'editor visuale e 
ripartito nei due file denominati Application1.java e Frame1.java.
Studiando il codice sono giunto alla conclusione che il problema sono i primi 
due valori passati al costruttore della classe Rectangle (riga 27 del file 
Frame1.java). Tuttavia il punto e' che, relativamente alla posizione del 
pulsante, non c'e' perfetta corrispondenza tra la finestra che appare 
nell'editor e quella creata a runtime. Forse e' un problema solo di JBuilder? 
Qualcuno potrebbe fare la stessa prova con l'editor visuale di un altro IDE e 
verificare se, nel suo caso, le cose vanno meglio?
********************************************************************************
Application1.java
********************************************************************************
package untitled1;
import java.awt.Toolkit;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import java.awt.Dimension;
public class Application1 {
     boolean packFrame = false;
     public Application1() {
         Frame1 frame = new Frame1();
         if (packFrame) {
             frame.pack();
         } else {
             frame.validate();
         }
         Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
         Dimension frameSize = frame.getSize();
         if (frameSize.height > screenSize.height) {
             frameSize.height = screenSize.height;
         }
         if (frameSize.width > screenSize.width) {
             frameSize.width = screenSize.width;
         }
         frame.setLocation((screenSize.width - frameSize.width) / 2,
                           (screenSize.height - frameSize.height) / 2);
         frame.setVisible(true);
     }
     public static void main(String[] args) {
         SwingUtilities.invokeLater(new Runnable() {
             public void run() {
                 try {
                     UIManager.setLookAndFeel(UIManager.
                                              getSystemLookAndFeelClassName());
                 } catch (Exception exception) {
                     exception.printStackTrace();
                 }
                 new Application1();
             }
         });
     }
}
********************************************************************************
Frame1.java
********************************************************************************
package untitled1;
import java.awt.Dimension;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;
import java.awt.Rectangle;
public class Frame1 extends JFrame {
     JPanel contentPane;
     JButton jButton1 = new JButton();
     public Frame1() {
         try {
             setDefaultCloseOperation(EXIT_ON_CLOSE);
             jbInit();
         } catch (Exception exception) {
             exception.printStackTrace();
         }
     }
     private void jbInit() throws Exception {
         contentPane = (JPanel) getContentPane();
         contentPane.setLayout(null);
         this.setResizable(false);
         setSize(new Dimension(400, 300));
         setTitle("Frame Title");
         this.setVisible(true);
         jButton1.setBounds(new Rectangle(317, 259, 74, 32));
         jButton1.setText("jButton1");
         contentPane.add(jButton1);
     }
}
********************************************************************************


          jButton1.setBounds(new Rectangle(317, 259, 74, 32));
Il pulsante viene posizionato all'asse X 317 e all'asse Y 259,
ed ha una larghezza di 74 e un'altezza di 32 (le misure, se non ricordo
male, sono tutte in pixel)
Enrico
P.S. non ho mai capito perche` JBuilder debba fare la porcata di
istanziare degli oggetti quando quelle misure possono essere passate
come valori interi...

 o altri Layout a seconda dei casi.
Appunto! E siccome non sei il solo questo dimostra che la gestione dei
layout in JAVA e' sempre stata piuttosto macchinosa. Il GridBagLayout
è estremamente flessibile e potente, potrei dire che fa tutte le cose che
ci si aspetta da un layout, ma il suo utilizzo completo non e' proprio
user-friendly.