Visual dBASE 7.01 Tutorial
Fase VI - La Configurazione di Partenza
Ultima Modifica: 5 Febbraio 1999Ken Mayer, TeamB
Un concetto interessante usato in tutte le applicazioni di esempio, incluse con l'ambiente di sviluppo Visual dBASE, è l'idea di creare un
"oggetto specifico" per il controllo dell'applicazione.
Il vantaggio che ne deriva è la possibilità di creare i nostri propri metodi (come "avvio" e
"chiusura") per gestire "codice specifico" per l'applicazione.
In altre parole stiamo incapsulando l'intera applicazione in questo oggetto (rigorosamente corretto dal punto di vista del "pensiero OOP" ). Noi arriveremo a questo creando un generico oggetto applicazione, da cui ne deriveremo un altro (subclassing) per questa particolare applicazione.
Nota: "Subclassing" è la tecnica che usa una classe come "classe base" . Cioè creare una nuova classe, la quale erediterà tutte le proprietà, i metodi, e gli eventi della classe base.
Un esempio di quanto suddetto, è creare una scheda in Visual dBASE (non schede "custom"). C'è una classe "base" per le schede (la classe form) che è integrata in Visual dBASE. Quando crei una nuova scheda, essa è una sotto classe della scheda base. Ha tutte le proprietà, eventi e metodi della scheda standard in dBASE.
Una volta che hai derivato (subclassed) un oggetto puoi cambiare le sue proprietà, i suoi eventi e puoi anche agganciare il tuo specifico codice nei metodi di quella classe, senza modificare la definizione della classe base.
Per realizzare quanto su detto, bisognerà fare un programma che gestisca la creazione dell'oggetto applicazione. Il programma sarà usato per impostare tutti files di procedura (e file di controlli custom, ecc.) che sono necessari per l'applicazione, per creare un'istanza dell'oggetto applicazione ed infine per eseguire il codice di avvio dell'applicazione.
Ancora una volta quello che faremo è basato sull' applicazione di esempio MUGS inclusa con Visual dBASE, ma ci saranno delle differenze significative.
Creiamo il programma di Avvio (Start.prg)
Per creare il programma, tramite il Centro di Controllo, clicca sul separatore "Programmi",
quindi un doppio clic sull'icona 
. Vedrai apparire la finestra "editor sorgenti".
È una buona idea digitare il codice e i commenti mostrati nel tutorial. Uno dei beta testers ha detto :
"Il tempo impiegato a "digitare" mi ha aiutato a comprendere maggiormente il codice ed è stato anche utile per vedere quando le cose non funzionavano a causa di errori di
digitazione."
Dovresti mettere probabilmente dei commenti all'inizio del codice, spiegando gli scopi del programma. I
commenti possono essere utili sia per te sia per chiunque altro stia esaminando il tuo codice sorgente:
/*
START.PRG
Author: Ken Mayer
Data : 5 Febbraio, 1999
Progetto Tutorial programma di avvio START.prg
Questo programma è usato per avviare l'applicazione
sviluppata con il Tutorial. E' basato "pesantemente" sullo
esempio MUGS incluso con Visual dBASE 7.
There is a reference to another .CC, which is
the genericMDIApp.CC file -- this contains
the generic application object, and below we
subclass it ...
The idea is that you have a lot of "things" that
you always do for any application that is
an MDI app. You create one object that handles
all of that, and then you subclass that for
the specifics for an application, as each is
at least slightly different.
*/
Non spenderò molto tempo parlando di alcune cose come la "visibilità" di una variabile (usando local
invece di pubblic, ecc.). Se hai bisogno di maggiori informazioni guarda nella guida in linea o nel manuale il linguaggio o nella guida alla programmazione.
Il codice seguente è la parte iniziale dell'applicazione. Può essere usato "così come è":
local app
set talk off
set procedure to GenericMDIApp.cc additive
app = new TutorialApp()
return ( app.open() )
Quello che fa l'istruzione "app = new TutorialApp()" è creare un'istanza dell'oggetto applicazione del tutorial. Noi definiremo questo un pezzo alla volta nei prossimi passi. L'istruzione "return" chiama semplicemente il metodo app.open(), che è il codice che noi creeremo--questo sarà un metodo dell'oggetto applicazione.
Il Generico Oggetto Applicazione
Salva il programma di Avvio (CTRL+S, e chiamalo "Start"), e nella finestra comandi digita (o,
tramite il Centro di Controllo seleziona il separatore "programmi",
quindi un doppio clic sull'icona .
Assicurati che quando salvi questo nuovo file il nome sia corretto e cioè GenericMDIApp.cc)
:
create command GenericMDIApp.cc
Questo comando aprirà una seconda finestra nell'editor di sorgenti ( puoi passare da un programma all'altro tramite i separatori in cima alla finestra dell'editor di sorgenti...).
Abbiamo bisogno di creare un oggetto. Abbastanza Interessante, per creare un oggetto in Visual dBASE che non sia basato su un oggetto stock (cioè non integrato in dBASE), la sintassi è così semplice come:
class GenericMDIApp
Questo dice a dBASE che stiamo creando il nostro proprio oggetto, chiamato
"GenericMDIApp."
Possiamo creare proprietà e metodi, ma non gli eventi. Per i nostri scopi, noi abbiamo bisogno almeno di due metodi, uno per gestire l'apertura dell'applicazione, l'altro per le operazioni di
chiusura o shut down (questo metodo dovrebbe gestire qualsiasi cleanup necessario).
Abbiamo bisogno anche, di avere del codice che imposta alcune proprietà custom, ed altre impostazioni che sono necessarie per l'oggetto applicazione. Questo codice è eseguito per ciascuna istanza dell'oggetto, quando l'oggetto è istanziato (app = new...). perché è messo prima dei metodi che definiremo. Questo è chiamato "codice costruttore."
// This custom property should be overwritten // in a subclass, or after instantiation, but // before the Open() method is invoked: this.FrameWinText = "Generic MDI application" // The same goes for this custom property: this.MenuClassName = "MyMainMenu" // We assume here that every MDI app will have // a SETUP.PRG do setup // Assign a property to _app.frameWin, which is // a reference to this object: "this". _app.framewin.app = this
Il metodo "Open"
Il metodo open che servirà per i nostri scopi sarà molto complicato. Compirà alcuni compiti di base:
Function Open
// Imposta un riferimento al menu
private c
// costruisce il comando tramite una "macro" :
c = 'this.rootMenu = new '+this.MenuClassName+;
'(_app.framewin,"Root")'
// esegue la macro:
&c.
// Chiude le eventali schede aperte
close forms
// Imposta l'ambiente in modalità di esecuzione
set design off
// imposta il tasto <Escape> ad "off" ma memorizza il
// valore corrente:
this.OldEscape = set("ESCAPE")
set escape off
// Disattiva la shell di Visual dBASE, ma
// lascia attiva la MDI frame window:
shell( false, true )
// disattiva la barra strumenti e la barra di stato
_app.speedbar := false
_app.statusBar := false
// Imposta la proprietà text dell'oggetto applicazione framewin
_app.framewin.oldText = _app.framewin.text
_app.framewin.text := this.FrameWinText
Nota: I primi tre comandi nel metodo Open mostrato sopra sono usati per creare un comando "macro" ed eseguirlo. Questo è un modo per costruire istruzioni di programma che hanno bisogno di essere eseguite ma hanno anche bisogno di essere molto flessibili.
Tramite l'uso di una stringa di caratteri, possiamo inserire valori di variabili, (in questo caso, il nome della classe menu), e poi una volta che l'intera stringa è costruita, possiamo eseguire il comando in un sol colpo (&c.). Per maggiori informazioni sull'operatore di macro espansione, vedi "&" nella guida in linea...
Il Metodo "Close"
Questo metodo gestirà la chiusura delle schede e le operazioni di "pulizia" connesse alla chiusura dell'applicazione, includendo il ripristino dell'ambiente di sviluppo in funzione delle impostazione modificate con il metodo Open.
function close
// chiude qualsiasi scheda che potrebbe essere
stata lasciata aperta
close forms
// Se siamo in ambiente di "runtime"
(cioè abbiamo lanciato l'eseguibile),
// vogliamo che sia eseguita l'istruzione "quit"
(altrimenti l'oggetto framewin
// resterà sullo schermo e VDB7RUN.EXE
resterà
// in memoria!)
if ( "runtime" $ lower( version(0) ) )
quit
else
// altrimenti siamo nell'
IDE, quindi ri-impostiamo
// alcuni valori:
with ( _app )
framewin.app
:= null
framewin.text
:= framewin.OldText
speedbar
:= true
statusBar := true
endwith
// ripristianiamo la
modalità progettazione:
set design on
// ripristiniamo il vecchio
valore assegnato
// al tasto <ESC>:
cEscape = this.oldEscape
set escape &cEscape.
// chiudiamo qualsiasi file
procedura aperti
set procedure to
// rislasciamo il menu
_app.framewin.root.release()
// ripristiniamo la shell
...
shell( true, true )
endif
ENDCLASS // non dimenticare questa istruzione di chiusura!
Nota: Il costrutto "with/endwith" è una nuova caratteristica di Visual dBASE 7.x, ed è molto utile quando stai lavorando con gli oggetti. Vedrai che è molto utilizzato se esamini il codice creato con impostazione scheda o impostazione report. Lo scopo principale è "accorciare" il tuo codice. Vedi nella guida in linea per maggiori dettagli.
C'è uno caveat con il costrutto with/endwith -- non puoi creare nuove (custom) proprietà di un oggetto dentro questo codice. Tu devi crearlo fuori dalla struttura with/endwith.
Salva questo file ed esci (Ctrl+W)... questo lascerà il file START.PRG nell'editor di sorgenti. Abbiamo bisogno di aggiungergli lo specifico oggetto applicazione.
Lo Specifico Oggetto Applicazione
In the same program file as the "start" program, you want to add the following (after the RETURN statement), which is the actual application specific part of the code:
class TutorialApp of GenericMDIApp // set any specific code for the subclassed // MDI application here: this.FrameWinText = "Visual dBASE 7.01 Tutorial Project" // note this is not the file name -- the // SETUP program must execute "set procedure ..." that // will open the file "TUTORIAL.MNU" ... the class // will be available from that point on. This is // the classname of the menu: this.MenuClassName = "TutorialMenu" endclass
Fa' attenzione che nell'istruzione precedente: ' this.MenuClassName = "TutorialMenu"
' non ci sono spazi tra "Tutorial" e "Menu."
Come detto precedentemente, questo codice è una versione semplificata di quello che è nella applicazione di esempio
MUGS. L'esempio MUGS usa le barre strumenti (toolbars) che non useremo per il tutorial. Questo è solamente al fine di semplificare un poco l'applicazione, e prenderebbe più tempo per completarla. Se sei interessato all'uso delle toolbars per le tue applicazioni, vedi "TOOLBAR.ZIP" al mio sito web.
Salva il programma START ed esci dall'editor sorgenti con Ctrl + W.
Creare il Programma SETUP
La prossima cosa che abbiamo bisogno di fare è creare un programma di SETUP. La ragione per questo programma è che si usa in due modi:
Piuttosto che inserire il codice in due "luoghi" diversi, lo inseriremo nel programma SETUP.PRG, ed esso sarà "disponibile" o lanciando il programma START o semplicemente lanciando il programma SETUP...
Crea un nuovo programma nell'editor sorgenti (doppio clic sull'icona
dal Centro di Controllo ovviamente il separatore selezionato deve essere "Programmi"), e immetti il seguente:
/*
SETUP.PRG
The "setup program" for the MDI Tutorial
application ... open any and all files
needed to run the application and/or develop
the application.
*/
// These always get me -- if the program
// crashes, and they usually do while developing --
// (due to programmer error), the speedBar and the
// statusBar in the IDE is not available ... this
// just puts them back. the MDI application class turns
// them back off ...
_app.speedbar := true
_app.statusBar := true
// this can also cause problems:
set design on
// Set procedures ...:
set procedure to START.PRG additive
// make sure the menu is available:
set procedure to tutorial.mnu additive
// set the directory to wherever you stored
// the .CC files -- the default is _DBWINHOME (the
// location of Visual dBASE) plus the CUSTOM
// directory as defined in the setup portion
// of this tutorial project. If you choose to
// store these files elsewhere (such as the
// tutorial directory), make sure that you
// change that path HERE:
CUSTOMDIR = _DBWINHOME+"CUSTOM\"
// custom controls used by the application
set procedure to CUSTOMDIR+"seeker.cc" additive
set procedure to CUSTOMDIR+"custbutt.cc" additive
set procedure to CUSTOMDIR+"formcntl.cc" additive
set procedure to CUSTOMDIR+"repcntl.cc" additive
set procedure to CUSTOMDIR+"report.cc" additive
// add others as needed here:
/*
End of Program: SETUP.PRG
*/
Potresti anche includere qualsiasi tipo di comando SET, come ad es. "SET EPOCH" od altri (per l'applicazione dovresti considerare di memorizzare questo genere di "comandi" nel file .INI dell'applicazione... vedremo questo discorso quando parleremo della preparazione per la distribuzione (deploy) dell'applicazione).
Quando hai finito di immettere i tuoi comandi come mostrato sopra, salva e esci dall'editor sorgenti (Ctrl+W, il nome del programma dovrà essere "SETUP").
Testare il Programma di avvio Start.prg
Dobbiamo verificare che il programma che abbiamo editato faccia il suo lavoro...
Per fare questa verifica tramite il Centro di Controllo" fai doppio clic sull'icona Start.prg oppure nella finestra comandi digita:
do start
Nota: Se dovessi commettere errori di immissione (typos) digitando il codice, essi saranno rilevati durante l'esecuzione del programma. Non farti prendere dal panico!
Seleziona il pulsante "Correggi" ,e verifica il codice immesso e correggi gli eventuali errori.
Se hai corretto il problema che ha generato l'errore il programma proseguirà l'esecuzione... altrimenti sarai avvisato che un altro problema si è verificato...
Nel peggiore dei casi, potrebbe verificarsi un GPF. Di nuovo, niente panico! Ci sono dei bugs nel nel meccanismo del gestore degli errori di Visual dBASE che possono causare questo problema. Seleziona il pulsante "No" quando ti viene chiesto di salvare il tuo lavoro, e poi fai ripartire Visual dBASE . Lancia il programma SETUP per ripristinare l'ambiente...
Porta il programma START o il programma SETUP, o la classe custom GenericMDIApp nell'editor di sorgenti e riverifica il codice...
Tu dovresti vedere tutto cambiato, il menu dovrebbe essere quello che abbiamo
progettato precedentemente, la barra del titolo (titlebar) dovrebbe mostrare il testo che
abbiamo definito, e così via. Eppure esiste un problema...
Prova selezionando l'opzione menu "File" e poi "Exit"... non accade nulla. Sei rimasto di STUCCO! Bene, non realmente... usa il pulsante ' x' nell'angolo in alto a destra della barra del titolo (questo chiuderà Visual dBASE)... Tu avrai bisogno di "resettare" Visual dBASE , e poi lanciare il programma SETUP (questo azzererà le toolbar, e simili ).
Torna al Menu
Torniamo al menu che abbiamo creato nella fase precedente ed aggiungiamo del codice. Il codice che aggiungeremo al momento è associato all'opzione
"Esci" che permette di chiudere l'applicazione. Altrimenti si verificherà la stessa cosa che abbiamo visto sopra, ogni volta che esamini l'applicazione...
Portiamo il tutorial menu in modalità impostazione, clicca su separatore "Schede", poi clicca il pulsante destro su "Tutorial.mnu". dal menu popup che appare seleziona "imposta menu". Puoi fare la stessa cosa trascinando il file menu sulla superficie di progettazione.
Clicca sull'oggetto menu "Esci" che appare sotto l'opzione "File". Nel modulo "Ispezione",
seleziona il separatore "Eventi", quindi sull'evento onClick. c'è il pulsante
cliccaci su . Questo aprirà una finestra con l'editor di sorgenti, e puoi scrivere codice per l'evento onClick dell'oggetto menu:
function EXIT_onClick
return ( _app.framewin.app.close() )
Puoi premere il tasto <Invio> dopo la seconda linea (un beta tester di questo tutorial trovò che la funzine precedente non funzionava senza aver premuto il suddetto tasto...).
Premi Ctrl+W per salvare le modifiche ed uscire.
Ri-testare il Programma di avvio START.prg
Proviamo di nuovo questo programma... nel Centro di Controllo, seleziona il separatore "Programmi", ed infine doppio clic sul programma chiamato "START".
Seleziona il menu "File", e osserva le opzioni. Prova gli altri menu...
Finalmente, seleziona il menu "File", e quindi l'opzione "Esci".
Ciò ti dovrebbe riportare dove prima eri ... meglio di prima... quello che questo vuole dire è che come noi andiamo attraverso
tutorial, una volta che del codice è agganciato nel menu per una opzione del menu,
possiamo testarlo e poi ritornare all'ambiente di sviluppo...
| tutorial menu |
Fine del File: STARTPROGRAM.HTM - 5 Febbraio 1999 - KJM
Avvertimento Legale: Questo documento è parte del Visual dBASE 7 Tutorial creato da Ken Mayer. Questo materiale è © proprietà letteraria riservata 1999, da Ken Mayer. Visual dBASE 7 e Visual dBASE 7.01, il BDE (Borland Database Engine) e BDE Administrator sono tutelati in base ai diritti d'autore e marchio di fabbrica da Inprise, International. Questo documento non può essere esposto altrove senza il permesso esplicito dell'autore, il quale si riserva tutti diritti sul documento.