Newsgroup: it.comp.java
Titolo: Come disegnare il layout di più frames in NetBeans

Salve a tutti,
scrivo sperando che possiate aiutarmi a risolvere questo mio problema.
In pratica sto realizzando un applicazione in Java con una GUI 
abbastanza complessa (decine di label, alcuni pulsanti, un JTree, un 
WindowListener associato alla chiusura del frame, ecc.).
Per questo motivo, per progettare il layout grafico della mia 
applicazione, non sto creando tutto a mano utilizzando uno dei tanti 
LayoutManager bensï¿œ ho scelto di usare il comodo strumento drag&drop che 
mette a disposizione NetBeans.
Nel fare cosï¿œ ho perï¿œ riscontrato un problema.
Quando creo la prima schermata della mia applicazione va tutto 
benissimo. A un certo punto perï¿œ il mio programma ha bisogno di aprire 
un nuovo frame alla pressione di un pulsante da parte dell'utente.
In pratica ogni volta che l'utente clicca su un pulsante dovrï¿œ aprirsi 
un nuovo frame che visualizza il contenuto del file selezionato 
dall'utente nel JTree:
     private void apriClick(java.awt.event.MouseEvent evt) { 
         apriBrowser(tree.getSelected());
     }
Anche questo nuovo frame ha una struttura abbastanza complessa e quindi 
preferirei non doverlo fare a mano. Il problema ï¿œ che non so come 
utilizzare lo strumento di editor grafico di NetBeans per creare tutti 
questi frames.
Netbeans infatti mi permette di creare UN SOLO frame alla volta a cui io 
aggiungo TOT componenti, chiamandoli comp1, comp2, comp3 e cosï¿œ via.
Io perï¿œ avrei necessitï¿œ di creare X frames, ognuno con i suoi componenti 
e ognuno con i suoi listener, le sue azioni, i suoi metodi, ecc.
Per ora sto quindi facendo in questo modo:
public void apriBrowser() {
	JFrame browser = new JFrame();
	browser.add(new JLabel("ciao"));
	browser.add(new JPanel());
	// .........
	frame.setVisible(true);
}
perï¿œ in questo modo sono obbligato a creare i frame a mano. Vorrei 
invece uno strumento che mi permetta di creare il layout grafico con 
facilitï¿œ e poi generare il codice del frame appena creato in modo da 
poterlo inserire nel codice del metodo apriBrowser().
Spero di essere riuscito a spiegarmi
-- 
Elminster

 scrivo sperando che possiate aiutarmi a risolvere questo mio problema.
Vedendo che ancora non mi avete risposto, mi sta venendo la paura di essermi 
spiegato male.
Ci riprovo in termini diversi.
Praticamente NetBeans mi permette di modellare come voglio un singolo frame. 
Ci aggiungo JPanel, JLabel, decido le dimensioni, gli aggiungo Listener, 
ecc., insomma ci faccio tutto quello che voflio.
Nessun problema se questo ï¿œ solo UN FRAME: lo progetto nei minimi dettagli e 
quando voglio, nel mio programma, lo apro lanciando (per esempio) un comando 
tipo:
frame.setVisible(true);
Se perï¿œ volessi progettare un frame che dovrï¿œ essere il frame di default a 
essere visualizzato quando l'utente effettua una certa azione, ovviamente in 
funzione dell'azione appena compiuta.
Per esempio, l'utente sceglie da una JList una immagine e poi clicca su un 
pulsante "Apri immagine".
A questo punto deve aprirsi il frame in questione che ospita l'immagine e 
tanti altri dettagli sull'immagine.
Ora perï¿œ, se l'utente sceglie un'altra immagine e riclicca sul pulsante, 
deve aprirsi un altro frame.
E cosï¿œ via.
Io perï¿œ non so come fare per progettare la veste grafica del frame con 
NetBeans ma allo stesso tempo fare in modo che, ogni volta che lancio un 
comando del tipo new MyFrame(parametri), esso venga rigenerato con tutti i 
parametri che gli passo.
In pratica, vorrei trovare un modo per creare graficamente il layout del mio 
frame attraverso semplici operazioni "drag&drop", ma poi ottenere il codice 
di questo frame in modo che possa inserirlo all'interno di un semplice 
metodo o costruttore per poterlo richiamare quante volte voglio e dove 
voglio.
Magari ï¿œ una cosa facilissima e si puï¿œ fare anche con NetBeans ma io ancora 
non sono riuscito a capire come.
Grazie per la disponibilitï¿œ
--
Elminster 

 non sono riuscito a capire come.
a me sembra che manchi qualche base...
crei classe del frame 1 (a mano o con l'editor visuale di netbeans on
importa)
crei classe del frame 2 (a mano o con l'editor visuale di netbeans on
importa)
.....
crei classe del frame N (a mano o con l'editor visuale di netbeans on
importa)
diciamo che nel frame 1 c'e' un bottone che dovrebbe aprire il frame 2.
allora aggiungi un actionlistener al pulsante e nell'actionperformed del
listener metti una roba del tipo:
frame2 = new frame2(parametri)
frame2.setQuisetLa
frame2.setvisible
e cosi' via 

 importa)
Il problema è proprio questo: i miei N frame sono tutti identici,
differiscono solo per i parametri che gli passo.
Solamente che, facendoli creare a NetBeans, non è facile poi
estrapolarli dal codice creato e inserirli all'interno di un nuovo
metodo, come servirebbe a me.
Se infatti aggiungo un nuovo frame tramite l'editor grafico di
NetBeans, il programma aggiunge tutte le dichiarazioni dei suoi
componenti all'inizio del mio listato, mischiandoli con quelle di
altri componenti di altri frames.
Poi aggiunge tutta la parte del codice relativa al layout in mezzo al
mio listato, insieme al layout di altri frames del mio programma. Se
poi dovessi aggiungere un eventuale Listener al mio frame, anche
questo verrebbe inserito in mezzo al mio codice. Insomma, non è facile
poi creare un metodo che si occupi solo di creare il nuovo frame
perché bisognerebbe andare a cercare e raccogliere tutte le parti di
listato relative a esso in mezzo al listato lungo centinaia di righe
del mio programma.
Spero di essermi spiegato. In pratica, io ho il mio programma composto
da vari frames... e va bene. Se però a un certo punto voglio
aggiungere un frame e lo faccio tramite NetBeans, il codice relativo a
questo nuovo frame non è facilmente isolabile e prelevabile ma
spezzettato all'interno del mio programma facendo sì che copiarlo e
incollarlo all'interno di un metodo ad-hoc non sia facile. Per questo
vorrei uno strumento che mi permetta di creare il codice relativo al
layout grafico di un frame che sia facilmente copiabile e incollabile
dentro un mio metodo che userò tutte le volte che voglio creare quel
frame.
E' più chiaro?
--
Elminster


no, fai uno screenshot e vediamo se si capisce che vuoi fare

 no, fai uno screenshot e vediamo se si capisce che vuoi fare
Credimi, mi dispiace tantissimo non riuscire a spiegarmi anche perch� in 
realt� quello che voglio fare � assolutamente semplice e banale ma a 
quanto pare non sono in grado di farvelo capire (e uno screenshot non 
pu� aiutare per nulla).
Cercher� di spiegarmi di nuovo passo a passo, in modo che pi� semplice 
non si pu�.
Io ho creato la mia applicazione. Questa applicazione ha un primo 
frame(che chiamer� loginFrame) che ho progettato graficamente con 
NetBeans e si occupa di fare il login dell'utente.
Questo frame contiene alcuni JLabel, un paio di JTextArea, tutti 
inseriti all'interno di un JPanel.
Ho inoltre creato un secondo frame chiamato fileSelectFrame che contiene 
una JList in cui sono presenti tanti file. A questa JList � associato un 
Listener che, quando l'utente seleziona un file, fa apparire a lato tre 
JLabel che contengono alcune informazioni sul file (nome, dimensione e 
data di creazione). Anche questo secondo frame l'ho realizzato con NetBeans.
A questo punto � stato facile gestire il "passaggio" da un frame 
all'altro in questo modo: all'avvio dell'applicazione eseguo le seguenti 
righe di codice:
loginFrame.setVisible(true);
fileSelectFrame.setVisible(false);
Quando l'utente effettua il login, richiamo il seguente metodo:
public void login(String username, String password) {
	if (autenticaUtente(username, password) == true) {
		loginFrame.setVisible(false);
		fileSelectFrame.setVisible(true);
	}
}
In questo modo, quello che faccio � ovvio: se il login ha buon esito, 
faccio sparire il primo frame e apparire il secondo, senn� non faccio nulla.
Fare questo � stato facile perch� grazie a NetBeans ho progettato 
graficamente entrambi i frame e ne visualizzo uno o l'altro a seconda 
delle azioni dell'utente.
Il programma per� prosegue in questo modo: una volta che l'utente sta 
visualizzando il secondo frame (che, come gi� detto, contiene una JList 
popolata coi nomi di tante immagini), se esso fa doppio clic sul nome di 
un'immagine deve aprirsi un terzo frame(che chiamiamo imageFrame) che 
contiene l'immagine, una serie di pulsanti per effettuare zoomIn e 
zoomOut dell'immagine, un pulsante per poter stampare l'immagine, ecc. ecc.
Alla comparsa del frame imageFrame per� deve restare aperto anche il 
secondo frame (fileSelectFrame), in modo che l'utente possa di nuovo 
fare doppio clic su un'altra immagine e aprire un quarto frame (che sar� 
identico all'imageFrame gi� aperto ma ovviamente conterr� un'altra 
immagine). E l'utente pu� ancora fare doppio clic su un'altra immagine e 
aprire quanti frame vuole.
Insomma, mentre i primi due frame di cui vi ho parlato (loginFrame e 
fileSelectFrame) sono singoli (ovvero non possono esisterne varie 
istanze), questo terzo frame (imageFrame) deve poter essere istanziato N 
volte e ogni volta ospitare al suo interno un'immagine diversa.
Il problema che nasce quindi � il seguente. I primi due frame li ho 
creati con NetBeans in quanto il loro contenuto era "statico" ovvero 
noto a priori. Ho provato a creare anche il terzo frame con NetBeans e 
l'ho chiamato imageFrame. A questo punto per� vorrei sapere come poter 
realizzare l'operazione che provo a spiegarvi con queste righe di 
pseudo-codice:
public void doppioClickListener() {
	if (utenteHaFattoDoppioClicSuUnImmagine) {
rendi-visibile-un-istanza-di-imageFrame-passandogli-per�-come...
...parametro-l'immagine-su-cui-ha-fatto-doppio-clic()
	}
}
In pratica, se volessi creare a mano il layout del frame, sarebbe cos�:
public void doppioClickListener() {
	if (utenteHaFattoDoppioClicSuUnImmagine) {
		jFrame frame = new JFrame();
		frame.add(new Label("Ecco l'immagine che vuoi vedere"));
		frame.add(new Image(list.getSelected());
		frame.add(new PulsanteZoomIn());
		frame.add(new PulsanteZoomOut());		
	}
}
Io per� NON VOGLIO crearlo a mano: vorrei creare tramite NetBeans un 
modello (una sorta di template) a cui passare i parametri del frame che 
voglio creare.
In pratica vorrei realizzare una funzione che sia cos� fatta:
public void apriImageFrame(String immagine) {
		jFrame frame = new JFrame();
		frame.add(new Label("Ecco l'immagine che vuoi vedere"));
		frame.add(new Image(immagine);
		frame.add(new PulsanteZoomIn());
		frame.add(new PulsanteZoomOut());	
}
Voi direte: e che ci vuole? L'hai fatta, no? Per� in realt� il frame che 
voglio creare io � molto pi� complesso e contiene svariate decine di 
pulsanti e di JLabel: vorrei quindi poter progettarlo tramite un facile 
strumento "drag&drop". Poi vorrei copiare il codice del frame appena 
generato dallo strumento cos� che a questo punto possa incollarlo dentro 
la mia funzione apriImageFrame().
Insomma, la mia domanda � sempre quella: come faccio a creare con 
NetBeans un frame che non sia una singola istanza della classe JFrame ma 
bens� un modello che posso istanziare N volte passandogli ogni volta un 
parametro diverso?
Se anche questa volta non sono riuscito a spiegarmi piango! :(
-- 
Elminster

 pu� aiutare per nulla).
Come previsto forse la soluzione era talmente banale e semplice che mi 
meraviglio di come facessi a non trovarla da me.
Invece di creare il nuovo frame cliccando col tasto destro 
sull'Inspector Window e scegliendo "Add from Palette" e poi Frame, basta 
fare File -> New file e da l� scegliere JFrame Form.
A questo punto viene creato un frame con il suo costruttore in modo che 
possa essere richiamato nel proprio codice da dove si vuole e allo 
stesso tempo � possibile progettarlo in modo grafico tramite "drag&drop".
Mi son reso conto che fino a ora io aggiungevo frame sempre alla stessa 
classe, invece di aggiungere frame al progetto.
Che idiota! :(
-- 
Elminster