Il Pascal di Delphi

{progetto 1}

Il linguaggio di programmazione usato in Delphi è l’evoluzione a oggetti del Pascal, chi lo avesse già utilizzato a scuola troverà sicuramente delle analogie. E’ strutturato a oggetti. Un oggetto, per cercare di semplificare, lo si potrebbe vedere come un pacchetto di codice completo e a se stante con tutto il necessario per gestire le proprie risorse. Tutte le nuove implementazioni di Delphi al Pascal sono oggetti, la form stessa è un oggetto, il pulsante che abbiamo posizionato sulla form è un oggetto.

Ogni oggetto ha un nome e questo deve essere univoco. Se tentate di dare a due oggetti, per esempio un pulsante e la form, il medesimo nome Delphi ve lo impedirà. Potete vedere da soli il nome di tutti gli oggetti nella nostra form di prova, basta selezionarli uno per volta e controllare nel’Object Inspector la voce relativa. Quando posizionate un componente sulla form automaticamente gli viene dato un nome univoco, ma abbiamo la possibilità di modificarlo se lo vogliamo. Possiamo chiamare il pulsante Btn1 e la form FormProva1, ma non cambierà nulla, rimarrà tutto come prima.

Ogni oggetto ha un proprietario che a sua volta potrà avere uno o più oggetti di sua proprietà. Prendendo sempre a esempio la nostra form, abbiamo detto che questa è un oggetto, quindi tutti i componenti che contiene sono di sua proprietà. Se mi devo riferire al pulsante in modo corretto non devo scrivere il pulsante è “Btn1” ma il pulsante è “FormProva1. Btn1”, dove il punto delimita la proprietà, l’appartenenza. Se mi voglio riferire al nome del pulsante dovrò scrivere “FormProva1. Btn1.Name”. Il semplice pulsante possiede molte proprietà: Name è la proprietà che indica il suo nome e la possiamo modificare, Font è un’altra proprietà che abbiamo visto per il componente TLabel e che possiede anche il pulsante. Quindi come vedete la stessa proprietà la possiamo trovare in più oggetti, come il nome, posseduto da tutti. Quindi è immediato pensare che se mi voglio riferire al font del pulsante dovrò scrivere “FormProva1.Btn1.Font” mentre per la form “FormProva1.Font”.

In realtà la lista delle proprietà degli oggetti l’abbiamo già vista e non è altro che l’Object Inspector (letteralmente “ispettore dell’oggetto”). Qui possiamo trovare le proprietà più comuni e quelle più utilizzate dal programmatore, ma altre sono nascoste e si utilizzano solo in casi particolari. Facciamo un esempio, selezioniamo sempre il pulsante e nella proprietà Caption cancelliamo quello che troviamo scritto e scriviamo “Chiudi”. Vediamo che la scritta che prima c’era sul pulsante è stata sostituita da “Chiudi” il che è più logico visto che questo pulsante ora fa chiudere la form. Lanciate il programma e verificate anche a runtime. Il fatto che ci troviamo di fronte alle proprietà dell’oggetto viene ricordato anche dalla linguetta in alto della sezione.

Facciamo qualche esempio, prendiamo un pulsante dalla Tool Palette a destra e ponetelo sulla nostra form, quindi facciamo doppio clic sul pulsante e nella riga dove compare il codice scriviamo:

eseguite il programma e verificate quello che accade. In pratica noi abbiamo assegnato a runtime un valore alla proprietà Caption della nostra label. Come potete notare per riferirmi in modo corretto è bastato anteporre il nome dell’oggetto a cui mi riferisco, ma perché non ho scritto anche quello della form? Perche ci troviamo all’interno dell’oggetto form, e in questo caso non abbiamo bisogno di specificarlo, potete anche farlo ma il risultato sarà identico.

Scrivete “FormProva1.Label1.Caption := ‘Prova Primo Programma’;” e verificate. Come si fa a capire se stiamo dentro o fuori l’oggetto form lo vedremo dopo.

Prima di continuare vorrei soffermarmi ancora un po’ sulle proprietà di un oggetto. Come si può notare dando uno sguardo all’object inspector non tutte le proprietà sono oggetti. La nostra “FormProva1” ha la proprietà Name che non è un oggetto ma una caratteristica costruttiva dell’oggetto form, mentre se osserviamo la proprietà Font si capisce che è un oggetto che racchiude altre proprietà. D’altronde anche Btn1 è di proprietà della nostra form ma è acquisito cioè lo ha ricevuto da qualcuno, infatti inizialmente quando abbiamo creato il progetto la nostra form era completamente vuota.

Dovete immaginare la nostra form di prova come un vassoio vuoto, noi possiamo poggiarci sopra qualsiasi cosa, un bicchiere per esempio, nel momento in cui l’oggetto viene posto sul vassoio questo ne diventa proprietario. Nel senso che se muovo il vassoio il bicchiere si muove con esso senza che nessuno lo sposta. Ora, avendo chiaro questo concetto, possiamo dare uno sguardo al codice e iniziare a capire alcune cose. Sotto la scritta type in alto possiamo notare una dichiarazione, “TFormProva1 = class(TForm)”

quello che abbiamo detto prima riguardo alla proprietà degli oggetti, e cioè che tutti gli oggetti sulla form sono di proprietà della form.

Come è possibile modificare la proprietà Name di un oggetto è possibile anche spostare la sua paternità (chi lo possiede). Nell’atto di porre il pulsante sulla form la sua paternità è divenuta la form, quindi la form possiede il pulsante. Noi possiamo modificare questa condizione anche a runtime. Ecco un esempio: facendo doppio clic su CheckBox1 scrivete questo codice nello spazio che compare “Btn1.Parent := Memo1;”.

Lanciate il programma e verificate quello che succede. Cliccando sulla check box spostiamo la proprietà del pulsante “Btn1” dalla form alla memo. Come si nota dal comando la parentela di un oggetto (a chi appartiene) è indicata nella proprietà Parent.

Abbiamo visto che un oggetto possiede molte proprietà (dette Properties) ma possiede anche degli eventi (detti Events). Gli eventi sono le risposte dell’oggetto a carico di un’azione fatta nei suoi riguardi, con un esempio ci spieghiamo meglio. Quando facciamo un clic sul pulsante della nostra form generiamo un evento, quando passiamo con il mouse sopra il pulsante generiamo un evento, oppure quando viene focalizzato (a runtime se premete Tab vedrete un riquadro spostarsi tra i componenti della form, quello è la focalizzazione o Focus). Per osservare la lista degli eventi di un componente basta selezionarlo e poi nell’Object Inspector cliccate sulla linguetta “Events”.

Tutti gli eventi sono preceduti dal suffisso “On” quindi si capisce da se che “OnClick” è quando viene fatto un clic del mouse sopra di esso. Ma noi l’evento OnClick lo abbiamo già utilizzato se vi ricordate, infatti tra gli eventi del nostro pulsante, troviamo Btn1Click. Facendo doppio clic con il mouse sopra la scritta “Btn1Click” si aprirà l’editor e vi mostrerà il codice che abbiamo scritto prima. Se fate doppio clic su uno spazio vuoto, per esempio in corrispondenza di “OnMouseExit”, Delphi creerà per noi un pezzo di codice vuoto dove noi andremo a scrivere come abbiamo fatto prima.

Per riassumere: quello che abbiamo visto in questo capitolo e che ogni componente preso dalla Tool Palette e messo sulla form, questa ne diventa proprietario e l’oggetto assume come parentela (Parent) la form dove viene appoggiato. Ogni oggetto possiede una serie di proprietà (Properties) che ne modificano l’aspetto e alcuni elementi caratteristici, infine possiede anche una serie di eventi (Events) che intervengono quando si intraprende un’azione nei loro riguardi.

I prossimi argomenti che affronteremo ci aiuteranno maggiormente a capire come gestire eventi e proprietà. Fino a ora abbiamo scritto qualcosa meccanicamente e anche se abbiamo visto i frutti di quello che facevamo, difficilmente si è riusciti a capire in fondo il nostro operato. Dopo aver capito come vengono gestiti gli oggetti, in seguito faremo un passo indietro apprenderemo le basi su cui si fonda il linguaggio Pascal e capiremo perché è uno dei linguaggi strutturati che aiuta il pensiero programmatico.