visual basic 6 base

CORSO DI VISUAL BASIC 6.0 Lezione n. 1

IInnttrroodduuzziioonnee aallllaa PPrrooggrraammmmaazziioonnee VViissuuaallee

Evoluzione del vecchio Basic: Premessa L’obiettivo di questo corso è di fornire quanti più suggerimenti e chiavi di lettura a chi è neofita della programmazione. Chi invece ha già dimestichezza con la programmazione Basic, ma non ha mai utilizzato l’ambiente visuale, potrà approfondire nei dettagli ciò che già conosceva in modo superficiale. Per introdurvi nel modo migliore alla programmazione visuale, partiamo dal vecchio Basic, delineandone le seguenti caratteristiche:

- era un linguaggio di programmazione di natura interpretata e ideale per i principianti, prendeva il nome di GW-BASIC; esisteva al tempo dei Pc IBM compatibili tipo (M24 dell’olivetti e M240);

- Offriva un ambiente di programmazione MS-DOS molto lento e aveva soltanto l’interfaccia testuale;

- Non era dotato di un compilatore e quindi non permetteva la generazione di un file autonomo eseguibile al di fuori dell’ambiente di programmazione

Dal Gw-Basic si è passati al QBASIC, con le seguenti caratteristiche:

- si è evoluto rispetto al Gw-Basic, in quanto dotato di un ambiente di sviluppo in modalità finestra, ma l’esecuzione del programma avveniva sempre in modalità Ms-dos (cioè testuale);

- era dotato di un compilatore, in grado di trasformare il codice sorgente in codice eseguibile al di fuori dell’ambiente di sviluppo;

Matura la prima versione di Visual Basic for Ms-Dos 1.0, e da questa versione se ne sono avute altre 5 per arrivare alla versione oggetto del corso che state seguendo lezione per lezione: Microsoft Visual Basic 6.0 Le caratteristiche della prima versione di Visual Basic 1.0 sono le seguenti:

Spalluzzi Francesco - Manuali.Net © 2005 Tutti i diritti riservati 1


- E’ rimasta sempre la possibilità di creare l’applicazione con interfaccia testuale;

- La novità è stata quella di avere un ambiente di disegno per costruire le form similari a quelle del Visual Basic 6.0

- Un compilatore per distribuire l’eseguibile dell’applicazione. Nelle varie versioni di VB che si sono succedute, la tecnica di fondo di creazione dei programmi windows è stata quella ‘di trascinare e rilasciare gli oggetti grafici sul form’ “Si dice che l’applicazione Windows appare davanti ai nostri occhi mentre aggiungiamo gli oggetti dalla casella degli strumenti” In una tabella rappresentiamo l’evoluzione del vecchio Basic, riproducendo i vari ambienti di programmazione

Ambiente di programmazione GW-BASIC

Ambiente di programmazione QBASIC 4.5



Ambiente di programmazione Visual Basic 1.0

MICROSOFT VISUAL BASIC 6.0 – Versione oggetto del corso

Dall’interfaccia testuale all’interfaccia grafica stile Windows Ogni applicazione che realizziamo con Visual Basic presenterà le seguenti caratteristiche:

• Alto grado di interazione da parte dell’utente, grazie ai vari elementi grafici che formano gli oggetti della finestra attiva

• La meccanica di programmazione, ossia l’aggiunta di codice permette l’interazione dell’utente con l’interfaccia grafica creata: Svolgerà, attraverso il codice sorgente una serie di compiti (o comportamenti) per la quale è stata progettata l’applicazione.



• Il codice sorgente verrà attivato in base ad una serie di eventi scatenati dall’utente ,attraverso sempre l’interfaccia grafica

Costruire una GUI (Graphic User Interface) non efficiente e corretta, comporterà un non apprezzamento del programma da parte dell’utente finale e il programmatore sarà tempestato di telefonate. L’efficienza sottolinea anche l’uso di corrette procedure di progettazione, codifica e manutenzione dello stesso, in modo che in uno spazio temporale ampio, sia possibile modellare la stessa interfaccia grafica con quel che l’utente desidererà svolgere al passo con i tempi. Prima dell’era della telefonia mobile un programma gestionale contatti, non prevedeva la diversificazione di contatti con telefonia fissa e quelli con telefonia mobile. Se tale gestionale fosse stato creato, prima di tale avvento, con una GUI non efficiente e corretta, i tempi di adeguamento dell’applicazione al Know-How tecnologico sarebbero abbastanza lunghi e l’utente finale si farebbe realizzare l’applicazione da un’azienda concorrente. Concetto di evento Nel paragrafo precedente è stato detto che un programma Visual Basic consiste nell’interfaccia visiva, con sopra localizzati controlli. All’atto di esecuzione del programma l’utente interagirà con la Gui. Questo in quale modalità? A tal proposito il programmatore svilupperà porzioni di codice da associare a ciascun controllo; diamo così la definizione di evento. Un evento è un’attività che avviene durante l’esecuzione di un programma, e tutti i programmi windows rispondono a degli eventi. Basti pensare, quando con il clic del mouse, sul pulsante Start, viene visualizzato il menu di avvio di tutti i programmi. L’azione ‘Visualizza menu di avvio’ è associata al clic dello strumento di puntamento o all’associazione di tasti di scelta rapida Cltrl+Escape. Quando parleremo di Visual Basic avanzato, faremo riferimento al trucco che ci permetterà di visualizzare il menu di Start di Windows via codice. Ad esempio se apriamo l’applicazione Notepad e selezioniamo Apri dal menu file, si apre una finestra di dialogo.



Domanda: Con quale libreria possiamo visualizzare la finestra di dialogo Apri comune a tutti i programmi Windows? A tale domanda risponderemo durante il prosieguo delle lezioni successive.



LLee bbaassii ddeellllaa pprrooggrraammmmaazziioonnee

Concetto di variabile e costante e tipi di dati Si definisce variabile, un luogo di memorizzazione temporanea per i dati del programma. Può contenere parole, numeri, date. In Visual Basic esiste una variabile di tipo oggetto che espone proprietà, metodi, eventi. Al concetto di variabile è legato il tipo di dato da memorizzare. Come il vecchio Basic, esiste l’istruzione Dim (che significa dimensione). Questa istruzione riserva lo spazio di memoria per la variabile quando si esegue un programma e permette a Visual Basic di sapere che tipo di dati vedrà in seguito. Implicitamente si parla anche di dichiarazione obbligatoria delle variabili: consiste nell’imporre a Visual Basic di generare errore quando, per errori di digitazione del nome, si vuole creare una variabile non dichiarata Esempio: Se con l’istruzione Dim creiamo la variabile numero e vi associamo un tipo di dato (ad esempio intero – o integer), e poi durante la digitazione del codice di programma sbagliamo a scrivere il nome della variabile (anziché numero scriviamo numeri), se è indicata la clausola Option Explicit, Visual Basic genererà un errore Nella cartella filmati esiste un filmato avi ‘OptionExplicit.avi’ che filmerà quanto detto a parole La dichiarazione obbligatoria delle variabili permetterà di razionalizzare lo spazio di memoria Ram. Esempio: Se non usassimo tale clausola, le variabili che Visual Basic creerà, potranno essere infinite, ovvero: Numero (è la variabile dichiarata con l’istruzione Dim) Gli errori di digitazione del nome della variabile comporterebbero la creazione di altre variabili, che però non saranno tipizzate (ossia non sarà assegnato loro



un tipo di dati da memorizzare). Le variabili non tipizzate, cioè di tipo Varìant, occuperanno più spazio di memoria. Un programma può contenere delle variabili che memorizzano valori che non cambiano mai. Il loro uso è similare alle variabili, ma non si può ovviamente modificare il suo valore in fase di esecuzione. Stiamo parlando di costanti Nella cartella filmati abbiamo costanti.avi, che vi spiegherà passo passo la dichiarazione di costanti e l’errore generato nel caso si desidera modificare tale valore durante l’esecuzione di un programma. Nella riproduzione del filmato costanti.avi, se si ha la necessità di modificare un valore di una variabile costante, occorre creare una variabile ordinaria dello stesso tipo della costante, e con un’istruzione di assegnazione procedere alla modifica:

Option Explicit Const numero as Integer=46 Sub Main Dim dato as Integer dato=numero dato=dato+67 msgbox(“valore di numero costante:” & numero) msgbox(“valore di numero modificato:” & dato) End Sub

Codice per modificare il valore di una costante dichiarata

Ciò che genererà un errore a livello di compilazione, è l’istruzione di assegnazione numero=numero+78 Concludiamo il paragrafo con la riproduzione di una tabella, nella quale rappresentiamo i vari tipi di dati ammessi da Visual Basic nella dichiarazione delle variabili o costanti

Tipo di dato Esempio di dichiarazione

Range valori Spazio occupato

Integer (Intero)

Dim numero as Integer

Da -32768 a 32767 2 byte

Long Dim numero as Long

Da -2.147.483.648 a 2.147.483.6477 4 byte

Single Dim numero as Single

Da -3,402823E38 a -1,401298E-45 per valori negativi; da 1,401298E-45 a 3,402823E38 per valori positivi

4 byte



Double Dim numero as Double

Da -1,79769313486232E308 a -4,94065645841247E-324 per valori negativi; da 4,94065645841247E-324 a 1,79769313486232E308 per valori positivi.

8 byte

Decimal Dim numero as Decimal

+/-79.228.162.514.264.337.593.543.950.335 senza virgola; +/-7,9228162514264337593543950335 con 28 decimali; il numero minore diverso da zero è +/-0,0000000000000000000000000001

14 byte

Date Dim compleanno as Date

Dall'1 gennaio 100 al 31 dicembre 9999 8 byte

Object Dim frm as Object

Qualsiasi riferimento Object 4 byte

String (Lunghezza Variabile)

Dim cognome as String

Da 0 a circa 2 miliardi 10 byte+ lunghezza della stringa

String (Lunghezza Fissa)

Dim cognome as String

Da 1 a circa 65.400 Lunghezza stringa

Variant (con numeri)

Dim datonum Qualsiasi valore numerico fino all'intervallo di un Double

16 byte

Variant (con caratteri)

Dim datocarattere

Stesso intervallo di String a lunghezza variabile 22 Byte+lunghezza carattere

Definito dall’utente utilizzando type

Type arch Cognome as string*20 Nome as string*20 End type Dim dato as Arch

L'intervallo di ciascun elemento è identico a quello del relativo tipo di dati sopraelencato.

Numero richiesto degli elementi

Boolean Dim flag as Boolean

True o False 2 byte

Byte Dim dato as Byte

Da 0 a 255 1 byte

Array, matrici e array di controllo Chi è veterano di programmazione conosce già il concetto di Array. Chi invece no, deve sapere che sono gruppi di dati con le seguenti caratteristiche:

• questi dati sono ordinati • e ogni dato che lo precede e lo succede è omogeneo

Esempio:



Se abbiamo n temperature rilevate in un certo momento, è sconsigliato creare n variabili ordinarie (ad esempio di tipo intero), ma utilizzeremo allo scopo un array (volgarmente detto vettore).

• Gli elementi omogenei sono le n temperature, • l’ordinamento di questi dati può essere alfabetico per dati alfanumerici

(ossia stringhe e numeri) o numerico (ordine crescente o descrescente) Nell’esempio, essendo le temperature grandezze numeriche, l’ordinamento è di tipo crescente (dalla temperatura più bassa rilevata in una certa città alla temperatura più alta) Queste strutture di dati possono essere monodimensionali (e vengono chiamati, come già precisato, vettori), bidimensionali (e vengono chiamati matrici, tipo quelle che si studiano in matematica), e così via fino ad arrivare ad un massimo di 60 dimensioni Come si dichiara, in modo semplice, un array in Visual Basic? A livello di modulo si ha: Dim nomi(20) as String Con questa semplice dichiarazione , si creano array di tipo statico. L’uso degli array statici comporta al programmatore il problema che non è possibile modificare la sua dimensione in fase di esecuzione dell’applicazione (c.d. operazione di ridimensionamento). L’operazione di ridimensionamento è possibile soltanto se si creano array dinamici. Essi sono sempre strutture di dati ordinate e omogenee, per le quali è possibile cambiare la dimensione (numero di elementi memorizzabili) in fase di esecuzione. I programmatori li utilizzano anche nelle applicazioni, per le quali non si conosce, con esattezza quanti elementi la struttura dell’array deve memorizzare. (possono essere 10 elementi, 20 elementi, ecc ecc). L’array dinamico si crea sempre con l’istruzione dim, e la riga di codice precedente diventa Dim nomi() As String Il ridimensionamento può avvenire in una o più parti dell’applicazione. Si utilizza a tale scopo l’istruzione redim. Esempio: Redim nomi(100) As String



Quando si crea un’array statico, si nota durante la stesura del codice, ciò che osservate nella figura in basso:

Se non si specifica l’indice inferiore dell’array, Visual Basic presume che sia 0, a meno che non si utilizzi un’istruzione Option Base 1 all’inizio di ogni modulo.

Nella creazione degli array dinamici, si può specificare l’indice inferiore, quando si utilizza l’istruzione redim Redim nomi (1 to 20) As String L’indice inferiore dell’array viene fissato a uno e l’istruzione di assegnazione Nomi(0)=”Giorgio” genera a run-time l’errore 9 ‘Subscript out of range’, in quanto l’indice inferiore è stato fissato a 1, e non più a zero. Tale errore viene generato anche quando si supera l’indice superiore dell’array o della matrice. Diciamo qualcosa sulla matrice dei controlli (ossia degli oggetti definiti sul form che hanno tutti la stessa proprietà Name). Se su un form avessimo un oggetto etichetta che ha la proprietà Name lbletichetta Per creare un’array di controlli, basta aggiungere un’altra etichetta e assegnarli la stessa proprietà name. Visual Basic in questa situazione ci propone l’alert



Rispondendo si alla domanda di voler creare un’array di controllo, tutti i controlli con la stessa proprietà Name (ossia oggetti etichetta) verranno indicizzati (partendo con l’indice inferiore 0) Per accedere alle sue proprietà caratteristiche si utilizzerà la proprietà name base Lbletichetta(indice).nomeproprietà Per assegnare un valore alle sue proprietà Lbletichetta(indice).nomeproprietà=<valore> Cicli e strutture decisionali Capita sovente di dover eseguire un gruppo di istruzioni un numero imprecisato di volte, un numero di volte conosciuto a priori prima di iniziare ad eseguire il loop (classico ciclo for). Partiamo con un esempio Sub Main Dim inizio as Integer Dim fine as Integer Fine=10 For inizio=1 to fine Msgbox(“Ciao Francesco” & “ “ & inizio & “ “ & “volta”) Next inizio End Sub

……….



Il ciclo For viene utilizzato ogni qual volta si conosce a priori il numero di volte che un gruppo di istruzioni devono essere ciclate. La variabile inizio stabilisce la posizione iniziale dalla quale partire; La variabile fine invece il numero di volte in cui il loop delle istruzioni comprese deve essere eseguito Consideriamo il caso in cui non conosciamo in modo preciso il numero di volte in cui il loop delle istruzioni comprese debba essere eseguito. Il ciclo for non può essere la struttura iterativa da utilizzare in quanto non conosciamo il valore della variabile fine. Visual Basic mette a disposizione degli sviluppatori altre due strutture iterative con le sue varianti: While Condizione Istruzione 1 Istruzione 2 Istruzione 3 …. Istruzione k …. Istruzione n Wend Do Istruzione 1 Istruzione 2 Istruzione 3 …. Istruzione k …. Istruzione n Loop until condizione Do while condizione Istruzione 1 Istruzione 2 Istruzione 3 … Istruzione k … Istruzione n Loop Do Istruzione 1 Istruzione 2 Istruzione 3 …



Istruzione k … Istruzione n Loop while condizione La struttura iterativa While condizione ….. Wend e la struttura Do while condizione …. Loop sono simili: Il funzionamento è il seguente: Le istruzioni comprese nel ciclo vengono eseguite finché la condizione è True (vera). Si dice anche che è “una struttura iterativa che cicla per vero” In altre parole se la condizione impostata all’inizio del ciclo risultasse già falsa, le istruzioni comprese non verranno eseguite neanche una volta. L’esempio classico è dato dal seguente problema: Dati dei numeri eseguire la loro somma. Tra i dati di ingresso non viene fornita l’informazione di quanti numeri il problema ha bisogno per calcolarne la somma. La struttura iterativa For..Next non può essere utilizzata. Però la struttura iterativa While… Wend o Do while condizione ….. Loop possono essere utilizzate in maniera indifferente. Basta impostare opportunamente la condizione (c.d. espressione booleana)(1), altrimenti si rischia di creare un loop senza uscita che farebbe bloccare l’applicazione (1) L’espressione booleana è un’espressione che assume due valori vero (True) o Falso (False) è può essere qualsiasi espressione numerica A=20 A<=20 A>=20 A>0 A<0 Sono tutte espressioni, e se ne possono impostarne delle altre a seconda dell’applicazione che si sta realizzando, ma restituiscono solo un valore vero o falso. Per il problema formulato in neretto (c.d. esempio classico) la condizione da impostare è la seguente ….. Scelta=”S” While scelta=”S” Istruzione 1 Istruzione 2 Istruzione 3 … Istruzione k … Istruzione n Wend Il codice Visual Basic è il seguente



Sub Main() Dim scelta As String Dim cts As Integer Dim numero As Integer scelta = "S" While scelta = "S" numero = InputBox("Inserisci un numero:") cts = cts + numero scelta = InputBox("Vuoi continuare S/N:") Wend MsgBox ("somma:" & cts) End Sub Poi esiste la struttura iterativa Do….. Loop Until condizione. Questa struttura iterativa ha la condizione impostata alla fine. Almeno una volta il loop delle istruzioni viene eseguito. Si dice anche che questa struttura iterativa cicla per falso. Finchè la condizione risulta falsa, le istruzioni comprese vengono eseguite, altrimenti termina il ciclo Dello stesso problema forniamo il codice Visual Basic, applicando tale struttura iterativa Sub Main() Dim scelta As String Dim cts As Integer Dim numero As Integer Do numero = InputBox("Inserisci un numero:") cts = cts + numero scelta = InputBox("Vuoi continuare S/N:") Loop Until scelta = "N" End Sub Al problema formulato per l’applicazione della struttura iterativa For…Next può essere adatta anche una di queste altre strutture iterative.. Ad esempio Do while condizione…… Loop Sub Main() Dim ct as integer Do while ct<=10 ct=ct+1 Msgbox(“Ciao Francesco” & “ “ & ct & “ “ & “volta”) Loop End Sub Le strutture di controllo che permettono al programma di effettuare delle scelte sono dette ‘Strutture decisionali’ e annoveriamo:



• If…Then… Else (o scelta a due vie). Se è vera l’espressione impostata

viene eseguito un blocco di istruzioni, altrimenti il blocco impostato dopo la clausola Else

• Select case (detta anche struttura decisionale multipla) Problema classico: Realizziamo in modulo standard di Visual Basic un menu di voci e applichiamo indifferentemente la prima struttura di controllo decisionale o la seconda (detta struttura decisionale multipla). La struttura di controllo Select Case può essere sviluppata con una serie di If .. Then… Else



SSttrruuttttuurraa ddii uunn pprrooggeettttoo VVBB

Tipologie di applicazioni creabili con Visual Basic 6.0 Un progetto Visual Basic è costituito da un’insieme di file, costituenti nella globalità l’applicazione stessa. Possiamo avere:

• Uno o più file contenenti codice (c.d. moduli standard) o definizioni di proprietà, metodi personalizzati per creare nuovi oggetti (c.d. moduli di classe)

• Uno o più file detti moduli di form (ossia moduli contenenti la descrizione dell’interfaccia grafica dell’applicazione, ovvero i controlli localizzati sopra i form, gli eventi associati) Possono contenere anche dichiarazioni di variabili, costanti, tipi di dati personalizzati, routine esterne)

• Altri file, che possono essere aggiunti al progetto dipendono dalla versione di Visual Basic (Enterprise o Professional) tipo creazione di documenti Activex o Controlli utente con la relativa finestra di progettazione. A questi file corrisponderà un’estensione diversa.

Per i moduli standard è stata associata, per compatibilità con il vecchio Basic, l’estensione Bas; per i moduli di classe l’estensione cls; per i moduli di form hanno estensione frm. Altre estensioni di file aggiungibili ad un progetto di VB possono essere Dsr (per i Data report e i Data Environment); il codice relativo ad una finestra di progettazione Activex e controllo utente è memorizzato in un file con estensione ctl; Si può aggiungere infine un file con estensione res (detto file di risorse). In questo file vengono memorizzate informazioni relative a stringhe, dati, e il motivo della loro aggiunta ad un progetto VB sta nel fatto di aumentare le prestazioni di esecuzione dell’applicazione, invece di caricare tutte le risorse assieme al caricamento dei form.



Infatti è possibile creare un menu in italiano e poi a seconda delle altre lingue tali voci di menu cambiano in base alla lingua scelta e tali informazioni possono essere riprese dal file risorse. All’avvio di Visual Basic viene avviato il Project Template, ossia una finestra di dialogo dove vengono riportate tutte le tipologie di applicazioni realizzabili. Esse variano con la versione installata sul proprio Personal Computer. Presentiamo nella figura qui sotto il Project Template di Visual Basic 6.0 versione Enterprise:

TIPOLOGIE DI APPLICAZIONI REALIZZABILI Abbiamo: Standard-Exe Crea un file eseguibile e l’applicazione può essere eseguita fuori dall’ambiente di sviluppo; Ovviamente sul pc dove viene distribuita l’applicazione occorre che siano correttamente installate le librerie utilizzate, come quelle di Visual Basic run time 6.0 (scaricabili da internet o installabili con Microsoft Office). L’installazione delle librerie utilizzate nel progetto può essere effettuata quando si lancia il setup creato con il pakage di installazione (utilità estremamente importante per la distribuzione delle applicazioni in VB6); ActiveX Control Si realizza un controllo utente personalizzato e quando viene compilato può essere utilizzato in tutte le applicazioni che supportino tale tecnologia (esempio Access, Word, Excel,pagina Web, e altri ambienti di sviluppo diversi da Microsoft); Diverse creazioni guidate per realizzare tipologie di applicazioni professionali; Tipologie di applicazioni per Internet (Dhtml Application e IIS Application); ActiveX Dll Si realizzeranno librerie di collegamento dinamico, esportabili in diverse applicazioni (tipo Office e le stesse applicazioni realizzate in Visual Basic).



Nel prosieguo delle lezioni daremo cenni sugli ActiveX Document Dll e ActiveX Document Exe e qualcosa sull’architettura di una IIS Application (ossia un’applicazione in linguaggio Active Server Page con Visual Basic integrato, eseguibile in Internet Information Service (componente di windows 2000,xp professional, 2003 server). Un’applicazione Dhtml è la combinazione di Html dinamico con codice visual basic compilato. Si crea quindi un’applicazione molto interattiva basata sul browser Web e valorizzata sul computer client che ha installato Microsoft Internet Explorer. Il Project Explorer (o struttura del progetto VB6)

Quando noi dal Project template, clicchiamo sull’icona Standard-Exe , allora nella finestra Project Explorer (o Esplora progetto), abbiamo:

Con lo short-cut Ctrl+R, viene attivata la finestra Esplora Progetto Dalla figura rappresentata, notiamo il nome di default di progetto (Project1) e la creazione automatica dell’oggetto Form (il cui nome di default è Form1) Se dovessimo cliccare con il tasto destro del mouse sul nome del progetto, dal menu contestuale che appare possiamo aggiungere un nuovo oggetto (vedi figura)



Osservazione: Non tutti questi oggetti saranno discussi nel prosieguo del corso, ma soltanto l’oggetto Form, Mdi Form, Module, Class Module, User Control, Data Report, DataEnvironment. Si può anche aggiungere un oggetto già disponibile sul supporto di memoria di massa (cliccando sulla voce Aggiungi file…, si aprirà una finestra di dialogo per mezzo della quale selezionare il file, esplorando il file system)

Dalla lista di riepilogo, Cerca in, è possibile selezionare il percorso di memorizzazione dell’oggetto da aggiungere; mentre nella lista di riepilogo Tipo file è possibile notare l’elenco delle estensioni di file generati con l’ambiente di sviluppo. Poi abbiamo un pulsante per ritornare al livello superiore della cartella corrente, e un pulsante per creare una nuova cartella I form, i moduli standard, i moduli di classe L’oggetto Form risulta essere elemento chiave di un’applicazione VB; non a caso, quando si crea un’applicazione Windows, appare per impostazione predefinita, nella finestra di esplorazione progetto che abbiamo rappresentato nel paragrafo precedente.

Oggetto principale di un’applicazione Windows Il form (finestra dell’applicazione) e i controlli che possono essere trascinati hanno la caratteristica di essere oggetti, e per questo motivo espongono una



serie di attributi (o proprietà), reagiscono a dei metodi, e provocano degli eventi. A questo oggetto principale, possono essere aggiunti oggetti dello stesso tipo (ossia altri form, o form già creati e salvati con l’estensione frm), oppure altri elementi come: I moduli standard (ossia file con estensione bas). Un modulo standard rappresenta l’area di codice dove vengono dichiarate le variabili, costanti, le funzioni (o function) e le routine (o subroutine) Oltre ai moduli standard possono essere aggiunti i c.d. moduli di classe (o file con estensione cls). Nell’area di codice che appare scriveremo le dichiarazioni di variabili, costanti, funzioni e routine, che assieme implementeranno la creazione e gestione di un oggetto personalizzato con una serie di proprietà, metodi, ed eventi

La finestra di Esplorazione Progetto (Project Explorer) e i tre oggetti base (form, modulo standard, modulo di classe)

La mia applicazione in Visual Basic Alterniamo, alla lettura delle prime tre lezioni del corso, un esempio classico per avviarvi a progettare un’interfaccia grafica molto semplice:

• con un casella di testo • con un’etichetta con un valore già preimpostato; • con un pulsante di comando

Nella cartella esempi trovate un file zippato applicsaluto.zip nel quale trovate il file di progetto, l’applicazione Stand-alone (eseguibile fuori dall’ambiente di sviluppo di VB6), l’interfaccia grafica dell’applicazione (frmsaluto.frm). Gli unici commenti che dobbiamo fare sono: Nella finestra proprietà del form imposteremo la proprietà Caption “Applicazione saluto”



La form in figura, prima di impostare le proprietà

• MDICHILD • MaxButton • MinButton

al valore False, aveva i tre pulsanti classici di una finestra Windows: Primo pulsante Riduci ad Icona Secondo pulsante Con un clic si visualizza a tutto schermo la form; Con un successivo clic si visualizza a forma normale la form. Adesso in figura ha un solo pulsante per chiudere la finestra e di conseguenza l’applicazione che si sta eseguendo. Abbiamo impostato la proprietà Caption per denominare la barra del titolo della Form. – In questa fattispecie si chiama ‘Applicazione saluto’



In quest’ultima figura abbiamo sintetizzato l’interfaccia grafica finale che dovrà avere l’applicazione, prima di essere eseguita. Il pulsante di comando preso dalla casetta degli attrezzi (c.d. Toolbox) ha una proprietà che si chiama Caption. Impostando tale proprietà appare, come in figura una scritta sul pulsante che rappresenta la funzione che dovrà svolgere Visual Basic all’evento OnClick Per scrivere la scritta [Ciao + il contenuto della casella di testo, che immetterà l’utente all’esecuzione dell’applicazione], si scriveranno le seguenti righe di codice



Per attivare la finestra di codice per configurare l’evento OnClick sul pulsante, basta fare doppio clic sull’oggetto pulsante sulla Form.

Lblsaluto, come txtsaluto rappresentano la proprietà Name. E’ una proprietà che restituisce il nome usato per identificare l’oggetto all’interno dell’applicazione. E’ utile durante la stesura del codice per accedere con la Dot Notation (o Notazione punto) alle proprietà da cambiare in fase di run-time (o esecuzione) dell’applicazione

OSSERVAZIONE L’accorgimento per far eseguire il codice associato all’evento OnClick del pulsante, mediante scorciatoia della tastiera, è l’impostazione della proprietà Caption, in questo modo, dalla relativa finestra delle proprietà dell’oggetto: &Saluto La scritta sul pulsante di comando sarà Saluto All’esecuzione dell’applicaziome, dopo aver digitato nella casella di testo il nome e cognome, apparirà (con Alt+S) il testo ‘Ciao Spalluzzi Francesco’ nell’oggetto etichetta (Lblsaluto) Per eseguire da tastiera detto codice basta premere contemporaneamente Alt+l’iniziale della scritta del pulsante (in questo caso la S maiuscola)



Per eseguire l’applicazione dall’ambiente di sviluppo, basta premere il tasto di funzione F5 direttamente dalla tastiera del Pc

Applicazione saluto in fase di esecuzione Nella cartella filmati troverete un file Avi che vi guiderà a creare l’esercizio commentato in quest’ultimo paragrafo della terza lezione del corso ‘prima applicazione VB6.avi’



CCrreeaazziioonnee ddii uunnaa ffoorrmm

I form e i controlli intrinseci disposti sulla Toolbox (o casella degli strumenti) Apriamo il paragrafo con l’osservazione della seguente immagine:

E’ un form dove disporre i vari controlli richiesti dall’applicazione. Questi controlli vengono presi della Cassetta degli attrezzi (o Toolbox)

Osservazione: Un’applicazione in Visual Basic 6, contenente soltanto i controlli presi dalla ToolBox, funziona correttamente solo con il file di run-time MSVBVM60.DLL. Ha bisogno di poca memoria per essere eseguita, a differenza di applicazioni contenente controlli di terze parti, le quali per funzionare hanno bisogni di moduli OCX (o ActiveX) aggiuntivi e come tale richiedono più memoria. Un’applicazione realizzata soltanto con i controlli presi dalla ToolBox è facilmente portabile da un Personal Computer a un altro, per il semplice fatto che richiede solo quella dll, scritta in rosso.



Ogni controllo intrinseco che vedete nella ToolBox, per essere portato su una form, richiede una procedura, che io divido in due tempi:

• Selezionare il controllo da portare su una form • Con il puntatore del mouse sul form, attraverso la tecnica di

trascinamento, disegniamo il controllo stesso, definendone l’altezza, la larghezza e la posizione

Nella cartella filmati esiste un file.avi che si chiama Disegnacontrollo.avi. Vi spiega passo passo la tecnica di disegno dei controlli intrinseci La proprietà di un controllo che definisce l’altezza prende il nome di Height La proprietà di un controllo che definisce la larghezza prende il nome di Width Le proprietà un controllo che definiscono la posizione sul form sono due: Left e Top



Tali proprietà sono espresse in un’unità di misura predefinita di Visual Basic: ossia in twip (centimetro logico) Proprietà comuni dei vari controlli Sebbene tutti i controlli intrinseci siano diversi per le funzioni che assolvono durante l’esecuzione dell’applicazione, presentano una serie di proprietà comuni:

Controlli Proprietà Comuni Label PictureBox TextBox Frame CommandButton Checkbox OptionButton ComboBox(*) ListBox HScrollBar VScrollBar Timer DriveListBox DirListBox FileListBox Shape Line Image Data Ole

Left,Top, Width,Height ForeColor,BackColor Caption e Text Parent e Container ENABLED VISIBLE hWnd Tabstop TabIndex MousePointer MouseIcon TAG INDEX,Appareance, Align,BorderStyle,ToolTip

(*) Non necessariamente tutti i controlli elencati supportino tutte e 4 le proprietà comuni di prima fascia (Left,Top,Width,Height). L’esempio classico è quello della casella Combinata (o ComboBox), la cui proprietà Height può essere letta, ma non modificata in fase di esecuzione dell’applicazione. L’altezza dipende dagli attributi dei caratteri del controllo L’altra osservazione da sollevare è che ci sono controlli intrinseci invisibili in fase di esecuzione (come Timer), che sebbene in fase di progettazione supportino quelle 4 proprietà comuni, non sono supportate in fase di esecuzione (ovvero non possono essere lette o modificate da programma) Le proprietà ForeColor e BackColor influenzano rispettivamente il colore del testo e il colore di sfondo



La maggior parte degli oggetti visibili (tra quelli elencati nella precedente tabella) supportano entrambe le proprietà. Le osservazioni anche qui non mancano:

• I colori di alcuni controlli, ad esempio delle barre di scorrimento sono dettati direttamente dalle impostazioni di sistema operativo, e come tale le proprietà ForeColor e Backcolor non li troverete nella finestra delle proprietà

• In altri gli effetti di queste due proprietà dipendono da altre proprietà dei controlli stessi: si fa l’esempio del controllo etichetta e del Controllo Pulsante di Comando

Il controllo Etichetta ha una proprietà che si chiama BackStyle. Se impostata a zero(Trasparent), non ha effetto la proprietà BackColor I controlli CommandButton espongono una proprietà BackColor, ma non una proprietà ForeColor. Il colore si sfondo è attivo solo se la proprietà Style è impostata a 1(Graphical) In un’appendice di questo corso torneremo a discutere di queste proprietà che accomunano i vari controlli intrinseci. Creazione dinamica di un controllo La creazione dinamica di un controllo (sempre intrinseco) può essere raggiunta secondo due modalità: La prima modalità l’approfondiremo nel corso delle lezioni successive (trattando approfonditamente gli array di controlli) L’oggetto Form espone un’insieme (detto collection) di nome Controls. Con la Versione 6 del linguaggio Visual Basic, questa collection è stata arricchita del Metodo Add. E’ proprio attraverso questo metodo che si creano dinamicamente controlli in fase di esecuzione. La riga di codice è la seguente Set newobj=Controls.Add(ProgId, Name [,Container]) ProgId è il nome di classe del controllo Name è il nome che desiderate assegnare al controllo (esso deve essere univoco, altrimenti viene generato l’errore 727) Container è un riferimento opzionale (ecco perché inserito tra parentesi quadre) I due controlli intrinseci contenitore sono PictureBox o Frame. Se viene omesso tale riferimento, i controlli creati dinamicamente occuperanno la superficie del form.



NewObj è una variabile oggetto, come spiegato nella lezione 2 sulle basi della programmazione. Gli eventi associati ai controlli intrinseci Gli eventi che possono essere associati ai controlli intrinseci li vediamo nella finestra di codice, in questo modo:

1) Posizioniamo il controllo Etichetta sul form 2) Poi con il tasto destro del mouse sul controllo aggiunto, selezioniamo la

voce Codice Ecco una finestra dalla quale scorreranno tutti i possibili eventi registrati per quel controllo

Dalla prima lista di riepilogo scegliamo il nome del controllo aggiunto, dall’altra dove adesso c’è scritto Declarations, saranno pronti tutti gli eventi associati a quel controllo.

Elenco dei possibili eventi Esempio: Creiamo un form con un controllo etichetta e associando l’evento OnClick a quest’ultimo, definiamo il seguente comportamento: ‘Cambiare la



proprietà Caption e colorare il testo di rosso, aumentando di 15 la dimensione del carattere

Il form con il controllo Etichetta aggiunto

Il comportamento o l’evento OnClick associato è dettato dalle seguenti righe di codice:

Righe di codice associate all’evento OnClick

Cliccando con il mouse sulla scritta Ciao, apparirà in modo grafico, ciò che è stato scritto sotto forma codice. Il clic del mouse genera l’evento OnClick

associato all’oggetto Label (etichetta)



GGeessttiirree ggllii aarrrraayy ddii rreeccoorrdd ccoonn VVBB66

Creare una struttura definita dall’utente Nelle prime lezioni abbiamo trattato l’argomento dei tipi di dati che Visual Basic mette a disposizione quando dichiariamo le variabili Possiamo, attraverso questi tipi di dati, creare un nostro tipo di dati personalizzato. Ciò avviene con l’enunciato Type <nome struttura>….. End type. Tale enunciato è possibile dichiararlo a livello di modulo standard, modulo di classe, ma non a livello di form, altrimenti in quest’ultimo caso genera errore di compilazione Esempio: Creiamo una struttura dati composta dai seguenti elementi Type archivio Cognome As String*30 Nome As String*30 Indirizzo As String*30 End type Ricordiamo che questa operazione definisce un tipo, ma la variabile ancora non esiste. Va dichiarata con l’istruzione Dim Dimensionare dinamicamente un array di record Si definisce record una riga logica e completa di informazioni. Con l’istruzione Dim possiamo attraverso il tipo di dati definito con Type..End Type creare una struttura denominata Array di record Dim arrayrec(1..20) as Archivio Con questa riga di codice si dichiara in modo statico l’array di record, in quanto viene assegnata a priori la dimensione (ossia di quanti elementi è costituito)



Possiamo con Visual Basic 6.0 compiere un passo in avanti: dimensionare dinamicamente l’array , ossia non fornire, con l’istruzione Dim, il numero di elementi, ma poterlo fornire successivamente con l’istruzione Redim Così avremo: Dim arrayrec() as Archivio ….. ….. Numelem=Inputbox(“Quanti elementi inserire:”) Redim arrayRec(Numelem) Grazie alla dimensione dinamica di un’array di record, non sprechiamo allocazioni di memoria non utilizzate N.b Se non si usa l’istruzione Redim, la struttura dati dichiarata con la variabile arrayrec non risulta disponibile per la memorizzazione dei dati. Gestire l’aggiornamento e la cancellazione di un elemento L’aggiornamento e la cancellazione di un elemento presuppone che già abbiamo già riempito l’array di record visto nei paragrafi precedenti. L’aggiornamento è un’operazione che comporta:

- la ricerca dell’elemento nella struttura dati definita - l’inserimento del nuovo elemento - l’assegnazione al posto del vecchio elemento quello nuovo

Nella struttura dell’array di record Type archivio Cognome As String Nome As String Città As String End type L’unico campo, che nella realtà, è suscettibile di modifiche è il campo città. Per trovare un elemento, all’interno di un array di record, occorre scrivere le seguenti righe di codice



Prima di far ciò descriviamo due funzioni importantissime di Visual Basic, che trovano applicazione per array o matrici Esse sono Lbound e Ubound Lbound restuisce l’indice inferiore dell’array o matrice. Può essere 0 se non è indicata la direttiva Option Base 1 Se invece è indicata tale direttiva Lbound restituisce 1 come indice inferiore Ubound invece restituisce l’indice superiore dell’array o della matrice (ossia il numero complessivo degli elementi) Option Explicit Option Base 1 Type archivio cognome As String nome As String city As String End Type Dim numelem As Integer Dim arrayrec() As archivio Sub main() Dim stringa As String Dim j As Integer Dim stringat As String Dim indice As Integer Dim modcity As String Dim citynew As String Dim MODIFICATO As String numelem = 5 'Assegnare dei valori all'array di record ReDim arrayrec(numelem) arrayrec(1).cognome = "Rossi" arrayrec(1).nome = "Marco" arrayrec(1).city = "Bari" arrayrec(2).cognome = "Rizzi" arrayrec(2).nome = "Marco" arrayrec(2).city = "Barletta" arrayrec(3).cognome = "Romino" arrayrec(3).nome = "Marco" arrayrec(3).city = "Giovinazzo" arrayrec(4).cognome = "Ricchiuti" arrayrec(4).nome = "Marco"



arrayrec(4).city = "Bari" arrayrec(5).cognome = "Retoldo" arrayrec(5).nome = "Luigi" arrayrec(5).city = "Trani" 'Procedere alla modifica della città For j = 1 To UBound(arrayrec) stringa = Str(j) & " " & arrayrec(j).cognome & vbCrLf stringat = stringat + stringa Next j stringat = "Elenco cognomi" & vbCrLf & stringat indice = InputBox(stringat) modcity = "Città da modificare per:" & arrayrec(indice).cognome & vbCrLf modcity = modcity & vbCrLf & "Città vecchia:" & arrayrec(indice).city & vbCrLf citynew = InputBox(modcity, "Nuova città") 'Modifica della città vecchia con la città nuova arrayrec(indice).city = citynew 'ARRAY MODIFCATO MODIFICATO = "COGNOME:" & arrayrec(indice).cognome & vbCrLf MODIFICATO = MODIFICATO & vbCrLf & "NOME:" & arrayrec(indice).nome & vbCrLf MODIFICATO = MODIFICATO & vbCrLf & "CITTA':" & arrayrec(indice).city MsgBox MODIFICATO, , "DATI MODIFICATI" End Sub Nell’esecuzione di questo codice viene solo descritto l’accesso all’array di record con indice uguale a quello che si vede nella finestra di dialogo msgbox Poi l’istruzione di modifica è in pratica un’operazione di assegnazione Arrayrec(indice).city=citynew L’operazione di cancellazione comporta la scrittura delle seguenti righe di codice Ammettiamo di scegliere dall’elenco dei dati codice cognome visualizzati nella finestra di dialogo un valore pari a indice arrayrec(indice).cognome=”” arrayrec(indice).nome=”” arrayrec(indice).city=”” ‘Visualizziamo nuovamente l’array di record



For j = 1 To UBound(arrayrec) Flag=false if indice=j then flag=true end if If flag=false stringa = Str(j) & " " & arrayrec(j).cognome & vbCrLf stringat = stringat + stringa end if Next j stringat = "Elenco cognomi" & vbCrLf & stringat MsgBox (stringat) Come potete verificare voi stessi, non avviene una redifinizione dell’indice, ma non viene praticamente visualizzato l’arrayrec(indice) con i campi cognome,nome,city nullo.



GGeessttiioonnee ggrraaffiiccaa ccoonn VViissuuaall BBaassiicc

Sui Controlli Immagine e PictureBox Entrambi i controlli svolgono il medesimo ruolo: Permettono di collocare su un form immagini recuperate da un file grafico. Supportano i seguenti tipi di file grafici:

• Bitmpap dall’estensione Bmp; • Puntatori (cursori) dall’estensione Cur; • File nel formato Graphics Interchange Format dall’estensione Gif; • Icone dall’estensione Ico; • File JPEG dall’estensione JPG o Jpeg; • Meta-file grafici dall’estensione WMF;

Una proprietà importante dei due controlli intrinseci di grafica è Picture. Dalla finestra di proprietà del controllo, è possibile fare doppio clic su tale proprietà, e selezionare. dal nostro Hard disk, uno dei tipi di file grafici elencati in precedenza, per caricarlo nel controllo. A run-time (ossia in modalità di esecuzione dell’applicazione) è possibile assegnare a tale proprietà il file grafico da caricare con la funzione LoadPicture. Tale funzione viene utilizzata anche per assegnare uno sfondo ad un form. Infatti una delle proprietà modificabili del form è proprio Picture. Anche in questo caso è di lettura e scrittura (ossia è possibile fare l’operazione di assegnazione con la funzione LoadPicture in modalità di esecuzione dell’applicazione). Una demo per comprenderne il concetto (nella sotto-cartella filmati della cartella vb6 c’è il filmato avi form_picture)



Viene settata la proprietà Picture dell’oggetto Form e si imposta uno sfondo con l’immagine realizzata con un qualsiasi programma di grafica.

Il controllo immagine ha due proprietà Width e Height. Prima di impostare tali proprietà è necessario assegnare il valore booleano True alla proprietà Stretch Questa proprietà permetterà di ridimensionare l’elemento grafico contenuto nel controllo immagine, allorquando si ridimensionerà quest’ultimo. Vediamo una demo per capire la funzione della proprietà Stretch del controllo Immagine. (Aprire il file avi Stretch_Picture nella sotto-cartella Filmati della cartella vb6) Impostando prima le dimensioni del controllo Image, senza aver impostato la proprietà Picture e impostando successivamente la proprietà Stretch al valore true, avverrà un ridimensionamento dell’elemento grafico alle dimensioni del controllo Image. Gli elementi differenziatori di questo controllo sono i seguenti:

• La casella Immagine (o Picturebox) è un controllo molto flessibile; la motivazione sta nella serie di metodi e proprietà che supporta rispetto al controllo Immagine;

• Il controllo Immagine è più efficiente e funziona al meglio nelle applicazioni che girano sui pc poco veloci.



Dato il fatto che attualmente i computer risultano molto veloci, sarà difficile verificare l’efficienza o meno tra i due controlli. A meno che si scrivano applicazioni per computer meno recenti, si consiglia di utilizzare il controllo casella Immagine per sfruttare la sua flessibilità. Sui controlli Linea e forma Oltre questi due controlli per caricare elementi grafici su un form, ne esistono altri due per disegnare: Essi sono i seguenti: Controllo Linea (o Line) e Controllo Forma (o shape) Una volta trascinato il Controllo linea, sul Form, dalla casella degli strumenti, si disegnano linee alla stessa maniera di utilizzare Macromedia Fireworks. Le sue proprietà caratteristiche sono: BorderStyle determina il formato della linea; Per impostazione predefinita, dalla finestra di proprietà, si osserva che è assegnata la costante 1-Solid BorderColor per colorare la linea BorderWidth per determinarne lo spessore della linea in punti (1/72 di pollice) X1,Y1,X2,Y2, proprietà queste che determinano le coordinate degli estremi del segmento. Due coordinate definiscono sul form un punto e un segmento è definito da due punti. Nella tabella seguente rappresentiamo le costanti che la proprietà BorderStyle può assumere

Costante Descrizione 1 – Solid Linea continua 2 – Dash Linea tratteggiata 3 – Dot Linea punteggiata 4 – Dash Dot Ogni trattino è seguito da un punto 5 – Dash – Dot Dot Ogni trattino è seguito da due punti

A differenza del controllo Linea che disegna soltanto linee, il controllo forma (o shape) supporta il disegno di figure geometriche diverse, a seconda della costante enumerativa assegnata alla proprietà shape. In questa tabella rappresentiamo quali sono le costanti enumerative della proprietà shape



Costante Descrizione 0 – Rectangle Rettangolo 1 – Square Quadrato 2 – Oval Disegna ellisse 3 – Circle Cerchio 4 – RoundRectangle Rettangolo con angoli smussati 5 – Rounded square Quadrato con angoli smussati

Realizziamo un applicazione che permette di scegliere da due liste di riepilogo la forma da disegnare e l’impostazione della proprietà FillStyle. La proprietà Fillstyle disegna il motivo interno della forma

Interfaccia grafica dell’applicazione da realizzare I controlli aggiunti sul form sono:

• Un controllo Line, opportunamente impostate delle proprietà deve venir uguale a quello che si vede in figura

• Una label con tale scritta (basta impostare la proprietà Capton) • Un’altra label con Forme da disegnare • Un’altra label con la proprietà Caption uguale a Forma • Un’altra label con la proprietà Caption uguale a Motivo • Due liste di riepilogo che memorizzano rispettivamente sia le forme da

disegnare che i motivi interni alla forma da applicare. • Un controllo shape (Controllo chiave dell’applicazione)

Due eventi OnClick sulle due liste di riepilogo Un’inizializzazione di tali liste avviene con l’evento Load associato all’oggetto Form Il metodo per caricare tali valori, che si vedono in figura, si chiama AddItem



Per applicare la forma al controllo shape basta scrivere la seguente riga di codice Form1.shape1.Fillstyle=List2.ListIndex La proprietà ListIndex dell’oggetto List2 restituisce la posizione dell’elemento, nella lista, selezionato con un clic sinistro del mouse Metodi grafici di VB6 Nel paragrafo precedente abbiamo visto due controlli che ci hanno permesso di disegnare linee e forme. Inoltre Visual Basic ci permette di disegnare anche con l’uso di metodi grafici. Questi metodi grafici li rappresentiamo in questa piccola tabella:

Metodo Pset Metodo Line Metodo Circle

Grazie a questi metodi, utilizzati con l’oggetto Form, si possono disegnare linee e forme senza l’uso di controlli in fase di esecuzione dell’applicazione Vediamo la sintassi dei vari metodi: Metodo Pset [nomeoggettoform].Pset [step] (intX,intY) [,colore] Il metodo Pset imposta un punto di un oggetto su un colore specificato. Il nome dell’oggetto può essere facoltativo; se viene omesso il metodo grafico agirà sull’oggetto form o casella immagine che ha lo stato attivo Lo stato attivo di un controllo, ad esempio di un form, è rappresentato dalla barra del titolo evidenziata



Attraverso le righe di codice associate all’evento OnClick del pulsante di comando sono riuscito a simulare lo stato attivo dell’oggetto Form. Private Sub Command1_Click() Dim obj As Form1 Set obj = New Form1 obj.Show End Sub Noterete in figura che il nuovo form ha il colore della barra del titolo più marcata; mentre la barra del titolo del primo Form ha un colore più pallido e ciò significa che non ha lo stato attivo, ma può essere dato, con un clic del mouse sulla barra, da parte dell’utente Ritornando al metodo Pset: Il pixel di coordinate 0,0 (rappresentato dai due parametri intX,intY) fa riferimento al pixel nel vertice superiore sinistro del form. Esempio: pset(100,100) attiva un pixel (ossia un punto) nelle coordinate intX=100 e intY=100 Vediamolo in figura

Dalla figura, Noterete un puntino (che è il pixel disegnato sull’oggetto form) con il metodo Pset Il colore del pixel disegnato è dato dal parametro ForeColor dell’oggetto Form o dell’oggetto casella immagine



Abbiamo impostato la proprietà ForeColor dell’oggetto Form al valore

esadecimale che rappresenta il colore rosso Disegnando adesso lo stesso pixel con il metodo Pset, prenderà il nuovo colore impostato con tale proprietà

Noterete in figura il pixel rosso disegnato con il metodo Pset Anche il metodo Pset ha il parametro Color. I valori che il parametro Color può assumere sono le costanti intrinseche di Visual Basic per i colori: Se invece si adotta lo stesso colore dello sfondo del form, il pixel disegnato viene disattivato



Costante Descrizione vbBlack Nero vbRed Rosso vbGreen Verde vbYellow Giallo vbBlue Blue vbMagenta Color Magenta vbWhite Bianco vbCyan Color Ciano

COSTANTI INTRINSECHE COLORI

E’ possibile disegnare con Pset utilizzando il ciclo for Esempio: for intX=1 to 40000 form1.pset (intx,250),vbRed next IntX

Risultato delle righe di codice Osservazione: Utilizzando il ciclo for si uniscono più pixel alla volta e si ottiene una linea del colore indicato dalla costante intrinseca (vedi tabella costanti colori) Questa osservazione introduce l’uso dell’altro metodo grafico dell’oggetto Form o del controllo Casella immagine), ossia il metodo Line Tale metodo disegna segmenti in modo più efficiente La sintassi è la seguente Nomeoggetto.Line (intX1,intY1) – (intX2,intY2),colore,[B] [F]



Il parametro B (che sta per box) disegna un rettangolo ; il parametro F(Fill) permette di riempire la figura disegnata dello stesso colore dei bordi Esempio: Disegnare un rettangolo di colore verde Il codice da scrivere è il seguente Private Sub Command1_Click() Dim X As Integer For X = 1 To 1000 Form1.Line (X, 100)-(X + 150, 450), vbGreen, BF Next X End Sub Il risultato:

Se omettessimo il parametro F, avremmo disegnato solo i bordi della figura geometrica, senza effettuare nessun riempimento di quest’ultima

Abbiamo disegnato un rettangolo senza effettuare il riempimento (omesso il parametro Fill). Il codice è il seguente: Private Sub Command1_Click() Form1.Line (100, 100)-(1000, 350), vbGreen, B End Sub Ci sono altri metodi grafici che disegnano anche forme curvilinee (ossia cerchi o ellissi)



Chi ha studiato geometria euclidea, conosce la definizione di ellisse. Si definisce ellisse un cerchio allungato, che forma un ovale.

orm o del controllo casella magine, a disegnare un ellisse

ri noi diamo per il fine di questo corso questa intassi:

cle [step] (intX,intY) sngraggio, [colore],,,,,sngaspetto

ità dell’ellisse tesso. Serve da moltiplicatore del raggio nelle due direzioni, verticale e

cle (1000,1250),600,,,,(4/10/2) (1) orm1.circle(2750,1250),600,,,,4 (2)

Proviamo, con il metodo Circle dell’oggetto Fim Il metodo circle ha molti paramets form1.Cir Il parametro sngaspetto definisce il c.d. rapporto di eccentricsorizzontale. Il rapporto di eccentricità è chiamato anche rapporto di aspetto. Un rapporto di aspetto 4, significa che l’asse verticale è 4 volte quello orizzontale. Un rapporto di 0,2 significa che l’ellisse è 5 volte più larga che alta. Form1.cirF

La prima ellisse (1) è quella disegnata in orizzontale

il raggio.

za di un punto ualsiasi della circonferenza dal centro che ha coordinate intX, intY

(1000,1000),600,vbred disegnerà un cerchio con i bordi ossi. Se volessimo disegnare anche il riempimento è la proprietà

La seconda ellisse (2) è quella disegnata in verticale Adesso proviamo a disegnare una circonferenza dato Sempre dalla geometria euclidea, si definisce raggio la distanq L’enunciato Form1.circlerBackcolor dell’oggetto form a determinarla. Basta però che non si imposti tale proprietà con lo stesso valore della costante Color del metodo Circle.



a proprietà DrawWidth dlel’oggetto Form determina lo spessore dei bordi del

e il parametro sngaspetto ha un valore inferiore all’unità, il

ontrolli per aggiungere suoni, filmati o animazioni Flash

Lcerchio disegnato Scircolo(ellisse) disegnato si allungherà orizzontalmente; se è maggiore dell’unità, l’allungamento sarà verticale; se è uguale a uno si disegnerà un circolo perfetto (ottenendo una circonferenza) C Visual basic è un linguaggio di programmazione visuale che non crea solo

controlli per ascoltare file musicali è

• Windows Media Player ntrollo 6.0

o progettato un’interfaccia grafica per avere un lettore Cd realizzato con il

applicazioni aziendali o dette anche in gergo ‘gestionali’, ma anche applicazioni carine di intrattenimento, tipo l’interfaccia per ascoltare un brano musicale in formato wav, mp3,cda, un filmato avi, e grazie anche al Flash Player di Macromedia, il controllo, da Visual Basic, di un’animazione compilata in swf I

• Microsoft Multimedia Co

Hlinguaggio di programmazione Visual Basic



Interfaccia grafica per realizzare un lettore Cd Sul form esistono i seguenti controlli: 3 etichette per visualizzare rispettivamente le scritte - Lettore cd - Lista tracce audio - Unità lettore cd (nome assegnato logicamente dal sistema operativo es d, e, f) 1 casella di testo per inserire il nome del drive (lettore cd) dove è stato inserito il cd audio per l’ascolto Una casella di riepilogo per gestire che traccia audio si desidera ascoltare 1 pulsante di comando per aggiungere tracce 1 pulsante di comando per chiudere l’ascolto della traccia corrente e deselezionare il nome della traccia all’interno della casella di riepilogo Questa interfaccia grafica consta del seguente codice:



CODICE PER GESTIRE L’APPLICAZIONE Gli eventi sono stati associati ai due pulsanti di comando

• cmd_aggtracce (nome del pulsante di comando con etichetta Aggiungi tracce) • cmd_scaricatraccie (nome del pulsante di comando con etichetta Chiudi)

E’ stato associato l’evento chiave alla lista di riepilogo list_tracceaudio Come funziona l’applicazione Basta inserire il nome dell’unità dove si trova il cd nella relativa casella di testo Premere il pulsante di comando sino a contenere la traccia che si vuole ascoltare Selezionare la traccia audio dalla lista di riepilogo (1) Si attiverà il controllo multimedia con i relativi pulsanti; cliccare sul pulsante Play simile a quello che si trova su tutti i comuni video registratori (1) Quando si preme il pulsante Aggiungi tracce naturalmente si segue la struttura dei file che stanno sul cd audio Track01.cda Track02.cda Track03.cda Track04.cda…. Track08.cda… Track10.cda Da 0 a 8 (9 tracce) avranno Track0K.cda Da 9 in poi avranno track[indice della traccia nella casella di riepilogo].cda



Di quanto descritto testualmente trovate il codice all’interno dell’evento cmd_aggtraccie_OnClick Se il numero di tracce aggiunte (list_tracceaudio.ListCount) è inferiore o uguale a 8 (0 a 8 sono 9 tracce) viene assegnata alla variabile nome la seguente stringa Nome= track & “0” & listtracceaudio.ListCount+1 Viene aggiunta l’unità perché sul cd audio non troverete mai un nome di file track00.cda Se il numero di tracce aggiunte è maggiore di 8 (ossia viene aggiunta la decima traccia, l’undicesima e così via) la stringa è simile solo che non è concatenato il carattere 0 Con il metodo AddItem viene aggiunto il valore di nome alla lista delle tracce audio Nell’evento on click sull’elemento della lista selezionato viene gestito l’ascolto della traccia audio Funziona pressappoco così: Se è la prima traccia (Track01.cda) ad essere ascoltata per prima, allora viene assegnata alla proprietà filename del controllo mmcontrol1 la stringa Txt_lett & “:\” & list_traccieaudio.List(list_traccieaudio.ListIndex) & “.cda” Viene attivato il comando Open del controllo mmcontrol1 E’ salvata la posizione corrente della traccia che si sta ascoltando (L’elemento, nella posizione 0 all’interno della lista, è la prima traccia) Adesso occorre gestire l’ascolto in avanti e in indietro e sono stati preparati opportunamente due cicli for uno di questi con la clausola step -1 decrementano il valore assunto da posizione; L’altro gestisce l’incremento del valore assunto da posizione Esempio se mi trovo alla 14 posizione e voglio ascoltare la 13 devo prima scaricare la traccia che stavo ascoltando (premendo il pulsante Chiudi) e poi selezionare la tredicesima. Il controllo mmcontrol1 arriva alla posizione 13 nel cd audio e premendo il pulsante play posso ascoltarla. Per concludere questo esercizio, vi devo suggerire come portare sul form il controllo Microsoft Multimedia Controllo 6.0



Per prima cosa, basta fare tasto destro sulla casella degli strumenti

Si seleziona la voce Components o Componenti (per chi ha la versione in Italiano di Visual Studio)

Da questa finestra di dialogo, con un segno di spunta al controllo, che si desidera aggiungere alla casella degli strumenti (in questo caso Microsoft Multimedia Control 6.0), confermare con Ok e detto controllo apparirà, come si vede in figura:



Il controllo aggiunto appare ,in figura, accanto al controllo oggetti Ole Un doppio clic su di esso apparirà sul form con stato attivo

Un controllo ActiveX aggiunto su un form

Per concludere l’argomento, apriamo una piccola parentesi sul controllo da Visual Basic di un’animazione in Macromedia Flash. Esempio: Ho disegnato un semplice sommario con due livelli: nel primo livello ho inserito i titoli delle prime 5 lezioni; nel secondo i titoli delle successive 5 Layer1 1-5 Layer2 6-10 In questo caso, per controllare ,da Visual Basic, la visualizzazione di questo filmato, occorre aggiungere sul form il controllo Shockwave Flash Vediamo l’interfaccia grafica dell’applicazione



Interfaccia grafica dell’applicazione

Il codice per gestire l’applicazione è: Private Sub Cmd_Layer2_Click() ShockwaveFlash1.TGotoFrame "Lezione6-10", 10 ShockwaveFlash1.Play End Sub Private Sub cmd_play_Click() ShockwaveFlash1.LoadMovie 0, "c:\testflavb6.swf" End Sub All’interno del file fla vi faccio vedere come ho strutturato l’animazione



Il contenuto che si vede nello stage sarà visualizzato nel controllo aggiunto sul

form quando si premerà il pulsante Layer 1-5

Il contenuto che si vede nello stage sarà visualizzato nel controllo aggiunto sul form quando si premerà il pulsante Layer 6-10

Su ogni layer creato ho aggiunto l’azione di stop in modo tale che quando viene caricato il movie non viene visualizzato il contenuto dello stage precedente. Un commento alle righe di codice Quando si premerà il pulsante Play verrà caricato il layer 0 (cioè il primo layer del filmato) con il metodo LoadMovie. A tale metodo viene assegnato il percorso dove si trova il file swf compilato con Macromedia Flash Quando si premerà il secondo pulsante Layer 6-10 vengono eseguite due righe di codice importanti

- Lo spostamento della testina di riproduzione del filmato al frame 10 - L’esecuzione del metodo Play caricherà il contenuto dello stage che si

trova al frame 10. Il parametro 10 viene assegnato al metodo TGotoFrame dell’oggetto ShockwaveFlash1 Durante l’esecuzione dell’applicazione dovrete ottenere



Premete il pulsante Play e otterrete quando si vede in figura

Premete il pulsante Layer 6-10 per ottenere lo spostamento della testina di riproduzione del filmato al frame 10

Verrà rilasciato il file swf testflavb6.swf in modo che potrete ricostruire il progetto di creazione dell’interfaccia con la vostra copia di Visual Basic 6.0



Ciò che abbiamo visto a proposito del controllo ShockwaveFlash è una dei tanti aspetti della gestione del controllo (quello più semplice da realizzare). Se volessi tornare al layer 1-5 devo aggiungere un pulsante home all’interfaccia e aggiungere queste righe di codice Private Sub Cmd_home_Click() ShockwaveFlash1.TGotoFrame "Lezione1-5", 1 ShockwaveFlash1.Play End Sub



LLee AAppii ddii WWiinnddoowwss

Natura delle librerie a collegamento dinamico Siamo finalmente arrivati alla lezione un pochino, se non proprio delicata dal titolo Le Api di Windows. Cercherò di usare un linguaggio molto semplice e chiaro da comprendere senza utilizzare del tecnicismo per evitare che poi nella pratica non si riesca a individuare l’applicazione in cui farne uso. Dopo questa premessa, diciamo che Visual Basic, come qualsiasi altro linguaggio di programmazione Visuale, estende le sue funzioni, avendo accesso, attraverso questo strumento (c.d. Application Programmino Interface di Windows), alle routine interne di Windows Domanda: Dove troviamo le routine interne di Windows? Le troviamo all’interno di DLL (Dynamic Link Library ossia nelle librerie a collegamento dinamico) Le Api di Windows non sono state create in Visual Basic, ma in C++ e memorizzate in queste librerie. Il compito di Visual Basic è quello di permettere l’accesso nelle modalità, le quali saranno descritte nei dettagli dei paragrafi che seguono. Concludiamo il paragrafo spiegando la natura delle librerie a collegamento dinamico. Dal punto di vista dei programmatori, quando una routine (subroutine o function che sia) è collegata dinamicamente all’applicazione, si afferma che non è connessa a quest’ultima neanche dopo l’attività di compilazione. La disponibilità avviene soltanto quando vengono invocate dall’applicazione in esecuzione



In altri termini la funzione Api dichiarata in Visual Basic viene caricata per il tempo necessario all’esecuzione, successivamente se non più necessaria, il sistema operativo Windows la scarica, ottimizzando la gestione delle risorse hardware. Le librerie Dll comuni di Windows: user32.dll, gdi32.dll, kernel32.dll Il sistema Operativo Windows si mantiene in esecuzione, se funzionano in modo ottimale tutte le librerie a collegamento dinamico richiamate per ogni tipo di operazione. Il vantaggio di appoggiarsi a queste librerie all’interno di applicazioni VB o altro ambiente di sviluppo che le supporta, è dato dalla portabilità delle routine incluse anche se cambia la versione del sistema Operativo. Quindi l’applicazione deve essere in grado di supportare le nuove funzionalità di Windows senza dover ricompilare tutte le applicazioni che utilizzano le Api di Windows. Ci sono delle librerie di collegamento che funzionano in modo efficiente, mediante le quali l’interfaccia grafica di Windows in tutte le sue operazioni, risponde bene all’utente. Quelle più comuni sono: User32.dll Contiene funzioni che controllano la GUI (Graphical User Interface – Ambiente e interfaccia grafica utente) di Windows, tipo cursori, menu e finestre di dialogo Gdi32.dll Contiene funzioni che controllano l’Output sullo schermo e su altre unità (E’ una dll che supporta funzioni grafiche) L’ultima dll comune che annoveriamo rappresenta il cuore del funzionamento di Windows: Supporta funzioni che controllano l’interfaccia grafica hardware e software interna di Windows (tipo gestione dei processi, della memoria, file e cartelle) Questa libreria è quella che si trova allo strato più basso del sistema operativo. All’utente invece è visibile solo l’interfaccia grafica che si estrinseca nell’uso del desktop e delle finestre. Possiamo comprendere bene che ogni programma Windows ha delle sue dll proprie, le quali possono far capo a quelle comuni; se non funziona una a cascata non funzionerà più l’applicazione che le richiama. Tutte le dll le troviamo nella cartella Windows\system Connessione alle librerie Dll con l’enunciato Declare Domanda: A che serve l’enunciato Declare? Esso serve a poter richiamare le Api di Windows. Quelle interne del linguaggio Visual Basic non hanno bisogno di



questo enunciato, in quanto VB conosce il loro funzionamento e sa quali sono gli argomenti necessari. Ogni Api di Windows ha dei propri argomenti da passare, alcuni obbligatori, altri opzionali e i tipi di dati, vedremo, possono trovare conflitto con quelli gestiti dal linguaggio con il quale si realizzano le applicazioni che li richiamano. Anche per le Api di windows si prospetta il discorso dell’area di validità pubblica o privata. Se nell’enunciato Declare, viene scritto che la routine Api chiamata è di tipo Pubblico, sarà visibile a tutta l’applicazione. Altrimenti sarà visibile solo nel form o nel modulo dove è stata dichiarata. Nell’ultimo paragrafo utilizzeremo lo strumento Visualizzatore Api per semplificare di molto la scrittura, nel nostro programma vb, dell’enunciato Declare con una semplice operazione di Copia e incolla. Se si parte da zero nella conoscenza di Visual Basic, occorre avere a disposizione una guida estensiva delle Api di Windows per poter essere in grado di scriverla autonomamente, altrimenti occorre avere un testo che le descriva e assieme questo valido strumento (Visualizzatore Api) Gli argomenti delle funzioni o subroutine e i tipi di dati Nelle routine o funzioni Api che possono essere richiamate, nell’enunciato Declare possiamo incontrare i seguenti tipi di dati: Any E’ un tipo di dati universale: Vengono passati per riferimento gli argomenti con questo tipo di dati e non serve la parola ByVal (Il passaggio per valori e per riferimento sarà chiaro tra 4 lezioni) ATOM E’ l’integer di Visual Basic. E’ un tipo di dati che supporta dati interi Sempre passati per valore con la clausola ByVal davanti al nome della variabile BOOL E’ l’intero lungo di Visual Basic (Long) Come per il tipo di dati precedente gli argomenti dichiarati vengono passati con la clausola ByVal (passaggio per valore) Char Dati tipo byte Anche in questo gli argomenti sono passati per valore COLOREF Di tipo Long utilizzati per definire valori di colori. Gli argomenti sono sempre passati per valore DWORD Di tipo Long (interi), i cui argomenti, dichiarati nella Api chiamata, sono sempre passati per valore Null Di tipo long (interi) utilizzati per valori non inizializzati Gli argomenti sono passati per valore



LPSTR, LPCSTR Corrispondenti dei dati di tipo string Anche in quest’ultimo caso sono passati gli argomenti per valore. STRUCTURE – Definizione di tipi di dati complessi Si nota facilmente come i tipi di dati degli argomenti delle Api di Windows riflettono in modo particolare l’ambiente di sviluppo con il quale sono state scritte (il C++ - letto c plus plus) e differenti dai tipi di dati esaminati con Visual Basic. Il visualizzatore Api e esempi di chiamate Concludiamo l’argomento sulle Api di Windows, trattando dello strumento installato con Microsoft Visual Studio, denominato Visualizzatore Api

Avviamo detto strumento, l’interfaccia grafica la vediamo in figura

Visualizzatore Api Nella casella di riepilogo Api type troviamo:



• tutte le costanti richiamate nelle api di windows dichiarate • tutti gli enunciati Declare della maggior parte delle Api incluse

nelle Dll comuni che abbiamo trattato nei paragrafi precedenti di questa lezione

• Nella sezione types sono richiamate la definizione di tipi di dati, a cui un argomento presente nell’enunciato Declare può far riferimento.

Per caricare la casella Api type, dal menu file occorre richiamare il file testuale WinApi32.txt, come si vede in figura

A titolo di esempio possiamo vedere la dichiarazione dell’Api di windows che crea una directory dato un pathname (o percorso di creazione) Ecco la finestra di codice che riflette le informazioni prese dal visualizzatore Api



Cercate CreateDirectoryEx dal sezione declares del visualizzatore api e copiatela in modulo standard. Poi cercate nella sezione tipi Security_Attributes e definite un tipo di dati personalizzato dall’utente. Dichiarate due variabili una di tipo long e l’altra di tipo security_attributes. Le informazioni assegnate alla variabile secattr sono prese direttamente dalla win32 sdk (facente parte di msdn library). Il valore di reval se è maggiore di 0 significa che la directory è stata creata con successo. C:\CORSO è una cartella di modello. Nel senso che apitest verrà creata con le informazioni prese da Corso. Es Se corso è di sola lettura, anche apitest sarà con l’attributo di sola lettura. Conoscere tutte le Api di Windows è un lavoro che richiede pazienza e tempo di apprendimento, ma le alternative all’accesso diretto alle Api, è dato dalla presenza di molte Dll che contengono già delle api compilate tipo una che vedremo alla fine del corso Microsoft Shell Controls Automation.



VViissuuaall BBaassiicc AAvvaannzzaattoo PPaarrttee PPrriimmaa

Cenni sull’accesso ai database Il punto di forza di Visual Basic è quello di gestire con strumenti semplici le basi di dati di qualsiasi formato Dbf database creati con Visual Dbase della borland oppure con le precedenti versioni di Dbase iii plus e Dbase IV sotto il precedente sistema operativo Ms-Dos, Mdb database creati con l’applicativo Microsoft Access nelle sue varie versioni Txt database in formato testo e database più professionali come SQL Server. Il controllo intrinseco, che si trova sulla casella degli strumenti di Visual Basic. ossia il controllo Data permette di accedere a database tipo:

L’elenco che vedete in figura sono i formati di basi di dati ai quali il controllo Data è abilitato a connettersi.

In questa tabella mostriamo le principali proprietà del controllo Data: Proprietà Descrizione Connect Scegliere dalla lista di riepilogo il formato di basi di

dati al quale connettersi



DatabaseName Indica il percorso di memorizzazione della nostra base di dati

RecordSource Restituisce o assegna il nome della tabella, dell’istruzione SQL e dell’oggetto query di un database che li supporta (tipo Access)

Se impostiamo dall’elenco della proprietà Connect Access come formato di database al quale connettersi, con la proprietà DatabaseName scegliamo di utilizzare un base di dati nel formato di Access 2000 Impostiamo infine, dall’elenco prodotto dalla proprietà RecordSource, l’oggetto da gestire tipo tabelle, query, o eseguire una determinata istruzione SQL Select per la selezione dei record. Visual Basic in sede di progettazione genera l’errore che verrà discusso nelle lezioni successive, ma che in questo paragrafo ve ne mostriamo comunque l’alert di errore:

Si riesce a tradurre che il database impostato con la proprietà DatabaseName ha un formato non riconosciuto dal controllo Data. (errore 3343) Il controllo data riconosce formati di database di Access nella versione 97 e il motore di gestione è viene gestito dalla libreria Microsoft Dao 3.51. Sta di fatto che quando aggiungiamo il controllo Data sul form, viene automaticamente aggiunto un riferimento a tale libreria:

Dal menu Progetto –Riferimenti si ottiene tale finestra di dialogo che elenca tutte le librerie necessarie a far funzionare correttamente l’applicazione



Domanda: Come possiamo creare un database in versione Access 97, attraverso l’ide di Microsoft Visual Basic? Con questa domanda abbandoniamo questo paragrafo, ma veniamo introdotti perfettamente nell’utility che verrà descritta nel paragrafo successivo ☺ Visual Database Tools Visual Database Tools è un’utility che semplifica molto la gestione di una base di dati, e permette a chi sa smanettare con Sql (linguaggio standard per creare,estrapolare,aggiornare,cancellare informazioni), di effettuare la creazione della struttura di una tabella o di fare un’inserimento dati, di interrogare la base di dati attraverso istruzioni del modulo DML DI SQL (Data manipulation Language o Linguaggio di manipolazione dei dati, istruzione Select, update, insert into per intenderci). Come si accede a questa utilità? Si accede dal menu Aggiunta (o Add-in per la versione Inglese di Visual Basic) selezionando Visual Data Manager. Appare la seguente interfaccia grafica:

Per rispondere alla domanda formulata alla chiusura del paragrafo precedente si procede nel modo seguente: Si accede, attraverso questa interfaccia grafica, dal menu file, alla voce



Nella finestra successiva potrete dare un nome alla base di dati e premere il pulsante salva

La finestra successiva rappresenta l’ambiente di lavoro per creare tabelle e troviamo poi un’altra finestra che chiameremo finestra di console, per digitare manualmente le istruzioni SQL.



Per creare una nuova tabella occorre cliccare con il tasto del destro del mouse sulla prima finestra a sinistra e selezionare New Table.

Si accede ad una finestra di dialogo esemplificativa per creare la struttura delle tabell; definendone il nome ed i campi; ad ogni campo assoceremo un tipo di dato; (Vedi figura qui sotto)

Una volta aggiunti tutti campi per la tabella, che troveremo nella casella di riepilogo Field List, si preme il pulsante Build the table (Costruisci la tabella)



Dal menu Utilità di Visual Data Manager c’è Data Form Designer Questa utilità permette di generare un oggetto form e di aggiungerlo automaticamente ad un progetto VB.

Premendo Build the Form, viene generato il form per la gestione della base di dati associata alla tabella tabprova.

Il controllo Data sta nella parte bassa del form, tutte le caselle di testo sono associate alla tabella tabprova e troviamo poi una serie di pulsanti:



Add: per aggiungere un record; Dolete: per cancellare il record corrente; Refresh: per aggiornare il valore di uno o più campi nel form; Update: per aggiornare materialmente l’informazione nella tabella; Close: per chiudere il form tabprova. Al controllo data c’è una barra di navigazione che ci permette di andare al primo record , ad ogni record successivo e all’ultimo record della tabella; Nell’aggiunta del primo record si preme il pulsante Add e poi si compilano i campi del form e si preme il pulsante Update. Per inserire ogni record successivo al primo si preme il pulsante Add. Il Data Environment Il Data Environment è una finestra di progettazione che offre un ambiente interattivo in grado di:

- facilitare l’accesso ai database di vario formato in fase di progettazione e, a livello di programmazione, in fase di esecuzione dell’applicazione.

In fase di progettazione vengono impostati i valori delle proprietà di due oggetti chiavi:

• Oggetto Connection • Oggetto Command

In fase di progettazione, a livello di codice si possono programmare gli eventi a cui il modello a oggetti Ado prevede (ma di questo non è parliamo per il livello di cenni che stiamo dando su questo argomento) Si possono trascinare gli oggetti Data Environment su form o report per creare controlli ad accesso ai dati A differenza del controllo Data, attraverso il Data Environment è possibile accedere a database di access 97/2000/2003. Mentre per i database di access superiori alla versione 97, il controllo Data solleva l’errore di formato sconosciuto e si deve intervenire con il codice in modo da utilizzarlo anche per la gestione di questi due formati. Applicazione da realizzare: Impostare le proprietà connection dell’oggetto DataEnvironment per accedere ad un database di Access 97. Impostare le proprietà dell’oggetto Command per accedere all’oggetto tabella. Trascinare l’oggetto command creato sul form, dovreste ottenere la seguente interfaccia grafica:



La seconda parte dell’applicazione deve prevedere l’aggiunta di una barra di navigazione con i tre pulsanti FIRST (Vai al primo record) Next (Vai al prossimo record con verifica che non ci sono più record da leggere) e Last (Vai all’ultimo record). Se si preme Last una seconda volta, l’oggetto DataEnvironment1, programmaticamente deve spostare la lettura del db partendo dal primo record. Ecco l’interfaccia grafica con l’aggiunta di questi pulsanti

Ecco la parte di codice che gestisce l’applicazione Option Explicit Dim ct As Integer Dim k As Integer Dim k1 As Integer Private Sub Cmd_First_Click() DataEnvironment1.rsCommand1.MoveFirst End Sub Private Sub CMD_LAST_Click() k1 = k1 + 1 If k1 = 2 Then MsgBox ("Sei già all'ultimo record:") DataEnvironment1.rsCommand1.MoveFirst Exit Sub End If DataEnvironment1.rsCommand1.MoveLast End Sub



Private Sub Cmd_Next_Click() k = k + 1 If k = ct Then GoTo esci Else DataEnvironment1.rsCommand1.MoveNext Exit Sub End If esci: MsgBox ("Non ci sono più records da leggere") Unload Form1 End Sub Private Sub Form_Load() ct = DataEnvironment1.rsCommand1.RecordCount End Sub L’oggetto RsCommand1 viene creato automaticamente dopo aver impostato le proprietà dell’oggetto Command I metodi moveNext, MoveFirst, MoveLast dell’oggetto RsCommand1 gestiscono la lettura della tabella (oggetto del database di Access) La proprietà RecordCount dell’oggetto RsCommand1 restituisce il numero di record aggiunti alla tabella Il metodo Unload Form1 distrugge l’oggetto Form1 e chiude definitivamente l’applicazione L’enunciato Exit Sub causa la chiusura anticipata dell’esecuzione del codice. L’enunciato End al posto di Exit Sub ha lo stesso effetto del metodo Unload Form1 Nella sottocartella filmati trovate una demo di come si configura l’ambiente di progettazione DataEnvironment. Vi sarà utile quando creerete il progetto esplicato nei dettagli (DataEnvironment.avi) La finestra QueryBuilder Questo strumento è stato aggiunto nelle edizioni di Visual Basic (Enterprise e Professional). Si attiva il menu query esclusivamente mentre si crea in modo interattivo una query SQL con Microsoft Query Builder Vediamo una demo: Nella sottocartella filmati della cartella vb6 troverete creaquery.avi



Il precitato strumento aiuta tutti coloro che non hanno mai smanettato con le istruzioni del linguaggio Sql. Come si potrà osservare dalla riproduzione del filmato, l’istruzione Sql viene generata automaticamente, dopo che l’utente ha impostato campi, criterio di ordinamento su un campo della tabella, aiutandosi con l’intuitiva interfaccia grafica a disposizione Finestre di dialogo comuni e l’utilizzo dei Controlli standard di Windows Questo paragrafo, rispetto a quello precedente non ha nessuna relazione e vuole essere una pausa sull’argomento così vasto come la gestione delle basi di dati con Microsoft Visual Basic. Quando si opera con il sistema operativo Windows o con programmi compatibili si è soliti incontrare determinate finestre di dialogo comuni: Esse possono essere: La scelta del font (ossia la finestra di dialogo per scegliere il tipo di carattere, la sua dimensione, il colore) La finestra di dialogo Apri e Salva nome file La tavolozza dei colori di sistema (simile a quella che incontriamo in Wordpad, Notepad, tutti i programmi di Office e altri programmi di grafica) La visualizzazione di un file help con il metodo ShowHelp, dopo aver impostato le proprietà HelpCommand e HelpFile La finestra di dialogo Stampa con il metodo ShowPrinter Tutta la gestione di queste finestre elencate sono incluse nel controllo Microsoft Common Dialog Control 6.0 (che può essere aggiunto alla casella degli strumenti mediante lo short Cut Ctrl+T che visualizza la finestra Componenti) Con l’aiuto della grafica creiamo un’applicazione che visualizzi tali finestre di dialogo:



FINESTRA DI DIALOGO COLORI (Commondialog1.ShowColor) Pulsante Tavolozza Colori

FINESTRA DI DIALOGO DI STAMPA (CommonDialog1.ShowPrinter)

Pulsante Finestra di dialogo di stampa

FINESTRA DI DIALOGO CARATTERE (CommonDialog1.ShowFont)

Pulsante FONT CARATTERE

FINESTRA DI DIALOGO APRI (CommonDialog1.ShowOpen)

Pulsante Finestra Apri



FINESTRA DI DIALOGO SALVA CON NOME (CommonDialog1.SHOWSAVE)

Pulsante Finestra Salva con Nome

Il codice per gestire tale applicazione molto semplice è quello che si vede in figura:



Per l’utilizzo del metodo ShowFont dell’oggetto Commondialog1, se non viene prima impostata la proprietà flags (cdlCFBoth) ,che visualizza la finestra di dialogo caratteri disponibili per schermo e per stampante), si genera l’errore di run-time 24574 (Nessun font risulta installato) all’esecuzione di tale metodo. Cenni di Excel con Visual Basic Una delle frontiere, che ha reso popolare l’utilizzo di Visual Basic, è stata quella di poter interagire con altri software microsoft e non. Il paragrafo s’intitola Excel con Visual Basic Dobbiamo spiegare in questo paragrafo soltanto il concetto di automazione. L’automazione si ottiene con l’utilizzo della funzione CreateObject, attraverso la quale viene creato e restituito un riferimento a un oggetto ActiveX. S’intende oggetto ActiveX, un oggetto che può essere esportato in altre applicazioni o strumenti di programmazione. L’oggetto ActiveX da esportare in Visual Basic è la libreria a collegamento dinamico di Microsoft Excel Possiamo gestire gli oggetti di Microsoft Excel in due modalità Private Sub Command1_Click() Dim obj As Object Set obj = CreateObject("Excel.Application") obj.workbooks.Add obj.Visible = True



End Sub L’altra modalità è quella di aggiungere un riferimento alla libreria di Microsoft Excel nell’applicazione di Visual Basic che si sta realizzando. Dal menu Progetto si aggiunge il riferimento per mezzo di questa finestra di dialogo:

e il codice per creare l’automazione Private Sub Command1_Click() Dim obj As New Excel.Application obj.Workbooks.Add obj.Visible = True End Sub Da sviluppatore vi suggerisco di utilizzare la prima modalità. Così vi assicurate di non generare errori sul computer del cliente, il quale potrebbe aver installato una versione di Excel successiva a quella aggiunta come riferimento o più vecchia. Mentre con la prima si sfrutta l’indirizzo programmatico del nome di classe dell’oggetto il quale è rimasto sempre Excel.Application Alcuni con la prima modalità aggiungono il numero di versione, quindi diventerebbe: CreateObject(“Excel.Application.9”) per Excel 2000 CreateObject(“Excel.Application.10”) per Excel 2002 CreateObject(“Excel.Application.11”) per Excel 2003 Io da sviluppatore non vi suggerisco di mettere il numero di versione, in quanto sarebbe equivalente ad aggiungere un riferimento alla libreria di Excel che il cliente potrebbe non avere. Viene generato a run-time l’errore 429



Tradotto in italiano tale codice di errore, significa che il componente ActiveX per il quale si vuole ottenere un riferimento non riesce a creare l’oggetto. E’ probabile che si è sbagliato a digitare correttamente il nome della classe dell’oggetto o che tale oggetto non sia registrato correttamente nel registro di configurazione di Windows. Esempio: Creiamo l’interfaccia grafica a tre pulsanti:

• Primo Pulsante crea una nuova cartella di lavoro di Excel • Secondo pulsante per chiudere la cartella creata • Terzo pulsante per aprire la cartella cartella

Un primo passo per descrivere il concetto di automazione

Il codice che gestisce l’applicazione



La creazione di una cartella di lavoro di Excel si crea ottenendo il riferimento all’oggetto Excel.Application. Poi viene creato l’oggetto cartella attraverso il metodo Add dell’oggetto Workbooks (c.d. cartella di lavoro) Il metodo SaveAs,passando il pathname, memorizza il file Xls sul nostro Personal Computer Nell’evento Cmd_chiudi_OnClick si chiude l’applicazione di Excel con il metodo Quit dell’oggetto Application. e si distruggono gli oggetti obj e cartella Nell’evento cmd_Open_OnClick vengono eseguite le seguenti operazioni: Creazione dell’oggetto Excel.Application Creazione dell’oggetto cartella, attraverso il metodo Open passando il pathname del file xls già creato Attraverso la proprietà Booleana (imposta il valore true) si rende visibile la cartella di lavoro di Excel. Tale proprietà è a livello di Excel.Application.

Cartella di lavoro di nome temp.xls



Fornire l’accesso a Internet ad un’applicazione Visual Basic fornisce l’accesso a Internet con diversi controlli, ma in questo paragrafo, descriviamo molto brevemente dell’oggetto WebBrowser (nelle successive lezioni lo approfondiremo con altri dettagli). Tale oggetto lo troviamo nella libreria Microsoft Internet Controls, il cui riferimento in una ipotetica applicazione avviene attraverso una finestra di dialogo accessibile con uno short-cut da tastiera Ctrl+T (premuti contemporaneamente; il tasto Ctrl è il tasto Control che si trova sotto il Caps Lock) La finestra di proprietà di detto oggetto la rappresentiamo nella figura qui sotto:

Step n° 1 : Aggiungiamo il controllo WebBrowser sul form



Step n° 2 Assegnare l’evento OnClick al pulsante di comando Libero.it Il pulsante di comando Libero.it (il cui nome dato al controllo è Cmd_Url) esegue il metodo navigate dell’oggetto WeBBrowser1 Step n° 3 Eseguire l’applicazione – L’oggetto WebBrowser permette di avere l’accesso a Internet direttamente dall’applicazione Visual Basic



WebBrowser1.Navigate “http://www.libero.it” è il codice assegnato all’evento Cmd_Url_OnClick

Oltre a utilizzare l’oggetto WebBrowser, esiste anche la libreria che supporta l’interfaccia grafica proprio di Internet Explorer. Per utilizzare questa libreria aggiungeremo il riferimento all’applicazione nel modo seguente: Menu Progetti - > Riferimenti -> Dalla finestra di dialogo sceglieremo Microsoft Internet Controls Utilizzando il principio dell’automazione visto per Excel avremo Private Sub Command1_Click() Dim obj As SHDocVw.InternetExplorer Set obj = New SHDocVw.InternetExplorer obj.Visible = True End Sub Concludiamo dicendo che, tali righe di codice visualizzeranno proprio il browser di Internet Explorer


http://www.libero.it/


VViissuuaall BBaassiicc aavvaannzzaattoo PPaarrttee sseeccoonnddaa

Controlli intrinseci avanzati Sono rimasti da analizzare pochi controlli intrinseci della ToolBox, che definisco avanzati perché permettono di effettuare operazioni molto professionali C’è il combobox che è un controllo composto. Con l’aggettivo composto intendo che è l’unione di una casella di testo e di una lista di riepilogo che vedremo successivamente. Vediamone il funzionamento

Partiamo da questa interfaccia grafica molto semplice: Si osservi l’aggiunta del controllo Combobox1 (ha un identificativo Combo1); di un pulsante di comando Aggiungi (cmd_aggiungi) Praticamente eseguendo quest’applicazione si caricheranno degli elementi all’interno del combobox1. Si selezionerà un elemento e premendo il tasto di funzione F1 si procederà alla modifica dell’elemento selezionato Il codice che esegue questo è:



Possiamo togliere il pulsante di comando e gestire con l’evento KeyDown del controllo Combo, l’operazione di aggiungere un elemento alla lista facendo il trapping (ossia premendo un tasto di funzione che questa volta ha valore keycode=113 ossia F2 della tastiera)

Adesso facciamo il trapping (ossia catturiamo il tasto di funzione F3) per effettuare la cancellazione dell’elemento. La cancellazione di un elemento avviene con il metodo RemoveItem (combo1.ListIndex) che rappresenta la posizione dell’elemento selezionato.



Il codice viene aggiornato in questo modo:

Poi abbiamo i controlli Checkbox e OptionButton (o Radio button). Essi sono altri due controlli intrinseci che graficamente si presentano

Nei controlli Checkbox, se sono in numero maggiore di 1, possiamo conservare la selezione del precedente controllo dello stesso tipo. Invece questo non accade per gli option button, dove selezionandone uno, viene deselezionato l’altro che perde lo stato attivo Il controllo Oggetti Ole permette di incorporare o collegare oggetti e dati. Nella fase di incorporazione oggetti e dati vengono memorizzati direttamente in Visual Basic; mentre nella fase di collegamento, viene solo creato un segnaposto in Visual Basic, mentre oggetti e dati collegati vengono gestiti e memorizzati dall’applicazione in cui sono stati creati. Il metodo chiave dell’oggetto Ole è InsertObjDlg Quando viene eseguito tale metodo, appare una finestra di dialogo come quella in figura:



Esempio: Proviamo a creare un oggetto nuovo ‘Documento di Word pad’, visualizzato come icona, e confermiamo con Ok. Apparirà quanto vedete in figura:

In un contenitore Ole può essere aggiunto solo un oggetto alla volta. Altrimenti occorre aggiungere sul form più controlli Ole Creazione di un ActiveX Document e di un ActiveX Exe Document Il concetto di ActiveX Document non vi deve risultare nuovo, se vi rappresento la seguente analogia di funzionamento: Un documento di Word (con estensione doc) è definito tecnicamente un ActiveX Document, ma dovete tenerlo distinto dall’applicazione che serve per realizzare tale documento Word document - > Winword.exe ( detta Word Application) Visual Basic Document (ActiveX Document) visualizzabile attraverso altri contenitori ActiveX (tipo Internet Explorer) Quando un documento di Word viene visualizzato attraverso il contenitore ActiveX di Internet Explorer, è l’applicazione di Winword.exe che fornisce tutti gli oggetti a quest’ultimo per visualizzare e attivare il documento stesso. Questa logica di funzionamento caratterizza anche la creazione di ActiveX document con Visual Basic che possono essere di due tipi:



• Può essere creata una dll (ActiveX Document) • Può essere di tipo exe (ActiveX Exe Document)

Creazione dal vero di un ActiveX Document In questo paragrafo spiegheremo passo passo come si crea un ActiveX Document con Visual Basic, dalla fase di progettazione sino alla fase di esecuzione nell’applicazione contenitore del Browser Web 1^ Passo Aprire l’ambiente di sviluppo Microsoft Visual Basic

2^ Passo Scegliere dal Project Template il tipo di progetto da creare ActoveX Document Dll 3^ Passo Visualizziamo in figura la finestra di progettazione (o Project Explorer)

4^ Passo Facciamo Doppio clic sull’oggetto User Document1, che si vede in figura



5^ Passo Aggiungiamo 2 etichette: lbl_titolo -> PRIMO ACTIVEX DOCUMENT lbl_url -> Url da visitare Una casella di testo Txt_url -> Casella di testo dove immettere l’indirizzo del sito Un pulsante di comando Cmd_naviga -> Pulsante di comando al quale associare le seguenti righe di Codice



Attraverso la proprietà HyperLink dell’oggetto UserDocument possiamo creare un activeX document che permette l’applicazione l’accesso a Internet. Tale proprietà ha a sua volta il metodo NavigateTo L’applicazione contenitore di Internet Explorer fornisce alcuni suoi oggetti chiave all’applicazione activex document che si sta creando con Visual Basic 6^ Passo Prima di passare al test vediamo in figura l’interfaccia grafica utente realizzata

7^ PASSO Configuriamo l’operazione di Debugging nella Project Properties (Dal menu Progetto scegliere la voce Project Properties)



PROJECT PROPERTIES

Dalla scheda Debugging possiamo scegliere l’user documents da testare direttamente in Internet Explorer(applicazione contenitore) Step n° 8: Facciamo L’F5 (ossia clicchiamo con il tasto di funzione F5, per avviare l’applicazione) OSSERVAZIONE: E’ l’applicazione dopo l’EXE Project Standard, che prima di essere compilata può essere eseguita



Viene avviato Internet Explorer e al suo interno viene visualizzato Il Visual Basic User Document con l’estensione vbd Possiamo nella casella di testo inserire l’URL di Manuali.net e cliccare sul pulsante Naviga. Verrà al suo interno visualizzato il sito di Internet a cui l’Url si riferisce (http://www.manuali.net)


http://www.manuali.net/


VViissuuaall BBaassiicc aavvaannzzaattoo PPaarrttee tteerrzzaa

Il modello ad oggetti ADO L’architettura Ado presenta le seguenti caratteristiche:

• Presenza di un numero minore di collection rispetto all’architettura Dao • Il minor numero di collection è compensato da un maggior numero di

proprietà, le quali permettono di supportare peculiarità specifiche di un provider per l’accesso ai dati: trattasi del provider OleDb

Le collection che costituiscono l’architettura ADO sono:

• La collection Connection • La collection Recordset • La collection Command

Questi tre oggetti sono tra loro indipendenti, ma possono correlarsi attraverso una proprietà comune che prende il nome di ActiveConnection Adesso dobbiamo motivare la presenza dell’oggetto Connection. Con l’uso dell’architettura Dao, se avessimo dovuto connetterci ad un database di access, non era indispensabile conoscere la sua stringa di connessione Basta scrivere in Dao, le seguenti righe di codice: Const dbLangGeneral = ";LANGID=0x0409;CP=1252;COUNTRY=0" … dim db as dao.database …. Set db=Dbengine.CreateDatabase(“c:\miodb.mdb”,dblanggeneral,dbversion40) Con ADO, invece se dovessimo connetterci allo stesso formato di db, abbiamo bisogno prima di configurare l’oggetto connection.



La configurazione avviene impostando quella che viene chiamata stringa di connessione al database. I parametri impostabili sono tanti, ma senza entrare troppo nei dettagli (anche perché questa lezione richiederebbe un ciclo di lezioni), diciamo che un modo per impostarla velocemente è quella di aggiungere sul form un controllo. Proprio il controllo che verrà descritto nel paragrafo successivo Per il motivo che gli oggetti Ado elencati sono indipendenti tra loro, l’oggetto Recordset ha la caratteristica di essere molto flessibile rispetto a quello dell’oggetto Dao. Con Ado abbiamo la possibilità di creare due tipi di recordset, senza neanche aprire una connessione con la base di dati: Recordset creati dal nulla (o stand-alone) Recordset basati su file Ecco perché si parla di recordset dissociati. Dao, questo non lo permette affatto. Il controllo Ado Data Control e i controlli associati a questo controllo Abbiamo detto nel paragrafo precedente, che se dovessimo creare semplicemente la stringa di connessione ai database con Ado, basterebbe che aggiungessimo sul form un controllo activeX Ado data control (scelto dalla finestra Componenti Ctrl+t). Con la comoda interfaccia grafica possiamo generare in automatico la stringa di connessione e poi scrivere queste righe di codice ….. Dim objConn as Adodb.Connection Set objConn=new Adodb.Connection Objconn.Open Adodc1.ConnectionString …… La properties Page del controllo Ado Data Control la possiamo osservare in figura, qui in basso:



Premendo il pulsante Build si segue un wizard che genera automaticamente la stringa di connessione, senza che dobbiamo digitarla manualmente quando inizializziamo l’oggetto Connection e utilizziamo il metodo OpenConnection A run-time basta che scriviamo le seguenti righe di codice …. Set objconn=New Adodb.Connection Objconn.OpenConnection Adodc1.ConnectionString,”Admin”,””

L’interfaccia che si vede in figura, ci introduce a parlare del controllo associato Microsoft DataList Control 6.0 (Comprende due controlli associati all’architettura Ado DataList e DataCombo) Dopo aver configurato la scheda RecordSource del controllo Adodc1



Di qui si passa a configurare la finestra proprietà del controllo DataCombo S’impostano le seguenti proprietà DataSource Adodc1 DataField cognome RowSource Adodc1 ListField cognomen Ecco la finestra proprietà dell’oggetto DataCombo1



VViissuuaall BBaassiicc aavvaannzzaattoo::PPrroocceedduurree ee

ffuunnzziioonnii Le Subroutine e le function Public e Private Dall’Ide di Visual Basic possiamo inserire, nella finestra di moduli standard e di classe, subroutine e function visibili o private (ossia che non saranno visibili ad altri moduli aggiunti o a tutti i form aggiunti

Abbiamo questa situazione. Se proviamo, in una delle due finestre di modulo, a creare una subroutine di tipo pubblico. Quesito n° 1: La possiamo invocare anche in subroutine o function del secondo modulo? O anche all’interno della finestra di codice dell’oggetto form1 o Form2? La riposta è affermativa. Tutte le variabili di tipo pubblico sono visibili a tutti gli oggetti del progetto (form, moduli di classe, moduli standard aggiunti) Facciamo il test in questo modo:



Decidiamo quale oggetto far partire per primo all’avvio dell’applicazione e possiamo verificare che la riga di codice Call saluto è visibile a tutto il progetto

Visualizziamo adesso il form che abbiamo scelto come Startup project (es.form2)

Clicchiamo sul pulsante di comando, e verifichiamo se, la routine Saluto, creata nel modulo 1, viene eseguita:



Per la prova del 9 facciamo lo startup project sul modulo 2 che ha routine Sub Main () End sub.. Se non c’è Sub Main..End sub, nessun modulo funziona

Funziona il tutto, possiamo avanzare di livello sull’argomento passando al paragrafo successivo, dove parleremo di passaggio di valori e per riferimento ad una subroutine o function DIFFERENZA TRA ROUTINE E FUNCTION: LA ROUTINE ESEGUE UN GRUPPO DI ISTRUZIONI; UNA FUNCTION ESEGUIRE UN GRUPPO DI ISTRUZIONI, MA RESTITUISCE UN VALORE DEI TIPI DI DATI VISTI NELLE LEZIONI PRECEDENTI Invece se riduciamo la visibilità di routine e function, dichiarandole private, non saranno visibili tra moduli e form diversi Se dichiarassimo una subroutine o function, all’interno dell’oggetto Form, per richiamarle utilizzeremo sempre l’istruzione call e come argomento passeremo il nome dell’oggetto Form.<nome routine> Comunque se è di tipo private la subroutine o la function, essa non sarà visibile da un form all’altro, o da un modulo ad un altro modulo. Passaggio per valori e per riferimento Domanda: Che significa che un argomento della subroutine viene passato per valore, ossia con l’uso della clausola Byval? Domanda: Che significa che un argomento della subroutine viene passato per riferimento, ossia con l’uso della clausola ByRef? Il passaggio per valore consente alla routine di accedere ad una copia della variabile; di conseguenza il valore effettivo della variabile non può essere modificato dalla routine passante In un modulo abbiamo due routine:



Sub Main Dim numero as integer Numero=56 Call passavalore(numero) Msgbox “valore:” & numero End sub Sub passavalore(byval dato) Msgbox “valore passato:” & dato Dato=dato+56 Msgbox(“dato modificato:” & dato) End sub Con queste due routine, la prova del nove la verifichiamo in questo modo: dopo l’esecuzione della routine passavalore, il valore della variabile numero sarà sempre 56 e non 112 come visualizzato dalla finestra di dialogo eseguita in passavalore Eseguendo il codice con il tasto di funzione F8 abbiamo

Si parte dalla subroutine principale Sub Main…

Viene assegnato il valore 56 alla variabile numero dichiarata di tipo

intero



Viene eseguita la subroutine passavalore e come argomento trasferisce il

contenuto della variabile numero

La subroutine passavalore accede ad una copia del valore di numero. Ogni sua modifica all’interno non influirà sul valore di numero della

subroutine Main

Al contenuto di dato, passato dalla subroutine Main, è stato aggiunto 56 e la somma visualizza ammonta a 112. Quando l’esecuzione passerà nuovamente alla routine Main, la finestra di dialogo “valore di numero” sarà sempre uguale

a 56 e non al nuovo valore 112

La prova del 9 è stata verificato . Principio dimostrato

Il passaggio di un argomento per riferimento risulta essere il contrario del primo tipo di passaggio (passaggio per valore). Nella subroutine a cui accediamo davanti a tutti gli argomenti potremo mettere la clausola byRef Il passaggio per riferimento è l’impostazione predefinita di Visual Basic. Ecco che davanti ai parametri della subroutine passante possiamo anche omettere di indicare la clausola byRef.



La subroutine passante avrà accesso all’indirizzo e quindi alla variabile effettiva. Ogni modifica, apportata all’interno, agli argomenti passati, quando continuerà l’esecuzione della routine che l’ha invocata, si rifletterà anche nella routine che l’ha invocata Esaminiamo questa finestra di codice:

Passaggio per riferimento

La variabile Ris avrà valore 0 nella routine Main, ma quando terminerà l’esecuzione della routine passavalore, assumerà il valore di dato=dato+56 Restituzione di un’array da parte di una subroutine Esercizio: Con la tecnica del passaggio di argomenti per riferimento, dobbiamo passare un array ad una subroutine, effettuare un incremento di tutti gli elementi di una costante (es. 56) e poi trasferire i valori alla routine principale Finestra di codice



Tutti gli elementi dell’array numeri saranno incrementati di 56



VViissuuaall BBaassiicc aavvaannzzaattoo::LLaa ggeessttiioonnee

ddeeggllii eerrrroorrii Errori logici e errori sintattici La gestione degli errori è un attività che porta il nome di ‘DEBUGGING”. Il nostro obiettivo è quello di creare un applicazione senza bug (c.d. errore) durante la fase di esecuzione. La loro presenza sarebbe un brutto biglietto da visita per il cliente che riposto la fiducia nella nostra esperienza di sviluppatori o programmatori Una prima categoria di errori (o bugs) che si possono presentare sono quelli sintattici. Si definisce errore di sintassi un errore nella grammatica del linguaggio di programmazione. Esempio Dobbiamo scrivere msgbox(“ciao mondo”) e scriviamo msgbox1(“ciao mondo”). Il carattere in più rispetto alla versione corretta della riga di codice genera un errore sintattico. Spesso capita che questo genere di errori, Visual Basic li considera errori di compilazione Sbagliare msgbox con Msgbox1, viene interpretato da Visual Basic con l’errore di compilazione con codice 35

In opzioni c’è una voce, la quale se viene spuntata permette il controllo automatico della sintassi del codice mentre lo digitiamo.



La voce Auto Syntax Chek, tradotta in italiano è Controllo automatico della sintassi. Se viene disattivata questa voce, gli errori di codifica non verranno rilevati e saranno tutti generati in via di esecuzione dell’applicazione. Comunque non è solo questa la categoria di errori che si possono commettere. Esiste l’altra categoria: i c.d. errori logici, difficilmente riscontrabili ma rilevabili durante l’esecuzione dell’applicazione. Gli errori logici non vengono segnalati in fase di compilazione. Dipendono dalla logica di programmazione. Esempio: Abbiamo un form dati che prende i valori da un db; quando effettuiamo delle assegnazioni, sovente capita questo errore: txtCognome.text=indirizzo txtnome.text=numerociv txtindirizzo.text=cognome In questo caso, dovunque siano messe queste righe di codice, all’esecuzione non viene generato e quindi segnalato da vb nessun errore sintattico o di run-time, ma se ne accorge il programmatore in quanto non segue la logica del programma che sta sviluppando. In finestre di codici più ricche, è arduo riconoscere dove si trovano, e occorre fare numerosi test. Errori di run-time Gli errori di run-time capitano spesso quando il programmatore non adotta enunciati di codice che li gestiscono. Esempio Scrivo un form con due caselle di testo Txtnumero.txt Txtnumero1.txt



Lblrisultato.caption=txtnumero.txt/txtnumero1.txt

Questi sono errori di run-time che se non vengono gestiti bloccano applicazioni di mole di codice.. Solo che quando si dà l’eseguibile o si distribuisce un controllo utente rilasciato, questo controllo smette di funzionare e occorre (‘richiamare a urla il programmatore’) Vedremo nel prossimo paragrafo come gestire questo particolare errore e rendere l’applicazione (molto semplice) efficiente, e senza nessun tipo di errore Comunque errori sintattici non sono stati rilevati. On Error goto…. Resume Next Questo enunciato lo s’inserisce prima dell’istruzione che a run-time può generare errore, tipo nell’applicazione precedente, prima di un’operazione di divisione. Quando si programma occorre mettersi sempre nella mente distratta dell’utente finale. Può digitare zero nella casella di testo, e quando viene eseguita l’istruzione Lblrisultato.caption=txtnumero.txt/txtnumero1.txt Occorre controllare txtnumero1.txt, ma adesso vi suggerisco questo trucco



In questo modo la finestra di errore di run-time non appare, ma se volessimo informare l’utente che ha inserito 0 ed una divisione per zero non può essere eseguita. Può aiutare l’utente a capire perché il risultato dell’operazione non viene scritto nella lblrisultato.caption A tal proposito si utilizza la funzione Err Ecco dove collocarla, vedete la finestra di codice in figura

Se volessimo evidenziare lo sfondo della casella di testo che ha generato l’errore di runtime con codice 11



Il metodo SetFocus permette di far ritornare lo stato attivo al controllo al quale viene applicato.



VViissuuaall BBaassiicc aavvaannzzaattoo::LLaa lliibbrreerriiee ddii

VViissuuaall BBaassiicc FFoorr AApppplliiccaattiioonn

La libreria di Visual Basic For Application (VBA) In questa lezione conosceremo la riposta ad una domanda ‘Come fa un’applicazione Visual Basic a funzionare correttamente? In altri termini quali sono le librerie che vengono aggiunte quando si clicca su crea progetto Exe Standard? Dalla finestra di dialogo Riferimenti (Menu progetto-Riferimenti) rileviamo la risposta a tale domanda:

Notiamo al primo posto che uno dei grandi moduli della libreria MSVBVM60.DLL è denominato Visual Basic For Application (siglato VBA). Dall’Object Browser, selezionando la libreria in argomento vediamo da quante classi è composta:



Permette di lavorare su tutti i tipi di dati di Visual Basic comprende diverse classi di funzioni in varie aree: Funzioni di conversione (Class Conversion) Funzioni per lavorare con le date e l’ora (Class DateTime) Funzioni matematiche (Class Math) Funzioni per lavorare con le stringhe (Class Strings) Funzioni finanziarie (Class Financial) Funzioni informative (Class Information) Funzioni per l’interattività con l’utente (Class Interaction) Poi abbiamo due classi:

• una per creare un nuovo tipo di dati: le collection (esiste proprio una classe vba apposita per gestirle con i metodi che vediamo in figura);



Un’altra classe per gestire gli errori di run-time: La classe ErrObject Una serie di costanti Class Constants Una serie di costanti enumerative

Questa lezione è servita per descrivere la libreria di Visual Basic For Application. Con questa libreria si possono fare tante cose, ma occorrerebbero lezioni e lezioni al di fuori di questo corso.



VViissuuaall BBaassiicc aavvaannzzaattoo::MMooddiiffiiccaarree

llee pprroopprriieettàà ddii uunnaa FFoorrmm ee iill mmeettooddoo

SShhoowwFFoonntt Tutorial Modificare le proprietà di una Form e il metodo ShowFont Possiamo provare a modificare le proprietà BackColor e fontname e fontsize in modalità run-time dell’oggetto Form. Ciò grazie alle finestre di dialogo ShowFont, ShowColor del controllo Microsoft Common dialog control 6.0 Presentiamo l’interfaccia grafica da realizzare

Ciò che vedete sul form (sull’angolo superiore sinistro) è il controllo Microsoft Common Dialog control 6.0 Ci sono due pulsanti Cambia Colore form e il pulsante cambia carattere form. Essi attivano rispettivamente due finestre di dialogo comuni. La finestra modifica carattere, dimensione carattere, colore carattere, e la tavolozza colori per modificare lo sfondo dell’oggetto Form



E’ stato scelto il colore azzurro (si vede da un quadrato concentrico ombreggiato di grigio)

Proprietà BackColor impostata al valore CommonDialog1.Color

FINESTRA CARATTERE ARIAL-GRASSETTO-20 punti



Nell’ultima figura abbiamo visto che gli obiettivi che ci eravamo prefissati a inizio lezione sono stati raggiunti positivamente Area di codice



VViissuuaall BBaassiicc aavvaannzzaattoo::ffoorrmm..pprriinntt

Tutorial: Il metodo print e il metodo Cls dell’oggetto Form Per compatibilità con il vecchio Basic, le due istruzioni Print e Cls sono diventate metodi dell’oggetto form e hanno conservato la medesima funzione, quella rispettivamente di stampare qualcosa sul form, e di cancellare ciò che viene stampato Tipo 20 locate 2,10:print “Ciao mondo” In codice Visual Basic diventa Private Sub Command1_Click() Form2.CurrentX = 200 Form2.CurrentY = 200 Form2.Print "Ciao Mondo" End Sub

Il metodo cls pulisce ciò che sta scritto sull’oggetto Form Ecco il form2 pulito



Con il primo pulsante si scrive la scritta Ciao mondo alle coordinate currentX e currentY Con il secondo viene pulito l’oggetto form (vedetelo in figura)



EEsseerrcciizziiaarriioo ddii VViissuuaall BBaassiicc:: PPaarrttee PPrriimmaa

ESERCIZIARIO 1: La mia prima applicazione con VB Tutti coloro che scrivono corsi.., videocorsi, libri su Visual Basic partono con il loro esempio classico Hello World, io invece voglio seguire la strada che la prima applicazione Windows da creare con Visual Basic sia: Date tre liste di riepilogo e due bottoni dobbiamo permettere all’utente di inserire dei valori nella prima e nella seconda lista; poi premendo il primo bottone verrà eseguita la somma del primo elemento della lista con l’elemento corrispondente della seconda e verrà memorizzato nella terza.. Alla fine premendo il secondo bottone otterremo la somma totale. Infatti gli elementi memorizzati nella terza lista sono definite somme parziali

DISEGNO DELL’INTERFACCIA GRAFICA

A tutti i controlli, quando vengono aggiunti sul form, visual basic genera automaticamente il valore della proprietà TabIndex. Infatti premendo il tasto



Tab della tastiera si passa da un controllo al successivo fino ad arrivare all’ultimo controllo aggiunto. In questo caso essendoci delle liste di riepilogo, lo stato attivo, all’avvio del form, lo prende la prima lista di riepilogo

Infatti si disegna un piccolo rettangolo nella prima lista Se non viene mai premuto il tasto Tab , detta lista conserva sempre lo stato attivo Come si apprende facilmente, consultando la guida MSDN Library di microsoft, su tutti i controlli che hanno lo stato attivo, è possibile catturare l’evento KeyDown Catturando questo evento è possibile verificare se viene premuto il tasto PageSu o PageGiù L’evento KeyDown associato alla lista di riepilogo 1 si presenta Private Sub List1_KeyDown(KeyCode As Integer, Shift As Integer) Al valore KeyCode dobbiamo associare una struttura di controllo decisionale come Select Case Select Case KeyCode Case Keycode=vbkeyPageUp ……. ……. Case Keycode=vbkeyPageDown …… ……



Case Else Msgbox(“Non hai premuto I tasti richiesti dall’applicazione”) End Select Dove ci sono i punti di sospensione, dobbiamo inserire le righe di codice che effettueranno l’inserimento del dato immesso dall’utente da tastiera nella prima o nella seconda lista Per il blocco Case vbkeyPageUp le righe di codice sono: valore = InputBox("Inserisci un numero:") List1.List(List1.ListCount) = valore Per il blocco case vbkeyPageDown le righe di codice sono: valore = InputBox("Inserisci un numero:") List2.List(List2.ListCount) = valore

OSSERVAZIONE

La proprietà ListCount di una qualsiasi lista di riepilogo fornisce il numero complessivo di elementi della lista. Per acquisire un dato da parte dell’utente con la tastiera , Visual Basic mette a disposizione la funzione InputBox

Appare così la finestra di dialogo della funzione InputBox

Il codice che esce fuori, è frutto sempre di un’analisi accurata dei dati ottenuti in via output con quelli attesi e verifica se l’algoritmo trovato funziona e funzioni sempre e non in alcuni casi particolari. Il codice si trova nel file pdf Esercizio1_Lez16.pdf Nella cartella Eserciziario troverete l’eseguibile dell’applicazione Esercizio1_Lez16.pdf Dall’esempio classico di HelloWorld a questo esempio, l’obiettivo è stimolare molto la fantasia nella programmazione orientata agli eventi e all’uso opportuno di tutte le strutture di controllo alla base di ogni linguaggio di programmazione visuale. ESERCIZIARIO 2: Gestione di un file ad accesso sequenziale



L’esercizio che ci accingiamo a sviluppare in questo paragrafo ha l’obiettivo di memorizzare qualsiasi informazione su un dispositivo di memoria di massa e poter in un futuro remoto recuperare tali informazioni per successive elaborazioni. Il concetto legato a questo esercizio è la parola che si trova in qualsiasi glossario d’informatica di base: ossia File A seconda dell’accesso, stabilito in fase di programmazione, su un file, distinguiamo:

• File ad accesso sequenziale, della cui gestione ci occuperemo in questo paragrafo

• File ad accesso casuale, della cui gestione ci occuperemo nel paragrafo successivo

Domanda: Che significa file sequenziale? Un file sequenziale è un file in cui si legge e si scrive nell’ordine partendo sempre dal suo principio. Essi sono facili da creare, ma possono risultare scomodi da usare. In contrapposizione ai file sequenziali, abbiamo detto che ci sono i file ad accesso casuale; essi permettono di accedere in modo molto più rapido alle informazioni desiderate, ma i programmi che li gestiscono sono piuttosto complicati di quelli che usano il primo tipo di accesso (accesso sequenziale) Quali sono i problemi dei quali occuparci nella gestione dei file sequenziali? Primo passo: Definizione dei dati su cui operare Secondo passo: Aprire il file sul dispositivo di massa e il programma utilizzerà un Handle di file, detto canale per accedervi. Per l’apertura del file, sia che l’accesso avvenga in modo sequenziale o casuale, Visual Basic utilizza l’enunciato Open Terzo passo: La scrittura delle informazioni, all’interno del file aperto, al quale viene associato un Handle (canale), avviene attraverso l’enunciato Print#<handle o canale>

OSSERVAZIONI TECNICHE L’Handle di file o canale è un numero positivo maggiore di 0 e non superiore a 511. Ciò significa che non posso tener aperti più di 511 file contemporaneamente. L’intervallo da 1 a 255 incluso per aprire file che non sono accessibili da altre applicazioni



L’intervallo da 256 a 511 incluso per aprire file che sono accessibili da altre applicazioni Si può usare a tal proposito la funzione Freefile() per conoscere l’handle di canale libero e non utilizzato da nessuna istruzione Open. Quarto Passo: Leggere le informazioni dal file aperto attraverso l’enunciato Input#<handle di file> Attraverso questi quattro passi è possibile memorizzare e aggiungere nuove informazioni in questo file con accesso sequenziale e di poterle recuperare (quindi visualizzare nell’interfaccia grafica le stesse informazioni dall’inizio alla fine del file) La gestione comunque comporta anche la possibilità

• di cancellare un gruppo logico di informazioni • di poter aggiornare (in altre parole modificare) un dato compreso in un

gruppo logico di informazioni • di ordinare il file secondo un dato compreso nel gruppo logico di

informazioni • di elaborare il file secondo un certo criterio (tipo le query che si creano

con le basi di dati) Quando la gestione delle informazioni diventa molto complessa è fortemente consigliato utilizzare lo strumento professionale delle basi di dati con i software applicativi in commercio. ESERCIZIARIO 3: Gestione di un file ad accesso casuale La gestione di un file ad accesso casuale comporta:

• la definizione di una struttura di dati definita dall’utente • la definizione di un parametro importantissimo quale la lunghezza del

record Per record intendiamo una riga logica del file (es. cognome, nome, indirizzo, telefono, etc.) che contiene un gruppo di dati completo. Il primo record di un file inizia dalla posizione 1, mentre tutti i record successivi sono scritti a partire da locazioni con incrementi pari alla lunghezza del file Esempio se il primo record ha lunghezza logica 120, il secondo record partirà dalla posizione 121 a 240; così a seguire con questo criterio tutti gli altri.



I due enunciati di Visual Basic che permettono, rispettivamente, di memorizzare un record in un file ad accesso casuale sono: put#<numerofile o handle>,<intnumerorecord> variabile Get#<numerofile o handle>,<intnumerorecord> variabile La variabile può essere qualsiasi tipo di dati elementare (stringa, numero, espressione booleana), un tipo di dato definito dall’utente (la combinazione di tutti i tipi di dati elementari disponibili e permessi da Visual Basic), addirittura una matrice. Ciò che rende potente l’uso di questo particolare accesso ai file, è quello di utilizzare qualsiasi tipo di variabile come singola unità. Cognome, nome, indirizzo in un file ad accesso sequenziale non vengono visti come singola unità, ma come tre campi uno sotto l’altro. Un tipo di dati definito dall’utente viene dichiarato attraverso l’enunciato Type.. End Type a livello di modulo standard o modulo di classe. Per aprire un file ad accesso casuale si usa sempre l’enunciato Open Open “casuale.txt” for Random as #1 Per chiudere qualsiasi tipo di file ad accesso sequenziale o casuale si usa l’enunciato Close con l’uso dell’handle di canale. Se viene omesso vengono chiusi tutti i file aperti




ESERCIZIARIO 4: Aggiungere un menu all’interno dell’applicazione Un applicazione Windows che si rispetti ha, dopo la barra del titolo, un menu. Si definisce menu un’insieme di azioni organizzati in più voci, per mezzo delle quali è possibile accedere in maniera molto rapida a tutte le funzionalità previste per l’applicazione che si sta realizzando. Visual Basic all’interno del suo ambiente di sviluppo, ha uno strumento che ci permette di creare, modificare, cancellare delle voci e disporle secondo un certo nostro ordine. Lo strumento prende il nome di Editor di menu

L’editor di menu è accessibile per mezzo anche dello short cut da tastiera con Ctrl+E

Nella sottocartella filmati della cartella del corso VB6, troverete il filmato in formato avi che si chiama creamenu.avi Vi spiegherà passo passo come aggiungere un menu all’applicazione con tale strumento che vedete in figura.



ESERCIZIARIO 5: Aggiungere l’interattività ad un menu già esistente Attraverso la demo abbiamo creato la seguente interfaccia grafica:

Il passo successivo, è quello di dare interattività al menu, che si vede in figura Su ogni voce, in sede di progettazione, basta cliccare sopra, che si apre la finestra di codice con la generazione della routine evento OnClick

A titolo di esercizio possiamo aggiungere sul form il controllo WebBrowser, già visto nelle lezioni precedenti.



Ecco l’interfaccia grafica con l’aggiunta di un menu di navigazione in tre siti commerciali e il controllo WebBrowser per visualizzare al suo interno il sito internet (c.d classica applicazione che dà l’accesso a

Internet) ESERCIZIARIO 6: Come si avviano i vari componenti di Office? Sempre con il principio di automazione, possiamo utilizzare la funzione CreateObject per accedere ai vari componenti di Office, direttamente da Visual Basic Per aprire Microsoft Word, basta scrivere le seguenti righe di codice ….. Dim objapplic As Object Set objapplic = CreateObject("Word.Application") objapplic.Visible = True ….. Per aprire Microsoft Excel, basta scrivere le seguenti righe di codice (esse sono di riepilogo a quelle già viste in una delle lezioni precedenti) Private Sub Command1_Click() Dim objapplic As Object Set objapplic = CreateObject("Excel.Application") objapplic.workbooks.Add objapplic.Visible = True End Sub Attraverso l’oggetto Access.Application possiamo creare un nuovo database di Access su disco Le righe di codice sono:



Private Sub Command1_Click() Dim objapplic As Object Set objapplic = CreateObject("Access.Application") objapplic.NewCurrentDatabase ("c:\vb6.mdb") objapplic.Quit End Sub La chiave di lettura di questo paragrafo: coloro che conoscono approfonditamente i modelli ad oggetti dei vari componenti di Microsoft Office, possono eseguire da Visual Basic una miriade di operazioni semplici, ma anche complesse. Questo sempre grazie al concetto di automazione già visto nelle lezioni precedenti.




ESERCIZIARIO 7: Access 2000/Xp e il controllo Data Con questo esercizio dobbiamo gestire l’errore di run-time 3343 “questo errore in inglese recita Unrecognized Database Format”. Ciò significa che il controllo Data, apparentemente non sia adatto a leggere database in formato access 2000,2002 (versione xp) e di Office System (versione 2003). Ma se apportiamo delle modifiche all’applicazione che stiamo realizzando, questo errore non verrà più sollevato da Visual Basic, per mezzo della libreria di Accesso Dao. Il controllo Data solleva tale errore perché è stato progettato per funzionare con il Jet (motore di gestione dei database) Engine 3.5, mentre per accedere a database con versione 2000 il motore di gestione è passato alla versione 3.6 Ecco ad ogni applicazione, per la quale vogliamo aggiungere il controllo Data per l’accesso ai database, si devono compiere i seguenti passi:

1) Aggiungere un riferimento alla nuova libreria Dao Microsoft Dao 3.6 Object Library dalla finestra di dialogo Riferimenti (da menu Progetti-Riferimenti)

2) Dichiarare una variabile di tipo Recordset 3) Dichiarare una variabile di tipo database 4) Aprire il recordset con il metodo Openrecordset dell’oggetto Database e

assegnarlo alla variabile di tipo Recordset 5) Assegnare la variabile Recordset istanziata alla proprietà Recordset del

controllo Data aggiunto sul form. Ricordo che ogni controllo Data aggiunto, Visual Basic assegna un numero progressivo (e avremo Data1, Data2, e così via) Ammettiamo che la variabile Recordset istanziata sia rs, la riga di codice per impostare la proprietà Recordset dell’oggetto Data1 è



Set data1.Recordset=rs Vi ricordo che oltre al controllo Data per l’accesso ai db, esiste il controllo Ado Data Control (che può essere aggiunto alla toolbox per mezzo della finestra Componenti – Ctrl+T). Viene sollevato l’errore “Unrecognized Database Format” nel caso si utilizzi il provider di accesso ai db Microsoft Jet.OLEDB.3.51 anziché il nuovo in versione 4.0. Il vecchio provider di accesso è quello installato automaticamente con Visual Basic. Dopo questi brevi indicazioni teoriche, possiamo creare l’interfaccia utente che utilizzi il controllo Data per accedere ad un database Access in formato Access 2003 Il database in versione Access 2002-2003 ha questi oggetti creati

La struttura della tabella ‘tabella_acc03” ha i seguenti campi:

• cognome • nome • indirizzo • telefono • email

I nomi dei campi risulteranno le etichette della nostra interfaccia utente Le caselle di testo saranno associate al controllo Data che andremo a configurare in maniera programmatica.



Interfaccia grafica per l’inserimento dei dati nel database Le righe di codice per il pulsante di comando Imposta sono:

Le righe di codice per il pulsante di comando Aggiungi sono: Private Sub Cmd_Aggiungi_Click() With Data1.Recordset .AddNew .Fields(0).Value = txtcognome.Text .Fields(1).Value = txtnome.Text .Fields(2).Value = txtindirizzo.Text .Fields(3).Value = txttelefono.Text .Fields(4).Value = txtemail.Text .Update End With txtcognome.Text = "" txtnome.Text = "" txtindirizzo.Text = "" txttelefono.Text = "" txtemail.Text = "" txtcognome.SetFocus End Sub Il costrutto With..End With viene utilizzato per rendere leggibile il codice quando si gestiscono le impostazioni delle proprietà di qualsiasi oggetto.



Il metodo Setfocus dell’oggetto casella di testo permette di riprendere un nuovo inserimento, partendo, in questo caso, dalla casella txtcognome N.b. Il controllo Data, all’esecuzione dell’applicazione, non ci serve e quindi impostiamo la proprietà Visible a False ESERCIZIARIO 8: Il controllo FlexGrid Partiamo da una piccola presentazione teorica sul controllo MsFlexGrid. E’ un controllo non intrinseco, infatti non lo troviamo immediatamente nella casella degli strumenti di Visual Basic. Ma per aggiungerlo a quest’ultima occorre selezionarlo dalla finestra Componenti (CTRL+T). Al solito lo aggiungiamo sul form è otteniamo quello che vediamo nella figura qui in basso

Controllo Flexgrid (o griglia) – Nella casella degli strumenti è rappresentato da un’icona gialla. Sul form appare simile ad un foglio di

Excel. Quando viene prelevato il controllo dalla casella degli strumenti e aggiunto sul form, MsFlexgrid1 (nome a cui dobbiamo sempre riferirci nel nostro codice) è ad una sola colonna. Le proprietà che ci permettono di impostare il numero di righe e il numero di colonne della griglia sono: rows e cols Tali proprietà sono di lettura e scrittura nel senso che permettono di impostare e restituire due valori, che rispettivamente ci forniscono due informazioni:

• numero di righe impostate • e numero di colonne

Esempio: Proviamo a impostare una griglia di 3 colonne e 4 righe Le righe di codice da scrivere sono Msflexgrid1.cols=4 Msflexgrid1.rows=5 I valori assegnati alle proprietà cols e rows rispetto a quelli richiesti dall’esempio sono sempre in ragione di una unità in più.



Otteniamo:

Nell’osservare bene la figura notiamo che i risultati richiesti dall’esempio sono stati raggiunti. (3 colonne e 4 righe). Adesso proviamo a intestare le colonne create (ossia le nominiamo in cognome,nome,indirizzo) Le righe di codice a riguardo sono: Msflexgrid1.textmatrix(0,1)=”cognome” Msflexgrid1.textmatrix(0,2)=”nome” Msflexgrid1.textmatrix(0,3)=”indirizzo” Possiamo aggiungere tre etichette lbl_cognome, lbl_nome, lbl_indirizzo e tre caselle di testo in un array di controllo txtvettore(0), txtvettore(1), txtvettore(3). Avremo l’interfaccia utente che si vede in figura

Il codice che gestisce l’interfaccia utente è il seguente: Option Explicit Dim numcolonne As Integer Dim numrighe As Integer Dim righeins As Integer Private Sub Cmd_immetti_Click() Dim colonne As Integer



righeins = righeins + 1 If righeins > numrighe Then 'aggiungiamo una nuova riga MSFlexGrid1.Rows = righeins + 1 End If For colonne = 1 To numcolonne MSFlexGrid1.Col = colonne MSFlexGrid1.Row = righeins MSFlexGrid1.Text = txt_vettore(colonne - 1).Text Next colonne End Sub Private Sub cmd_intesta_Click() MSFlexGrid1.TextMatrix(0, 1) = "cognome" MSFlexGrid1.TextMatrix(0, 2) = "nome" MSFlexGrid1.TextMatrix(0, 3) = "indirizzo" End Sub Private Sub cmd_nuovo_Click() 'Maschera inserimento vuota Dim numcampi As Integer Dim j As Integer numcampi = txt_vettore.Count For j = 0 To numcampi - 1 txt_vettore(j).Text = "" Next j End Sub Private Sub Form_Load() 'Impostazioni controllo MSFlexgrid numcolonne = MSFlexGrid1.Cols - 1 numrighe = MSFlexGrid1.Rows - 1 'rendiamo a run-time la larghezza delle colonne modificabili MSFlexGrid1.AllowUserResizing = flexResizeColumns End Sub Recuperiamo adesso una riga di dati dal controllo Flexgrid e la copiamo nella maschera d’inserimento Il codice che dovrà essere aggiunto a quello visto in precedenza è:



Private Sub MSFlexGrid1_Click() Dim recsel As Integer Dim colonne As Integer Dim indice As Integer recsel = MSFlexGrid1.RowSel colonne = MSFlexGrid1.Cols - 1 For indice = 1 To colonne MSFlexGrid1.Col = indice MSFlexGrid1.Row = recsel txt_vettore(indice - 1).Text = MSFlexGrid1.Text Next indice End Sub



EEsseerrcciizziiaarriioo ddii VViissuuaall BBaassiicc:: PPaarrttee SSeeccoonnddaa

ESERCIZIARIO 9: Aprire una maschera creata in Access da VB L’esercizio di questo paragrafo richiede di accedere ad un oggetto maschera di un db in formato access direttamente da Visual Basic Come si realizza questo esercizio?

1) Per prima cosa occorre aprire Visual Basic e creare un progetto Exe Standard;

2) Aggiungere come riferimento Microsoft v xx Access Object Library (dove xx sta per versione installata sul vostro Personal Computer)

3) Aggiungere una casella di testo nella quale memorizzare il nome della maschera che si desidera aprire

4) Un pulsante di comando per eseguire le seguenti righe di codice Nella sotto-cartella esempi della cartella del corso VB6, c’è un database che si chiama esercizio_db.mdb, la maschera da aprire è masch_prodotti Prima dell’indicazione delle righe di codice, rappresentiamo in figura l’interfaccia grafica utente da realizzare

Il pulsante di comando si chiama cmd_aprimasch Private Sub cmd_aprimasch_Click() Dim OBJAPPLIC As Access.Application



Set OBJAPPLIC = New Access.Application OBJAPPLIC.OpenCurrentDatabase ("C:\Documents and settings\Utente principale\desktop\corso\vb6\esempi\esercizio_db.mdb") OBJAPPLIC.DoCmd.OpenForm txt_nomemasch.Text, acNormal, , , acFormEdit, acDialog End Sub ESERCIZIARIO 10: Applicazione con l’uso dei controlli intrinseci Data una listbox di parole, l’interfaccia utente deve eseguire le seguenti operazioni:

• Immissione dati nella lista • Mettere in ordine alfabetico gli elementi della lista • Permettere la cancellazione di un elemento (cognome e nome) dalla lista

L’interfaccia grafica utente da realizzare è la seguente:

Le righe di codice per gestire l’applicazione sono: Option Explicit Private Sub Cmd_Cancella_Click() Dim msg As Integer Dim INDICE As Integer If lst_parole.ListIndex = -1 Then msg = MsgBox("Non hai selezionato nessun elemento!", vbCritical) Else INDICE = lst_parole.ListIndex lst_parole.RemoveItem INDICE End If End Sub



Private Sub Cmd_Immetti_Click() Dim elemento As String elemento = InputBox("Inserire una parola:") lst_parole.AddItem elemento End Sub Private Sub cmd_ordina_Click() Dim NUMELEMENTI As Integer Dim TEMP As String Dim J As Integer Dim K As Integer Dim VET() As String NUMELEMENTI = lst_parole.ListCount ReDim VET(NUMELEMENTI) For J = 0 To NUMELEMENTI - 1 VET(J + 1) = lst_parole.List(J) Next J For J = 1 To NUMELEMENTI For K = J + 1 To NUMELEMENTI If VET(J) > VET(K) Then TEMP = VET(J) VET(J) = VET(K) VET(K) = TEMP End If Next K Next J lst_parole.Clear For J = 0 To NUMELEMENTI - 1 lst_parole.AddItem VET(J + 1) Next J End Sub A titolo di esempio ho sviluppato il codice per ordinare una lista di riepilogo, simile alla tecnica di ordinamento di un vettore monodimensionale (o array) Comunque vi ricordo che in sede di aggiunta del controllo ListBox sul form, c’è una proprietà sorted, che se viene impostata a true, ordina alfabeticamente e automaticamente tutti gli elementi aggiunti alla lista con il metodo AddItem Per cancellare un elemento dalla lista occorre prima selezionarlo Se la proprietà index dovesse risultare uguale a -1, significa che non è stato selezionato nessun elemento e genera un alert di errore In caso la proprietà listIndex è diversa da -1, allora viene eseguito il metodo removeItem indice dove indice è la posizione dell’elemento, nella lista, selezionato.



LLaa rraaccccoollttaa ddeeii ttrruucccchhii ddii VVBB66[[11]]

Trucco n° 1: Le Api di Windows e il controllo dell’esistenza di una cartella Dalla lezione 20 parte un ciclo di lezioni che fornirà a tutti i corsisti una serie di trucchi utili da poter inserire nelle proprie applicazioni: non a caso il titolo della lezione è La raccolta dei trucchi di VB6 Introduciamo questo ciclo di lezioni fornendo la funzione Api di Windows che controlla l’esistenza di una cartella. Il dato di input del problema è fornire un path name (o percorso) della cartella. Oltre la funzione Api di Windows, che adesso forniremo, esiste una funzione che si chiama GetATTR. Essa permette di ottenere la stessa informazione (cioè dell’esistenza della cartella controllando che il path name fornito non corrisponda ad un file bensì ad una cartella). Le righe di codice di applicazione di detta funzione sono: Function controllafolder(pathname As String) As Boolean On Error Resume Next controllafolder = GetAttr(pathname) And vbDirectory End Function Sub Main() Dim pathname1 As String Dim msg As Integer pathname1 = InputBox("Inserisci percorso cartella:") If controllafolder(pathname1) = False Then msg = MsgBox("La cartella non esiste:", vbCritical) Else msg = MsgBox("La cartella:" & " " & pathname1 & " " & "esiste", vbInformation) End If



End Sub Per provare detto trucco, basta aggiungere al progetto un modulo, fare un copia incolla del codice dato nella finestra, e premere il tasto di funzione F5 per l’esecuzione dell’applicazione Utilizzando le Api di windows, per il controllo delle cartelle e di ogni operazioni sui file, occorre far riferimento alla libreria di collegamento dinamico Public Declare Function GetFileAttributes Lib "kernel32" Alias "GetFileAttributesA" (ByVal pathfolder As String) As Long Sub main() Dim pathname1 As String Dim msg As Integer Dim codice_attributo As Long pathname1 = InputBox("Inserisci percorso cartella:") codice_attributo = GetFileAttributes(pathname1) If codice_attributo = 16 Then msg = MsgBox("La cartella:" & " " & pathname1 & " " & "esiste!!", vbInformation) Else msg = MsgBox("La cartella non esiste!", vbCritical) End If End Sub




��

��

� ��

�� !�"��#��$�� %��&� �� '�� &�� %%��(��(�� !��)�� *+�� )�� *+�� )��'��*+�� *+�� ,��#��-�� .�/� ��&� ��0�� 1��%%�� (�� 1�� (�� $�� $�� !��2�� '�� '�� !��1��'��(��'��(��!��(��)��



��

��

��

��

��

�"��3��'��4��5��(��1��(��'�� +��6��2��$�� '��7&8&9&�:��!�� '��,��&7&9&; ��<�� $�� =��>��(��?*+��?+*+��7��?*+��9��?@*+��;�,��?&?+&?&?@ ��?@��?��?+��?��A�� '�� '��3��B��,��+&+&+&+ � ��+&+&+& � ��+&+&+&@ � ��+&+&+&> �,��+&+&+&7 � ��+&+&+&8 � ��+&+&+&9 � ��+&+&+&C �,��+&+&+&; ��)��(��

• �� (��&� �� • ��%%��(��

��



��

��

� ��

�� !�� "�� #��$� �� !!�!�� $� �� $� �� %�� !!�&�� !�� '� �� "��(�)*�+�� !�� !� �� ,�� %�� )�� $� �� -�� !�� $� �� .� �� !!��-�� +�� !�� .� ��!�� !��*�+�� *��/�� $� � �� !��0��/�� $� �� !��0��$�� !!� �� !�� *��1��

�



1��

�

�� *��0�� $��-�� $�� &��

�&&�� $�� %�� )$�� %�� &��)$�� %�� &��)*�� %��-�� &2�� )��

��

�� !"� �� #��$��%� $��

��&��'��(��#��)%�*��

+��'��%�

�

�� #�� $�� '�� (�� #�� ,�� '��

��%�

� �



�



Trucco n° 4: Il controllo Internet Transfer Control e il codice Html Il trucco che esamineremo in questo paragrafo è la possibilità di conoscere il codice html di una pagina web salvata, ad esempio su uno spazio web personale e di visualizzarla attraverso il controllo WebBrowser L’interfaccia grafica utente è quella che si vede in figura

Una piccola descrizione: L’interfaccia grafica in figura consta di

• una casella di testo multi-riga (basta dalla pagina di proprietà dell’oggetto impostare a true la proprietà multiline)

• due pulsanti di comando (Get html page) e un pulsante per visualizzare la pagina Web attraverso il controllo WebBrowser

Private Sub Command1_Click() Dim htmlpage As String Form1.Inet1.Cancel Inet1.Protocol = icHTTP



htmlpage = Inet1.OpenURL("http://xoomer.virgilio.it/newit1/ecdl-start.htm") Text1.Text = htmlpage Open "c:\test.htm" For Output As #1 Print #1, Text1.Text Close 1 End Sub Private Sub Command2_Click() Form2.WebBrowser1.Visible = True Form2.WebBrowser1.AddressBar = True Form2.WebBrowser1.MenuBar = True Form2.WebBrowser1.Navigate "file:///c:/test.htm" Form2.Show 1 End Sub Per eseguire questo trucco avete bisogno di creare un progetto con due form Nel primo form realizzate l’interfaccia utente vista in figura, aggiungendo dalla finestra componenti (Ctrl+T), il controllo Microsoft Internet Transfer Control Commentando il codice associato al primo pulsante abbiamo:

• Chiudiamo con il metodo cancel ogni sessione di trasferimento in qualsiasi modalità impostata con la proprietà protocol dell’oggetto Inet1

• Impostiamo la proprietà Protocol a IcHTTP • Assegniamo ad una variabile di tipo stringa tutto il codice Html con il

metodo OpenUrl dell’oggetto Inet1 e passando come argomento un Url della pagina web online

• Assegniamo il contenuto di tale variabile all’oggetto textbox1 • Creiamo come già sappiamo un file ad accesso sequenziale dove

memorizziamo il codice html ottenuto Nel secondo form aggiungiamo il controllo WebBrowser Attraverso il primo form visualizziamo il secondo e otterrete il seguente risultato:




Trucco n° 5: Accesso ad un database protetto da Password Capita sovente di aver creato un database di Access con Microsoft Office Access e di proteggerlo con password. Prendiamo come esempio il file mdb esercizio_db.mdb. Se esso viene aperto con Microsoft Office Access, apparirà una finestra di richiesta della Password. Solo dopo aver immesso quella giusta, l’applicazione risulterà funzionante, altrimenti non conosceremo sino ad allora il contenuto dei vari oggetti creati. Domanda: Come si può con Visual Basic, aprire un database di access protetto da password? Il trucco che vedremo a tal proposito sta nella scrittura della stringa di connessione con Ado (il modello ad oggetti più potente per accedere a database di vario tipo, tra cui anche Access) Dim cn As New Adodb.Connection Cn.Provider=”Microsoft Jet 4.0 OLE DB Provider” Cn.ConnectionString=”Data source=c:\esercizio_db.mdb” Cn.Open Se non viene impostata nella stringa di connessione anche la password di accesso, viene generato da Ado tramite Visual Basic un errore a run-time



Prima di cn.Open, mancava la riga di codice cn.Properties("Jet OLEDB:Database Password") = "corsovb6" corsovb6 è la password di accesso al database esercizio_db.mdb N.b. Per eseguire questo trucco occorre che abbiate sul vostro pc un database di Access protetto con una password che avete scelto voi e cambiare alcuni riferimenti che in questo trucco non ci sono: tipo il path name del database sul vostro pc la password da voi impostata attraverso l’applicativo di Access




Trucco n° 6: Lo sviluppo della proprietà sorted del controllo ListBox Si chiude il ciclo delle lezioni sui trucchi di Visual Basic. Trattasi della funzione che permette di ordinare una lista di riepilogo senza impostare a true la proprietà sorted del controllo stesso. Dobbiamo immaginare la lista di riepilogo come un’array monodimensionale (o vettore) e applicare la tecnica di ordinamento oramai famosa e classica in tutti i testi didattici di informatica di base Private Sub cmd_ordina_Click() Dim NUMELEMENTI As Integer Dim TEMP As String Dim J As Integer Dim K As Integer Dim VET() As String NUMELEMENTI = lst_parole.ListCount ReDim VET(NUMELEMENTI) For J = 0 To NUMELEMENTI - 1 VET(J + 1) = lst_parole.List(J) Next J For J = 1 To NUMELEMENTI For K = J + 1 To NUMELEMENTI If VET(J) > VET(K) Then TEMP = VET(J) VET(J) = VET(K) VET(K) = TEMP End If Next K Next J lst_parole.Clear For J = 0 To NUMELEMENTI - 1



lst_parole.AddItem VET(J + 1) Next J End Sub In questo trucco ci sono dei riferimenti teorici molto importanti: La proprietà Listcount del controllo listBox ci restituisce il numero degli elementi aggiunti Abbiamo dichiarato un array dinamico con l’istruzione Dim Una volta conosciuto il valore di ListCount (variabile ad ogni elemento aggiunto), avviene il ridimensionamento della variabile array di tipo stringa. Allocherà, se listcount dovesse essere 5, 5 cellette di memoria Poi con le righe di codice For J = 0 To NUMELEMENTI - 1 VET(J + 1) = lst_parole.List(J) Next J Avviene il caricamento degli elementi della lista nel variabile array vet Indice parte da 0 perché il primo elemento della lista ha posizione 0 Solo che quando carichiamo il valore dell’array, lo mettiamo in posizione 1; ciò è giustificato dalla scrittura vet(j+1) Con un ciclo nidificato , ad ogni vet(j)>vet(k) avviene lo scambio per mezzo di una variabile temporanea temp, sempre di tipo stringa Alla fine di questi due cicli for, abbiamo il vettore ordinato e possiamo caricare gli elementi nella lista, dopo averla pulita con il metodo Clear



II ccoonnttrroollllii ppeerr ggeessttiirree ll’’aacccceessssoo aaii ffiillee ee

ddiirreeccttoorryy DriveListBox, DirListBox, FileListBox Questo gruppo di controlli intrinseci ci facilitano il lavoro per conoscere il contenuto del file system di ogni supporto di memoria di massa (hard disk, floppy, cd-rom) in base al valore di DriveListBox Cominciamo col portare i tre controlli su un form

Adesso si tratta di compiere un’operazione di sincronizzazione tra questi tre controlli, ossia selezionando l’unità drive si deve aggiornare automaticamente la lista delle cartelle (DirListBox), selezionando una cartella con doppio clic, si deve aggiornare la lista dei file ivi contenuti (FileListBox) Per far ciò gli eventi Change associati a driveListBox e dirlistBox sono: Private Sub Dir1_Change() File1.Path = Dir1.Path End Sub



Private Sub Drive1_Change() Dir1.Path = Drive1.Drive End Sub Per conoscere il nome del file selezionato nel controllo FileListBox, basta utilizzare la proprietà FileName Quando verrà eseguita detta applicazione si può verificare il seguente errore run-time caratteristico del controllo DriveListBox

Errore run-time 68

Tale errore viene generato per i seguenti dispositivi rimovibili: cd-rom e floppy. Per l’hard disk in condizione di integrità, non genererà nessun errore, in quanto è disco fisso e sempre pronto. Dovendo gestire l’errore run-time 68, possiamo personalizzare l’alert in questo modo

Per far visualizzare tale alert personalizzato occorre modificare le righe di codice associate all’evento change del controllo Drive1



Attraverso l’enunciato On Error Resume Next possiamo catturare tutti gli errori di run-time. Occorre solo saper (e non c’è una regola) localizzare, nel codice, al punto giusto questo enunciato. Poi c’è l’enunciato err con una serie di proprietà, tra cui number che ci fornirà il codice di errore generato. Siccome il codice di run-time generato è 68 digiteremo If err.number=68 then …… ….. End if



CCoommee aavvvviieennee llaa ddiissttrriibbuuzziioonnee

ddeellll’’aapppplliiccaazziioonnee Distribuire l’applicazione per conto terzi L’operazione che stiamo per esaminare in questo paragrafo capita frequentemente quando terminiamo di sviluppare l’applicazione e dobbiamo consegnarla al nostro cliente che l’ha commissionata Quando installiamo Microsoft Visual Studio o una copia retail di solo Visual Basic, nel menu di start si aggiunge un link ad un Tool fondamentale:

TOOL PER DISTRIBUIRE LE NOSTRE APPLICAZIONI E’ Package & Deployment Wizard

Pensiamo di voler distribuire l’applicazione con l’uso soltanto dei controlli intrinseci. Vi ricordo che è errato pensare che si possa passare al cliente solo il file eseguibile creato (nome progetto.exe), attraverso l’IDE(Integrated Development Environment o Ambiente di sviluppo integrato). Occorre sempre utilizzare il tool Package Develoment Wizard, in quanto un semplice programma, con l’uso dei controlli intrinseci (ossia soltanto quelli presenti nella ToolBox), per il corretto funzionamento dipende da una libreria fondamentale.



Tale libreria prende il nome di: MSVBVM60.DLL. (contiene numerosi file ausiliari che servono all’applicazione eseguibile per poter funzionare) In altre parole se funziona l’applicazione sul nostro Computer, mancando tale libreria installata sul pc del nostro cliente, l’applicazione creata non funzionerà proprio. Ecco che la creazione guidata dei pacchetti di installazione servirà proprio a gestire le dipendenze della nostra applicazioni di eventuali librerie aggiunte oltre quella di base che è MSVBVM60.DLL Durante questo corso ne abbiamo viste di librerie e controlli di terze parti aggiunti.



AAllccuunnee lliibbrreerriiee uuttiillii nneellllee aapppplliiccaazziioonnii

La libreria Microsoft Scripting Runtime La libreria a collegamento dinamico, che prende il nome di Microsoft Scripting Runtime, si chiama scrrun.dll Viene impiegata per gestire al meglio:

1. Le matrici associative attraverso l’oggetto Dictionary;

2. i file system attraverso l’uso di filesystemObject o l’equivalente Oggetto TextStream

3. Permette di capire se un file esiste su un supporto magnetico oppure no

e sulla base di una data cartella conoscere tutti i file attraverso la collection Files, oppure riempire la collections folders(insieme di tutte le cartelle conoscendo il nome dei drive (c:\ hard disk, a:\ floppy disk, d: cd-rom e: eventuale altro cd-rom)

Esempio: Creazione di un’interfaccia che carica tutti i nomi assegnati alle varie unità hardware (floppy, hard disk, lettori cd-rom); poi selezionando una di queste unità, nella seconda lista vengono caricate tutte le cartelle, selezionando a loro volta una di queste cartelle, vengono caricate nell’ultima lista di riepilogo tutti i file contenuti



Interfaccia grafica dell’applicazione

Osservazione: In questo esempio di applicazione non si trovano pulsanti, in quanto sono stati associati 3 eventi a catena: L’evento di selezione di un elemento della prima lista riempie la seconda lista. La selezione di un elemento della seconda lista riempie la terza e ultima lista. L’evento che accomuna queste tre liste di riepilogo è OnClick

Quando il form viene caricato, viene eseguito l’evento Form_Load: Le righe di codice associate permettono di creare:

• un’istanza alla classe Scripting.FileSystemObject



• Poi avviene tramite l’istruzione set l’assegnazione della collection Drives dell’oggetto Obj alla variabile ObjDrive

• Viene eseguito un for each nella collection Objdrive creata al punto 2 • Con il metodo AddItem della lista di riepilogo n° 1 vengono caricati i

nomi dei drive logici assegnati dal sistema Operativo (vedi proprietà driveLetter)

Poi è stato associato l’evento OnClick alla prima lista di riepilogo caricata secondo la procedura già spiegata in precedenza Nella variabile lettera viene recuperata la root del nome del drive selezionato attraverso la prima lista di riepilogo Il contenuto di questa variabile diventa argomento del metodo GetFolder dell’oggetto Obj (Scripting.FileSystemObject) L’espressione Obj.GetFolder(lettera) viene assegnato all’oggetto Objfile di tipo Folder Viene eseguito un ciclo For Each per esaminare tutti i nomi delle sottocartelle contenute nella root del drive selezionato nella prima lista di riepilogo La stessa procedura viene applicata anche per recuperare i file della sottocartella selezionata nella seconda lista di riepilogo. Vediamo un’ultima figura per comprenderne gli effetti di questo esempio di applicazione

Basta selezionare l’unità drive dell’hard disk (c:\), vengono caricate nella lista di riepilogo tutte le cartelle (o folder) della root e poi selezionando una di quelle cartelle, vengono caricate nell’ultima lista di riepilogo tutti i files in essa contenuti Nella cartella esempi del corso (\vb6\esempi) c’è un file zippato che si chiama applicfolder.zip. In quel file troverete i sorgenti e il file eseguibile allo scopo di avere subito una demo operativa dell’applicazione.




La libreria Microsoft Script control 1.0 In un’applicazione di Visual Basic 6.0, aver aggiunto un riferimento alla libreria che porta il nome del paragrafo della lezione 29-esima del corso, significa poter imparare didatticamente, direttamente da una semplice applicazione, l’utilizzo dei linguaggi di scripting più autorevoli del Web (c.d. linguaggi lato client) come VBScript e Jscript. In questo paragrafo, suddiviso in 3 steps, impareremo velocemente a crearci un piccolo editor, in cui scriveremo il codice in VBScript in una casella di testo multiriga, e premeremo un pulsante di comando per eseguirlo. Primo steps:

- Avvio di Microsoft Visual Basic 6.0 - Creazione di un’applicazione Exe Standard

Su questo form posizioneremo una casella di testo multiriga txtcodicevbs e un pulsante di comando Esegui (cmd_esegui)



Definizione dell’interfaccia di base Steps n° 2 Aggiungere un riferimento alla libreria Microsoft Script Control 1.0

Scegliere Riferimenti dal menu Progetto



Scegliere la libreria Microsoft Script Control 1.0 e mettere un segno di spunta al relativo checkbox e confermare con Ok. Da adesso in poi Visual Basic conoscerà metodi, oggetti, ed eventi di questo ActiveX

Fatto questo è possibile associare all’evento OnClick, del pulsante di comando aggiunto sul form, le seguenti righe di codice

Cuore dell’applicazione Tre righe di codice che permetteranno di eseguire del codice VBScript all’interno dell’applicazione VB6

Steps n° 3 Esecuzione dell’applicazione



Nella casella di testo multiriga osservate le righe di codice da eseguire con il linguaggio VBScript. Basta premere il pulsante Esegui script per esegure tale codice




La libreria Microsoft Shell Controls And Automation La libreria Microsoft Shell Controls And Automation è la libreria compilata della maggior parte delle chiamate ad Api di Windows che facilitano gran parte del nostro lavoro. Ecco che la utilizzeremo nelle nostre applicazioni quando:

- Dobbiamo visualizzare la finestra di dialogo Sfoglia per cartelle: Il codice per utilizzare tale libreria allo scopo di visualizzare detta finestra è

- Dobbiamo visualizzare dalla nostra applicazione il pannello di controllo



Il codice da utilizzare è il seguente

Il parametro da passare al metodo ControlPanelItem dell’oggetto Shell della libreria Microsoft Shell Controls And Automation è il percorso del file con estensione Cpl (che è un file di configurazione di ciascun elemento che troviamo nel pannello di controllo di Windows) Io sul mio pc ho un file di estensione del Pannello di controllo che si chiama timedate.cpl (voi potete fare una ricerca sul vostro pc e verificare quali file di estensioni del pannello di controllo avete in base al sistema operativo installato) Questo file, solitamente per i sistemi Xp sta nella cartella windows\system32 e la riga di codice



Objshell.ControlPanelItem “c:\windows\system32\timedate.cpl” visualizzerà il datario, la cui icona la troviamo anche nella system tray (o barra di sistema) In figura vediamo ciò che viene visualizzato

Per ottenere la finestra Esplora risorse, utilizzeremo sempre questa libreria Il codice è ObjShell.Explore “c:\” Visualizzerà



CONCLUSIONI: Provate ad aggiungere dalla finestra di dialogo riferimenti, la predetta libreria e divertitevi a utilizzare i restanti metodi non presi in considerazione. Servirà a voi per stimolare a saper utilizzare i controlli Il futuro di Visual Basic 6.0, sebbene sia stato un ambiente di sviluppo visuale molto popolare, ha esaurito il suo ciclo di sviluppo ed è stato sostituito in modo radicale dalla nuova piattaforma microsoft che porta da un paio di anni la sigla .Net. Leggevo recentemente su una rivista che molti sviluppatori vorrebbero creare un clone freeware di Visual Basic e dare la possibilità a molti, che non vogliono utilizzare ancora il sistema complesso di VB.NET, di fare esperienza ancora su Visual Basic 6.0 Queste sono voci, il tempo ci darà ragione di cosa succederà.



VViissuuaall bbaassiicc iinn ttrreennttaa lleezziioonnii:: TTeesstt ffiinnaallee

TEST FINALE DEL CORSO DI VISUAL BASIC IN TRENTA LEZIONI: Premessa Corsisti, non vi appesantisco più di tanto, perché il corso è già stato corredato, come avete potuto notare, di esempi pratici e anche di alcuni filmati chiavi. E’ solo per stimolare la vostra curiosità nel trovare nelle trenta lezioni e altrove anche la risposta. Infatti nel lavoro di sviluppo, quando si è in difficoltà di come si svolgerà qualsiasi operazione, non vi basterà il corso che è solo guida per fornirvi le chiavi per far partire ‘macchina’, ma è esistono una miriade di strumenti, tipo forum, portali su visual basic, il motore di ricerca, la msdn library online di microsoft (anche se molto difficile alcune volte leggerla, perché molto vasta, ma molto importante che ci sia – su di essa troverete gigabyte di informazioni su Visual Basic e non solo). Dopo questa doverosa premessa, risponderete a 10 domande:

1) Che cosa s’intende per form? 2) Cosa contiene la casella degli strumenti (o c.d. Toolbox)? 3) Come si cambia tipo ,dimensione e colore del carattere di una casella di

testo durante l’esecuzione dell’applicazione? Suggerimento (mi bastano solo le righe di codice)

4) Quali sono i controlli intrinseci di VB, per mezzo dei quali si accede al file system (file o cartelle su hard disk, cd-rom, floppy)?

5) Quali sono i metodi caratteristici dell’oggetto ListBox.? Per il controllo ComboBox risultano essere uguali?

6) Osservate questo pezzo di codice e risponderete ad una domanda:

Option Explicit Sub Main Dim Cognome As String Dim Nome As String Dim City As String



Cognome=Inputbox(“Inserire il cognome:”) Nome=Inputbox(“Inserire il nome:”) City=Inputbox(“Inserire la città:”) End Sub Sub Visualizza Dim stringaTesto As String stringaTesto=”Dati inseriti:” & cognome & vbCrlf stringaTesto=StringaTesto & nome & vbcrlf stringTesto=StringaTesto & city Msgbox(stringaTesto) End Sub Le domande sono: • Dall’analisi del codice la routine Visualizza verrà eseguita oppure no?

In caso negativo quale istruzione manca per richiamare tale subroutine?

7) Qual è il controllo intrinseco che permette di accedere ai database? 8) Quali sono le righe di codice che permettono di impostare le righe e le

colonne del controllo Flexgrid 9) Per inserire un valore all’interno del controllo Flexgrid nella cella (1,4)

quali sono le righe di codice 10) Con quale proprietà del controllo Flexgrid si può rendere modificabile la larghezza delle colonne?



VViissuuaall bbaassiicc iinn ttrreennttaa lleezziioonnii:: RRiissppoossttee aall

TTeesstt ffiinnaallee TEST FINALE DEL CORSO DI VISUAL BASIC IN TRENTA LEZIONI: Risposte Spero siate riusciti, grazie a questo corso, a rispondere serenamente alle domande che vi sono state poste nella lezione dedicata all’elenco delle 10 domande, e a considerare che non esauriscono tutto Visual Basic, in quanto è l’esperienza di anni con questo strumento di programmazione, a farvi comprendere la logica di funzionamento delle applicazioni stile Windows. Comunque le risposte al test delle 10 domande sono:

1) Alla prima domanda, molto semplice ‘Cosa s’intende per form’ si rispondeva semplice E’ l’oggetto chiave con il quale si progetteranno le interfaccie grafiche utente di ogni applicazione Windows, sulla quale si possono inserire controlli intrinseci e di terze parti detti oggetti.

2) La ToolBox (o detta anche casella degli strumenti) contiene una serie di controlli intrinseci che possono essere predisposti sull’oggetto Form ed essere personalizzati attraverso la finestra proprietà del controllo Essi sono:

a. Casella Immagine (PictureBox) b. Casella di testo (TextBox) c. Casella di riepilogo (ListBox) d. Casella combinata (ComboBox) e. Pulsante di Comando (Command Button) f. Controllo Immagine (Image) g. Casella di controllo (CheckBox) h. Pulsante di opzione (OptionButton) i. Contenitore Ole (Ole Object) j. DriveListBox, DirListBox,FileListBox gruppo di controlli per accesso

ai file e cartelle sul file system E altri, ma già con questi potete già rendere funzionali le vostre applicazioni



3) Le righe di codice richieste sono:

form1.TextBox1.FontName=”Arial” form1.TextBox1.Forecolor=vbred form1.textbox1.fontsize=20

Ecco il risultato in base alle righe di codice

4) I controlli intrinseci,per mezzo dei quali si accede al file system sono tre:

• DriveListBox • DirListBox • FileListBox

Per farli funzionare, occorre, come è stato detto durante il corso, di sincronizzare con il codice, che selezionando un drive (c:\,a:\,d:\, e:\ per eventuali lettori cd o dvd) si carica la lista delle cartelle e doppio clic su una cartella si deve caricare la lista dei files contenuti

5) I metodi caratteristici dell’oggetto ListBox sono:

Additem per aggiungere un elemento List per accedere ad un elemento selezionato, la cui posizione all’interno è data dalla proprietà ListIndex RemoveItem per rimuovere un elemento conoscendo sempre il valore della proprietà ListIndex Quelli della casella combinata sono simili, in quanto la logica di funzionamento è uguale.

6) Osservate questo pezzo di codice e risponderete ad una domanda:

Option Explicit Sub Main Dim Cognome As String Dim Nome As String Dim City As String Cognome=Inputbox(“Inserire il cognome:”) Nome=Inputbox(“Inserire il nome:”) City=Inputbox(“Inserire la città:”) End Sub Sub Visualizza Dim stringaTesto As String



stringaTesto=”Dati inseriti:” & cognome & vbCrlf stringaTesto=StringaTesto & nome & vbcrlf stringTesto=StringaTesto & city Msgbox(stringaTesto) End Sub Le domande sono: • Dall’analisi del codice la routine Visualizza verrà eseguita oppure no?

In caso negativo quale istruzione manca per richiamare tale subroutine?

• Risposta: La routine non verrà mai visualizzata in quanto manca l’istruzione Call con il nome della subroutine (in questo caso visualizza) Comunque le variabili visualizzate all’interno della subroutine visualizza non avranno contenuto, perché le variabili dichiarate sono a livello di modulo. Una volta passato il controllo a visualizza, esse perdono e non conservano più i valori acquisiti all’interno della subroutine principale

7) Il controllo intrinseco che permette di accedere ai database è il controllo Data. Tale controllo è stato progettato per leggere database con un motore di accesso Jet Engine 3.5 Riuscirà a legere, facendo l’esempio di db in access, quelli in formato Access 95,97. Dalla versione 2000 in poi tale controllo genera l’errore 3343. Durante il corso si è discusso di come di gestirlo. 8) Le righe di codice sono: msflexgrid1.cols=x msflexgrid1.rows=y 9) Per inserire un valore nella cella (1,4) Msflexgrid1.col=1 Msflexgrid1.row=4 Msflexgrid.text=valore 10) MSFlexGrid1.AllowUserResizing=flexResizeBoth


visual basic 6 base

Documents

Transcript of visual basic 6 base