Capitolo 5
Controlli per acquisire l’input
Nella nostra introduzione ai controlli, abbiamo imparato a conoscere la maggior parte dei tipi
base dei controlli con i loro eventi, ossia immagini, etichette, pulsanti, e barra di avanzamento.
Abbiamo anche imparato a rilevare quando il mouse è su un controllo e quali azioni si possano
adottare quando si è dentro o fuori un controllo. Questi tipi di controlli presentano tutti dei dati o
rispondono agli eventi come il mouse che fa clic su un pulsante, ma non permettono agli utenti di
scegliere alternative da una raccolta di elementi o da un elenco o digitare il loro nome, . . . In questo
capitolo, aggiungeremo al nostro arsenale di conoscenze Gambas, come realizzare tali compiti e
come rispondere ad altri eventi. Ci accingiamo a costruire un programma che ci introdurrà ai
seguenti controlli e che ci permetterà d’imparare ad utilizzarli:
• TextLabel
• TextBox
• ComboBox
• ListBox
• ToggleButton
• Panel
• Frame
• Checkbox
• RadioButton
Ecco come apparirà il nostro programma quando avremo finito il nuovo progetto (figura 1). In
questo esercizio, impareremo a mettere il titolo sulla finestra del nostra programma, utilizzeremo
una casella di input per acquisire HTML formattato e visualizzeremo quest’ultimo in un nuovo
tipo di etichetta, la TextLabel. Impareremo anche come raggruppare e organizzare i controlli sul
form, utilizzando i pannelli, le cornici e i controlli RadioButtons e CheckBoxes. Infine, impareremo ad utilizzare i controlli ListBoxes e ComboBoxes per consentire all’utente di selezionare
una voce da una lista si scelte. Lungo questo percorso, impareremo qualcos’altro sulla codifica
degli eventi cercando di scrivere qualcosa d’interessante. Iniziamo creando un nuovo progetto con
Gambas scegliendo un’interfaccia grafica utente. Attraverso la procedura guidata, rendiamo il
progetto traducibile e pubblici i controlli del form. Selezioniamo il nome ThirdProject per il
nome del progetto e mettiamolo in una directory a nostra scelta. All’apertura dell’IDE, creiamo
una nuova classe di avvio form. Con doppio clic su un punto del form vedremo comparire la
finestra del codice. Si dovrebbe vedere qualcosa del genere:
’ Gambas class file
PUBLIC SUB Form_Open()
END
1
This product is [C] 2005 by John W. Rittinghouse, all rights reserved. It is released to the
Gambas User Community under an Open Content License [OCL] and may not be distributed
under any other terms or conditions without the express written consent of the author.
2
A Beginner’s Guide to Gambas
Figura 1: Il risultato finale di ThirdProject.
Incominciamo mettendo il titolo al nostro programma nella parte superiore della finestra quando il programma viene eseguito. Per fare questo, imposteremo la proprietà Caption del form con il
testo che desideriamo utilizzare come titolo. Entriamo nella subroutine Form Open( ) e scriviamo:
ME.Caption = " *** ThirdProject *** "
Quanto sopra si occupa del testo da assegnare per il titolo della finestra. Ora, se guardiamo il
risultato finale della figura 1, notiamo che dobbiamo aggiungere ancora dei nostri controlli. A
partire dalla parte superiore, aggiungendo i controlli che già conosciamo: Label, TextBox e
Button. Collochiamo ogni controllo come indicato nella figura 1 chiamandoli Label1, TextBox1
e UpdateBtn. Questi controlli sono stati utilizzati nel precedente capitolo, pertanto, non avremo
problemi ad impiegarli nel programma. Aggiungiamo adesso il pulsante Quit nell’angolo in basso a
destra del form chiamandolo QuitBtn. Adesso, aggiungiamo il codice per questo controllo. Doppio
clic del mouse sul pulsante QuitBtn e scriviamo nella subroutine QuitBtn Click():
PUBLIC SUB QuitBtn_Click()
Form1.Close
END
Per il pulsante Update, vogliamo trasferire il testo digitato dall’utente nel controllo TextBox, nel TextLabel, riflettendo qualsiasi formattazione HTML che viene inserita. Ecco il codice
necessario per fare questo:
PUBLIC SUB UpdateBtn_Click()
TextLabel1.Text = TextBox1.Text
END
Da questo punto in poi, impareremo a utilizzare nuovi controlli e caratteristiche di Gambas.
Abbiamo già scritto del codice per assegnare dati di input al TextLabel, quindi prendiamoci il
tempo necessario per imparare tutto il possibile su di esso. Prima di andare avanti, è buona cosa
fare clic sul pulsante Salva dell’IDE per salvare il nostro lavoro.
0.1
TextLabel
Questa classe si può creare ed essa eredita i suoi attributi dalla classe Control. Essa implementa
un controllo in grado di visualizzare semplice testo HTML. È possibile utilizzare entità HTML
This product is [C] 2005 by John W. Rittinghouse, all rights reserved. It is released to the
Gambas User Community under an Open Content License [OCL] and may not be distributed
under any other terms or conditions without the express written consent of the author.
A Beginner’s Guide to Gambas
3
Figura 2: Utilizzo del formato HTML per l’output di TextLabel.
Figura 3: Output modificato di TextLabel utilizzando la formattazione HTML.
come &lt e &gt per visualizzare caratteri come < e >. Per HTML che richiede l’uso di attributi
quotati, evitare “” perché non funziona. Ad esempio, immettendo:
<div align="center"> <b> This won’t work.</b>
la figura 2 mostra un esempio di questo lavoro. TextLabel, definito come DIM hTextLabel AS
TextLabel, può essere dichiarato come:
hTextLabel = NEW TextLabel ( Parent AS Container )
Quello che vogliamo fare adesso è scrivere il codice per il pulsante Update, in modo da sfruttare
questa caratteristica con il codice HTML. Per fare questo, abbiamo bisogno di modificare il codice
che abbiamo scritto in precedenza per l’evento clic del pulsante Update. Quindi, doppio clic sul
controllo UpdateBtn e modifichiamolo con il seguente:
PUBLIC SUB UpdateBtn_Click()
TextLabel1.Text = "<div align=center> <b>" & TextBox1.Text & "</b>"
END
Invece di assegnare un input semplice, per la proprietà testo di TextLabel1.Text, l’abbiamo resa
più fantasiosa. Adesso, qualunque utente che digita del testo, lo vedrà centrato automaticamente
in grassetto ed immesso sul controllo TextLabel1. Se salviamo il progetto e avviamo il programma,
i risultati dovrebbero essere quelli della figura 3.
0.2
TextBox
Il prossimo obiettivo è imparare qualcosa di più sul controllo TextBox che abbiamo utilizzato poco
fa. Sappiamo già che è impiegato per consentire all’utente di scrivere in input una riga di testo
e restituirla al programma sotto forma di stringa. TextBox eredita i suoi attributi dalla classe
Control e questa classe implementa un controllo per una singola riga di testo. questa classe si può
creare e dichiarare in questo modo:
DIM hTextBox AS TextBox
Per creare e fare un’istanza ad un nuovo controllo TextBox nel nostro codice, si può utilizzare
questo formato:
hTextBox = NEW TextBox ( Parent AS Container )
This product is [C] 2005 by John W. Rittinghouse, all rights reserved. It is released to the
Gambas User Community under an Open Content License [OCL] and may not be distributed
under any other terms or conditions without the express written consent of the author.
4
A Beginner’s Guide to Gambas
Proviamo qualcosa di diverso. Supponiamo di voler semplificare la nostra applicazione in
modo che l’utente non debba fare clic sul pulsante Update quando immette il testo. Inoltre,
sarebbe bello avere il campo di testo vuoto quando il mouse punta nella zona del controllo ed
avere il testo di default quando il mouse viene spostato fuori dal controllo. Vorremmo preservare
quello che è stato digitato nel campo utente quando il mouse lascia il controllo, in modo che non
dobbiamo ricordare il valore attuale assegnato al campo del TextBox1.Text destinato al campo
TextLabel1.Text. Vogliamo continuare ad utilizzare il formato HTML con le capacità offerte dal
TextLabel.
Dovremo modificare il nostro codice. Per prima cosa, dobbiamo creare il gestore eventi per il
mouse entrante e uscente dal controllo. Facciamo clic una volta sul controllo TextBox1 sul form
e clic destro col mouse per selezionare la voce Event. Dal sottomenù Event scegliamo Enter.
Ripetere la stessa cosa per l’evento Leave. Adesso, andiamo nell’editor del codice e cerchiamo la
subroutine (TextBox1 Enter()) e inseriamo il seguente codice tra la prima e l’ultima riga:
TextBox1.Clear
È tutto per questa routine. Abbiamo invocato un metodo fatto a posta per cancellare il testo.
Adesso, abbiamo ancora bisogno di andare nella subroutine TextBox1 Leave() ed immettere
questo codice:
TextLabel1.Text = "<div align=center> <b>" & TextBox1.Text & "</b>"
TextBox1.Text = "<Enter text here>"
La prima riga di codice utilizza l’HTML per formattare e centrare la stringa TextBox1.Text
impostando il testo in grassetto. La riga successiva di codice assegna il prompt della stringa di
default che avevamo creato inizialmente per TextBox1.Text in modo che, quando il mouse esce
dall’area del controllo venga salvato quello che l’utente ha digitato l’ultima volta, quando ritorna
nell’area del controllo venga ripristinato quello che c’era al momento del puntamento del controllo.
Salviamo il nostro lavoro ed eseguiamo il programma per vedere come funziona.
I metodi discussi non sono gli unici per TextBox; visto che stiamo imparando gli eventi, giochiamo ancora un po’ con il codice per conoscere i metodi Show e Hide e come impiegarli in un
programma. Fare clic singolo sul form (fare attenzione a non fare clic su un controllo qualsiasi
del form) e facciamo clic destro col mouse per selezionare la voce Event. Dal sottomenù scegliere
l’evento MouseDown. Ripetere questo processo e scegliere l’evento DblClick. Adesso, andiamo
nell’editor del codice, troviamo la subroutine Form MouseDown() e inseriamo il codice seguente
tra la prima e l’ultima riga:
UpdateBtn.Hide
Quanto sopra è necessario se vogliamo nascondere il controllo UpdateBtn. Se l’utente sceglie
di non utilizzare il pulsante subito, tutto quello che deve fare è scegliere di nasconderlo. Come si
fa a riportarlo sul form? Il trucco è fare doppio clic. Dall’editor del codice troviamo la subroutine
Form DblClick() e immettiamo questo codice:
UpdateBtn.Show
Adesso però, potremmo chiederci “Come fa un altro utente ad accorgersi della possibilità di
nascondere il pulsante?” Bella domanda. Lo sapranno grazie alla proprietà ToolTip. Facciamo
clic sul pulsante UpdateBtn. Nella finestra delle proprietà cerchiamo la voce ToolTip. Sulla
destra della voce c’è un campo d’immissione con una casella grigia e tre punti (. . . ). Questi punti
significano che si aprirà un’altra finestra di dialogo facendo clic su di essi. In questo caso, si
aprirà una finestra dove potremo formattare il ToolTip con il linguaggio HTML. Facciamo clic
sulla finestra di dialogo e inseriamo questo testo:
Click <b> (or doubleclick)</b> on the form to hide <b> (or show) </b> me.
This product is [C] 2005 by John W. Rittinghouse, all rights reserved. It is released to the
Gambas User Community under an Open Content License [OCL] and may not be distributed
under any other terms or conditions without the express written consent of the author.
A Beginner’s Guide to Gambas
5
Figura 4: Aggiunta di un ToolTip per informare l’utente come visualizzare/nascondere un
controllo.
Adesso salviamo il nostro programma ed avviamolo per osservare come lavora. Quando il
mouse sorvola il pulsante Update, compare un ToolTip formattato come si vede nella figura 4.
Ci sono un paio di eventi, esclusivamente per TextBox, chiamati KeyPress e KeyRelease.
Gli esamineremo più avanti nel corso del libro quando inizieremo a lavorare con la tastiera. Pronti
per andare avanti? Stiamo per aggiungere alcuni controlli di selezione al nostro programma. Il
ComboBox e il ListBox consentono all’utente di scegliere tra diverse opzioni. Iniziamo per
prima con ComboBox.
0.3
ComboBox
Il controllo ComboBox eredita i suoi attributi dalla classe Control. Esso implementa una casella
testuale in combinazione con un box lista popup. Questa classe si può creare dichiarandola con il
seguente formato:
DIM hComboBox AS ComboBox
Per fare un’istanza della variabile appena creata, dobbiamo utilizzare il seguente formato:
hComboBox = NEW ComboBox ( Parent AS Container )
Questo crea un nuovo controllo ComboBox. Questa classe si comporta come un array in sola
lettura. In altre parole, se vogliamo dichiarare la variabile, farne un’istanza e recuperarne un
valore direttamente dal codice, dovremmo operare in questo modo:
DIM hComboBox AS ComboBox
DIM hComboBoxItem AS .ComboBoxItem
DIM Index as Integer
hComboBoxItem = hComboBox[Index]
L’ultima linea di codice restituisce un item combo-box da un indice intero. Notare che la scrittura
.ComboBoxItem rappresenta un item dalla lista popup del combo-box. Questa classe è virtuale.
Non si può usarla come tipo di dato e non può essere creata. Essa ha un’unica proprietà; Text,
restituisce un valore stringa che rappresenta l’item ComboBox individuato da un Index (indice).
Adesso creiamo un ComboBox sul nostro form. La figura 5 rappresenta quello che vedremo.
Certo, siamo d’accordo che esso non è il massimo della fantasia e che la lista è sicuramente
di bassa creatività, tuttavia il lavoro fatto ci insegna ad utilizzare i controlli ComboBoxes. Per
costruire il nostro nuovo controllo, andiamo nella casella degli strumenti di Gambas e selezioniamo
il controllo ComboBox. Collochiamolo sul form (facciamo riferimento alla figura 1 all’inizio di
questo capitolo per vedere dove dovrebbe essere posizionato) e proviamo a renderlo il più fedele
possibile alla figura 1. Fatto questo, facciamo clic singolo su di esso e andiamo alla finestra
proprietà. Cerchiamo la proprietà List. Se facciamo clic sulla destra della casella di input, è
disponibile una finestra di dialogo per selezione (ricordate cosa fanno i tre puntini?). Vedremo
comparire una finestra per editare la lista degli item del controllo (figura 6).
Per inserire un elemento nell’elenco digitare la voce nella casella di testo nella parte inferiore
dell’editor. Il primo item (elemento) della lista è predefinito. Viene spesso utilizzato per impostare
This product is [C] 2005 by John W. Rittinghouse, all rights reserved. It is released to the
Gambas User Community under an Open Content License [OCL] and may not be distributed
under any other terms or conditions without the express written consent of the author.
6
A Beginner’s Guide to Gambas
Figura 5: Il controllo ComboBox.
Figura 6: L’editor della proprietà List.
This product is [C] 2005 by John W. Rittinghouse, all rights reserved. It is released to the
Gambas User Community under an Open Content License [OCL] and may not be distributed
under any other terms or conditions without the express written consent of the author.
A Beginner’s Guide to Gambas
7
Figura 7: Il controllo TextLabel formattato con l’HTML.
Figura 8: Pulsanti + e - per modificare la lista del ComboBox.
una voce per indicare la selezione. Nel nostro caso, digitiamo Pick an item, e facciamo clic sul
pulsante Insert. Aggiungiamo all’elenco le voci Item 1, Item 2, Item 3 e Item 4. Assicurarsi
che essi appaino nell’ordine mostrato dalla figura 6. Una volta che abbiamo impostato il tutto,
è sufficiente fare clic sul pulsante OK e l’editor si chiuderà. Salviamo il progetto e avviamo il
programma per vedere come si comporta il controllo sul form. Quando abbiamo finito di guardare
il lavoro che abbiamo fatto finora, usciamo dal programma per continuare aggiungendo un po’ di
codice per gestire le selezioni (le voci contenute) del ComboBox.
Quando l’utente seleziona qualcosa dal comboBox, l’item (l’elemento) cambia e questo cambiamento genera un evento che possiamo gestire. Sul form, selezioniamo il controllo ComboBox e
facciamo clic destro. Puntiamo sulla voce Event e facciamo clic sulla voce Change del sottomenù.
Entriamo in modalità codice e cerchiamo la subroutine PUBLIC SUB ComboBox1 Change().
Aggiungiamo alla subroutine il seguente codice:
PUBLIC SUB ComboBox1_Change()
DIM result AS String
result = Trim(ComboBox1.Text)
TextLabel1.Text = result & " was selected from the ComboBox"
END
Salviamo il progetto e avviamo il programma per vedere cosa succede. Notiamo che quando selezioniamo un elemento dal ComboBox, il controllo TextLabel1.Text si aggiorna, tuttavia
senza una formattazione sofisticata. Nessun problema, questa cosa è semplice da implementare.
Cambiamo il codice precedente in questo modo:
PUBLIC SUB ComboBox1_Change()
DIM result AS String
result = "<div align=center> <b>" & Trim(ComboBox1.Text) & "</b>"
TextLabel1.Text = result & " was selected."
END
Salviamo e avviamo il programma un’altra volta. Dovremmo vedere qualcosa di simile alla
figura 7 sul controllo TextLabel1.
Modifichiamo leggermente il nostro programma per consentire di aggiungere o rimuovere dinamicamente gli elementi dal ComboBox. Per fare questo, abbiamo bisogno di un pulsante che
indica l’aggiunta di un elemento e un altro pulsante per rimuovere un elemento. Aggiungiamo
quindi due pulsanti sul form, uno chiamato PlusBtn e l’altro chiamato a MinusBtn come mostrato
nella figura 8.
doppio clic sul pulsante PlusBtn e aggiungiamo il seguente codice:
PUBLIC SUB PlusBtn_Click()
DIM Item AS String
DIM NumItems AS Integer
ComboBox1.Refresh
NumItems = ComboBox1.Count
IF NumItems = 0 THEN
Item = "Pick an Item"
This product is [C] 2005 by John W. Rittinghouse, all rights reserved. It is released to the
Gambas User Community under an Open Content License [OCL] and may not be distributed
under any other terms or conditions without the express written consent of the author.
8
A Beginner’s Guide to Gambas
ELSE
Item = "Item " & Str(NumItems)
ENDIF
ComboBox1.Refresh
ComboBox1.Add(Item,NumItems)
END
Nel codice di cui sopra, abbiamo dichiarato due variabili, Item e NumItems. Item è una stringa
e NumItems un intero. NumItems è impiegata per determinare quanti items (elementi) sono già
presenti nella lista. Il loro numero è determinato dalla proprietà .Count. Se non ci sono items
nella lista, viene impostato come item numero zero quello di default, ovvero “Pick an item”.
I ComboBox sono basati sulla logica degli array (che iniziano da zero); il conteggio incomincia
da zero non da uno. Se il valore di NumItems è zero si creerà una stringa di default. In caso
contrario, varrà concatenato il numero dell’item, all’item della parola, in modo da aggiungere
un nuovo posto alla successiva apertura della lista. Invochiamo il metodo Refresh per forzare
il ComboBox ad aggiornare la proprietà Count, in modo che l’utenta possa selezionare i nuovi
elementi. L’ultima riga di codice utilizza il metodo .Add per aggiungere il nuovo item alla lista
degli item contenuti nel ComboBox. Adesso, facciamo doppio clic sul pulsante MinusBtn per
aggiungere questo codice:
PUBLIC SUB MinusBtn_Click()
DIM NumItems AS Integer
’The combobox array starts at zero
ComboBox1.Refresh
NumItems = ComboBox1.Count
IF NumItems > 0 THEN
DEC NumItems
IF NumItems <> 0 THEN
ComboBox1.Remove(NumItems)
ENDIF
ComboBox1.Refresh
ENDIF
END
Rimuovere gli elementi dalla lista è molto semplice. Abbiamo solo bisogno di una variabile
intera per determinare il numero di elementi nella lista. Ancora una volta, questo si fa utilizzando
la proprietà .Count. Nel nostro esempio, Count restituisce un valore di 5 la prima volta che viene
letta. Se non ci sono elementi nella lista non c’è nessuna cosa da fare. Siccome gli elementi di
un ComboBox sono memorizzati come gli array, dobbiamo diminuire il Count di uno quando essi
sono zero (cioè quando non ci sono elementi, il Count deve essere -1). Adesso, salviamo il progetto
ed eseguiamo il programma. Proviamo a rimuovere tutti gli elementi della lista e successivamente
reinseriamoli. Bello verò? Andiamo avanti discutendo il controllo ListBox nella prossima sezione.
0.4
ListBox
Il controllo ListBox eredita i suoi attributi dalla classe Control. ListBox implementa una lista di
elementi testuali selezionabili. Questa classe si può creare. Il codice seguente dichiara un ListBox
e lo crea:
DIM hListBox AS ListBox
hListBox = NEW ListBox ( Parent AS Container )
La classe ComboBox si comporta come un array in sola lettura.
DIM Index as Integer
This product is [C] 2005 by John W. Rittinghouse, all rights reserved. It is released to the
Gambas User Community under an Open Content License [OCL] and may not be distributed
under any other terms or conditions without the express written consent of the author.
A Beginner’s Guide to Gambas
9
Figura 9: Controllo ListBox come visualizzato sul form.
Figura 10: Proprietà List del ListBox.
DIM hListBox AS ListBox
DIM hListBoxItem AS .ListBoxItem
hListBoxItem = hListBox[Index]
L’ultima linea di codice restituisce un elemento del Listbox da un indice intero. Notare che
.ListBoxItem rappresenta un elemento della lista popup ListBox. Questa classe è virtuale. Non
è possibile utilizzarla come tipo di dato né crearla. Ha una sola proprietà, Text restituisce un
valore stringa rappresentato da un elemento del ListBox che è individuato da un indice. Adesso
siamo pronti per creare un ListBox sul nostro form. La figura 9 mostra come vedremo il controllo.
Al fine di costruire il nostro nuovo controllo, andiamo nel Toolbox di Gambas e selezioniamo il
controllo ListBox. Collochiamolo sul form (facciamo riferimento all’immagine d’inizio capitolo per
vedere dove dobbiamo inserirlo) cercando di posizionarlo il più fedelmente possibile all’immagine
iniziale. Una volta conclusa l’operazione, facciamo clic su di esso, se non dovessimo vedere i
quadratini del controllo, e andiamo nella finestra delle proprietà. Cerchiamo la proprietà List. La
casella di immissione a destra di questa, permette di utilizzare una finestra di dialogo facendo clic
su di essa. Facciamo clic sul pulsante di selezione dialogo (ricordiamo i tre puntini?) e apparirà
una finestra di dialogo per editare una lista:
Si tratta dello stesso editor impiegato per costruire il controllo ComboBox1. A questo punto,
siamo pronti per aggiungere elementi alla lista e per imparare qualcosa della classe System. La
classe System è una parte della libreria component (componenti) di Gambas e fornisce supporto
per tutte le classe incluse nell’interprete. La classe System è statica e fornisce informazioni di sola
lettura sull’ambiente del sistema operativo. Questa classe può leggere anche le proprietà Charset,
Domain, Home, Host, Language, Path, e User. Utilizziamo l’editor e inseriamo i seguenti elementi
nella lista:
Charset
Domain
Home
Host
This product is [C] 2005 by John W. Rittinghouse, all rights reserved. It is released to the
Gambas User Community under an Open Content License [OCL] and may not be distributed
under any other terms or conditions without the express written consent of the author.
10
A Beginner’s Guide to Gambas
Language
Path
User
Adesso, facciamo doppio clic sul controllo ListBox1. Finiremo nella finestra del codice nella
subroutine PUBLIC SUB ListBox1 Click(). Il codice seguente mostra come accedere ai valori
di cui sopra. Scriviamo:
PUBLIC SUB ListBox1_Click()
IF Trim(ListBox1.Text) = "System.Charset" THEN
TextLabel1.Text = System.Charset
ELSE IF Trim(ListBox1.Text) = "Domain" THEN
TextLabel1.Text = System.Domain
ELSE IF Trim(ListBox1.Text) = "Home" THEN
TextLabel1.Text = System.Home
ELSE IF Trim(ListBox1.Text) = "Host" THEN
TextLabel1.Text = System.Host
ELSE IF Trim(ListBox1.Text) = "Language" THEN
TextLabel1.Text = System.Language
ELSE IF Trim(ListBox1.Text) = "Path" THEN
TextLabel1.Text = System.Path
ELSE IF Trim(ListBox1.Text) = "User" THEN
TextLabel1.Text = System.User
ENDIF
END
Salviamo il progetto e avviamo il programma. Proviamo a selezionare tutti gli elementi della
lista osservando quali informazioni restituiscono. Come si vede, List e ComboBox sono molto
semplici da implementare ed utilizzare. Un grande vantaggio che scaturisce dall’impiego di questi
componenti è, in linea di principo, quello d’impedire ad un utente di scrivere dati sbagliati. Nella
prossima sezione, impareremo come organizzare al meglio la disposizione dei controlli sul form per
presentarli all’utente in modo elegante. Inoltre, si vedrà qual è il motivo per cui i frames (cornici)
e i panels (pannelli) sono molto utili nelle prime fasi del processo di sviluppo di un programma.
0.5
Frame
La classe Frame eredita i suoi attributi dalla classe Container. Questo controllo è un contenitore
con un bordo inciso e un’etichetta. Questa classe si può creare. Per dichiarare e fare un’istanza
ad un Frame, utilizziamo il seguente formato:
DIM hFrame AS Frame
hFrame = NEW Frame (Parent AS Container)
Il grande vantaggio di un frame è che funziona come una sorta di finestra pur non avendo
una finestra. Qualsiasi controllo collocato nel frame diventa, per cosı̀ dire, parte di esso. Questo
significa che se abilitiamo un controllo CheckBox, un pulsante, o qualunque altra cosa sul frame e
decidessimo di spostarlo, tutti i controlli in esso contenuti si sposterebbero con esso. Essi possono
essere disposti diversamente sul frame, ma se il frame si sposta, si nasconde, . . . , essi fanno
altrettanto. La figura 11 mostra quello i controlli che aggiungeremo al nostro frame.
Per continuare nello sviluppo del nostro progetto, aggiungiamo per prima cosa un controllo
Frame (di nome Frame1) sul form come si vede dalla figura 1 d’inizio capitolo. Poi aggiungiamo
due controlli ToggleButton (di nome ToggleButton1 e ToggleButton2) e tre controlli CheckBox
(di nome CheckBox1, CheckBox2, e CheckBox3). Collochiamo il tutto come si vede nella figura
11. Dopo che abbiamo posizionato correttamente i controlli sul form, saremo pronti per il prossimo
passo e scrivere gli eventi che risponderanno nel nostro programma.
This product is [C] 2005 by John W. Rittinghouse, all rights reserved. It is released to the
Gambas User Community under an Open Content License [OCL] and may not be distributed
under any other terms or conditions without the express written consent of the author.
A Beginner’s Guide to Gambas
11
Figura 11: Quello che si vede nell’esempio dalla costruzione del frame.
0.6
ToggleButton
Il controllo ToggleButton eredita gli attributi dalla classe Control e implementa un pulsante tipo
interruttore; tipo interruttore on/off. Questa classe si può creare. Per dichiare e fare un’istanza
di questo controllo, si può impiegare il seguente codice:
DIM hToggleButton AS ToggleButton
hToggleButton = NEW ToggleButton ( Parent AS Container )
Faccio doppio clic sul controllo ToggleButton1 e aggiungiamo il seguente codice nella subroutine
PUBLIC SUB ToggleButton1 Click():
PUBLIC SUB ToggleButton1_Click()
IF ToggleButton1.Value = TRUE THEN
Frame1.Text = "Toggled 1 down"
ELSE
Frame1.Text = "Toggled 1 up"
ENDIF
END
Ripetiamo la stessa operazione per il controllo ToggleButton2:
PUBLIC SUB ToggleButton2_Click()
DIM result AS String
IF ToggleButton2.Value = TRUE THEN
Frame1.Text = "Toggled 2 down"
ELSE
Frame1.Text = "Toggled 2 up"
ENDIF
END
Ciò che abbiamo fatto con il codice di cui sopra è verificare la proprietà ToggleButton.Value
per vedere se è TRUE, il che significa che il pulsante è stato cliccato. Se è FALSE (stato off),
facendo clic su di esso, ripristiamo esso su on. Indipendentemente dalla posizione che occupa,
vediamo che Frame1.Text visualizza lo stato del pulsante allo stato dell’ultimo clic. Ora passiamo
al controllo CheckBox.
0.7
Checkbox
La classe CheckBox eredita i suoi attributi dalla classe Control. Questa classe implementa un
controllo check-box e si può creare. Per dichiarare e fare un’istanza della classe si può impiegare
il seguente codice:
DIM hCheckBox AS CheckBox
hCheckBox = NEW CheckBox ( Parent AS Container )
This product is [C] 2005 by John W. Rittinghouse, all rights reserved. It is released to the
Gambas User Community under an Open Content License [OCL] and may not be distributed
under any other terms or conditions without the express written consent of the author.
12
A Beginner’s Guide to Gambas
Quando facciamo clic su un controllo CheckBox, vogliamo rilevare l’evento e rispondere immediatamente. In questo caso, dobbiamo cambiare la proprietà Checkbox.Text ogni volta che
CheckBox.Value è selezionato tornando al valore TRUE. In questo modo attiveremo l’evento clic
in base al valore TRUE o FALSE (spuntato o non spuntato). Quando la casella non è selezionata, vogliamo tornare allo stato “normale”. Su CheckBox1, facciamo doppio clic sul controllo e
immettiamo il codice seguente per subroutine Public Sub CheckBox1 Click():
PUBLIC SUB CheckBox1_Click()
DIM outline1 AS String
DIM outline2 AS String
DIM outline3 AS String
IF CheckBox1.Value = TRUE THEN
Checkbox1.Text = "I was picked"
ELSE
Checkbox1.Text = "Checkbox1"
ENDIF
END
Ripetiamo quanto sopra per i controlli CheckBox2 e CheckBox3:
PUBLIC SUB CheckBox2_Click()
IF CheckBox2.Value = TRUE THEN
Checkbox2.Text = "I was picked"
ELSE
Checkbox2.Text = "Checkbox2"
ENDIF
END
PUBLIC SUB CheckBox3_Click()
IF CheckBox3.Value = TRUE THEN
Checkbox3.Text = "I was picked"
ELSE
Checkbox3.Text = "Checkbox3"
ENDIF
END
Salviamo il progetto e avviamo il programma. Quanto siamo soddisfatti del lavorano fatto,
chiudiamo il programma e continuamo il nostro progetto con l’aggiunta degli ultimi due controlli
che stiamo per affrontare in questo capitolo, Panel e RadioButton.
0.8
Panel
La classe Panel (pannello) eredita i suoi attributi dalla classe Container. Questa classe implementa
un pannello di controllo con un bordo mutevole. Questa classe si può creare. Possiamo dichiarare
e fare un’istanza di un pannello in questo modo:
DIM hPanel AS Panel
hPanel = NEW Panel ( Parent AS Container )
Nel nostro programma, abbiamo intenzione di utilizzare un Panel per raggruppare i controlli
RadioButtons al suo interno. La figura 12 mostra come apparirà il pannello alla fine della sua
costruzione.
Aggiungiamo un controllo Panel (di nome Panel1) sul form e posizioniamolo come si vede nella
figura 1 d’inizio capitolo. Poi si si aggiungano due controlli RadioButton (di nome RadioButton1
e RadioButton2). Collochiamo il tutto come nella figura 12.
This product is [C] 2005 by John W. Rittinghouse, all rights reserved. It is released to the
Gambas User Community under an Open Content License [OCL] and may not be distributed
under any other terms or conditions without the express written consent of the author.
A Beginner’s Guide to Gambas
13
Figura 12: Il controllo Panel insieme ai RadioButtons.
0.9
RadioButton
La classe RadioButton eredita i suoi attributi dalla classe Control e si può impiegare per implementare un controllo radio button. I controlli RadioButton sono mutuamente esclusivi (all’interno
di un raggruppamento, in questo caso nel contenitore Panel). Si può selezioanre un RadioButton
per volta. Questa classe si può creare. Per dichiarare e fare un’istanza di RadioButton utilizziamo
il seguente codice:
DIM hRadioButton AS RadioButton
hRadioButton = NEW RadioButton ( Parent AS Container )
Selezioniamo il controllo RadioButton dal ToolBox e collochiamolo sul form. Chiamiamolo RadioButton1 e ripetiamo la stessa cosa per il secondo RadioButton, chiamato RadioButton2. dopo
averli posizionati correttamente proseguiamo conla scrittura del codice. Doppio clic sul primo
RadioButton e inseriamo il seguente codice:
PUBLIC SUB RadioButton1_Click()
RadioButton1.Text = "HaHa RB2"
RadioButton2.Text = "RadioButton2"
END
Ripetiamo la stessa cosa per il secondo RadioButton:
PUBLIC SUB RadioButton2_Click()
RadioButton2.Text = "HaHa RB1"
RadioButton1.Text = "RadioButton1"
END
Salviamo il progetto e avviamo il programma. Quando saremo certi che il programma esegue
le operazioni previste, prendiamoci una pausa; servirà per affrontare meglio il prossimo capitolo.
This product is [C] 2005 by John W. Rittinghouse, all rights reserved. It is released to the
Gambas User Community under an Open Content License [OCL] and may not be distributed
under any other terms or conditions without the express written consent of the author.