Più form
In questo capitolo realizzeremo un progetto con più di una form, daremo finalmente un nome al nostro progetto, non il monotono “Progetto1”, e sceglieremo anche un’icona da associare al programma. Quindi le cose da fare per partire sono queste:
Creare un progetto e salvare la unit principale con il nome “UMultiForm” e il progetto “MultiForm” (quando compare la finestra di salvataggio scrivere il nome che abbiamo scelto).
Modificate il font della form in modo che il carattere sia un po’ più grande (giusto per fare pratica) e centriamola sullo schermo.
Mettere sulla form due pulsanti chiamati “Mostra Form 1” e “Mostra Form 2”, se la caption non entra potete allungare la forma del pulsante.
Modifichiamo il titolo della finestra con “Programma MultiForm” e facciamo in modo che la finestra sia di tipo “bsSingle”, senza possibilità di resize.
Il risultato dovrà essere all’incirca questo:
A questo punto creiamo la nostra seconda form:
E salviamola allo stesso modo di come si salva il progetto, dopo la prima volta:
Il nome possiamo lasciargli anche quello di default, l’importante e che abbiamo capito come si fa a modificarlo, quando un progetto inizia ad avere molte form è sempre consigliato chiamare la form con il nome del lavoro che deve fare, così in fase di editing possiamo capire al volo cosa contiene una unit.
Come si vede l’editor crea una nuova istanza identica a quella che abbiamo visto fino a ora. Abbiamo allora due linguette che ci permettono di passare dall’una all’altra form in modo immediato. Possiamo anche creare la terza form seguendo lo stesso procedimento, così da avere alla fine:
Fate attenzione quando salvate una nuova form, per default la finestra di salvataggio vi propone la cartella del progetto, ma in taluni casi potrebbe mostrare una destinazione diversa e poi non vi trovate più la vostra unit.
Volendo possiamo dare uno sguardo al file di progetto “MultiForm.dpr” e osservare come Delphi ha modificato il contenuto, se avete seguito le mie istruzione dovrebbe essere così:
program MultiForm;
uses
Forms,
UMultiForm in 'UMultiForm.pas' {Form1},
Unit2 in 'Unit2.pas' {Form2},
Unit3 in 'Unit3.pas' {Form3};
{$R *.res}
begin
Application.Initialize;
Application.CreateForm(TForm1, Form1);
Application.CreateForm(TForm2, Form2);
Application.CreateForm(TForm3, Form3);
Application.Run;
end.
Scopriamo che creando le form il codice di creazione è stato aggiunto tra begin ed end, mentre nella sezione delle dichiarazioni delle unit troviamo l’indicazione riguardo alle nostre Form. Non prestate molta attenzione a ciò che vedete scritto, più in la capiremo cosa vogliono dire e sappiate, come abbiamo già detto, che questo file non va toccato.
Un’ultima cosa prima di passare al codice che chiama le nostre form è associare una icona al nostro programma. Selezionare dal menù principale “Project\Options...” e nella finestra che compare evidenziate nella lista a sinistra la sezione “Application”. Questa è la sezione dove si impostano alcuni parametri riguardo al nostro eseguibile.
Title - il testo scritto qui viene mostrato sul pulsante della barra delle applicazioni, quando viene lanciato il programma. Per default è il nome dell’eseguibile.
Help File - qui si indica il nome del file help associato al programma (lo vedremo più in la)
Load Icon - questo pulsante apre una finestra dove possiamo scegliere e caricare la nostra icona.
Nella stessa posizione dove nel primo progetto abbiamo trovate delle immagini, possiamo trovare anche delle icone da poter utilizzare come prova:
Quindi con il pulsante “Load Icon” selezionate la vostra icona e chiudete premendo “Ok”, il gioco è fatto.
Se avete fatto come me, nella barra delle applicazioni il vostro programma apparirà così:
Abbiamo detto che la prima form creata è la principale, nel senso che è quella che viene creata e mostrata per prima e se la si chiude il programma termina. Se ricordate il codice del progetto visto prima è possibile notare che le form secondarie (form 2 e form3) vengono già create, il nostro compito è solo quello di visualizzarle. Esistono due modi di visualizzare una form secondaria, in modo normale e modale. In modalità normale dopo la visualizzazione della form è sempre possibile controllare anche la form principale, in modale invece non è possibile accedere alla principale fin quando non si chiude la form secondaria (come succede con i messaggi di avviso). Il comando per visualizzare una form normalmente è Show mentre per il tipo modale ShowModal, anche in questo caso il nome delle procedure ci aiuta. Avendo due pulsanti apriremo le due finestre nei due modi visti, così vedremo la differenza:
procedure TForm1.Button2Click(Sender: TObject);
begin
Form2.ShowModal;
end;
procedure TForm1.Button3Click(Sender: TObject);
begin
Form3.Show;
end;
Dopo aver scritto il codice, all’atto della compilazione viene mostrato un messaggio di avvertimento riguardo al riferimento a una unit che non è stata dichiarata (Unit2), e rispondendo “Si” la dichiarazione verrà fatta in automatico:
Questo perché, come abbiamo già detto, per riferirsi a un codice scritto in una unit questa deve essere dichiarata nella sezione USES. Ma perché questa dichiarazione è stata inserita dopo “implementation”?
Semplicemente perché le due form create fanno parte del nostro progetto e non sono Unit esterne al progetto, quelle che dichiariamo in alto sono unit generiche non create dall’editor di Delphi. Sappiate quindi che le unit che contengono le form secondarie del nostro progetto vanno dichiarate dopo la sezione “implementation”. Ora non ci resta che lanciare il programma e verificare quanto detto prima.
La finestra lanciata dal primo pulsante non permette l’accesso alla form principale infatti non sarà possibile chiudere il programma fin quando form2 sarà visibile. Al contrario, con il secondo pulsante la finestra rende possibile l’accesso a quella principale: provate a ridurre a icona o a chiudere, tutto funzionerà regolarmente.
Ora passeremo a vedere come gestire le proprietà di queste finestre, così faremo un ripasso sulle caratteristiche degli oggetti. Nella finestra principale sistemate una ListBox (la trovate in “Standard”) di fianco ai due pulsanti. Nell’evento onShow (evento che viene chiamato quando la finestra viene visualizzata) delle due finestre secondarie scriviamo un codice che permette di inserire nella listbox della form principale il momento in cui è stata lanciata:
procedure TForm2.FormShow(Sender: TObject);
VAR Momento : String;
begin
Momento := DateTimeToStr(Now);
Form1.ListBox1.Items.Add(Form2.Name+' - '+Momento);
end;
Questa è la procedura della form2, nella form3 dovremmo scrivere la stessa cosa. In pratica abbiamo dichiarato una variabile di tipo stringa di nome “Momento”, questa conterrà la data e l’orario in cui viene visualizzata la form. La funzione che ci permette di ricavare la data e l’orario di sistema è “DateTimeToStr”, questa è una delle tante messe a disposizione da Delphi per la gestione del tempo e dell’orario. Nell’help potete sfogliare la lista completa di queste funzioni disponibili, basta premere F1 sul nome oppure per maggiori dettagli a volte si può cercare su internet il nome della funzione, troverete sicuramente anche qualche esempio più dettagliato. Passando come parametro a DateTimeToStr il risultato della funzione “Now” avremo come risposta la formattazione in una stringa della data e dell’orario del momento. Il comando anteposto alla funzione “Form2.Name” si capisce quello che fa, scrive prima del momento il nome della form.
Dopo scritto il codice ci accorgiamo, appena tentiamo di compilare o lanciare il progetto, che viene mostrato il solito messaggio di avvertimento riguardo alla form1. Infatti anche nelle due form secondarie va dichiarata la unit che usa la form1, e anche in questo caso l’editor la scrive in automatico se premiamo “Si”. E’ possibile notare il modo con cui scriviamo qualcosa nella listbox inserita nella form principale: infatti abbiamo detto che per riferirci a un dato oggetto fuori dalla form in cui si scrive, bisogna indicare tutta la parentela (nel nostro caso “Form1.ListBox1.Items.Add”) a cui l’oggetto appartiene, se volete è come mandare una lettera, bisogna scrivere l’indirizzo completo e in modo preciso.
Vediamo un po’ più da vicino il nuovo componente inserito nella form principale, TListBox. Se cercate nell’help di Delphi:
troverete sicuramente molte informazioni, il modo più semplice a volte per vedere tutte le caratteristiche di un componente è quello di selezionarlo sulla form è premere F1 o dare uno sguardo all’object inspector o infine rivolgersi a internet. A parte le solite proprietà, sicuramente la più importante è “Items” in quanto permette di gestire il testo contenuto nella lista sotto forma di righe (items appunto).
Items è una variabile oggetto di tipo TStrings che incorpora tutti i comandi per gestire una lista di stringhe. ListBox sfrutta questa variabile oggetto per il testo che visualizza. Tutto questo si tramuta in una serie di comandi intuitivi che ci permettono, tra le altre cose, di inserire, selezionare e cancellare righe di testo in questa box. La procedura Add(‘’) utilizzata nel nostro codice è quella che permette di inserire una stringa nella lista, le altre le vedremo man mano che useremo questo componente nei nostri esempi.
Ritornando alla gestione delle form, vorrei affrontare un altro modo di mostrare una finestra. All’inizio della trattazione riguardo alle form secondarie abbiamo visto che vengono create direttamente nel progetto del programma (file dpr), per mostrarle basta lanciare la procedura “Show” o “ShowModal”. Questo significa che l’evento “onCreate” di ogni form viene chiamato alla creazione del progetto, per vedere questo basta scrivere queste righe di codice nell’evento “onCreate” di tutte le form:
procedure TForm1.FormCreate(Sender: TObject);
VAR Momento : String;
begin
Momento := DateTimeToStr(Now);
Form1.ListBox1.Items.Add('Creata '+Form1.Name+' - '+Momento);
end;
Questa è il codice nella form principale, nelle altre è tutto identico tranne che per la procedura che richiama il nome della form (come abbiamo già visto prima). Se lanciate il programma vedrete che la lista mostra il momento della creazione delle tre form, seguendo l’ordine che si vede nel file progetto. Questo dimostra che anche se non le vediamo sullo schermo in realtà già esistono, sono invisibili in attesa che vengano visualizzate da uno dei due comandi visti prima.
Il prossimo passo è quello di creare e mostrare una form solo quando ci serve è poi chiuderla sul serio, non semplicemente farla sparire dallo schermo. In realtà dire creare una form non è propriamente corretto infatti noi la form la creiamo nell’editor di Delphi, quindi nell’eseguibile il progetto della form già esiste. In questo caso creare una form significa inizializzarla da zero assegnando a lei e alle variabili che utilizza spazio in memoria, più tante altre cose che non ci interessano. L’importante di tutto questo discorso è sapere che se facciamo come abbiamo fatto fino a ora, le finestre secondarie vengono create quando si lancia il programma, quindi se metti caso il progetto ha venti finestre, all’avvio del programma deve creare venti finestre, è più opportuno allora in taluni casi creare la finestra solo quando viene chiamata.
Per capire come viene creata una finestra a runtime basta dare un’occhiata al file progetto del programma e, come abbiamo già visto prima, per esempio la riga di codice che crea la form2 è questa:
Application.CreateForm(TForm2, Form2);
Application è un oggetto che Delphi crea quando noi creiamo un progetto, essa contiene informazioni riguardo appunto al progetto stesso. Le informazioni di questo oggetto sono disponibili a runtime e utilizzabili dal programmatore in qualsiasi momento. Per esempio a runtime è possibile sapere il nome e il path dell’eseguibile, l’icona che lo rappresenta, il nome del file di help associato e tante altre cose. Tutto questo per farvi capire che quando si crea una form quest’operazione viene fatta dall’oggetto Application che ne diviene proprietario a tutti gli effetti. Per ora a noi basta questo, col tempo useremo questo oggetto per sapere qualcosa sul nostro eseguibile. Quindi se vogliamo creare la form secondaria per conto nostro bisogna usare CreateForm dell’oggetto Applicaton e poi fare in modo che Delphi non crei la finestra in automatico.
Prossimo passo è creare una terza form secondaria e, come abbiamo già fatto per le prime due, scrivere nell’evento “onCreate” le due righe di codice per sapere quando viene lanciata. Nella finestra principale inserire un altro pulsante che servirà a mostrare questa terza form.
e in onClick scrivere questo codice:
procedure TForm1.Button4Click(Sender: TObject);
begin
Application.CreateForm(TForm4, Form4);
Form4.ShowModal;
Form4.Free;
end;
Come vedete, il primo rigo crea la form come Delphi fa nel file progetto, il secondo comando visualizza la form in modo modale mentre il terzo libera del tutto l’istanza della form, come se non fosse mai stata lanciata; la prima riga di comando richiama l’evento “onCreate” di form4, il secondo l’evento “onShow” e l’ultimo “onClose”.
Ci rimane solo da indicare a Delphi di non creare la form in automatico. Dal menù principale “Project\Options”, selezionare “Forms” e spostare “Form4” nella lista a destra:
da così
a così
Lanciando il programma dovreste vedere che la form4 non compare nell’elenco delle finestre create, ma il momento di creazione viene scritto solo premendo l’ultimo pulsante.
