[Java]Primo approccio Swing...

[RaouL_BennetH]

E rieccomi... :)

Vorrei iniziare a mettere in pratica alcune cose che ho fatto in Java ma sempre tramite applicazioni console.

Quello che vorrei cercare di fare è:

1)Un form di login per la connessione ad un db
2) se l'autenticazione riesce, il programma parte con un form 'padre'
3) Nel form padre, un menu attraverso il quale l'utente decide dove andare o se uscire dal programma
4) Caricare i form 'figli' all'interno del form padre

Al momento mi fermerei qui.. altrimenti...

Con la premessa che sto leggendo la documentazione di swing, vorrei avere da voi qualche suggerimento tenendo presente quello che ho già fatto e se per cortesia mi potreste fare qualche esempio pratico.

Quello che fino adesso ho fatto è:

1)Creato la classe per la connessione al database, testata e funziona
2)Una piccola classe che riconosce che tipi di dati vengono inseriti dall'utente (cioè se sono interi, float, etc...)
3)la classe main dove al momento testo solo se si apre la connessione con il database ed eseguo qualche query.

Una cosa importante, non vorrei utilizzare gli strumenti grafici messi a disposizione da netbeans o da eclipse ma vorrei fare tutto da codice, con la speranza di capire qualcosa che poi possa servirmi anche per il futuro...(riuso il codice.... :p )

Grazie a tutti come sempre.

RaouL.

[PGI-Bis]

Eccomi :D.

Vale per ogni lingua, framework, api, idea. Il primo passo è disegnare, a mano, con gimp, paint, quello che vuoi, la bozza dell'interfaccia che vuoi ottenere.

Una volta che hai la bozza, riprodurla, sia per ciò che riguarda l'associazione di forme e colori che per la distribuzione degli spazi, è una mera questione di dimestichezza con gli strumenti di Swing. Che non hanno nulla di più complicato rispetto alle API IO, nio, pio o quel che è.

Aggiunto.

Accanto al problema visivo e interattivo (il look e il feel, cioè come apparirà l'interfaccia e come l'utente interagirà con l'interfaccia) ne esiste uno prettamente meccanico: come i diversi oggetti che creerai per la tua GUI interagiscono tra loro. Io consiglio, sommessamente, di risolverlo in via preliminare. Di cosa diamine parli, PGI?

Hai stabilito che esite un form per il log-in. L'autenticazione può riuscire o no. Si tratta di un fatto che dovrai comunicare all'utente. Puoi scegliere liberamente se dotare lo stesso oggetto che propone il login della capacità di comunicare l'esito oppure se crearne degli altri.

Se ne crei più d'uno hai un problema di collaborazione: A cattura nome utente e password, li passa a B che controlla se siano validi che richiama C se siano invalidi o D se validi.

Grande classico dei sistemi orientati agli oggetti: come faccio a farli parlare tra loro. Una possibilità, rigida ma molto efficace, è stabilire che ogni elemento che partecipa alla definizione dell'interfaccia grafica sia collegato ad un intermediario e che l'intermediario disponga di un riferimento ad ogni componente. Esempio:

public abstract class ApplicationComponent {
private ApplicationEnvironment environment;

public synchronized ApplicationEnvironment getEnvironment() { return environment; }
public synchronized void setEnvironment(ApplicationEnvironment environment) { this.environment = environment; }
}

public interface Environment {
LoginFrame getLoginFrame();
MainFrame getMainFrame();
AuthComponent getAuthComponent();
}

public class Main implements Environment {
private LoginFrame loginFrame = new LoginFrame();
private MainFrame mainFrame = new MainFrame();
private AuthComponent authComponent = new AuthComponent();

public Main() {
loginFrame.setEnvironment(this);
mainFrame.setEnvironment(this);
authComponent.setEnvironment(this);
}

public LoginFrame getLoginFrame() { return loginFrame; }
public MainFrame getMainFrame() { return mainFrame; }
public AuthComponent getAuthComponent() { return authComponent; }

public static void main(String[] args) {
Main main = new Main();
main.getLoginFrame().show();
}
}

Una cosa di questo o d'altro genere (è per dare un'idea non devi necessariamente fare così) ti permette di dire, ad esempio all'interno di LoginFrame:

public class LoginFrame extends ApplicationComponent {

private void autentica() {
getEnvironment().getAuthComponent().validate(userName, password);
}
}

AuthComponent potrebbe dire:

public class AuthComponent extends ApplicationComponent {
public void validate(String userName, String password) {
Database db = getEnvironment().getDatabase();
if(db.getPassword(userName).equals(password)) {
getEnvironment().getLoginFrame().hide();
getEnvironment().getMainFrame().show();
}
}
}

Nulla più di un meccanismo di comunicazione. E' importante non trascurare questi dettagli che apparentemente sanno poco di GUI perchè i componenti di una GUI sono solitamente parecchi, tutti specializzati. E' possibile concentrare tutto in un solo componente ma viene fuori un mostrone difficilmente controllabile.

Tutto il resto è una questione mimetica. Pigli la bozza della gui e con tre layout (BorderLayout, FlowLayout e GridBagLayout), due icone un paio di risorse (ResourceBundle, semplicissimo da usare, se ti interessa fischia) ottieni quello che vuoi.

[RaouL_BennetH]

Eccomi :D.

Vale per ogni lingua, framework, api, idea. Il primo passo è disegnare, a mano, con gimp, paint, quello che vuoi, la bozza dell'interfaccia che vuoi ottenere.

Una volta che hai la bozza, riprodurla, sia per ciò che riguarda l'associazione di forme e colori che per la distribuzione degli spazi, è una mera questione di dimestichezza con gli strumenti di Swing. Che non hanno nulla di più complicato rispetto alle API IO, nio, pio o quel che è.

...sto aggiungendo una cosa...

:)

Allora, la bozza infatti io l'ho prima disegnata proprio a mano, nel senso che ho l'idea precisa di come vorrei che fosse l'interfaccia grafica, e di tutto ciò che vorrei rappresentare. Al momento ovviamente mi limito ai primi 4 punti per non mettere troppe cose in pentola.

[PGI-Bis]

Ok, se hai la bozza e un'idea dello schema di comunicazione sei già a posto. Immagino che tu abbia dato un'occhiata ai LayoutManager. Quello che ci interessa, in particolare, è il fatto che alcuni di loro realizzino una certa distribuzione degli spazi.

Il FlowLayout è utile per le barre dei pulsanti che, solitamente, si trovano in fondo ad una finestra di dialogo. Si combina con il BorderLayout è il GridBagLayout. Per combinarsi intendo che puoi prendere un contenitore (JPanel), dotarlo di un layout ed inserire in questo contenitore un secondo JPanel dotato di un diverso layout. Ad esempio:

JPanel content = new JPanel(new BorderLayout());
JPanel buttons = new JPanel(new FlowLayout(FlowLayout.RIGHT));
content.add(buttons, BorderLayout.SOUTH);

Qui che succede. Succede che il pannello content si trova ad avere in basso un componente che è un contenitore di altri componenti. Se aggiungo un componente a "buttons", il componente apparirà in "content". E' una sorta di annidamento.

Se, osservando la bozza, ti capita di non ravvisare uno schema corrispondente ad uno dei LayoutManager più rigidi, puoi usare GridBagLayout. L'uso di GridBagLayout richiede, a meno di casi elementari, la creazione di una classe d'appoggio che ti permetta un'espressione più informale.

Mi fermo per il momento.

[RaouL_BennetH]

Primo piccolo intoppo:

Non riuscivo a rappresentare il frame in fullscreen, e leggendo la documentazione di swing ho visto che dovevo fare così:



myFrame.setExtendedState(Frame.MAXIMIZED_BOTH);

//ma non mi funzionava... allora prendendo spunto da un'altra cosa trovata in rete:

Dimension fullscreen = Toolkit.getDefaultToolkit().getScreenSize;

myFrame.setPreferredSize(new Dimension(fullscreen));

//così funziona... ma... funziona non sempre è sinonimo di va bene....


Suggerimenti?


EDIT: scusami :( non avevo letto il post di prima...

[PGI-Bis]

In teoria funziona così:

import java.awt.*;
import javax.swing.*;

public class Main {

public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() { public void run() {
JFrame frame = new JFrame();
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
if(Toolkit.getDefaultToolkit().isFrameStateSupported(JFrame.MAXIMIZED_BOTH)) {
frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
}
frame.setVisible(true);
}});
}
}

La differenza tra quello che fai con setSize e con setExtendedState è che nel primo caso ingradisci la dimensione della finestra, nel secondo caso agisci proprio sullo stato di massimizzazione. La massimizzazione è una sorta di mutazione temporanea delle dimensioni: la finestra diventa grande quanto lo schermo ma, a richiesta (pulsante di mezzo nella barra del titolo, in Windows), riassume la dimensione originale.