Capitolo 6 Men`u, moduli, finestre di dialogo e di messaggio

Transcript

Capitolo 6
Menù, moduli, finestre di dialogo
e di messaggio
Quasi tutti i programmi basati sulle GUI, utilizzano una combinazione di menù, finestre di messaggio e finestre di dialogo standard per comunicare con l’utente. Gambas non è diverso dagli
altri. Dato che non esiste un linguaggio di programmazione in grado di garantire ad un programmatore qualunque utilizzo, in termini di componenti precompilati, vengono utilizzati i moduli per
scrivere quello che Gambas non prevede nel suo linguaggio. Ad esempio, se abbiamo bisogno di
una funzione che restituisca il nome di un colore, a partire da una scelta effettuata con una finestra di dialogo standard, dovremmo scrivercela; questo è quello che faremo nel prossimo esempio.
In questo capitolo impareremo ad utilizzare questo genere di controlli. La figura 1 mostra uno
screenshot del nostro prossimo progetto.
Costruiamo quattro menu. Ognuno di essi viene utilizzato per imparare a conoscere i controlli e
le finestre di dialogo standard in questo capitolo. Iniziamo con la barra dei menù, come si vede
nella figura 1, poi vediamo come utilizzare la finestra di dialogo standar del colore, le finestre
Messaggio, ed infine i moduli. Iniziamo il nostro progetto aprendo Gambas e creiamo una nuova
interfaccia grafica utente. Chiamiamo il progetto MenuProject e impostiamo tutti i controlli in
traducibili e pubblici. Una volta all’interno dell’IDE, creiamo un form, Form1, impostandolo come
classe di avvio. Aggiungiamo sul form un pulsante Quit, come indicato in figura 1 e inseriamo il
codice seguente relativo all’evento clic di quest’ultimo:
PUBLIC SUB QuitBtn_Click()
Form1.Close
END
Adesso facciamo doppio clic su un punto qualsiasi del form al di fuori dei bordi del pulsante e
collochiamoci nella subroutine PUBLIC SUB Form Open().
Inseriamo il seguente codice:
Figura 1: Risultato finale del progetto menù.
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 2: L’editor dei menù al primo avvio.
ME.Caption = " Working with Menus "
Aggiungiamo una TextLabel, di nome textLabel1, come mostrato in figura 1. A questo punto
vediamo come costruire il menù e utilizzare le finestre di dialogo standard fornite con Gambas.
0.1
L’editor dei menù
Gambas possiede un sistema incorporato per la costruzione dei menù, il MenuEditor. È possibile
accedervi dal form, premendo CTRL-E, o facendo clic destro selezionando l’opzione Editor Menu
nella finestra popup. In entrambi i casi, viene visualizzato il MenuEditor con un aspetto simile
alla figura 2.
Al primo avvio del MenuEditor, la finestra è ovviamente vuota. Dato che il suo utilizzo non
è molto evidente, impieghiamo un po’ di tempo per imparare ad usarlo. Incominciamo con la
terminologia. Il testo che è visualizzato orizzontalmente, nella parte superiore di un form, viene
chiamato barra dei menù. Essa può contenere uno o più MenuItems; sono gli elementi dei menù
elencati verticalmente. I MenuItems possono contenere a loro volta sottomenù; sono altri MenuItems nidificati che possono a loro volta visualizzare altri MenuItems. In pratica i menù possono
contenere diversi strati di sottomenù nidificati.
Per inserire un menù si utilizza il pulsante Insert (Inserisci). Il pulsante Next (Successivo)
sposta il cursore sul menù successivo verso il basso. Quando si giunge alla fine della lista lo
spostamento si arresta, consentendo soltanto la selezione su una voce di menù o la possibilità di
aggiungerne uno nuovo. Il pulsante Delete (Elimina) rimuove la voce di menù selezionata.
I pulsanti freccia ↑ e ↓ (su e giù), a destra del pulsante Delete, spostano il menù selezionato
in alto o in basso rispetto all’elenco delle voci del menù. Se si scelgono le frecce ← e → (rientrotabulazione e tabulazione)1 , effettueremo un rientro in funzione dello schema di raggrupamento
che abbiamo scelto per il nostro menù. Applicando un rientro su una voce del menù, collocheremo
1 Il senso è la non indentazione e l’indentazione del gergo informatico. Simile all’operazione di rientro del testo
nei comuni wordprocessors o editors di codice sorgente.
3
Figura 3: Campi dell’editor dei menù.
quest’ultimo ad un livello d’indentazione più basso. L’indentazione di un MenuItem è indicata
dalla presenza di tre punti . . . davanti ad un MenuItem che è diventato subMenuItem. Più di
tre punti (in multipli di tre), indicano che si tratta di un subMenuItem indentato a livello di
subsubMenuItem rispetto al MenuItem capolista di riferimento. Dopo aver implementato un paio
di menù, sarà molto facile comprendere il meccanismo di funzionamento della costruzione dei
menù. Ad ogni clic sul pulsante Insert, si vedono nuovi campi visualizzati nella parte inferiore del
MenuEditor (figura 3). Essi vengono presentati di seguito.
Il campo Name (Nome), meglio chiamarlo variabile Name, in quanto si comporta come tale,
è il nome della variabile a cui si riferisce il file class del codice sorgente quando incontra questo
particolare oggetto.
Il campo Group (Gruppo) si riferisce al Control Group (Gruppo di controllo). Il Control
Group è utilizzato nell’IDE Gambas per creare e gestire gruppi di controlli come entità uniche.
Quando si seleziona un qualsiasi controllo su un form, nella finestra di dialogo proprietà, si dovrebbe
notare una proprietà Group che non corrisponde ad alcuna proprietà documentata per tale controllo. Questa speciale pseudo-proprietà permette di assegnare gruppi di controllo. In pratica,
quando il controllo viene creato in fase di runtime, sarà trattato come se fosse creato in modalità
codice in questo modo:
myControl = NEW ColumnView(ME) AS "myGroup"
e i suoi gestori di evento devono essere chiamati in questo modo:
PUBLIC SUB myGroup_Click()
È possibile fare riferimento al controllo con la parola chiave LAST, oppure è possibile assegnare
un Tag ad ogni controllo per differenziarli tra loro, utilizzando un valore etichetta.
Caption è il testo che gli utenti vedono quando viene eseguito il programma. Tag è riservato
ai programmatori per memorizzare i dati ed è una proprietà comune per quasi tutti i controlli.
Vedremo come utilizzare la proprietà Tag più avanti. Per ora, è sufficiente sapere che essa può
contenere qualsiasi tipo di dati Variant.
Lo Shortcut CheckBoxes consente di definire un tasto di scelta rapida per invocare automaticamente l’evento clic di un certo menù. Ricordiamo che anche voci dei menù rispondono agli eventi
clic e alle scorciatoie da tastiera. Il campo Picture (Immagine) consente di specificare il nome
del file icona visualizzato accanto ad un MenuItem. L’anteprima dell’immagine scelta appare alla
4
Figura 4: Costruzione del menù.
destra del campo immagine.
I campi CheckBoxes sulla destra, Visible (visibile), Enabled (Abilitato) e Checked (Spuntato), si riferiscono allo stato della voce di menù. Per impostazione predefinita, tutte le voci dei
menù sono attive e visibili. In particolare, è possibile specificare se l’ItemMenu è spuntato oppure
no. Si può vedere se la voce è selezionata oppure no, guardando la proprietà Checked del menù.
Essa restituisce il valore TRUE (VERO) o FALSE (FALSO) indicante lo stato dell’oggetto. Ecco
un esempio di come assegnare un segno di spunta da on ad off, quando viene scelta una voce di
menù:
IF Menu2Item1.Checked THEN
Menu2Item1.Checked = FALSE
ELSE
Menu2Item1.Checked = TRUE
ENDIF
Il costrutto IF, controlla la proprietà Checked dell’oggetto Menu2Item1 e se il valore booleano
è TRUE viene impostata su FALSE. Se l’operatore booleano è NOT TRUE, viene eseguita la
clausola ELSE, impostando il Checked value su TRUE. Questo approccio può essere utilizzato per
attivare o disattivare qualsiasi menù o sottomenù.
NOTA: Usare questa logica con cautela in funzione di GUI semplici; molti utenti si sentono
sopraffatti quando l’interfaccia grafica si presenta ricca di opzioni.
0.2
Costruire i menù
Adesso creiamo il nostro menù. Quando avremo finito, vedremo qualcosa di simile alla figura 4.
Per iniziare, facciamo clic sul pulsante Inserisci. Inseriamo i menu ColorDialog, MessageBoxes,
FileDialogs ed Help a livello toplevel. Utilizziamo la figura 5 come riferimento.
Inseriamo le voci di menù nel primo menù. Queste voci apparterranno al menù ColorDialog della
figura 6.
5
Figura 5: Menù Toplevel.
Figura 6: Menù Colordialog.
Adesso posizioniamoci al livello toplevel successivo. Inseriamo le voci del menù MessageBoxes
come si vede in figura 7.
Assicuriamoci che l’Error, il Warning e il Delete, siano rientrati di due livelli sotto la voce di
menù Alert Messages. Adesso aggiungiamo l’ultima voce di menù, Help, facendo riferimento alla
figura 8.
Questo è tutto quello che serve! Facciamo clic sul pulsante OK per chiudere l’editor dei menù e
tornare sul form. Vedremo comparire i menù. Se non dovessero corrispondere a quelli dell’esempio,
torniamo al MenuEditor e impostiamo le voci fino a quando non soddisfino i criteri dell’esempio.
Il prossimo passo è scrivere il codice per gli eventi di ciascun menù. Prima di fare questo, abbiamo bisogno d’imparare ad utilizzare le finestre di dialogo standard e le finestre MessageBoxes
disponibili in Gambas.
0.3
La classe Dialog
La classe Dialog viene utilizzata per implementare tutte le finestre di dialogo standard di Gambas.
La classe fa uso di metodi statici per richiamarle. Questa classe è statica. I metodi supportati (per
le finestre di dialogo standard) sono i seguenti: OpenFile, Savefile, SelectColor, SelectDirectory e
SelectFont. Le proprietà supportate da questa classe sono: Color, Filter, Font, Path e Title.
Color è un valore intero che la finestra di dialogo SelectColor restituisce; esso rappresenta il
nome del colore selezionato. È interessante notare che Gambas dispone di 32 colori predefiniti,
ma la finestra di dialogo standard SelectColor ne contiene 48. Questo significa che non è possibile
utilizzare le costanti predefinite come Red, Black, ecc . . . , in un costrutto CASE o altrove. Ma allora, quando si è scelto un colore, come facciamo a determinare se si tratta di un colore predefinito
Figura 7: Menù Messagebox.
6
Figura 8: Menù Help.
o di un colore fuori dalla gamma dei 32 predefiniti in Gambas? È sufficiente scrivere un modulo
per stabilirlo! Torneremo su questo argomento dopo aver spiegato come utilizzare la finestra di
dialogo SelectColor.
Quando si utilizzano le finestre relative ai files, vengono restituite le proprietà Filter e Path.
Filter è definita come STATIC PROPERTY Filter AS String[] e restituisce o imposta i filtri
(vale a dire, classificare i files in base all’estensione, per esempio, tutti i files .doc o .png) utilizzati
nelle finestre di dialogo standard. Questa proprietà restituisce o riceve un array stringa. Ogni
elemento della matrice rappresenta un filtro che viene utilizzato ad ogni chiamata della finestra di
dialogo. Ogni filtro stringa deve rispettare la seguente sintassi:
• Nome del filtro.
• Uno spazio.
• Una parentesi aperta.
• Uno o più percorsi, separati da un punto e virgola.
• Una parentesi chiusa.
Di seguito, un esempio che dimostra l’utilizzo della proprietà Title della finestra di dialogo:
Dialog.Title = "Choose a file"
Dialog.Filter = ["Pictures (*.png;*.jpg;*.jpeg)","All files (*.*)"]
Dialog.OpenFile
La finestra di dialogo dei files (SelectDirectory, OpenFile e Savefile) restituisce la proprietà Path,
una stringa contenente il percorso del file selezionato. Nel caso della finestra di dialogo SelectDirectory, la stringa viene troncata al livello della directory. Ora, proviamo a codificare la nostra prima
voce del menu, Foreground Color (il colore di primo piano). Dalla finestra del form, scegliamo la
voce di Foreground Color sotto il menù ColorDialog ed inseriamo questo codice nella subroutine
PUBLIC SUB Menu1Item1 Click():
PUBLIC SUB Menu1Item1_Click()
Dialog.Title = "Choose a foreground color"
Dialog.SelectColor
TextLabel1.ForeColor = Dialog.Color
TextLabel1.Text = "Color selected was " & ColorName & "."
END
Per prima cosa, impostiamo il titolo della finestra di dialogo in “Choose a foreground color” in
modo che l’utente abbia un’idea di ciò che fà la finestra di dialogo. Chiamiamo la finestra di dialogo
con Dialog.SelectColor. Una volta che l’utente ha scelto o cancellato un colore dalla finestra di
dialogo, viene assegnato il nome del colore nella variabile TextLabel1.Text che abbiamo creato
all’inizio del nostro progetto. Scegliamo la TextLabel perché ci permette di formattare il nostro
output in questo modo:
TextLabel1.Text = "Color selected was "&Str(Dialog.Color) & " ."
7
Figura 9: Etichetta di testo formattata che visualizza il valore del colore.
La riga di codice di cui sopra, imposta in grassetto la parte “Color selected was” della stringa,
concatena alla stringa il valore Color, previa conversione del valore intero in stringa utilizzando la
funzione di conversione Str$, ed infine concatena una stringa finale di punteggiatura. Si dovrebbe
vedere qualcosa di simile alla figura 9.
Bhé, 21760 non è un’informazione molto utile. Questa è la rappresentazione interna del colore che
abbiamo selezionato. In effetti, abbiamo bisogno di sviluppare alcuni metodi per conoscere il tipo
di colore, rosso, blu, verde, cioé il nome della costante colore. Questo è quanto si stava alludendo
nella sezione precedente, a proposito del problema che si verifica con i colori. Ecco quindi che
entrano in gioco i moduli.
0.4
I moduli
Creiamo un modulo che restituisce il nome di un colore se si tratta di una costante predefinita. In
caso contrario, impostiamo una stringa che ci comunichi che non si tratta di una costante colore
predefinita. Definito il modulo, modifichiamo il codice per utilizzarlo. Dalla finestra del progetto,
trovare la voce Modules nel TreeView e selezionare un nuovo modulo, di nome Module1. Quando
appare la finestra di dialogo, lasciamo in bianco la CheckBoxes ed assumiamo il nome predefinito
facendo clic su OK. Una nuova finestra di codice, chiamata Module1.module, compare nell’IDE.
Essa dovrebbe presentare un commento simile a questo:
’ Gambas module file
Ora, scriviamo tutto il codice per la nostra funzione, che chiameremo SetColorName. In primo
luogo, dobbiamo dichiarare la funzione e individuare i parametri d’input ed output che saranno
processati. Ecco come fare:
PUBLIC FUNCTION SetColorName ( iVal AS Integer) AS String
Dichiariamo una funzione pubblica, che prende un parametro intero e restituisce una stringa.
Questo modulo necessita di un valore intero, acquisito dalla finestra di dialogo SelectColor, per
verificare se si tratta di uno dei 32 colori predefiniti utilizzati in Gambas. Se trova una corrispondenza con una costante colore, viene assegnato il nome ad una stringa temporanea. In caso
contario, impostiamo una stringa che comunichi che non si tratta di una costante colore. Per
creare una variabile stringa temporanea aggiungiamo questa variabile dichiarandola nella prima
riga di codice all’interno della funzione:
DIM rval AS String
Aggiungiamo un costrutto CASE SELECT. Esso utilizza il parametro intero iVal che viene passato
alla funzione. Ecco il codice da inserire:
DIM rval AS String
SELECT iVal
8
CASE Color.Black
rval = "Black"
CASE Color.Blue
rval = "Blue"
CASE Color.Cyan
rval = "Cyan"
CASE Color.DarkBlue
rval = "DarkBlue"
CASE Color.DarkCyan
rval = "DarkCyan"
CASE Color.DarkGray
rval = "DarkGray"
CASE Color.DarkGreen
rval = "DarkGreen"
CASE Color.DarkMagenta
rval = "DarkMagenta"
CASE Color.DarkRed
rval = "DarkRed"
CASE Color.DarkYellow
rval = "DarkYellow"
CASE Color.Gray
rval = "Gray"
CASE Color.Green
rval = "Green"
CASE Color.LightGray
rval = "LightGray"
CASE Color.Magenta
rval = "Magenta"
CASE Color.Orange
rval = "Orange"
CASE Color.Pink
rval = "Pink"
CASE Color.Red
rval = "Red"
CASE Color.Transparent
rval = "Transparent"
CASE Color.Violet
rval = "Violet"
CASE Color.White
rval = "White"
CASE Color.Yellow
rval = "Yellow"
DEFAULT
rval = Str$(ival) & "
END SELECT
RETURN rval
END
and it is not a predefined color constant"
Dopo aver compilato questo codice, salviamo il file del modulo e torniamo alla finestra del codice
sul Form1. Dobbiamo modificare il codice della subroutine Menu1Item1 Click per utilizzare il
modulo. Di seguito il codice della nuova subroutine:
Dialog.SelectColor
9
ColorName = Module1.SetColorName(Dialog.Color)
END
Abbiamo aggiunto la linea di codice ColorName = . . . ma non abbiamo ancora dichiarato la
variabile ColorName. Questa variabile deve essere globale, perché noi invochiamo un modulo che
restituisce il valore ColorName. Quindi, all’inizio del codice di Form1.class, aggiungiamo questo
codice prima della subroutine PUBLIC SUB Form Open ():
’ Gambas class file
’ declare a global variable to be used with our SetColorName module
ColorName AS String
Adesso, quando il programma viene eseguito, la variabile sarà nota. Nel codice di seguito, la
chiamata a:
restituisce la stringa alla nostra nostra variabile ColorName. La riga di codice seguente
TextLabel1.Forecolor = Dialog.Color
imposta il colore del testo di primo piano (ForeColor). Ora, prendiamo la stringa e visualizziamola
(formattata) assegnandola alla proprietà TextLabel1.Text:
La versione finale della routine Menu1Item1 Click dovrebbe essere cosı̀:
Dialog.SelectColor
END
Adesso vogliamo fare la stessa cosa per il colore dello sfondo. La seconda voce di menù, del menu
ColorDialog, è proprio il colore di sfondo. Scriviamo nell’IDE il codice seguente:
Dialog.Title = "Choose a background color"
Dialog.SelectColor
TextLabel1.BackColor = Dialog.Color
END
L’ultima opzione nel nostro primo menù è quella di cambiare il tipo di carattere. Per far questo,
utilizziamo la finestra di dialogo SelectFont. Ancora una volta, andiamo nel form dei menù e
scegliamo l’opzione Font del menù ColorDialog. I Fonts vengono gestiti in Gambas attraverso la
classe Font. Questa classe rappresenta un tipo di carattere impiegato per disegnare o visualizzare
del testo nei controlli. Questa classe si può creare. Per dichiarare una variabile font, si utilizza il
seguente formato:
DIM hFont AS Font
hFont = NEW Font ( [ Font AS String ] )
10
Il codice di cui sopra crea un nuovo oggetto font da un descrittore font. Questa classe si comporta
come una matrice in sola lettura. Il codice seguente crea e restituisce un nuovo oggetto font da
un descrittore font:
DIM hFont AS Font
hFont = Font [ Font AS String ]
Le proprietà che si possono utilizzare con Font includono:
• Ascent
• Bold
• Descent
• Fixed
• Italic
• Name
• Resolution
• Size
• StrikeOut
• Styles
• Underline
Di seguito un esempio di come utilizzare le proprietà Font:
Form1.Font.Name = "Utopia"
Form1.Font.Bold = TRUE
Form1.Font.Italic = TRUE
Form1.Font.Size = "14"
Form1.Font.StrikeOut = FALSE
Form1.Font.Underline = TRUE
La classe Font ha tre metodi che si possono invocare: Height, ToString e Width. Height è una
funzione che restituisce l’altezza del testo visualizzato con il font. Si dichiara come:
FUNCTION Height ( Text AS String ) AS Integer
ToString restituisce il nome completo di un font come descrittore stringa. Questa stringa è una
concatenazione di tutte le proprietà font separate da virgole. Si dichiara cosı̀:
FUNCTION ToString ( ) AS String
Un esempio di chiamata a ToString è:
PRINT Application.Font.ToString()
Width è una funzione che, al pari di Height, restituisce la larghezza del testo visualizzato con il
font:
FUNCTION Width ( Text AS String ) AS Integer
11
Ora continuiamo ad inserire il nostro codice per il programma MenuProject nella routine PUBLIC SUB Menu1Item3 Click(). In primo luogo, si dichiarano due variabili locali, fontdata e
oldfontdata. Vogliamo ottenere il nuovo font dalla chiamata della finestra di dialogo SelectFont, ma
vogliamo anche mantenere il vecchio dato font, nel caso in cui ce ne fosse bisogno. Successivamente,
dichiariamo due variabili stringa, attr e sel (attributo e selezione) per impostare il tipo di carattere
stringa assegnato; selezione è una stringa dinamica; essa cambia in base alle varie selezioni da parte
dell’utente.
DIM fontdata AS font
DIM oldfontdata AS Font
DIM attr AS String
DIM sel AS String
A questo punto, è possibile che venga chiesto se non si può semplicemente utilizzare la proprietà
ToString per farlo. La risposta è Sı̀, ma in questo modo non s’impara molto. La riga di codice
seguente imposta semplicemente in bianco gli spazi vuoti della stringa attr:
attr = ""
Adesso, si assegna la proprietà TextLabel1.font alla variabile oldfontdata:
oldfontdata = TextLabel1.Font
Impostiamo il titolo della finestra di dialogo SelectFont e invochiamola con queste due righe:
Dialog.Title = " Pick a font... "
Dialog.SelectFont
Quando l’utente seleziona un font dalla finestra di dialogo SelectFont, vogliamo assegnare il il font
scelto alla variabile fontdata:
fontdata = Dialog.Font
A questo punto, verifichiamo l’attributo scelto dall’utente e la stringa dinamica di output che è
stata costruita. Avremmo potuto utilizzare un costrutto IF THEN ELSE per controllare ogni
proprietà supportata dalla classe Font, ma non è di nostro interesse in questo esercizio.
IF fontdata.Italic THEN
sel = " Italic"
attr = attr & sel
ENDIF
IF fontdata.Bold THEN
sel = " Bold"
attr = attr & sel
ENDIF
IF fontdata.Strikeout THEN
sel = " Strikeout"
attr = attr & sel
ENDIF
IF fontdata.Underline THEN
sel = " Underline"
attr = attr & sel
ENDIF
Adesso, impostiamo il font nel controllo textLabel1 in base alla scelta dell’utente e visualizziamo
dinamicamente la stringa di caratteri composta:
12
Figura 10: Colore e font selezionati.
Figura 11: Nuovo default per il font del controllo TextLabel1.
TextLabel1.Font = fontdata
TextLabel1.Text = "Font: "&fontdata.Name&", "&Str(Round(fontdata.Size)) & attr
Diamo l’opportunità o meno di mantenere le impostazioni correnti o ripristinare quelle precedenti,
impostando una pausa di cinque secondi:
WAIT 5.0
SELECT Message.Question("Keep the new font?", "Yes","No","Don’t know")
CASE 1
TextLabel1.Text = "This is now the default font."
CASE 2
TextLabel1.Font = oldfontdata
TextLabel1.Text = "Reverted to previous font setting."
CASE 3
TextLabel1.Text = "No change was made to default font."
END SELECT
END
Si noti che abbiamo introdotto l’uso della MessageBoxes senza dare spiegazioni a riguardo. Questo
è il nostro prossimo compito. Salvare il progetto ed eseguirlo. I risultati dovrebbero essere simili
a quelli riportati in figura 10, a seconda dei colori e del font selezionato.
Se decidiamo di mantenere il default, dovremmo vedere qualcosa di simile alla figura 11.
A questo punto del nostro percorso di apprendimento, sappiamo abbastanza cose su Gambas.
Proseguiamo con la gestione dell’input e dell’output. Le MessageBoxes sono un altro prezioso
strumento di Gambas. Conosciamole più da vicino.
0.5
MessageBoxes (finestre di messaggio)
I controlli MessageBox sono uno strumento molto pratico per comunicare informazioni all’utente
e per ottenere risposte del tipo TRUE/FALSE. In generale, le MessageBoxes rientrano in una
delle quattro grandi categorie: domanda del tipo and/or, informazione, avvertimento, notifica di
13
Figura 12: Un’informazione in un MessageBox.
Figura 13: Il menù Info Message spuntato.
errore/allarme. Per visualizzare queste MessageBoxes viene utilizzata la classe Message. Questa
classe è statica e può essere utilizzata come una funzione. Si dichiara cosı̀:
STATIC FUNCTION Messagge (Message As String [, Button As String]) As Integer
I metodi supportati dalla classe Message sono Info, Question, Delete, Error e Warning. Si è già
visto il metodo Message.Question. Ogni metodo serve per uno scopo specifico e deve essere pensato
con attenzione. Iniziamo con il metodo più semplice del MessageBox, il metodo Information.
0.5.1
Messaggi Information
Questo metodo viene dichiarato come:
STATIC FUNCTION Info (Message As String [, Button As String]) As Integer
ed è utilizzato per visualizzare informazioni in un MessageBox con un solo pulsante. L’utente
non è tenuto a prendere nessuna decisione; egli deve prendere atto esclusivamente del messaggio
d’informazione. Per questo è necessario un solo pulsante. Ecco ciò che il nostro codice produce
(figura 12).
Per continuare a costruire il nostro programma, sul Form1 andiamo al menù MessageBoxes e facciamo clic sulla voce Info Message. Nell’editor del codice inseriamo quanto segue nella subroutine
Menu2Item1 Clicked():
Message.Info("Here is some information to consider.")
END
Semplice, vero? Come fare invece se vogliamo passare dal valore TRUE a FALSE e viceversa, ogni
volta che selezioniamo la voce del menù (figura 13)?
Modifichiamo il codice di cui sopra come segue:
ELSE
ENDIF
END
14
La figura 13 mostra il menù item spuntato. Selezioniamo e deselezioniamo un paio di volte. Non
è stato troppo difficile, vero? Ora passiamo alla prossima MessageBox.
0.5.2
Messaggi conferma
Di questa categoria fanno parte Question e Delete. Question è definita come:
STATIC FUNCTION Question ( Message AS String [ , Button1 AS String,
Button2 AS String, Button3 AS String ] ) AS Integer
Invochiamo una MessageBox tipo question con tre pulsanti. Viene restituito l’indice del pulsante
in base al clic dell’utente. Torniamo al odice precedente ed esaminiamolo in dettaglio:
SELECT Message.Question("Keep the new font?", "Yes","No","Don’t know")
CASE 1
CASE 2
CASE 3
END SELECT
Dato che viene restituito l’indice del pulsante cliccato dall’utente, è più facile incorporare la chiamata alla Message.Question in un costrutto SELECT/CASE. SELECT restituisce un valore intero;
poiché sappiamo che possono essere restituiti solo i CASE 1, 2 o 3, non ci serve una sezione di
default. Si potrebbe tuttavia implementarla, ma non è necessario. A seconda del valore restituito,
si esegue un’azione Yes, un’azione No, o un’azione Don’t know perché questo è ciò che è specificato nella nostra chiamata alla finestra di dialogo (nel costrutto SELECT). Adesso scriviamo il
nuovo codice per la voce Question Message del menù MessageBoxes. Selezioniamola dal Form1 e
inseriamo il codice seguente:
SELECT Message.Question("Did you like this?", "Yes","No","Don’t know")
CASE 1
TextLabel1.Text = "Liked it."
CASE 2
TextLabel1.Text = "Did not like it."
CASE 3
TextLabel1.Text = "Did not know."
END SELECT
END
Quando si esegue il programma vedremo qualcosa di simile alla figura 14.
0.5.3
Messaggi Error
La funzione Error mostra un MessageBox error con tre pulsanti. Viene restituito l’indice del
pulsante selezionato dall’utente. Error è definita come:
STATIC FUNCTION Error (Message AS String[,Btn1 AS String, Btn2 AS String, Btn3
AS String]) AS Integer
Torniamo indietro al Form1 e facciamo clic sul subMenuItem Error Message. Digitiamo il seguente
codice:
15
Figura 14: MessageBox tipo Question.
Figura 15: MessageBox tipo Error.
PUBLIC SUB subMenuItem1_Click()
Message.Error("Wow! This was a mistake.")
END
La figura 15 mostra quello che dovrebbe vedersi quando eseguiamo il programma.
0.5.4
Messaggi Warning a Alert
La finestra di messaggio Warning contiene tre pulsanti. Viene restituito l’indice del pulsante
selezionato dall’utente. La finestra Warning si dichiara cosı̀:
STATIC FUNCTION Warning (Message AS String[,Btn1 AS String, Btn2 AS
String, Btn3 AS String ] ) AS Integer
Nel nostro programma di esempio, i messaggi error, warning e delete fanno parte di un sottomenù
che abbiamo creato per farli comparire sotto la voce Alert Message. Per codificare il messaggio
di warning, abbiamo bisogno di cliccare sulla voce Warning Message di Alert Message. Scriviamo
questo codice:
Message.Warning("You have been warned about this!")
END
Quando eseguiamo il programma vedremo qualcosa di simile alla figura 16.
0.5.5
Messaggi Delete
La funzione Delete mostra la MessageBox di cancellazione con tre pulsanti. Viene restituito l’indice
del pulsante selezionato dall’utente. Delete si dichiara cosı̀:
STATIC FUNCTION Delete (Message AS String [, Btn1 AS String, Btn2 AS
String, Btn3 AS String ] ) AS Integer
Selezioniamo l’evento clic per Delete Message e scriviamo il seguente codice:
16
Figura 16: MessageBox tipo Error.
Figura 17: MessageBox Deleet con tre pulsanti.
SELECT Message.Delete("Delete?", "Yes","No","Cancel")
CASE 1
TextLabel1.Text = "Deleted it."
CASE 2
TextLabel1.Text = "Not Deleted."
CASE 3
TextLabel1.Text = "Canceled!"
END SELECT
END
Quando eseguiamo il programma vedremo qualcosa di simile alla figura 17.
0.6
Funzioni Dialog Class per i Files
Le finestre di dialogo standard fornite con Gambas supportano anche l’apertura di un file, il
salvataggio di un file e la scelta di un percorso di una directory. Esse sono piuttosto standard ma
il grande vantaggio consiste nel non doverle costruire all’occorrenza. Questa sezione mostra come
è facile usarle nelle operazioni sui files.
0.6.1
Funzione dialogo OpenFile
La funzione dialogo OpenFile invoca la finestra di dialogo standard per i files con acquisizione
del nome di un file da aprire. Questa funzione restituisce TRUE se l’utente clicca sul pulsante
CANCEL e FALSE se l’utente clicca sul pulsante OK. Essa si dichiara cosı̀:
STATIC FUNCTION OpenFile ( ) AS Boolean
Dalla finestra del form del nostro programma, fare clic sul menù FileDialogs e selezionare la voce
di menù File open . . . Questo avvierà l’eventop clic che conterrà il seguente codice:
Dialog.Title = " Open file... "
17
Figura 18: La finestra di dialogo Open File.
Dialog.OpenFile
TextLabel1.Text = " OPEN: " & Dialog.Path
END
Il codice di cui sopra definisce semplicemente il titolo e chiama la finestra di dialogo standard.
Quando l’utente termina la selezione, la stringa restituita dalla finestra Dialog OpenFile, viene
assegnata alla variabile TextLabel1.Text. Ecco ciò che dovrebbe vedersi quando eseguiamo il
programma (figura 18):
0.6.2
Funzione dialogo SaveFile
La funzione dialogo SaveFile invoca la finestra di dialogo standard per i files acquisendo il nome
di un file da salvare. Questa funzione restituisce TRUE se l’utente clicca sul pulsante CANCEL e
FALSE se l’utente clicca sul pulsante OK. Essa si dichiara cosı̀:
STATIC FUNCTION SaveFile ( ) AS Boolean
Creiamo l’evento clic per File Save . . . nel menù FileDialogs inserendo il seguente codice:
Dialog.Title = " Save file to... "
Dialog.SaveFile
TextLabel1.Text = "SAVE: " & Dialog.Path
END
La figura 19 mostra il risultato.
0.6.3
Funzione dialogo SelectDirectory
La funzione dialogo SelectDirectory invoca la finestra di dialogo standard per acquisire il nome
della directory corrente. Questa funzione restituisce TRUE se l’utente clicca sul pulsante CANCEL
e FALSE se l’utente clicca sul pulsante OK. Essa si dichiara cosı̀:
STATIC FUNCTION SelectDirectory ( ) AS Boolean
Questo è l’ultimo evento clic che dobbiamo codificare. Scegliamo nel menù FileDialogs la voce
SelectDir e scriviamo il seguente codice:
18
Figura 19: La finestra di dialogo Save File.
Figura 20: La finestra di dialogo Select Directory.
Dialog.Title = " Pick a dir... "
Dialog.SelectDirectory
TextLabel1.Text = "SAVE to DIR: " & Dialog.Path
END
Salviamo il nostro progetto ed eseguiamo il programma. La figura 20 mostra quello che dovremmo
vedere.
A questo punto abbiamo scritto tutto il codice necessario per completare il nostro programma
MenuProject. Salviamo ed eseguiamo il programma. La sezione successiva presenta il codice
sorgente completo del programma . Nel prossimo capitolo, impareremo a gestire l’input e l’output
da parte degli utenti utilizzando stringhe e files.
0.7
Codice sorgente completo del programma
’ Gambas class file
’ declare a global variable to be used with our SetColorName module
ColorName AS String
PUBLIC SUB Form_Open()
ME.Caption = " Working with Menus "
END
19
PUBLIC SUB QuitBtn_Click()
Form1.Close
END
Dialog.SelectColor
END
Dialog.Title = "Choose a background color"
Dialog.SelectColor
TextLabel1.BackColor = Dialog.Color
END
DIM fontdata AS font
DIM oldfontdata AS Font
DIM attr AS String
DIM sel AS String
attr = ""
oldfontdata = TextLabel1.Font
Dialog.Title = " Pick a font... "
Dialog.SelectFont
fontdata = Dialog.Font
IF fontdata.Italic THEN
sel = " Italic"
attr = attr & sel
ENDIF
IF fontdata.Bold THEN
sel = " Bold"
attr = attr & sel
ENDIF
IF fontdata.Strikeout THEN
sel = " Strikeout"
attr = attr & sel
ENDIF
IF fontdata.Underline THEN
sel = " Underline"
attr = attr & sel
ENDIF
TextLabel1.Font = fontdata
TextLabel1.Text = "Font: " & fontdata.Name & ", " & Str(Round
(fontdata.Size)) & attr
WAIT 5.0
SELECT Message.Question("Keep new font?", "Yes","No","Don’t know")
CASE 1
CASE 2
CASE 3
20
END SELECT
END
ELSE
ENDIF
END
Message.Error("Wow! This was a mistake.")
END
Message.Warning("You have been warned about this!")
END
SELECT Message.Delete("Delete?", "Yes","No","Cancel")
CASE 1
TextLabel1.Text = "Deleted it"
CASE 2
TextLabel1.Text = "Not Deleted"
CASE 3
TextLabel1.Text = "Cancelled!"
END SELECT
END
SELECT Message.Question("Did you like this?", "Yes","No","Don’t know")
CASE 1
TextLabel1.Text = "Liked it."
CASE 2
TextLabel1.Text = "Did not like it."
CASE 3
TextLabel1.Text = "Did not know."
END SELECT
END
Dialog.Title = " Open file... "
Dialog.OpenFile
TextLabel1.Text = " OPEN: " & Dialog.Path
END
Dialog.Title = " Save file to... "
Dialog.SaveFile
TextLabel1.Text = "SAVE: " & Dialog.Path
END
Dialog.Title = " Pick a dir... "
Dialog.SelectDirectory
TextLabel1.Text = "SAVE to DIR: " & Dialog.Path
END
21
Message.Info("This is all about Gambas Programming!")
END
0.8
Codice sorgente di Module1.module
rval AS String
SELECT iVal
CASE Color.Black
rval = "Black"
CASE Color.Blue
rval = "Blue"
CASE Color.Cyan
rval = "Cyan"
CASE Color.DarkBlue
rval = "DarkBlue"
CASE Color.DarkCyan
rval = "DarkCyan"
CASE Color.DarkGray
rval = "DarkGray"
CASE Color.DarkGreen
rval = "DarkGreen"
CASE Color.DarkMagenta
rval = "DarkMagenta"
CASE Color.DarkRed
rval = "DarkRed"
CASE Color.DarkYellow
rval = "DarkYellow"
CASE Color.Gray
rval = "Gray"
CASE Color.Green
rval = "Green"
CASE Color.LightGray
rval = "LightGray"
CASE Color.Magenta
rval = "Magenta"
CASE Color.Orange
rval = "Orange"
CASE Color.Pink
rval = "Pink"
CASE Color.Red
rval = "Red"
CASE Color.Transparent
rval = "Transparent"
CASE Color.Violet
rval = "Violet"
CASE Color.White
rval = "White"
CASE Color.Yellow
rval = "Yellow"
DEFAULT
rval = Str$(ival) & " and it is not a predefined color constant"
22
END SELECT
RETURN rval
END

Capitolo 6 Men`u, moduli, finestre di dialogo e di messaggio

Transcript

Documenti analoghi

www.calendarcolors.com Rose Delight™ Little Treasure™ Canaries™

carbon - birrificio farnese

Russula emetica - Comunità Montana Val Trompia

Salvatore Settis - Fondazione COLOR YOUR LIFE

REGOLE PER L`INSERIMENTO DEI TESTI LATINI

Tag RFID per l`abbigliamento dei bambini Boboli

SCRITTORI LEGGONO SCRITTORI 1

Introduzione ai fogli di stile

NOTE OPERATIVE PER L`UTILIZZO DEL PROGRAMMA “IrfanView”

Capitolo 9 Lavorare con i files