 |
| | HOMEPAGE | INDICE FORUM | REGOLAMENTO | ::. | NEI PREFERITI | .:: | RSS Forum | RSS News | NEWS web | NEWS software | |
| | PUBBLICITA' | | | ARTICOLI | WIN XP | VISTA | WIN 7 | REGISTRI | SOFTWARE | MANUALI | RECENSIONI | LINUX | HUMOR | HARDWARE | DOWNLOAD | | | CERCA nel FORUM » | |
15-05-2014, 17.03.47
|
#16 |
|
Senior Member
WT Expert
Registrato: 19-05-2007
Loc.: Verona
Messaggi: 1.302
 |
I Menù dell’Editor di VBA  Vediamo ora una panoramica dei comandi dei menù e della barra strumenti dell'editor di VB per fare una carrellata delle capacità dell'editor stesso. Nella linea sotto l’intestazione appare la barra con i menu: File, Modifica, Visualizza, Inserisci, Formato, Debug, Esegui, Strumenti, Aggiunte, Finestra?  Menu FileIl menu File come in tutte le applicazioni Windows, contiene i comandi relativi al salvataggio e all'apertura dei file. Nell'Editor VB, il menu file offre i comandi necessari per salvare le modifiche apportate ai progetti VBA e stampare il codice sorgente delle macro  Fig. 1Ogni menu è di tipo a tendina e si apre con un clic del mouse, mostrando una serie di comandi. I comandi possono essere momentaneamente disattivati e appaiono sbiaditi (scritte in grigio) in quanto rappresentano un comando non ancora attivo per il progetto in corso. Vediamo ora quali sono i comandi facendo una panoramica dei menu e della barra strumenti dell’Editor di VBA riassumendo i comandi ed elencando lo scopo di ciascuno.
Menù modificaIl menù modifica contiene i comandi per manipolare il codice sorgente di una macro nella finestra del Codice e gli oggetti su un Form
Menu VisualizzaIl menu visualizza mette a disposizione i comandi per scegliere quali elementi dell’editor VB si vogliono vedere e come visualizzarli
Menu InserisciIl menu inserisci permette di aggiungere vari oggetti (moduli, Form) al progetto
Menù FormatoI comandi del menù formato si usano per creare proprie finestre di dialogo personalizzate. Essi permettono di allineare gli oggetti su un Form, di variare la dimensione dei controlli in modo da adattarsi ai contenuti e di fare molte altre cose utili
Menu DebugI comandi del menu Debug vengono usati quando si fa il collaudo delle macro, ovvero quando si procede al debugging delle stesse, che consiste in un processo atto a individuare gli errori nel programma
Menu EseguiI comandi del menu esegui permettono di avviare l’esecuzione di una macro, interromperla o riprendere l’esecuzione.
Menu StrumentiI comandi del menu strumenti non solo rendono possibile selezionare la macro da eseguire, ma consentono anche l’accesso a librerie di macro e controlli per i Form addizionali esterni oltre a quelli integrati nel VBA
L’Editor VB dispone di altri tre menu: Aggiunte, Finestra e Guida. Il menu Aggiunte contiene una sola voce "Gestione delle aggiunte". Questo comando apre la corrispondente finestra di dialogo Gestione delle aggiunte che può essere impiegata per aggiungere o eliminare programmi aggiuntivi (Add-In) di Visual Basic. Il menu Finestra consente di passare da un Form all'altro, portando in primo piano sul desktop quello su cui vogliamo lavorare Il menu Guida dà accesso alla guida on-line di Visual Basic For Applications che contiene istruzioni, suggerimenti, spiegazioni tecniche consultabili durante il lavoro di programmazione. Per una consultazione rapida, basta posizionare il mouse sull'oggetto che interessa e poi premere il tasto F1. La Barra strumenti dell’Editor di VBALa selezione di un pulsante di comando col mouse risulta in genere più comoda per l’utente rispetto alla scelta di un comando da menu. L’Editor VB presenta i comandi più importanti e più usati sotto forma di pulsanti (icone) in una barra strumenti. Per default l’Editor VB visualizza solo la barra strumenti Standard come si vede in figura 2  Fig. 2Oltre a questa l’Editor di VB dispone di altre tre barre strumenti: Modifica, Debug e Userform. La barra strumenti Modifica contiene vari pulsanti di comando utili per editare il testo nella finestra del codice. Si può controllare quali barre strumenti vengono visualizzate tramite il comando Visualizza - Barre strumenti e dato che per default l’Editor di VB non visualizza la barra strumenti Modifica, sarà necessario renderla visibile manualmente. Per visualizzare o nascondere una delle barre strumenti dell’Editor si procede così: Selezionare il comando Visualizza - Barre strumenti per aprire un sotto menu che elenca le varie barre strumenti dell’Editor. Fare clic sul nome della barra strumenti che si vuole visualizzare, per esempio se si vuole rendere visibile la barra strumenti Modifica, fare clic nel sotto menu su Modifica e l’Editor di VB renderà visibile la barra strumenti selezionata Per default l’Editor di VB mostra la barra Strumenti Standard ancorata in alto nella finestra dell’Editor. Una barra strumenti può anche essere resa flottante, ossia non ancorata ad un lato della finestra. In tal caso essa compare in una finestra dotata di bordi e titolo.  Fig. 3Per ancorare o rendere flottante una barra strumenti nell'Editor di VB si usa la medesima tecnica usata per le barre strumenti di Excel, basta trascinare la barra strumenti nella posizione desiderata e poi rilasciare il pulsante del mouse. La barra strumenti Standard dell’Editor di VB contiene 18 pulsanti (icone) ognuno dei quali offre l’accesso rapido a un comando di menu con un semplice clic. I comandi della barra Strumenti Standard partendo dal lato sinistro di figura 2 sono:
___________________________________
- Il primo fondamento della sicurezza non e' la tecnologia, ma l'attitudine mentale - |
|
|
|
15-05-2014, 17.07.36
|
#17 |
|
Senior Member
WT Expert
Registrato: 19-05-2007
Loc.: Verona
Messaggi: 1.302
|
Programmazione ad Oggetti: Metodi e Proprietà E’ bene ricordare che il VBA è un linguaggio di programmazione orientato agli oggetti che consente di gestire le applicazioni con semplicità e la Programmazione ad Oggetti è un sistema di organizzazione del codice di un programma mediante raggruppamento all'interno di oggetti, ovvero singoli elementi che presentano Proprietà e Metodi, in pratica non è più il programma a gestire il flusso di istruzioni, ma sono gli oggetti che interagiscono tra di loro intervenendo sulle azioni del programma, introducendo il concetto di Evento che tratteremo nella prossima lezione. Per fare un esempio concreto, possiamo dire che tutto il mondo intorno a noi è pieno di oggetti: la tastiera, il mouse, lo schermo e così via, quello che contraddistingue un oggetto è una serie di caratteristiche o Proprietà, infatti il mouse è dotato di una rotellina e di due tasti, un oggetto, oltre alle proprietà, possiede anche dei Metodi ossia delle funzioni attraverso le quali esercitare delle azioni. Nell'esempio appena citato, (quello del mouse) tenendo premuto il tasto sinistro e facendo scorrere il mouse si seleziona una o più parole di una riga di testo. Riferendoci alla nostra cartella di lavoro possiamo dire che essa è costituita da oggetti di varia natura, come gli oggetti grafici o i controlli (finestre di dialogo, pulsanti ecc.) incollati su un foglio, ma non è questa la peculiarità di un foglio elettronico la cui ossatura è costituita, partendo dal livello più basso, da :
Sintatticamente possiamo affermare che ciascun oggetto fa parte di una famiglia o classe e l'accesso al singolo membro di ciascuna classe si effettua attraverso metodi, pluralistici, cioè da una pluralità di metodi che collaborano e interagiscono con i vari oggetti in maniera omogenea e ai quali corrispondono insiemi di oggetti quali :Workbooks, Worksheet, Range e Cells, inoltre i membri più elevati si possono omettere nel caso che il soggetto sia attivo; vedremo meglio questo passaggio fra poche righe. Fin qui abbiamo delineato i componenti principali cercando di esporre come vengono interpretati dal Visual Basic applicato al foglio elettronico, ma l'obiettivo vero è quello di focalizzare gli oggetti che formano l'ossatura, il nucleo di uno spreadsheet (foglio di lavoro), al cui centro, vi sono intervalli e celle con il loro contenuto di dati da elaborare o formule e il loro inquadramento nel mondo Visual Basic è fondamentale e aiuterà a capire meglio tutto il resto, vediamo di interpretare quanto appena affermato usando il Visual Basic. Con queste sintassi Workbooks("Lezione2.xls") e Worksheets("Foglio1") si individuano rispettivamente la cartella e il foglio di lavoro (notare i loro nomi virgolettati dentro le parentesi), ma dobbiamo però tenere presente che un elemento può anche venire individuato tramite un indice, il quale può essere o il numero di ordine o il nome fra virgolette, per capire meglio il concetto di indice possiamo dire che la sintassi Workbooks(2) e Workbooks("Lezione2.xls") puntano entrambe alla stessa cartella Lezione2.xls a patto che questa sia la seconda fra quelle aperte contemporaneamente da Excel. Infatti se abbiamo solo la cartella Lezione2.xls aperta, la sintassi esatta diventa Workbooks(1). A questo punto è abbastanza chiaro che l'indice che usiamo fra parentesi nell'oggetto Workbooks varia ed è strettamente legato al numero di cartelle aperte nel momento dell'esecuzione di questa istruzione, pertanto possiamo far notare che è possibile scrivere questa istruzione in tre diversi modi:
Possiamo ridurre tutto il listato ad un semplice Range("A1:B10"), in caso contrario credo che sia abbastanza chiaro come agire usando gli indici per individuare il nostro intervallo (o Range). Si deve inoltre prestare attenzione alle proprietà "pluralistiche" che poco sopra abbiamo citato: le prime volte è facile scordarsi del plurale, scrivendo Workbook("Lezione2.xls") anziché Workbooks("Lezione2.xls") oppure Worksheet("Foglio1") invece di Worksheets("Foglio1"). Vediamo qualche esempio di codice da applicare a quanto esposto finora, ma sopratutto vediamo come automatizzare l'esecuzione di routine creando un pulsante, ad esempio apriamo la nostra cartella ("Lezione2.xls") e rientriamo nel Visual Basic Editor. Questa volta scriveremo noi una macro direttamente senza affidarci all'aiuto del Registratore di macro utilizzato nella precedente lezione. Ponendoci al di sotto dell'ultima riga della macro precedente (basta porre il cursore alla fine di End Sub e premere una o due volte Invio), scriviamo il seguente codice Codice:
Sub Nascondi_Foglio() Worksheets(2).Visible = False MsgBox "Il Foglio 2 è sparito" End Sub MsgBox "Il Foglio 2 è sparito" è invece una funzione di VBA che permette di mostrare all'utente un messaggio che nella sua forma più semplice riporta un messaggio di avviso per l'utente (il testo racchiuso fra virgolette) ed un bottone di OK necessario per la sua chiusura. Torniamo ora ad Excel e facciamo click col destro del mouse sulla barra degli strumenti, ci comparirà un box con delle voci, scegliamo Moduli  Fig. 1Ci comparirà un nuova barra flottante che possiamo ancorare alle altre barre degli strumenti semplicemente trascinandocela.  Fig. 2Premiamo sul pulsante evidenziato dalla freccia rossa e poi spostandoci sul foglio di lavoro teniamo premuto il pulsante di sinistra del mouse, trasciniamolo fino a raggiungere le dimensioni desiderate ed al rilascio ci comparirà il nostro pulsante. Contestualmente si aprirà anche la finestra per assegnare la macro (Nascondi_Foglio) al pulsante appena creato  Fig. 3Stessa operazione e identico risultato si può ottenere inserendo un'immagine sul foglio (si dovrà attivare la barra degli strumenti Disegno) e quindi tramite il solito menu contestuale ottenuto cliccando col destro sull'immagine, assegnargli la macro. Possiamo ridimensionare il pulsante, editarne il testo, cambiarne i caratteri etc. facendo clic sopra al pulsante stesso col pulsante destro del mouse e scegliere, tra le voci del menù contestuale che compare, quella di cui abbiamo bisogno. Se invece vogliamo spostare il pulsante, facciamo ancora clic col destro del mouse, sparirà il menù contestuale e rimarrà evidenziato il pulsante  Fig. 4Possiamo allora spostarlo a piacimento e ridimensionarlo trascinandolo negli angoli  Fig. 5Nota : Per versioni di Excel superiori alla 2003 si deve seguire il percorso : File - Opzioni - Personalizzazione barra multifunzione e nel box Personalizza barra Multifunzione mettere il flag al campo Sviluppo, come da figura sottostante  Fig. 6  Fig. 7A questo punto è comparso un altro menu nella barra multifunzione, il menu Sviluppo, tramite il sotto menu Inserisci scegliere il pulsante e procedere come spiegato poco sopra per la Ver. 2003  Fig. 8PS: E’ possibile usare una forma geometrica invece di un pulsante a cui assegnare una macro, in questo caso si procede in questo modo: dal menu Inserisci - Forme  Fig. 9 Scegliere il rettangolo e disegnarlo sul foglio, a operazione compiuta verrà riportata in automatico la finestra delle macro, in alternativa è possibile farla comparire cliccando col tasto destro del mouse sulla forma e nel menù che compare scegliere la voce Assegna Macro  Fig. 10Fine Nota Possiamo ora mandare in esecuzione la macro stessa semplicemente cliccando sul pulsante appena creato, adesso il foglio è sparito, come facciamo a farlo riapparire? Basta creare una nuova macro che assoceremo ad un altro pulsante, con le stesse modalità di costruzione della precedente: Codice:
Sub Mostra_Foglio() Worksheets(2).Visible = True MsgBox "Il Foglio 2 è Ricomparso" End Sub
___________________________________
- Il primo fondamento della sicurezza non e' la tecnologia, ma l'attitudine mentale - |
|
|
|
|
15-05-2014, 17.10.07
|
#18 |
|
Senior Member
WT Expert
Registrato: 19-05-2007
Loc.: Verona
Messaggi: 1.302
|
Gli eventi della cartella di lavoro o ThisWorkbook Per funzionare appropriatamente, la maggior parte dei programmi di Excel, VBA modifica in qualche modo l’ambiente dell’applicazione stessa, queste modifiche possono comportare l’aggiunta di comandi di menu, la visualizzazione di barre degli strumenti o l’impostazione di opzioni. Nella maggior parte dei casi, tutti questi cambiamenti devono essere apportati in Excel prima che l’utente avvii il programma di VBA, in modo che i comandi di menu e le barre degli strumenti siano disponibili fin dall’inizio. Un programma di VBA non dovrebbe obbligare l’utente ad aggiungere menu e barre degli strumenti e a modificare le impostazioni delle opzioni, pertanto dobbiamo fare in modo che questi cambiamenti si verifichino automaticamente all'avvio usando una routine di gestione dell’evento Open della cartella di lavoro. L’evento Open viene generato quando viene aperta una cartella di lavoro e il codice di una routine Open, viene eseguito ogni volta che la cartella di lavoro viene aperta e rappresenta uno strumento ideale per impostare le eventuali condizioni speciali necessarie per la cartella stessa. Per poter accedere agli eventi della cartella si deve agire in questo modo:  Fig. 1Selezionare la voce ThisWorkbook nella finestra del progetto, indicato dalla freccia rossa in figura 1, per accedere al modulo di classe della cartella di lavoro (Workbook) di seguito selezionare Workbook nella casella a discesa sopra la finestra del codice, indicata dalla freccia blu e nella casella a fianco, indicata dalla freccia verde compariranno i vari eventi per l’oggetto. Di seguito riportiamo gli eventi principali associati all’oggetto WorkBook: Private Sub Workbook_Open ()Questo evento può innescare una procedura quando si apre la cartella di lavoro Codice:
Private Sub Workbook_Open()
MsgBox "Buongiorno " & Environ("UserName")
End Sub
Private Sub Workbook_Open()
MsgBox “Benvenuto”
End Sub
Private Sub Workbook_Open()
Sheets("Foglio3").Activate
End Sub
Private Sub Workbook_Activate()Questo evento viene innescato quando viene attivata la cartella di lavoro. La procedura non viene avviata se si proviene da un'altra applicazione, mentre la cartella di lavoro era attiva Codice:
Private Sub Workbook_Activate()
‘nascondere la barra della formula
Application.DisplayFormulaBar = False
End Sub
Private Sub Workbook_Activate()
‘mostra la userform1
Userform1.Show
End Sub
Private Sub Workbook_Activate()
MsgBox "Benvenuto”
End Sub
Private Sub Workbook_Deactivate ()Questo evento viene attivato quando si seleziona un'altra cartella di lavoro. Codice:
Private Sub Workbook_Deactivate()
‘attiva la barra della formula
Application.DisplayFormulaBar = True
End Sub
Private Sub Workbook_Deactivate()
MsgBox "Arrivederci"
End Sub
Private Sub Workbook_BeforeClose (Cancel As Boolean) Questo evento viene generato prima di chiudere la cartella di lavoro, che si chiude solo quando l'evento è terminato. Il parametro Cancel impedisce la chiusura del file. Codice:
Private Sub Workbook_BeforeClose(Cancel As Boolean)
‘blocca la chiusura della cartella di lavoro finchè la cella A1 è vuota.
If Sheets("Foglio1").Range("A1") = "" Then
MsgBox "Completare l’inserimento in A1"
Cancel = True
Else
ThisWorkbook.Save
End If
End Sub
Private Sub Workbook_BeforeClose(Cancel As Boolean)
If MsgBox("Vuoi veramente chiudere la cartella di lavoro?", 36, "Conferma") = vbNo Then
Cancel = True
End If
End Sub
Private Sub Workbook_BeforeClose(Cancel As Boolean)
‘salvare data e ora nel foglio1
Worksheets("Foglio1").Range("A1").Value = _
Format(Date + Time, "dd/mm/yy hh:mm")
ThisWorkbook.Save
End Sub
Private Sub Workbook_BeforePrint (Cancel As Boolean)Questo evento si verifica prima della stampa che inizia solo dopo questa procedura, il parametro Cancel blocca l’esecuzione della macro Codice:
Private Sub Workbook_BeforePrint(Cancel As Boolean)
‘ricalcola tutti i fogli della cartella di lavoro attiva prima di stampare
For Each wk in Worksheets
wk.Calculate
Next
End Sub
Private Sub Workbook_BeforePrint(Cancel As Boolean)
ActiveSheet.PageSetup.PrintArea = Selection
End Sub
Private Sub Workbook_BeforePrint(Cancel As Boolean)
Cancel = false
Worksheets("Foglio1").PageSetup.RightFooter = "Produced by " & myname
End Sub
Private Sub Workbook_BeforeSave (ByVal SaveAsUI As Boolean, Cancel As Boolean)Questo evento viene generato prima di avviare il lavoro di backup, il parametro SaveAsUI restituisce TRUE se la casella "Salva con nome" verrà visualizzata, se si specifica il parametro Cancel = True verrà bloccata l’operazione di salvataggio Codice:
Private Sub Workbook_BeforeSave(ByVal SaveAsUI As Boolean, Cancel As Boolean)
‘impedire il salvataggio
Cancel = True
End Sub
Private Sub Workbook_BeforeSave(ByVal SaveAsUI As Boolean, Cancel as Boolean)
a = MsgBox("Vuoi salvare la cartella corrente?", vbYesNo)
If a = vbNo Then Cancel = True
End Sub
Private Sub Workbook_BeforeSave(ByVal SaveAsUI As Boolean, Cancel As Boolean)
MsgBox "Arrivederci cartella salvata con successo"
End Sub
Private Sub Workbook_NewSheet (ByVal Sh As Object)Questo evento viene attivato quando un nuovo foglio viene inserito nella cartella di lavoro, il parametro Sh è il foglio di lavoro creato Codice:
Private Sub Workbook_NewSheet(ByVal Sh As Object)
‘visualizza il nome e l’indice del nuovo foglio.
MsgBox Sh.Name & " : " & Sh.Index
End Sub
Private Sub Workbook_NewSheet(ByVal Sh as Object)
‘sposta nuovi fogli alla fine del lavoro
Sh.Move After:= Sheets(Sheets.Count)
End Sub
Private Sub Workbook_NewSheet(ByVal Sh As Object)
Sheet1.UsedRange.Copy Sh.UsedRange
End Sub
Private Sub Workbook_WindowActivate (ByVal Wn As Window) Questo evento si verifica quando si attiva la finestra che contiene la cartella di lavoro e il parametro Wn corrisponde alla finestra attiva Codice:
Private Sub Workbook_WindowActivate(ByVal Wn As Excel.Window)
Wn.WindowState = xlMaximized
End Sub
Private Sub Workbook_WindowActivate(ByVal Wn As Window)
MsgBox "Attivato"
End Sub
Private Sub Workbook_WindowActivate(ByVal Wn As Window)
Msgbox "Questa cartella è attiva"
End Sub
Private Sub Workbook_WindowDeactivate (ByVal Wn As Window) Questo evento si verifica quando si disattiva la finestra che contiene la cartella di lavoro per attivare un'altra finestra di Excel e il parametro Wn corrisponde alla finestra disabilitata. Codice:
Private Sub Workbook_WindowDeactivate(ByVal Wn As Window)
MsgBox "Disattivato"
End Sub
Private Sub Workbook_WindowDeactivate(ByVal Wn As Window)
‘nasconde la barra multifunzione se l'altezza è inferiore a 100
altezz = Application.CommandBars("Ribbon").Height
If altezz < 100 Then Application.SendKeys ("^{F1}")
End Sub
Private Sub Workbook_WindowDeactivate(ByVal Wn As Window)
MsgBox “Hai disattivato “ & Wn.Caption
End Sub
Private Sub Workbook_WindowResize (ByVal Wn As Window) Questo evento si verifica quando si ridimensiona la finestra che contiene la cartella di lavoro e il parametro Wn corrisponde alla finestra. Codice:
Private Sub Workbook_WindowResize(ByVal Wn As Excel.Window)
‘Inserisce nella barra di stato il nome del file e la scritta “ridimensionata”
Application.StatusBar = Wn.Caption & " Ridimensionata"
End Sub
Private Sub Workbook_WindowResize(ByVal Wn As Window)
‘ridimensionando la finestra inserisce il valore in B1
With ThisWorkbook.ActiveSheet.Range("B1")
.Value = .Value + 1
End With
End Sub
Private Sub Workbook_WindowResize(ByVal Wn As Window)
‘parcheggia la finestra se viene ridimensionata
Wn.WindowState = xlMinimized
End Sub
Private Sub Workbook_AddinInstall ()Questo evento viene utilizzato nei componenti aggiuntivi (XLA) e viene attivato durante l'installazione del componente aggiuntivo contenuto nella procedura evento. Codice:
Private Sub Workbook_AddinInstall()
‘aggiunge un controllo alla barra degli strumenti standard
With Application.Commandbars("Standard").Controls.Add
.Caption = "Aggiungi Voci al menu"
.OnAction = "'pippo11.xls'!Amacro"
End With End Sub
End Sub
Private Sub Workbook_AddinInstall()
Dim MyForm As Object
Set MyForm = ActiveWorkbook.VBProject.VBComponents.Add(vbext_ct_MSForm)
'nuova userform
With MyForm
.Properties("Caption") = "My Form"
.Properties("Width") = 450
.Properties("Height") = 300
End With
End Sub
Private Sub Workbook_AddinInstall()
Run "AddMenus"
End Sub
Private Sub Workbook_AddinUninstall () Questo evento viene utilizzato nei Componenti aggiuntivi e viene attivata quando il componente aggiuntivo viene disinstallato. Codice:
Private Sub Workbook_AddinUninstall()
Run "DeleteMenu"
End Sub
Private Sub Workbook_AddinUninstall()
Application.WindowState = xlMinimized
End Sub
Private Sub Workbook_AddinUninstall()
For Each Component In ActiveWorkbook.VBProject.VBComponents
If Component.Type = 3 Then
ActiveWorkbook.VBProject.VBComponents.Remove Component
End If
Next Component
End Sub
Private Sub Workbook_BeforeXmlExport (ByVal Map As XmlMap, ByVal Url As String, Cancel As Boolean) Questo evento si attiva quando Excel salva o esporta i dati XML da questa cartella di lavoro specifica, il parametro Map rappresenta la tabella xml di mappatura utilizzata per l'esportazione e il parametro Url restituisce il percorso completo del file xml che verrà utilizzato per l'esportazione. Si specifica Cancel = True per impedire l'esportazione. Codice:
Private Sub Workbook_BeforeXmlExport(ByVal Map As XmlMap, ByVal Url As String, _
Cancel As Boolean)
MsgBox Map.Name & vbCrLf & Url
End Sub
Private Sub Workbook_BeforeXmlExport(ByVal Map As XmlMap, ByVal Url As String, _
Cancel As Boolean)
If (Map.IsExportable) Then
If MsgBox("Microsoft Excel è pronto" & " per esportare in XML da " & "Map.Name" & "." & vbCrLf & _
" Vuoi continuare?", vbYesNo + vbQuestion, "Processo di esportazione in XML") = 7 Then Cancel = True
End If
End Sub
Private Sub Workbook_BeforeXmlExport(ByVal Map As XmlMap, _ ByVal Url As String, Cancel As Boolean)
Debug.Print "Verifica prima di esportare", Map, Url, IsRefresh, Cancel
End Sub
Private Sub Workbook_BeforeXmlImport (ByVal Map As XmlMap, ByVal Url As String, ByVal IsRefresh As Boolean, Cancel As Boolean)Questo evento si attiva quando si importano dei dati da un file XML nel foglio di lavoro. Il parametro Map rappresenta i dati di mapping che importano il file XML e il parametro URL restituisce il percorso completo del file XML importato. Il parametro IsRefresh identifica se l'importazione è di una nuova origine dati o se è un aggiornamento esistente nel foglio. Se viene restituito True è un aggiornamento, si specifica Cancel = True per impedire l'importazione. Codice:
Private Sub Workbook_BeforeXmlImport(ByVal Map As XmlMap, ByVal Url As String, ByVal IsRefresh As Boolean, Cancel As Boolean)
MsgBox Map.Name & vbCrLf & Url
End Sub
Private Sub Workbook_BeforeXmlImport(ByVal Map As XmlMap, ByVal Url As String, ByVal IsRefresh As Boolean, Cancel As Boolean)
MsgBox IsRefresh & vbCrLf & _
Map.Name & vbCrLf & _
Url
End Sub
Private Sub Workbook_BeforeXmlImport(ByVal Map As XmlMap, ByVal Url As String, ByVal IsRefresh As Boolean, Cancel As Boolean)
Debug.Print "Verifica prima di importare", Map, Url, IsRefresh, Cancel
End Sub
Private Sub Workbook_BeforeXmlImport(ByVal Map As XmlMap, ByVal Url As String, ByVal IsRefresh As Boolean, Cancel As Boolean)
If Map.RootElementName = “Modello_pippo” Then
MsgBox “Il file XML che hai selezionato non può essere importato”
Cancel = True
End If
End Sub
Private Sub Workbook_AfterXmlExport (ByVal Map As XmlMap, ByVal Url As String, ByVal Result As XlXmlExportResult)Questo evento viene attivato dopo l'esportazione dei dati in un file xml (da Excel2003), il parametro Map rappresenta la tabella xml di mappatura utilizzata per l'esportazione il parametro URL restituisce il percorso completo del file xml salvato durante l'esportazione, mentre invece il parametro Result restituisce il risultato dell'esportazione che può essere:
Codice:
Private Sub Workbook_AfterXmlExport(ByVal Map As XmlMap, ByVal Url As String, ByVal Result As XlXmlExportResult)
MsgBox Map.Name & vbCrLf & _
Url & vbCrLf & _
Result
End Sub
Private Sub Workbook_AfterXmlImport (ByVal Map As XmlMap, ByVal IsRefresh As boolean, ByVal result As XlXmlImportResult) Questo evento viene attivato dopo l'inserimento o l'aggiornamento dei dati XML nel foglio di lavoro (da Excel2003), il parametro Map rappresenta la tabella xml di mappatura derivante dall'importazione e il parametro IsRefresh identifica se l'importazione è di una nuova origine dati o se si sta aggiornando un foglio di lavoro esistente, e viene restituito True se si tratta di un aggiornamento. Parametro result restituisce il risultato dell'importazione, che può essere:
Codice:
Private Sub Workbook_AfterXmlImport(ByVal Map As XmlMap, ByVal IsRefresh As Boolean, _
ByVal Result As XlXmlImportResult)
MsgBox IsRefresh & vbCrLf & _
Map.Name & vbCrLf & _
Result
End Sub
Private Sub Workbook_PivotTableOpenConnection (ByVal Target As pivot)L'evento è attivato quando una tabella pivot si connette a un'origine dati e il parametro Target è corrisponde alla tabella Codice:
Private Sub Workbook_PivotTableOpenConnection(ByVal Target As PivotTable)
MsgBox "La connessione alla tabella Pivot è stata aperta"
End Sub
Private Sub Workbook_PivotTableOpenConnection(ByVal Target As PivotTable)
Application.DisplayAlerts = False
End Sub
Private Sub Workbook_PivotTableCloseConnection (ByVal Target As pivot)L'evento è attivato quando una tabella pivot è scollegata dalla sorgente dati e il parametro Target corrisponde alla tabella offline. Private Sub Workbook_RowsetComplete (ByVal Description As String, ByVal Sheet As String, ByVal Success As Boolean)Si verifica quando l'utente esamina il recordset o chiama il set di righe per un oggetto tabella pivot (da Excel2007). Il parametro Description restituisce una breve descrizione dell'evento e il parametro Sheet restituisce il nome del foglio che contiene il Recordset creato. Private Sub Workbook_Sync (ByVal SyncEventType As Office.MsoSyncEventType) Viene generato quando la copia in locale di un foglio di lavoro che fa parte del lavoro di un documento è sincronizzato con la copia sul server (da Excel2003 .) Il parametro SyncEventType può assumere i seguenti valori:
Codice:
Private Sub Workbook_Sync(ByVal SyncEventType As Office.MsoSyncEventType)
If SyncEventType = msoSyncEventDownloadFailed Or _
SyncEventType = msoSyncEventUploadFailed Then _
MsgBox "La sincronizzazione è fallita"
End Sub
Private Sub Workbook_SheetActivate (ByVal Sh As Object) Identifica l'attivazione di un foglio nella cartella di lavoro e il parametro Sh corrisponde al foglio selezionato Codice:
Private Sub Workbook_SheetActivate(ByVal Sh As Object)
‘restituisce il nome del foglio selezionato.
MsgBox Sh.Name
End Sub
Private Sub Workbook_SheetActivate(ByVal Sh As Object)
MsgBox "Nome del Foglio : " & Sh.Name
End Sub
Private Sub Workbook_SheetActivate(ByVal Sh As Object)
Sh.Calculate
End Sub
Private Sub Workbook_SheetDeactivate (ByVal Sh As Object)Si verifica quando un foglio nella cartella di lavoro viene disattivato e il parametro Sh corrisponde al foglio disabilitato Codice:
Private Sub Workbook_SheetDeactivate(ByVal Sh As Object)
MsgBox Sh.Name
End Sub
Private Sub Workbook_SheetDeactivate(ByVal Sh As Object)
MsgBox ("Foglio Disattivato")
End Sub
Private Sub Workbook_SheetDeactivate(ByVal Sh As Object)
‘parcheggiare la finestra di excel
ThisWorkbook.Windows(1).WindowState = xlMinimized
End Sub
Private Sub Workbook_SheetChange (ByVal Sh As Object, ByVal Target As Range)Questo evento viene attivato quando avvengono dei cambiamenti in una cella della cartella di lavoro, il parametro Sh corrisponde al foglio contenente la cella modificata e il parametro Target corrisponde alla cella modificata. Questo esempio identifica la cella che avete appena modificato. Codice:
Private Sub Workbook_SheetChange(ByVal Sh As Object, ByVal Target As Range)
‘identifica la cella modificata
If Target.Count > 1 Then Exit Sub
MsgBox "Hai modificato la cella " & Target.Address & _
" (" & Target.Value & ")" & _
" Nel foglio denominato " & Sh.Name
End Sub
Private Sub Workbook_SheetChange(ByVal Sh As Object, ByVal Target As Range)
‘incrementare la cella A1
Application.EnableEvents = False
Sheets(1).Range("A1") = Sheets(1).Range("A1") + 1
Application.EnableEvents = True
End Sub
Private Sub Workbook_SheetChange(ByVal Sh As Object, ByVal Target As Range)
‘inserire il carattere grassetto e il colore rosso nella cella modificata
Target.Font.Bold = True
Target.Font.Color = vbRed
End Sub
Private Sub Workbook_SheetBeforeDoubleClick (ByVal Sh As Object, ByVal Target As Range, Cancel As Boolean) Identifica il doppio click in una cella. Questo evento viene attivato dopo Worksheet_BeforeDoubleClick. Parametro Sh corrisponde alla scheda attiva e il parametro Target è la cella che riceve un doppio clic. il parametro Cancel disabilita l'azione della macro associata Codice:
Private Sub Workbook_SheetBeforeDoubleClick(ByVal Sh As Object, ByVal Target As Range, Cancel AsBoolean)
If Sh.Name = "Foglio1" Then
Target.Interior.Color = RGB(255, 108, 0) 'Arancione
Else
Target.Interior.Color = RGB(136, 255, 0) 'Verde
End If
End Sub
Private Sub Workbook_SheetBeforeDoubleClick(ByVal Sh As Object, _
ByVal Target As Range, ByVal Cancel As Boolean)
‘disabilitare il doppio click
Cancel = True
End Sub
Private Sub Workbook_SheetBeforeDoubleClick(ByVal Sh As Object, ByVal Target As Range, Cancel As Boolean)
MsgBox "Hai fatto doppio click nel Foglio: " & Sh.Name & vbLf & "e nella Cella: " & Target.Address
End Sub
Private Sub Workbook_SheetBeforeRightClick (ByVal Sh As Object, ByVal Target As Range, Cancel As Boolean) Questo evento si verifica quando si utilizza il pulsante destro del mouse in uno dei fogli della cartella di lavoro e viene attivato dopo WorkSheet_BeforeRightClick. Il parametro Sh corrisponde al foglio attivo e il parametro Target è la cella che riceve il tasto destro del mouse, mentre il parametro Cancel disabilita l'azione associata della macro. Codice:
Private Sub Workbook_SheetBeforeRightClick(ByVal Sh As Object, ByVal Target As Range, Cancel As Boolean)
‘disabilita la visualizzazione del menu contestuale in tutti i fogli della cartella di lavoro
Dim x As Long, lngColorIndex As Long
Cancel = True
lngColorIndex = Application.Dialogs(xlDialogPatterns).Show
x = ActiveCell.Interior.ColorIndex
If lngColorIndex = xlColorIndexAutomatic Then x = xlColorIndexNone
ActiveCell.Interior.ColorIndex = x
End Sub
Private Sub Workbook_SheetCalculate (ByVal Sh As Object) Questo evento viene attivato quando si esegue il ricalcolo (formule di convalida o di aggiornamento) in uno dei fogli della cartella di lavoro. L'evento si verifica dopo Worksheet_Calculate e il parametro Sh corrisponde al foglio che contiene la formula. Private Sub Workbook_SheetFollowHyperlink (ByVal Sh As Object, ByVal Target As Hyperlink)L'evento si verifica quando viene attivato un collegamento ipertestuale e il parametro Sh corrisponde al foglio che contiene il collegamento, mentre il parametro Target è il collegamento ipertestuale dell’oggetto Codice:
Private Sub Workbook_SheetFollowHyperlink(ByVal Sh As Object, ByVal Target As Hyperlink)
‘mostra l'indirizzo del collegamento attivato
MsgBox Target.Address & vbCrLf & Target.SubAddress
End Sub
Private Sub Workbook_SheetPivotTableUpdate (ByVal Sh As Object, ByVal Target As pivot)Questo evento si verifica quando si aggiorna una tabella pivot, il parametro Sh corrisponde a foglio che contiene la tabella e il parametro Target è l'oggetto Tabella pivot aggiornato. Codice:
Private Sub Workbook_SheetPivotTableUpdate(ByVal Sh As Object, ByVal Target As PivotTable)
MsgBox "E’ stata aggiornata " & Sh.Name & " / " & Target.Name
End Sub
Private Sub Workbook_SheetSelectionChange (ByVal Sh As Object, ByVal Target As Range)Questo evento si verifica quando viene modificata la selezione di una cella in uno dei fogli della cartella di lavoro e viene attivato dopo Worksheet_SelectionChange. Il parametro Sh è il foglio attivo e il parametro Target corrisponde alla cella selezionata. Codice:
Private Sub Workbook_SheetSelectionChange(ByVal Sh As Object, ByVal Target As Range)
‘recuperare il nome del foglio e l'indirizzo della cella
MsgBox "Hai selezionato la cella " & Target.Address & _
" nel foglio denominato " & Sh.Name
End Sub
___________________________________
- Il primo fondamento della sicurezza non e' la tecnologia, ma l'attitudine mentale - |
|
|
|
|
15-05-2014, 17.12.20
|
#19 |
|
Senior Member
WT Expert
Registrato: 19-05-2007
Loc.: Verona
Messaggi: 1.302
|
Scrittura di nuove macro e procedure Se esaminiamo una macro ottenuta con il Registratore di macro si potrà notare che hanno tutte alcune caratteristiche in comune. Per esempio registriamo due macro, una che formatti una selezione di celle (A1:D10) e applichi al carattere il formato grassetto e l’altra che applichi il colore rosso allo stesso intervallo di celle. Operando dal Registratore di macro, come abbiamo già visto, per la prima macro, quella che formatta le celle in grassetto otteniamo il seguente listato. Codice:
1) Sub Grassetto()
2) '
3) ' Macro Grassetto
4) ' Macro registrata il ……
5) '
6) Range("A1:D10").Select
7) Selection.Font.Bold = False
8) Range("A1").Select
9) End Sub
Codice:
1) Sub Colore()
2) '
3) ' colore Macro
4) ' Macro registrata il …….
5) '
6) Range("A1:D10").Select
7) Selection.Font.ColorIndex = 3
8) Range("A1").Select
9) End Sub
Come abbiamo esordito all’inizio affermando che tutte le macro hanno caratteristiche in comune, con questi due listati possiamo iniziare a notare qualche affinità. La riga 1 è sempre l’inizio della macro e ogni macro VBA inizia con il termine Sub seguito dal nome della macro. La linea che contiene la parola chiave Sub e il nome della macro viene detta “dichiarazione della macro”, in quanto è quella che rende noto al VBA l’esistenza della macro stessa. Il nome della macro, a sua volta, è sempre seguito da una coppia di parentesi vuote(), il cui scopo e utilizzo verrà affrontato più avanti nel corso, per il momento basta solo sapere che le due parentesi devono sempre comparire dopo il nome della macro nel codice sorgente. Un'altra affinità è rappresentata dalla parola chiave End Sub alla riga 9 che segnala al VBA che è stata raggiunta la fine della macro. Dalla riga 2 alla riga 5 dei due listati sono presenti dei commenti. Un commento è una riga della macro che non contiene istruzioni ma che fanno parte della macro stessa, generalmente viene usato per dei chiarimenti sull’azione che sta per compiere la macro stessa. Come si può notare, ogni riga di commento inizia con un apostrofo (‘) e il VBA tratta ogni riga che comincia con un apostrofo come un commenta e non processa il testo al suo interno. Subito dopo la dichiarazione Sub nome_della_macro () segue il corpo della macro che può includere varie righe di codice e/o di commento. Nel caso della macro Grassetto le righe da 6 a 8 costituiscono il corpo della macro, così come la macro Colore. Ogni riga del corpo della macro consiste in uno o più enunciati che rappresentano una serie di parole chiave e altri simboli che assieme costituiscono un’istruzione VBA completa. Gli enunciati VBA di una macro registrata contengono le istruzioni che svolgono azioni equivalenti a quelle che sono state eseguite quando si è registrata la macro stessa. Per esempio la riga 6 della macro Grassetto seleziona il Range di celle A1:D10 così come la stessa riga della macro Colore, mentre invece la riga 7 della macro Grassetto fissa il carattere al formato grassetto, la stessa riga della macro Colore fissa il colore del testo a rosso. La riga 8 dei due listati seleziona la cella A1 in quanto dopo aver formattato le celle abbiamo cliccato sulla cella A1. Quando si esegue una macro il VBA parte dalla prima riga del corpo della macro (la prima dopo la dichiarazione) eseguendo le istruzioni contenute in essa in sequenza, da sinistra verso destra, poi passa alla riga successiva ed esegue le istruzioni in essa contenute e così di seguito fino a raggiungere la fine della macro, definita dall’enunciato End Sub. Possiamo inoltre notare che alcune parti del testo della macro sono visualizzate in colori differenti, i commenti sono visualizzati in colore verde, mentre le parole chiave Sub e End Sub e altre del VBA sono di colore blu, mentre il testo rimanente della macro è di colore nero, a indicare che si tratta di dati e enunciati creati dall'utente. Il colore con cui VBA contraddistingue le varie parti di testo sullo schermo servono a rendere più chiara la parte della macro o di un enunciato che si sta esaminando. Modifica del testo di una macroPer apportare delle modifiche al codice sorgente di una macro in un modulo si usano comandi e tecniche che risultano già famigliari a chi usa Windows, la modifica del testo in un modulo visualizzato nella finestra Codice avviene esattamente come quando si edita un testo in Word o in qualsiasi altro elaboratore di testi, per aggiungere, eliminare, selezionare, tagliare etc. si useranno quindi i medesimi comandi da tastiera o col mouse. Le modifiche apportate a un modulo si possono salvare tramite il comando File - Salva dell’Editor di VB oppure facendo clic sul pulsante Salva della barra degli strumenti. Ogni modifica effettuata su un modulo viene comunque salvata quando si salva la cartella di lavoro che contiene il modulo stesso. Per fare un esempio di come effettuare modifiche a una macro prendiamo in esame la prima macro registrata (Grassetto) e andiamo a modificarla, oltre ad applicare il formato grassetto vogliamo anche cambiare dimensioni al carattere. Possiamo procedere in questo modo, portiamoci nell’Editor di VBA nella macro Grassetto e spostiamo il punto di inserimento (il cursore) alla fine della riga 4 e premiamo Invio per inserire una riga vuota. Digitiamo un apostrofo (‘) e digitiamo poi il testo del commento (per esempio: la linea successiva cambia la dimensione del carattere) a questo punto nella riga successiva al commento dobbiamo solo scrivere il codice VBA che esegua l’operazione richiesta. Possiamo aiutarci col registratore di macro, quando abbiamo trattato il registratore abbiamo detto che una volta attivato registra tutte le operazioni svolte dall'operatore e le converte in codice VBA, pertanto possiamo ritornare a Excel, attivare la registrazione di una nuova macro, selezionare l’intervallo di celle riportato nella macro Grassetto e modificare la dimensione del carattere. Una volta eseguita questa operazione fermiamo la registrazione e torniamo nell’Editor VBA per vedere il codice, che si presenta in questo modo: Codice:
Sub Macro2()
'
' Macro2 Macro
' Macro registrata il ………
'
Range("A1:D10").Select
With Selection.Font
.Name = "Arial"
.Size = 12
.Strikethrough = False
.Superscript = False
.Subscript = False
.OutlineFont = False
.Shadow = False
.Underline = xlUnderlineStyleNone
.ColorIndex = xlAutomatic
End With
End Sub
Codice:
With Selection.Font
.Name = "Arial"
.Size = 12
End With
A questo punto andiamo nella macro Grassetto e posizioniamo il cursore sulla riga sotto al commento che abbiamo inserito in cui abbiamo scritto che veniva modificata la dimensione del carattere e premiamo consecutivamente i tasti Ctrl+V oppure dal menù Modifica - Incolla. Adesso la macro è diventata Codice:
Sub Grassetto()
‘
' Grassetto Macro
' Macro registrata il ……
' La linea successiva cambia la dimensione del carattere
Range("A1:D10").Select
With Selection.Font
.Name = "Arial"
.Size = 12
End With
Selection.Font.Bold = False
Range("A1").Select
End Sub
Scrittura di nuove macro e procedurePer scrivere una propria macro senza ricorrere al registratore di macro si può digitare la macro entro un modulo esistente o creare un nuovo modulo, finora abbiamo utilizzato il termine macro per identificare sia quelle scritte usando il registratore di macro che quelle "autonome" cioè scritte di proprio pugno, esiste però un termine che aiuta a distinguere tra macro registrate e “autonome” e, strettamente parlando, il termine macro dovrebbe essere applicato solo alle macro registrate, mentre invece le macro scritte partendo da zero sono chiamate procedure sub (subroutine) o semplicemente procedure, pertanto nel proseguo di questo corso verrà utilizzato il termine macro per identificare il codice sorgente ottenuto usando il registratore di macro e procedure per riferirsi al codice VBA scritto dall'utente Per scrivere una nuova procedura entro un modulo esistente bisogna prima aprire la finestra Codice facendo doppio clic sul modulo in Gestione progetti oppure selezionando il modulo e poi scegliere Visualizza - Codice. Per scrivere il testo del codice di una procedura, che venga aggiunta ad un modulo nuovo o a uno esistente, si deve portare il cursore di testo nella finestra Codice sul punto del modulo in cui si vuole digitare la nuova procedura. Si può battere il testo di una nuova procedura in una posizione qualsiasi di un modulo, purchè essa venga comunque posizionata dopo l’enunciato End Sub che segna la fine della procedura precedente e prima dell’enunciato Sub della procedura immediatamente successiva, personalmente consiglio di aggiungere una nuova procedura sempre alla fine del modulo. Quando si scrive una procedura bisogna specificarne il nome e includere la parola chiave Sub e End Sub rispettivamente all'inizio e alla fine della procedura stessa, se si trascura uno di questi tre particolari la sintassi della procedura non risulterà corretta e l’Editor di VB visualizzerà un messaggio di errore quando si eseguirà la procedura. Si deve tenere presente che se digitiamo il nome della procedura preceduto dalla parola chiave Sub e battiamo il tasto invio l’Editor completerà la procedura aggiungendo le due parentesi vuote e la parola chiave End Sub Il primo classico programma che si scrive in un qualsiasi linguaggio di programmazione, per tradizione, è quello che visualizza a video la frase : Ciao Mondo! Il listato che segue mostra un programma VBA con una singola procedura che adempie allo scopo. Codice:
Sub Mondo() MsgBox "Ciao Mondo!" End Sub
 Fig. 1L’argomento che si prevede sia il prossimo ad essere digitato compare in grassetto in questa finestrella (un argomento è un’informazione richiesta dalla procedura per poter svolgere il suo lavoro) la finestrella Informazioni rapide automatiche si chiude non appena si preme Invio per iniziare una nuova riga nella finestra del codice oppure ci si sposta dalla linea del codice con i tasti freccia o col cursore del mouse. Se la finestrella delle informazioni rapide automatiche anziché essere utile dà fastidio, la si può disabilitare (e riattivare) col comando Strumenti - Opzioni dell’Editor VB. Una volta immesso il codice sorgente della procedura Mondo la si può eseguire in questo modo:
 Fig. 2Si consideri l’uso della funzione MsgBox a puro titolo di esempio, tratteremo questa interessante funzione molto dettagliatamente nel proseguo del corso, lo scopo della procedura Mondo era solo per mostrare i passaggi da eseguire per scrivere una procedura manualmente
___________________________________
- Il primo fondamento della sicurezza non e' la tecnologia, ma l'attitudine mentale - |
|
|
|
|
15-05-2014, 17.17.19
|
#20 |
|
Senior Member
WT Expert
Registrato: 19-05-2007
Loc.: Verona
Messaggi: 1.302
|
Operatori di confronto, logici e matematici Per combinare o confrontare specifici valori in un’espressione si usano gli operatori. Il loro nome deriva dal fatto che essi sono i simboli che indicano specifiche operazioni matematiche o di altro genere da eseguire su vari valori in un’espressione. Quando in un’espressione si usa un operatore, i dati, che siano variabili o costanti su cui l’operatore agisce vengono detti operandi. Nell'espressione 2+1, per esempio, i numeri 2 e 1 sono gli operandi dell’operatore di somma (+). Adesso vediamo i vari tipi di operatori e come si usano Operatori di confrontoGli operatori di confronto, chiamati a volte operatori relazionali, vengono utilizzati soprattutto per stabilire il criterio, in base al quale prendere delle decisioni. Il risultato di un’operazione di confronto è sempre di tipo Boolean: True o False e sono usati per comparare valori letterali, costanti o variabili di ogni tipo. La tabella rappresentata in figura 1 elenca gli operatori di confronto disponibili nel VBA  Fig. 1Se entrambi gli operandi di un’espressione di confronto sono dello stesso tipo di dati, il VBA esegue il confronto diretto per quel tipo di dati, per esempio se entrambi sono stringhe, VBA compara le due stringhe, se sono date VBA compara le date e così via. Utilizzando gli operatori, è possibile impostare delle condizioni più sofisticate alle istruzioni che andremo a scrivere. Aiutiamoci con un esempio per comprendere l’utilizzo degli operatori di confronto 4 <> 5 => il risultato è True, 4 è diverso da 5 Alex > Carlo => il risultato è False, “Alex” è più corto di “Carlo” Abc = abc => il risultato è False, Abc è diverso da abc Possiamo dire, In maniera molto sintetica, che questo tipo di operatore altro non fa che confrontare due variabili e appurare se la condizione che chiediamo tramite il simbolo dell’operatore, sia vera o falsa e il risultato del confronto è sempre un valore di tipo Boolean. Le variabili booleane riportano o accettano solo due valori, Vero(True) e Falso(False) e possiamo impostarle in questo modo Dim alex As Boolean alex = True Dalle due righe di codice abbiamo dedotto che è stata dichiarata la variabile alex con tipo di dati Boolean invece di impostarla come tipo di dati con Integer o Stringa. La seconda linea di codice inserisce un valore nella variabile, ma non è un dato che possiamo manipolare, mettiamo solo una “condizione” cioè diciamo che la variabile alex è uguale a Vero. Vediamo qualche riga di codice per comprendere meglio come usarla Codice:
If alex = True Then MsgBox "E 'vero" Else MsgBox "E 'falso" End If Codice:
Sub operatori() Dim alex As Integer alex = 10 If alex < 20 Then MsgBox alex & " " & "è inferiore a 20" End If End Sub  Fig. 2Possiamo usare altri operatori esposti in figura 1 in tutti i casi che possono aiutarci a porre delle condizioni come per esempio utilizzando un ciclo If in questo modo Codice:
Sub operatori() Dim alex As Integer alex = 19 If alex = 20 Then MsgBox alex & " " & "è uguale a 20" ElseIf alex > 20 Then MsgBox alex & " " & "è maggiore di 20" Else MsgBox alex & " " & "è inferiore a 20" End If End Sub  Fig. 3Per concludere l’argomento possiamo riassumere affermando che Il risultato di un operatore di confronto è un cosiddetto valore di verità: può essere vero(True) oppure falso(False) Operatori MatematiciIl VBA è in grado di eseguire tutte le operazioni aritmetiche normali come somma, sottrazione, divisione e moltiplicazione in quanto l’elaborazione di dati numerici è una delle attività principali di un programma. VBA supporta una serie di operatori matematici che possono essere usati negli enunciati di un programma. Queste operazioni, con il relativo simbolo che identifica l'operatore matematico, sono riportate nella tabella di figura 4  Fig. 4Avrete certamente notato nelle linee di codice sopra esposte che abbiamo usato un simbolo particolare dopo l’istruzione MsgBox. Abbiamo inserito la variabile alex poi uno spazio e poi una E commerciale (&). Questo simbolo in VBA serve per concatenare (unire) due o più stringhe. Infatti dopo la & abbiamo uno spazio seguito da una stringa vuota posta virgolette, poi ancora una &, uno spazio e il testo del messaggio racchiuso tra virgolette. Quindi, con la & abbiamo unito la variabile e il testo separandolo da uno spazio vuoto Se NON avessimo usato la concatenazione tra la variabile e il testo del messaggio avremmo ricevuto un errore di compilazione come il seguente  Fig. 5Al tempo stesso concatenando la variabile col testo del messaggio senza inserire lo spazio vuoto avremmo ottenuto un box come il seguente  Fig. 6Come si può notare il valore della variabile alex risulta essere attaccato al testo del messaggio, che sicuramente è poco leggibile e interpretabile. Per meglio comprendere possiamo usare il codice sotto riportato Codice:
Sub Prova() a = "Auguro a tutti" b = "gli utenti del Pianeta" c = "Buon Natale e Felice Anno Nuovo" > MsgBox a & b & c End Sub  Fig. 7Nota : Fate attenzione che se avete all'inizio delle routine la parola chiave Option Explicit vi viene rimandato un errore, in quanto come abbiamo detto poco sopra in presenza di questa parola chiave tutte la variabili vanno dichiarate. Se osservate attentamente la Fig. 9 noterete che ci sono delle frasi attaccate (tuttigli e PianetaBuon), modifichiamo allora il nostro codice utilizzando un operatore di concatenazione (&) in questo modo Codice:
Sub Prova1() a = "Auguro a tutti" b = "gli utenti del Pianeta" c = "Buon Natale e Felice Anno Nuovo" MsgBox a & " " & b & " " & c End Sub  Fig. 8Con questi operatori possiamo anche fare operazioni matematiche usando le variabili, se prendiamo questo codice, ricordando che le variabili Alex, x e y sono state dichiarate come Integer nella barra delle dichiarazioni quindi condivisibili in tutto il modulo Codice:
Sub somma() Dim operator As Integer Alex = 10 x = 20 y = 30 operator = y - x + Alex MsgBox "Il risultato della tua operazione è" & " " & operator End Sub  Fig. 9 Operatori LogiciIl più delle volte gli operatori logici forniti dal VBA vengono usati per combinare i risultati di singole espressioni di confronto al fine di costruire criteri complessi per prendere una decisione all'interno di una procedura, oppure per stabilire le condizioni in base alle quali un enunciato o un gruppo di istruzioni possa essere replicato. Come operando di un operatore logico si può usare qualsiasi espressione valida che dia un risultato Boolean, o un numero che il VBA possa convertire in valore booleano. Il VBA considera 0 come equivalente a False e ogni altro valore numerico equivalente a True. Nella tabella di Figura 12 viene fornito l’elenco degli operatori logici presenti nel VBA  Fig. 10Per poter comprendere al meglio la struttura degli operatori logici è importante saper leggere la tabella delle verità Booleana, essa non è altro che una tabella che mostra tutte le possibili combinazioni di valori per una particolare espressione logica e il risultato di ognuna. Questa tabella ha 3 colonne, la prima contiene il valore del primo operando, la seconda il valore del secondo operando e la terza il valore del risultato dell’espressione. Guardando la riga sotto esposta False True False In essa il primo operando è False, il secondo True e il risultato dell’operatore And con questi valori è False. La riga in questione, perciò, insegna che il risultato dell’espressione False And True è False. La sintassi dell’operatore And è la seguente: Operando1 And Operando2 Vediamo ora la tabella della verità booleana per l’operatore And
L’operatore And effettua una congiunzione logica (detta anche somma logica) e il risultato di un’operazione And è True solo se ambedue gli operatori sono True altrimenti è False. L’operatore And viene utilizzato per determinare se due diverse condizioni sono vere contemporaneamente. Per esempio: (ricavo < 5000) And (profitto < 1000) L’espressione precedente risulta vera (True) se il valore di ricavo è minore di 5.000 e al tempo stesso il valore del profitto è minore di 1.000 (e solo in quel caso). Si noterà che i due operandi in questa espressione sono espressioni di confronto e anche che sono poste tra parentesi per renderli operandi dell’operatore And. Le parentesi indicano al VBA di calcolare il risultato dell’espressione tra parentesi prima di valutare altre parti dell’espressione completa. Le parentesi, inoltre, rendono l’espressione più leggibile raggruppando le parti correlate di un’espressione. L’uso in questo modo delle parentesi, per raggruppare parti di un’espressione in una sotto-espressione è molto comune con espressioni di ogni tipo, numeriche, di stringa, di data e di confronto. L’operatore Or effettua una disgiunzione logica, spesso specificata anche come or inclusivo. Il risultato di un’operazione Or è True solo se uno o entrambi gli operandi è True, altrimenti è False. L’operatore Or ha questa sintassi:Operando1 Or Operando2 La tabella della verità booleana per l’operatore Or è la seguente:
Si userà l’operatore Or per determinare se una o l’altra di due condizioni sia vera. Per esempio (ricavo < 5000) Or (profitto < 1000) Il risultato sarà True se il valore di ricavo è minore di 5.000 oppure il valore di profitto è minore di 1.000 L’operatore Not effettua la negazione logica, cioè inverte il valore dell’unico operando. Il risultato quindi è True se l’operando è False e False se l’operando è True.
___________________________________
- Il primo fondamento della sicurezza non e' la tecnologia, ma l'attitudine mentale - |
|
|
|
|
15-05-2014, 17.21.41
|
#21 |
|
Senior Member
WT Expert
Registrato: 19-05-2007
Loc.: Verona
Messaggi: 1.302
|
Le Matrici - Statiche e Dinamiche Una Matrice (o Array) è una collezione di variabili che condividono lo stesso nome e tipo di dati e costituiscono un comodo metodi per memorizzare un certo numero di dati nello stesso contenitore. Diversamente da quanto accade con i tipi di dati definiti dall'utente, gli elementi di una matrice devono essere tutti dello stesso tipo. Per esempio se si crea una matrice di tipo Integer, tutti gli elementi al suo interno devono essere di tipo Integer, in altre parole le matrici vengono utilizzate per rappresentare elenchi o tabelle in cui tutti i dati siano dello stesso tipo. Una matrice permette di memorizzare ed elaborare una serie di dati utilizzando una sola variabile che permette oltre alla riduzione complessiva di nomi di variabili da gestire, la possibilità di utilizzare dei cicli per semplificare l’elaborazione dei diversi elementi che la compongono. Combinando matrici e cicli (tipicamente cicli For Next e ForEach) è possibile scrivere procedure di poche istruzioni che elaborano grandi quantità di dati, che se si dovesse usare nomi distinti per le variabili, le stesse procedure potrebbero richiedere centinaia di istruzioni. La forma più semplice di una matrice non è altro che un elenco di elementi che vengono definite semplici o unidimensionali Dichiarazioni di MatriciPer dichiarare una matrice è necessario prevedere il limite superiore (l'ultimo e più grande numero di indice), mentre il limite inferiore (il primo e il più piccolo numero di indice) è facoltativo e se si omette questo argomento, viene determinato dalle impostazione del modulo, che di default è uguale a 0. Per riuscire a tenere traccia delle dimenzioni di un array siano essi statici o dinamici il VBA prevede due funzioni, Lbound e Ubound, che restituiscono il valore minimo e massimo per gli indici di un array. La sintassi generica per queste funzioni è LBound(NomeArray [, dimensione]) UBound(NomeArray [, dimensione]) L’argomento “dimensione” è un numero intero che specifica per quale dimensione dell’array si vuole ottenere il limite minimo o massimo. Se non viene specificato VBA restituisce l’estremo relativo alla prima dimensione dell’array. La funzione "UBound" restituisce il valore della posizione più alta per la dimensione indicata di una matrice, mentre "LBound" è l’opposto e restituisce il valore più basso possibile, mentre il valore di ritorno per entrambe queste funzioni è un dato di tipo Integer. Quando un array utilizza un solo indice viene chiamato "unidimensionale", mentre una matrice "multidimensionale" utilizza più di un indice. Va ricordato che la dimensione di una matrice è il numero totale di elementi che è determinato dal prodotto delle sue dimensioni e per determinare la sua dimensione massima si deve tenere presente che gli indici partono da 0 e il valore massimo è definito dal numero indicato nella dichiarazione. È possibile dichiarare un array multidimensionale di tipo Byte con la sintassi: Dim K As Byte e ottenere la dimensione della matrice utilizzando la funzione "UBound", oppure utilizzare la funzione LBound per ottenere il valore più basso possibile per l'indice. Se l'array ha un solo elemento, il valore di ritorno di Ubound è uguale a 0 e LBound restituisce sempre 0 finchè l'array non è stato inizializzato, anche se non ha elementi. Esempio per un array monodimensionale: Dim MyArray1 (5) As String Limite Inferiore = Lbound (MyArray1) ‘Restituisce il valore 0 Limite Superiore = Ubound (MyArray1) ‘Restituisce il valore 0 Dimensioni = Ubound (MyArray1) - Lbound (MyArray1) + 6 ‘Restituisce il valore 6 Si deve tenere presente che quando si utilizzano queste funzioni per un array multi-dimensionale, si deve specificare la dimensione in base al quale il limite inferiore o superiore devono essere determinati. Dovrebbe risultare familiare l’uso dell’istruzione Dim che abbiamo visto usare per le variabili, ma viene usata anche per la dichiarazione di matrici, in effetti la parola chiave Dim è un’abbreviazione di dimension e nella versione moderna del VBA la parola chiave Dim permette di dichiarare matrici sia unidimensionali che a più dimensioni. La sintassi generica per la dichiarazione è la seguente Dim Nome_variabile ([Indici]) [As Tipo] Nome_variabile rappresenta un qualsiasi nome per la matrice che risponda alle regole di VBA per i nomi delle variabili e l’argomento Indici rappresenta le dimensioni della matrice, che è possibile dichiarare con un numero di dimensioni fino a 60. Per una matrice unidimensionale si usa una sola dichiarazione di indici, per una a due dimensioni se ne includono due separate da una virgola e via così fino a raggiungere il numero di dimensioni desiderato per la matrice. La sezione Indici ha la seguente sintassi [minimo To] massimo [, [minimo To] massimo] Minimo specifica il valore minimo valido per l’indice della matrice e massimo quello più alto, si deve tenere presente che è richiesto soltanto il limite superiore, in quanto l’indicazione del valore minimo per l’indice è opzionale. Se si specifica solo il limite superiore, VBA numera gli elementi della matrice coerentemente con l’impostazione Option Base, se è stato specificato Option Base 1, VBA numera gli elementi della matrice da 1 al valore massimo, in caso contrario gli elementi della matrice vengono numerati da 0 al valore massimo. Per esempio Dim gennaio (1 to 31) As String Dim gennaio(31) As String Nella seconda riga del listato poco sopra si presume Option Base 1 e specificando la parte minimo To si facilita la comprensibilità del codice e si semplifica la ricerca di errori, rendendo i programmi più affidabili. Dichiarare la parte minimo To permette anche di specificare come valore di partenza per l’indice un valore diverso da 0 o 1. Per esempio potreste voler creare una matrice i cui elementi siano numerati da 5 a 10 o da -5 a 0, a seconda della particolare operazione che intendete compiere. Come nelle normali dichiarazioni di variabili, è possibile dichiarare per una matrice un particolare tipo di dati specificando la parte As tipo, in questo modo ogni elemento della matrice sarà del tipo specificato, che può essere qualsiasi tipo di dato VBA valido Finora abbiamo visto matrici dotate di indici che iniziano da 0 (zero-based), che secondo questa convenzione di numerazione, l’indice del primo elemento di qualsiasi dimensione di una matrice è 0, una matrice di 5 elementi ha dunque indici che vanno da 0 a 4. Evidentemente la numerazione zero-based può generare confusione perché l’elemento di indice zero in realtà indica il primo componente della matrice l’indice 4 indica il quinto elemento e così via. Sarebbe molto più comodo se gli elementi di una matrice fossero numerati a partire da 1 invece che da 0. In questo caso l’indice 1 indicherebbe il primo elemento della matrice, l'indice 5 il quinto e così via. Fortunatamente VBA permette di specificare il numero iniziale per gli elementi di una matrice, infatti è possibile specificare se si desidera che gli indici della matrice partano da 0 o da 1 con l’istruzione Option Base che presenta questa sintassi Option Base 0|1 L’istruzione Option Base permette di impostare 0 o 1 come indice di base della matrice, in mancanza di questa istruzione VBA assegna per default la numerazione degli elementi della matrice a partire da 0. L’istruzione Option Base deve essere inserita nell’area delle dichiarazioni di un modulo prima di qualsiasi dichiarazione di variabile, costante o procedura e non può comparire all’interno di una procedura. Ecco due esempi Option Base 0 ‘Impostazione predefinita Option Base 1 ‘Gli indici della matrice partono da 1 Matrici Unidimensionali Un array monodimensionale è un elenco di elementi che hanno una singola riga o una singola colonna, ad esempio, le vendite trimestrali di una società durante l'anno (la dimensione sarà la riga o la colonna dei 4 trimestri dell'anno per il quale i dati di vendita saranno inseriti). Di seguito vediamo alcune dichiarazioni per creare un array: Per creare un array con 7 elementi, con i numeri di indice 0-6 (il valore predefinito del limite inferiore è 0) si usa la sintassi: Dim prova1(6) As String oppure Dim prova1(0 To 6) As String. In questo secondo caso il limite inferiore deve essere specificato in modo esplicito, con la parola chiave To. Supponiamo di avere un array che ha 20 elementi in cui i numeri di indice vanno da 1 a 20 si può usare la seguente dichiarazione: Dim prova2(1 To 20) As Integer. Nel caso si abbia un array con 51 elementi in cui i numeri di indice vanno da 100 a 150 si può usare la seguente dichiarazione: Dim prova2(100 To 150) As Integer. in sostanza i formati per una dichiarazione di matrice unidimensionale, con e senza specificare il limite inferiore possono essere rispettivamente: Dim ArrayName(Index) as DataType, oppure Dim ArrayName(First_Index To Last_Index) as DataType, pertanto possiamo riassumere che il nome è legato al fatto che un elenco di dati è assimilabile a una linea tracciata su un foglio, che ha una sola dimensione, e una sola lunghezza, ed è quindi unidimensionale o monodimensionale.  Fig. 1La Figura 1 rappresenta una matrice unidimensionale e ogni dato memorizzato nella matrice è detto elemento della matrice e come si vede in figura la matrice contiene 5 elementi, ciascuno dei quali contiene un numero di tipo Double, noterete anche che gli elementi della matrice sono numerati da 0 a 4 per un totale di 5 e che la numerazione parte da zero. Per accedere al dato memorizzato in un certo elemento si usa il nome della matrice seguito dal numero (detto indice) dell’elemento desiderato racchiuso tra parentesi tonde. Per esempio se il nome della matrice fosse NumMat la seguente istruzione assegnerebbe il valore 11,6 alla variabile alex alex = NumMat(3) Nell'esempio sopra riportato 3 è l'indice della matrice, è racchiuso tra parentesi tonde e non è separato da spazi dal nome della matrice. Visto che la numerazione degli elementi parte da zero, l’elemento a cui fa riferimento l’istruzione è in realtà il numero 4 di NumMat e quando si esegue questa istruzione VBA legge il valore 11,6 dall'elemento della matrice indicato e lo memorizza nella variabile alex come per qualsiasi assegnamento. L’indice viene anche utilizzato tutte le volte che si vuole salvare un valore in un certo elemento della matrice, l’istruzione seguente, per esempio, memorizza nel secondo elemento della matrice il valore 12 NumMat(2) = 12 Quando VBA esegue l’istruzione sopra riportata, scrive il valore 12 nell’elemento della matrice indicato, sostituendone il contenuto precedente, esattamente come per qualsiasi assegnazione, potete usare gli elementi di una matrice all’interno di una espressione VBA come se si trattasse di una qualsiasi variabile. Vediamo degli esempi di codice per un array monodimensionale: Codice:
Sub demo1() Dim K1(3) As String K1(0) = "Primo " K1(1) = "Secondo " K1(2) = "Terzo " K1(3) = "Quarto " MsgBox K1(0) & "- " & K1(1) & "- " & K1(2) & "- " & K1(3) End Sub  Fig. 2Codice:
Sub demo2() Dim K2(-3 To 2) As String K2(-3) = "Uno" K2(-2) = "Due" K2(-1) = "Tre" K2(0) = "Quattro" K2(1) = "Cinque" K2(2) = "Sei" MsgBox K2(-3) & " - " & K2(-2) & " - " & K2(-1) & " -" & K2(0) & " - " & K2(1) & " - " & K2(2) End Sub  [b] Fig. 3[b]Esempio: gestire gli array monodimensionali con un ciclo  Fig. 4Codice:
Sub demo3()
Dim i As Integer
Dim nome(2 To 5) As String, peso(2 To 5) As Single
For i = 2 To 5
nome(i) = InputBox("Inserisci il Nome")
peso(i) = InputBox("Inserisci il Peso")
Sheet4.Cells(i, 1) = nome(i)
Sheet4.Cells(i, 2) = peso(i) & " Kg."
Next i
End Sub
Matrici MultidimensionaliLe matrici unidimensionali vanno bene finchè si tratta di rappresentare semplici elenchi di dati, spesso però nei vostri programmi vi troverete a dover rappresentare tabelle di informazioni in cui i dati sono organizzati in righe e colonne, più o meno come accade in un foglio di Excel, per farlo dovete ricorrere a una matrice multidimensionale, che rappresentiamo in figura 5  Fig. 5Una matrice bidimensionale ha 2 dimensioni, comprendenti righe e colonne e utilizza due indici, uno rappresenta le righe e l'altro rappresenta le colonne e vengono utilizzati quando è necessario specificare un elemento con due attributi, ad esempio, le vendite trimestrali di una società nel corso degli ultimi 5 anni (una dimensione saranno i 4 trimestri dell'anno e la seconda dimensione saranno i 5 anni). Un array bidimensionale appare con una forma a tabella, con più righe e colonne e la sintassi è: Dim ArrayName (Index1, Index2) As DataType oppure Dim ArrayName (First_Index1 To Last_Index1, First_Index2 To Last_Index2) As DataType. Per esempio se si dichiara un array bidimensionale si utilizza la seguente forma: Dim prova (7,9) As Long oppure Dim prova (7,1 To 9) As Long, tenendo presente che il limite inferiore può essere specificato in modo esplicito in una o entrambe le dimensioni. Semplificando quanto esposto possiamo affermare che le matrici multidimensionali devono il loro nome al fatto di avere più di una dimensione, la lunghezza (il numero di righe) e la larghezza (il numero di colonne), come si vede in in figura 5, la matrice ha due colonne (numerate 0 e 1) e 5 righe numerate da 0 a 4 per un totale di 10 elementi. Per accedere agli elementi di matrici multidimensionali si usa un indice, cioè si usano i riferimenti di riga e colonna per identificare un certo elemento. L’indicizzazione di una matrice bidimensionale assomiglia molto al metodo per identificare le celle di un foglio di lavoro di Excel, la prima dimensione della matrice corrisponde alle colonne del foglio di lavoro e la seconda alle righe. Se chiamiamo NewMat la matrice di figura 5 la seguente istruzione assegna alla variabile alex il valore 12,4 (prima riga, seconda colonna della matrice) alex = NewMat(1,0) Analogamente, la seguente istruzione memorizza il valore 5,5 nella seconda riga della prima colonna della matrice NewMat(0,1) = 5,5 Da notare che in entrambe le precedenti istruzioni gli indici della matrice sono racchiuse tra parentesi e che le coordinare della colonna e della riga sono separate da virgole. Le matrici possono avere più di due dimensioni, la figura sottostante (Fig. 6) mostra una matrice a tre dimensioni con una lunghezza, una larghezza e una profondità (per modo di dire)  Fig. 6Potete pensare ad una matrice tridimensionale come all’insieme delle pagine di un libro in cui ogni pagina contenga una tabella con lo stesso numero di righe e colonne. Nella figura sopra riportata (Figura 6) la nostra matrice è di tre pagine (per riprendere l’esempio del libro) numerate da 0 a 2 e ogni pagina contiene una tabella di 2 colonne e 5 righe, e nelle caselle di ogni elemento sono riportate le coordinate nella matrice. Esempio di una matrice a due dimensioni  Fig. 7Codice:
Sub demo2() Dim i As Integer, n As Integer Dim vendi(1 To 4, 1 To 5) As Long vendi(1, 1) = 500 vendi(2, 1) = 520 vendi(3, 1) = 545 vendi(4, 1) = 595 vendi(1, 2) = 410 vendi(2, 2) = 440 vendi(3, 2) = 425 vendi(4, 2) = 485 vendi(1, 3) = 320 vendi(2, 3) = 330 vendi(3, 3) = 335 vendi(4, 3) = 300 vendi(1, 4) = 250 vendi(2, 4) = 280 vendi(3, 4) = 275 vendi(4, 4) = 205 vendi(1, 5) = 150 vendi(2, 5) = 180 vendi(3, 5) = 175 vendi(4, 5) = 105 For i = 1 To 4 For n = 1 To 5 Foglio1.Cells(i + 1, n + 1) = vendi(i, n) Next n Next i End Sub Matrici Statiche e DinamicheIn VBA possono essere create due tipi di matrici, matrici a dimensione fissa o statiche e matrici dinamiche. Una matrice che ha un numero fisso di elementi è una matrice di dimensioni fisse e viene utilizzato quando si conosce il numero preciso di elementi che verranno contenuti nella matrice, però la maggior parte delle volte sarà necessario creare array dinamico, perché non si sa l'esatta dimensione della matrice richiesta all'inizio e serve una certa flessibilità per modificare il numero di elementi della matrice. Normalmente la dichiarazione di una matrice indica a VBA l’estensione delle varie dimensioni che provvede ad allocare una quantità di memoria sufficiente per tutti gli elementi della matrice, nel caso della matrice di figura 1 VBA alloccherebbe memoria per 5 interi mentre per la matrice di figura 6 VBA alloccherebbe memoria per 10 elementi. VBA riserva spazio in memoria per tutti gli elementi della matrice finchè la relativa variabile esiste, matrici di questo tipo vengono dette Statiche perché il numero di elementi non cambia. Scegliere la dimensione di una matrice può essere complicato se non sapete a priori quanti dati dovrà ospitare o se la quantità di dati raccolti è molto variabile. Se a volte gli elementi da memorizzare sono 100 e altre volte 10, potenzialmente vi troverete a sprecare lo spazio per memorizzare 90 elementi inutili (è la differenza tra il numero maggiore di elementi e il minore), per casi come questi il VBA prevede un tipo particolare di matrice, detto dinamico. Le matrici dinamiche sono definite in questo modo perché è possibile modificarne il numero di elementi durante l’esecuzione del programma e le matrici dinamiche se associate a una corretta programmazione possono crescere o stringersi per far posto esattamente al numero di elementi necessari eliminando lo spreco di spazio. Per modificare le dimensioni di una matrice dinamica si usa l’istruzione Redim. E’ possibile dichiarare una variabile dinamica con le dimensioni dell'indice vuoto e successivamente dimensionare o ridimensionare la matrice dinamica che è già stata dichiarata, utilizzando l'istruzione ReDim. Per ridimensionare un array, è necessario fornire il limite superiore, mentre il limite inferiore è facoltativo e se non si menziona verrà determinato dalle impostazione del modulo, che di default è Option Base 0. Per esempio è possibile dichiarare la matrice prova1 come una matrice dinamica in questo modo: Dim prova1 () As String, per ridimensionare le dimensioni della matrice e portarla a 3 elementi (specificare Option Base 1), si utilizza l'istruzione Redim in questo modo: ReDim prova1 (3) As String, si può utilizzare una matrice dinamica invece di una a dimensione fissa, se si desidera regolare il numero di record nel database in fase di esecuzione. Esempio di array dinamico Codice:
Option Base 1 Sub prova2() Dim prova1() As String ReDim prova1(3) As String prova1(1) = "Lunedì" prova1(2) = "Martedì" prova1(3) = "Mercoledì" MsgBox prova1(1) & " - " & prova1(2) & " - " & prova1(3) End Sub Codice:
Option Base 1 Sub prova3() Dim prova2() As String ReDim prova2(3) As String prova2(1) = "Lunedì" prova2(2) = "Martedì" prova2(3) = "Mercoledì" ReDim prova2(4) As String prova2(4) = "Giovedì" MsgBox prova2(1) & " - " & prova2(2) & " - " & prova2(3) & " - " & prova2(4) End Sub Array dinamici – usare la parola chiave Preserve con l'istruzione ReDimQuando un array viene ridimensionato utilizzando l'istruzione ReDim, i suoi valori si potrebbero perdere, per ovviare a questo possibile inconveniente e garantire che i valori della matrice non siano persi, si utilizza la parola chiave “Preserve” l'istruzione ReDim, che consentirà di conservare i dati esistenti nella matrice. Ad esempio, prima viene usata l'istruzione ReDim per dimensionare la matrice prova2: "ReDim prova2 (3) As String" che veniva popolata con 3 elementi, ora per ridimensionare la matrice e consentire la memorizzazione di 4 variabili senza perdere i dati esistenti, è necessario utilizzare l'istruzione "ReDim Preserve myArray (4) As String". Vedere l’esempio sotto riportato Codice:
Option Base 1 Sub demo4() Dim New_mat() As String ReDim New_mat(3) As String New_mat(1) = "Primo" New_mat(2) = "Secondo" New_mat(3) = "Terzo" ReDim Preserve New_mat(4) As String New_mat(4) = "Quarto" MsgBox New_mat(1) & " - " & New_mat(2) & " - " & New_mat(3) & " - " & New_mat(4) End Sub
 Fig. 8Codice:
Sub demo_6()
Dim annO As Integer, reP As Integer, ampliaM As Integer, limitI As Integer, limitS As Integer, limitSR As Integer, rng As String
Dim matriC() As Integer
'la 1° dimensione specifica i 4 trimestri, la seconda dimensione specifica 2 anni di dati
'per i quali saranno inseriti i dati di vendita
ReDim matriC(1 To 4, 1 To 2)
'Stabilire i limiti superiori delle 2 dimensioni
limitI = UBound(matriC, 1)
limitS = UBound(matriC, 2)
For annO = 1 To limitS
For reP = 1 To limitI
matriC(reP, annO) = InputBox("Inserisci le vendite del reparto " & reP & " per l'anno " & annO)
Foglio1.Cells(reP + 1, annO + 1) = matriC(reP, annO)
Next reP
Next annO
If MsgBox("Continuare al prossimo anno?", vbQuestion + vbYesNo, "Confirmation") = vbYes Then
'con ReDim aumentiamo i dati di vendita a tre anni, dai 2 precedenti, per i 4 trimestri
ReDim matriC(1 To 4, 1 To limitS + 1)
'Determinare il limite superiore della seconda dimensione, dopo il ridimensionamento
limitSR = UBound(matriC, 2)
'si cicla per ciascuno dei 4 trimestri, inserendo i dati di vendita per l'anno aggiuntivo
For ampliaM = 1 To limitI
matriC(ampliaM, limitSR) = InputBox("Inserire i dati di vendita " & ampliaM & " per l'anno " & limitSR)
Foglio1.Cells(1, 4) = "Anno 3"
Foglio1.Cells(ampliaM + 1, limitSR + 1) = matriC(ampliaM, limitSR)
Next ampliaM
End If
If MsgBox("Continuare con la riduzione della matrice?", vbQuestion + vbYesNo, "Confermare") = vbYes Then
'è possibile inserire qualsiasi condizione, come cancellare i dati immessi in precedenza
With Sheets("Foglio1")
rng = .Name & "!" & .Cells(2, "B").Address & ":" & .Cells(limitI + 1, limitS + 2).Address
End With
Foglio1.Range(rng).ClearContents
'ora la matrice conterrà i dati di vendita per due anni
ReDim matriC(1 To 2, 1 To 2)
For annO = 1 To 2
For reP = 1 To 2
matriC(reP, annO) = InputBox("Inserisci i dati di vendita " & reP & " per l'anno " & annO)
Foglio1.Cells(reP + 1, annO + 1) = matriC(reP, annO)
Next reP
Next annO
End If
End Sub
 Fig. 9Terminata la fase di inserimento dei 2 anni, viene richiesta la conferma per continuare ai prossimi anni  Fig. 10Inseriti i dati dell’anno richiesto ritorna un messaggio per ridurre la matrice  Fig. 11Cliccando sul pulsante Si verranno cancellati i dati, ridotta la matrice e richiesti nuovi dati  Fig. 12Una volta inseriti i dati richiesti la matrice presenta questo aspetto  Fig. 13
___________________________________
- Il primo fondamento della sicurezza non e' la tecnologia, ma l'attitudine mentale - |
|
|
|
|
15-05-2014, 20.23.44
|
#22 |
|
Senior Member
WT Expert
Registrato: 19-05-2007
Loc.: Verona
Messaggi: 1.302
|
Azioni ripetitive : Il Ciclo For e il ciclo For Each Ora che sappiamo come scegliere diverse azioni basandosi su delle condizioni predeterminate, siamo pronti a vedere come ripetere delle azioni un numero predeterminato di volte se si verifica, o non si verifica una particolare condizione nella nostra procedura. Uno degli svantaggi delle macro è la loro incapacità di ripetere le azioni a meno che le azioni desiderate non vengano registrate ripetutamente, VBA fornisce diverse strutture potenti e versatili per permetterci di ripetere facilmente le azioni e per controllare il modo in cui VBA effettua queste ripetizioni. Le strutture del programma che ripetono l'esecuzione di una o più istruzioni sono chiamate Cicli, alcune strutture per i cicli sono costruite in modo da venire eseguite un numero impostato di volte, e vengono chiamate cicli ad interazione fissa, mentre altri tipi di strutture per i cicli vengono impostate un numero variabile di volte sulla base di alcune condizioni impostate, proprio perchè il numero di ripetizioni di queste strutture non è definito questi cicli vengono chiamati cicli ad interazione indefinita. Sia nelle strutture ad interazione fissa che nelle strutture ad interazione indefinita, ci sono alcune espressioni che determinano quante volte il ciclo viene ripetuto, questa espressione viene chiamata determinante del ciclo, questa espressione in un ciclo ad interazione fissa è quasi sempre una espressione numerica, mentre per i cicli a interazione indefinita la determinante del ciclo è solitamente un'espressione logica che descrive la condizione sotto la quale il ciclo può continuare o interrompere la sua esecuzione, praticamente vengono usate delle espressioni logiche per la determinante dei cicli allo stesso modo in cui sono state usate per prendere delle decisioni in VBA. Il ciclo For NextLa più semplice struttura per i cicli è quella ad interazione fissa, VBA ne fornisce due diverse tipologie che vengono espresse così For ...Next e For ...Each ... Next entrambi i cicli vengono chiamati cicli For perchè vengono eseguiti per uno specifico numero di volte. Il ciclo For ... Next ha la seguente sintassi For contatore = inizio To fine istruzioni Next contatore contatore viene rappresentato da una qualsiasi variabile numerica, di tipo Integer o Long, inizio è anch'esso rappresentato da una variabile numerica e specifica il valore iniziale per la variabile contatore, anche fine è una espressione numerica che rappresenta il valore finale per la variabile contatore. Per default VBA incrementa la variabile [I]contatore di 1 ogni volta che esegue le istruzioni di un ciclo. La parola chiave Next indica a VBA che è stata raggiunta la fine del ciclo, inoltre la variabile contatore, dopo la parola chiave Next, deve essere la stessa variabile contatore che abbiamo messo appena dopo l'enunciato For all’inizio della struttura del ciclo. Quando VBA esegue un ciclo For, prima assegna il valore rappresentato da inizio alla variabile contatore, quindi esegue tutte le istruzioni rappresentate da istruzioni fino a quando non raggiunge la parola chiave Next che indica che è stata raggiunta la fine del ciclo. VBA poi incrementa la variabile contatore di 1 e ritorna all’inizio del ciclo e confronta il valore corrente della variabile contatore col valore rappresentato da fine. Se contatore è minore o uguale a fine esegue nuovamente il ciclo. Se invece contatore è maggiore di fine VBA esce dal ciclo e continua la sua esecuzione con la prima istruzione dopo la parola chiave Next. Possiamo però anche specificare un valore diverso per l'incremento della variabile contatore includendo la parola chiave Step [opzionale], in questo caso dobbiamo specificare l'incremento della variabile contatore, e la sintassi diventa così : For contatore = inizio To fine Step passo istruzioni Next contatore In questo caso l'espressione passo viene rappresentato da una espressione numerica e indica la quantità per incrementare la variabile contatore, vediamo qualche esempio Codice:
Sub for_semplice() For I = 1 To 10 MsgBox (I) Next I End Sub Codice:
Sub for_step() For I = 1 To 10 Step 2 MsgBox (I) Next I End Sub In ultima analisi l'enunciato For viene interpretato così : For I [Per I] = 1 To 10 [che và da 1 a 10] Step 2 [incrementa di 2], Esegui le istruzioni , Next I [incrementa il valore di I], Il ciclo For ..Next ha la flessibilità di poter incrementare e decrementare la variabile, possiamo modificare il listato da For I = 1 To 10 Step 2 a For I = 100 To 1 Step -2 pertanto le possibilità di impiego sono abbastanza vaste, possiamo eseguire somme, incrementare e decrementare il valore delle variabili, utilizzare la ciclicità per ogni bisogno che richieda il nostro programma fermo restando i principi di impiego esposti all'inizio. Esiste anche un'altra forma di ciclo ed è il ciclo For Each ..Next Il ciclo For EachA differenza del ciclo For … Next il ciclo For Each … Next non usa un contatore, ma viene eseguito tante volte quanti sono gli elementi di un gruppo specifico, come una collezione di oggetti o un vettore. In breve il ciclo For Each … Next viene eseguito una volta per ogni elemento di un gruppo. Questo tipo di ciclo ha la seguente sintassi For Each elemento In gruppo Istruzioni Next [elemento] Dove, elemento è una variabile usata per interare il ciclo per tutti gli elementi del gruppo, gruppo è una collezione di oggetti o un vettore (matrice), se gruppo è una collezione di oggetti, elemento deve essere una variabile di tipo Variant o Object o uno specifico tipo di oggetto come Range, Worksheet, Cells e così via. Istruzioni rappresenta nessuna, una o più istruzioni VBA che formano il corpo del ciclo. Questo tipo di ciclo ha meno opzioni del ciclo For Next, l'incremento del contatore non è rilevante in questo ciclo, perchè viene sempre eseguito tante volte quanti sono gli elementi presenti nel gruppo specificato. In pratica non dovendo indicare il numero iniziale e finale per impostare quante volte il ciclo deve ripetere le nostre istruzioni, la nostra ricerca sarà rappresentata da quante volte il dato da cercare sarà presente nell’area di ricerca e l’inizio sarà sempre dal primo record contenuto nell’area di ricerca. Per meglio comprendere vediamo un esempio di questo tipo : Supponiamo di avere un elenco di nomi nell’intervallo di celle (Range) A1:A5 e si deve confrontare il valore della cella B1 e verificare se è presente nel Range, possiamo scrivere questo codice : Codice:
Sub prova_each()
Dim x As Boolean
y = Range("B1").Value
For Each cl In Range("A1:A5")
If cl = y Then
x = True
End If
Next
If x = True Then
MsgBox ("Valore Presente")
Else
MsgBox ("Valore Assente")
End If
End Sub
Possiamo quindi semplificare affermando che gruppo può essere un insieme di oggetti come le celle, le righe e le colonne di un foglio di calcolo, i fogli di lavoro di un file Excel oppure gli oggetti che possiamo inserire in un foglio come pulsanti, caselle di testo pulsanti di comando Userform etc.. E’ indubbio che un ciclo For Each rappresenta un modo pratico per sfogliare gli insiemi di una collezione, va ricordato che l’istruzione For Each funziona come Set, ovvero assegna un riferimento dell’oggetto a una variabile, ma invece di assegnarne uno solo, sceglie tutti gli elementi di una raccolta. Quindi, per ogni oggetto della raccolta, Visual Basic esegue tutte le istruzioni fino al’istruzione Next, anche se tecnicamente, non è necessario inserire il nome della variabile dopo Next, se lo si utilizza, Visual Basic richiede che corrisponda al nome della variabile dopo For Each. Si consiglia di utilizzare sempre la variabile del ciclo dopo Next in modo che Visual Basic possa contribuire a evitare bug nella macro. Le istruzioni che hanno inizio con For Each e terminano con Next sono definite blocchi For Each o cicli For Each. Cicli NidificatiÈ possibile nidificare cicli mettendo un ciclo all'interno di un altro ciclo, fino a un numero illimitato di volte. La variabile contatore per ogni ciclo deve essere univoca ed è possibile nidificare un tipo di ciclo all'interno di un altro tipo diverso. In un ciclo for, è necessario che il ciclo interno sia completato prima che si esegua l'istruzione successiva del ciclo esterno. È inoltre possibile nidificare un tipo di struttura di controllo all'interno di un altro tipo vale a dire che è possibile nidificare un'istruzione IF all'interno di un blocco With che può a sua volta essere annidato all'interno di un For ... Each. Tuttavia, le strutture di controllo non possono essere sovrapposte, ogni blocco nidificato si deve chiudere e terminare entro il livello nidificato esterno. Esempio di nidificazione di un ciclo IF all'interno di un blocco With che è annidato all'interno di un For. Il codice del ciclo Loop scorre ogni cella nell'intervallo A1: A10, e se il valore della cella è superiore a 5, il colore di sfondo viene impostato come giallo, mentre per valori inferiori a 5 viene usato il colore rosso Codice:
Sub ciclo1()
Dim iCell As Range
For Each iCell In ActiveSheet.Range("A1:A10")
With iCell
If iCell > 5 Then
.Interior.Color = RGB(255, 255, 0)
Else
.Interior.Color = RGB(255, 0, 0)
End If
End With
Next iCell
End Sub
Uscita anticipata dal cicloÈ possibile uscire da un ciclo For (For ... Next e For Each ... Next) in anticipo, senza completare il ciclo, utilizzando la dichiarazione Exit For che interromperà immediatamente l'esecuzione del ciclo esistente e passerà ad eseguire la sezione di codice immediatamente successiva all'istruzione Next, e nel caso di livello nidificato interno si ferma ed eseguirà il successivo livello nidificato esterno. Si può avere qualsiasi numero di istruzioni Exit For in un ciclo ed è particolarmente utile nel caso in cui si desidera terminare il ciclo al raggiungimento di un certo valore o di soddisfare una condizione specifica, o nel caso in cui si desidera interrompere un Loop infinito a un certo punto. Esempio: Se la cella A1 è vuota, la variabile nTotal si somma al valore 25, mentre se la cella A1 contiene il valore 5, il ciclo termina ed esce quando il contatore raggiunge il valore 5 Codice:
Sub ciclo2 ()
Dim n As Integer, nTotal As Integer
nTotal = 0
For n = 1 To 10
nTotal = n + nTotal
If n = ActiveSheet.Range("A1") Then
Exit For
End If
Next n
MsgBox nTotal
End Sub
___________________________________
- Il primo fondamento della sicurezza non e' la tecnologia, ma l'attitudine mentale - Ultima modifica di VincenzoGTA : 18-05-2014 alle ore 15.23.29 |
|
|
|
|
01-06-2014, 10.20.05
|
#23 |
|
Senior Member
WT Expert
Registrato: 19-05-2007
Loc.: Verona
Messaggi: 1.302
|
#3
Struttura Foglio Principale
La scelta dell’aspetto grafico è uno dei momenti più delicati quando si crea un nuovo programma. Innanzi tutto bisogna tenere presente che il foglio deve essere strutturato in modo da poter presentare un layout adeguato ad un documento commerciale, pertanto si deve prestare attenzione a dove vengono posizionati i vari campi e al loro contenuto, che deve essere conforme al documento che si sta preparando. Iniziamo suddividendo le colonne e le righe e dimensionare la loro larghezza, che nel nostro esempio riporta queste dimensioni: Colonna A = 0,5 dalla B alla K = 6 L e M = 4 N = 6 O e P = 4 Q = 8, mentre le righe sono tutte alte 14 ad eccezione di: riga 2 = 37 11, 14, 16 e 55 = 18 12 e 15 = 7. Il foglio così dimensionato si presenta come in figura sotto riportata  Fig. 1Mentre invece nella parte finale del documento, dove totalizziamo gli importi, è stato inserito un campo note e un campo per l’accettazione del preventivo da parte del cliente; la struttura si presenta come in figura 2  Fig. 2In questo nostro esempio è stata definita l’area di lavoro principale nel foglio “Preventivi”, che ne abbiamo appena visto la struttura, ora per emettere un preventivo si devono eseguire queste operazioni. 1) Come prima operazione si deve cliccare sul pulsante Nuovo documento, tramite il quale verrà inserita la data corrente e il numero del documento 2) Successivamente apparirà un box in cui scegliere il cliente destinatario del documento 3) In seguito vanno compilati i campi Agente e Trasporto agendo sulle frecce di selezione del campo 4) Infine si devono inserire gli articoli cliccando sul pulsante Inserisci Articoli e scegliere gli articoli dal box che apparirà Una volta eseguite queste operazioni il documento è compilato in tutte le sue parti e si può eseguire la stampa e salvare il documento in archivio premendo il pulsante “Memorizza”. Per automatizzare queste operazioni si inizia cliccando sul pulsante Nuovo Documento che manda in esecuzione questo codice: Codice:
Sub nuovo()
1) If Left(ActiveSheet.Name, 10) = "Preventivi" Then
2) svuota_prev
3) [M14] = Date
4) [P14] = Sheets("Setup").[B1].Value + 1 ' incremento n° preventivo
5) Sheets("Setup").[B2] = False ' Flag
6) calcola
7) cliente
8) End If
9) [H14].Select
End Sub
La procedura inizia con un ciclo IF alla riga 1, che consente l'esecuzione della macro solo se il foglio "Preventivi" è attivo. Il compito della riga di codice sopra esposta è quella di leggere, partendo da sinistra, il nome del foglio attivo tramite l’istruzione ActiveSheet.Name per 10 caratteri e se il valore verificato è uguale a Preventivi esegue il resto del codice, altrimenti salta tutte le istruzioni ed esce dalla Sub. Per personalizzare questo procedimento si devono contare i caratteri del nome del foglio e dopo l'istruzione ActiveSheet.Name mettere la cifra dei caratteri contati separati da una virgola. Alla riga 2 la macro svuota_prev si occupa di svuotare tutti i campi del foglio, in quanto si deve partire col foglio pulito; il codice è il seguente Codice:
Sub svuota_prev()
Range("M6:M8,B11:L11,B14:Q14,B17:Q48,P50:Q50,P52:Q52,P54:Q54").ClearContents
Sheets("Setup").Range("B2:B4,B8:B9,B11:B12").ClearContents
End Sub
La numerazione univoca per un preventivo non è una procedura richiesta dalla vigente normativa, risulta però molto comoda e utile nella gestione futura della documentazione emessa. Nel nostro esempio viene memorizzato il numero del documento quando si esegue la routine di salvataggio sia in archivio che nel foglio Setup, in modo che emettendo un nuovo documento, conoscendo il numero dell’ultimo preventivo emesso, risulta facile numerare progressivamente i preventivi. Osservando in Fig. 1, il numero del preventivo è situato nella cella P14 che nel codice della macro è stata rappresentata in valore assoluto con la forma [P14] (che equivale a scrivere; Range("P14")) ed è stato posto il suo valore uguale al contenuto della cella B1 del foglio Setup, dove viene memorizzato il numero dell’ultimo preventivo emesso, che incrementandolo di 1 quando si emette un nuovo preventivo, si ottiene il numero progressivo per il nuovo preventivo e, al tempo stesso, una numerazione univoca dei documenti  Fig. 3La riga 5 rappresenta un Flag (bandierina), che viene usato come indicatore dell’operazione in corso memorizzando nella cella B2 del foglio Setup un valore Booleano espresso con la dicitura FALSE oppure TRUE. Per il calcolatore risulta impossibile sapere se si sta operando su un nuovo documento oppure su un preventivo già memorizzato in archivio. In pratica questa semplice operazione servirà per contraddistinguere un nuovo preventivo, memorizzando il valore Booleano FALSE da un preventivo già memorizzato che stiamo modificando, utilizzando il valore TRUE. Quando viene eseguita l’operazione di memorizzazione in archivio di un preventivo, se il valore della cella B2 del foglio Setup è uguale a False, non viene richiesta nessuna azione all’utente, in quanto si tratta di un nuovo preventivo, mentre invece se il valore della cella B2 è uguale a True, significa che l’utente sta modificando un documento presente in archivio e il programma avverte l’operatore che il preventivo era già in memoria, chiedendo l'autorizzazione a salvare le modifiche fatte con un avviso come questo  Fig. 4Altra riga 6 viene richiamata la routine calcola, vediamo il suo codice e di cosa si occupa. Codice:
Private Sub calcola()
1. Dim mydate, mystr
2. mydate = [M14]
3. mymonth = Month(mydate)
4. posiz = mymonth * 8 - 7 'colonna
5. Sheets("Setup").[B4] = posiz 'scrivo la colonna
6. m = 2
7. Do Until Sheets("Archivio").Cells(m, posiz).Value = Empty
8. m = m + 30
9. Loop
10. Sheets("Setup").[B3] = m ' scrivo n° di riga
End Sub
 Fig. 5Approfondiremo in seguito e in maniera più dettagliata la struttura di questo foglio, ora proseguiamo a commentare il codice. Alla riga 1 vengono dichiarate due variabili, e alla riga 2 il valore della variabile mydate viene prelevato dalla cella N14 in cui è stata inserita la data del documento tramite la routine Nuovo. Alla riga 3 viene calcolato il mese corrente in formato numerico per cui Gennaio =1, Febbraio =2 etc. e alla riga 4 viene utilizzata la variabile posiz per memorizzare la colonna da utilizzare per salvare il preventivo in base al mese di emissione, con un calcolo matematico espresso in questo modo. Supponiamo, per esempio, di essere nel mese di Febbraio (per cui 2), utilizzando l’espressione rappresentata nella riga 4 il codice diventa: posiz = 2 * 8 - 7 che risulta 16-7 = 9. Come si può vedere in Fig. 5 la prima colonna del mese di Febbraio corrisponde a I, che in forma numerica è la nona colonna, e sarà utilizzata come colonna iniziale per salvare i dati del mese di febbraio. Alla riga 5 il valore della variabile posiz viene memorizzato nella cella B4 del foglio Setup. Ora si deve reperire il numero di riga che riceverà i dati del preventivo, pertanto dalla riga 6 alla riga 9 con un ciclo Do Loop scorriamo tutto il foglio Archivio alla colonna definita dalla variabile posiz, fino a trovare una riga vuota, che rappresenterà la riga da utilizzare. Questa ricerca inizia dalla riga 6 ponendo una variabile (m) uguale a 2, che rappresenta la riga iniziale dell’archivio dati, in quanto la riga uno viene utilizzata per le intestazioni delle colonne. Con il ciclo Do loop si scorrono le righe con un "salto" di 30 righe ad ogni ciclo, che rappresenta il valore in righe dello spazio destinato a contenere i dati. Una volta calcolata la riga, viene memorizzato il suo valore nella cella B3 del foglio Setup con l’istruzione alla riga 10. Riassumendo i valori della variabile m e della variabile posiz corrispondono alla riga e alla colonna da utilizzare per salvare i dati. Una dichiarazione molto importante a riguardo è l'uso delle variabili, che devono essere dichiarate Public (pubbliche), pertanto condivisibili in tutte le routine, ad inizio del listato in questo modo Public m As Integer, posiz As Integer Alla riga 7 viene eseguita la routine cliente, che si occupa di mostrare a video un box con una casella a discesa in cui scegliere a quale cliente intestare il preventive. Il box si presenta in questo modo  Fig. 6Cliccando sulla freccia del box comparirà un elenco a discesa dei clienti archiviati, selezionando il cliente interessato e cliccando sul pulsante Procedi verranno caricati i dati del cliente dall’archivio anagrafico e inseriti negli appositi campi del preventivo. Vedremo il codice e le procedure di questa routine più avanti, adesso completiamo il listato iniziale con l’ultima istruzione presente nella routine Nuovo in cui viene selezionata la cella H14 che contiene l’agente di riferimento per il preventivo. In questo campo e nel campo trasporto, per facilitare l'inserimento di valori ripetitivi e al tempo stesso evitare di continuare a scriverli viene usato Convalida Dati, per inserire nelle rispettive celle i dati che verranno scelti di volta in volta. I due campi si presentano in questo modo  Fig. 7 Fig. 8Per inserire nei due campi il menu a tendina si deve selezionare la cella e dal menù Dati - Convalida verrà portato a video un box come quello sotto riportato  Fig. 9Cliccando sul box Consenti si deve scegliere la voce Elenco dal menu a tendina che compare e passando poi nel box Origine, cliccando sull'icona segnalata dalla freccia rossa nell’immagine sottostante, si può selezionare un intervallo di celle che i valori presenti in questo intervallo andranno a costituire l’elenco mostrato nel menu a tendina.  Fig. 10Per inserire gli agenti e l’incaricato del trasporto utilizziamo il foglio di appoggio Setup, dove sono stati memorizzati i dati, come possiamo vedere in figura 3, dove alla riga 5 si trovano gli incaricati del trasporto (Mittente, Destinatario e Vettore) e nella riga successiva gli agenti commerciali dell’azienda. Concludiamo questa prima parte con la routine collegata al pulsante Formule. A volte può succedere di dover ricorrere a modifiche manuali, oppure semplicemente a un copia/incolla di una riga, e si può correre il rischio che gli importi a seguito di queste operazioni non vengano calcolate, per cui basta cliccare sul pulsante per inserire automaticamente tutte le formule per calcolare gli importi e totalizzare il documento. La routine ha questo codice Codice:
Sub formule()
1. r = 17
2. Do Until Sheets("Preventivi").Cells(r, 2) = Empty
3. With Sheets("Preventivi")
4. .Cells(r, 17).Formula = "=RC[-2]*RC[-3]"
5. End With
6. r = r + 1
7. Loop
8. [P50].Formula = "=sum(Q17:Q48)" 'totale imponibile
9. [P52].Formula = "=(P50*22)/100" 'Importo iva
10. [P54].Formula = "=sum(P50+P52)" 'totale ordine
End Sub
___________________________________
- Il primo fondamento della sicurezza non e' la tecnologia, ma l'attitudine mentale - |
|
|
|
|
01-06-2014, 10.23.50
|
#24 |
|
Senior Member
WT Expert
Registrato: 19-05-2007
Loc.: Verona
Messaggi: 1.302
|
#4
Salva e Richiama Preventivo
Una volta che il preventivo è stato compilato in tutte le sue parti si può procedere con la stampa e il trasferimento dei dati in archivio cliccando sul pulsante Memorizza che si occupa di inviare il documento prima alla stampante di sistema e successivamente di archiviarlo. Una volta premuto il pulsante viene visualizzato questo avviso  Fig. 1In questa finestra di scelta prima dell’archiviazione è possibile scegliere se stampare il documento oppure no. Se viene premuto il pulsante Si il Preventivo viene inviato alla stampante di sistema e poi archiviato, cliccando invece sul pulsante No si archivia direttamente il preventivo senza eseguire la routine di stampa. Il codice associato al pulsante Memorizza è il seguente Codice:
Sub Memorizza()
1. m = Sheets("Setup").[B3] 'riga dove scrivere
2. posiz = Sheets("Setup").[B4] 'colonna dove scrivere
3. If Sheets("Setup").[B2] = True Then 'controllo il flag
4. Mt = Mt & "Attenzione Il Preventivo era già in memoria " & Chr(13) & Chr(13)
5. Mt = Mt & "Vuoi Sovrascriverlo??" & Chr(13) & Chr(13)
6. rs = MsgBox(prompt:=Mt, Title:="Gestione Preventivi", Buttons:=vbYesNo + vbQuestion)
7. If rs = vbNo Then Exit Sub
8. salva
9. svuota_prev
10. ElseIf Sheets("Setup").[B2] = False Then
11. Sheets("Setup").[B1] = [P14]
12. controllo
13. End If
End Sub
Alla riga 3 viene posta una condizione tramite il ciclo IF per scegliere quali istruzioni eseguire. Questa scelta si basa esclusivamente sul tracciato di “provenienza” del documento. Per riconoscere se si sta operando su un nuovo preventivo oppure su un documento caricato dall’archivio per modificarlo, si procede con la lettura del valore presente nella cella B2 del foglio Setup, nella quale è stato inserito un valore Booleano al momento della creazione del documento. La cella B2 contiene il valore FALSE se viene creato un nuovo documento e TRUE se si sta operando su un documento estratto dall’archivio, pertanto alla riga 3 viene verificato il valore nella cella B2 e se il valore corrisponde a TRUE, pertanto si sta operando su un documento già archiviato, alla riga 4 – 5 e 6 si richiede l’autorizzazione all’operatore di procedere al salvataggio delle modifiche tramite un messaggio a video. Il messaggio visualizzato è il seguente  Fig. 2Qualora si negasse l’autorizzazione cliccando sul pulsante NO, con l’istruzione alla riga 7 vengono saltate tutte le istruzione e si esce dalla routine ritornando al foglio preventivi. Nel caso sia stato cliccato il pulsante SI alla richiesta di procedere con il salvataggio dei dati si richiama la routine salva alla riga 8, che commenteremo Alla riga 9 viene svuotato il documento tramite la routine svuota_prev che è stata commentata nella lezione precedente chiudendo così la prima istruzione del ciclo IF. Qualora il valore della cella B2 del foglio Setup fosse stato uguale a FALSE, confermando così la presenza di un nuovo documento, tutte le istruzioni dalla riga 3 alla riga 10 non sarebbero state eseguite e il controllo della routine sarebbe passato alla riga 10 per la verifica del valore della cella B2, per poi assegnare alla cella B1 del foglio Setup il valore presente nella cella P14 del foglio Preventivi che rappresenta il numero di documento alla riga 11. Alla riga 12 si esegue la routine controllo e alla riga successiva si termina ciclo e routine. La routine controllo presenta questo codice Codice:
Private Sub controllo() 1. If [M6] = "" Then: MsgBox "Inserire nome cliente": [M6].Select: Exit Sub 2. salva 3. svuota_prev End Sub Codice:
Private Sub salva()
1. j = 17
2. With Sheets("Archivio")
3. .Cells(m, posiz) = [M6] 'Cliente
4. .Cells(m, posiz + 1) = [M7] 'Indirizzo
5. .Cells(m, posiz + 2) = [M8] 'Città
6. .Cells(m, posiz + 3) = [B11] 'pagamento
7. .Cells(m, posiz + 4) = [G11] 'banca
8. .Cells(m, posiz + 5) = [M14].Value 'data preventivo
9. .Cells(m, posiz + 6) = [P14] 'n° preventivo
10. .Cells(m + 1, posiz) = [D14] 'email
11. .Cells(m + 1, posiz + 1) = [H14] 'Agente
12. .Cells(m + 1, posiz + 2) = [J14] 'trasporto
13. .Cells(m + 1, posiz + 3) = [P50] 'tot. imponibile
14. .Cells(m + 1, posiz + 4) = [P52] 'importo iva
15. .Cells(m + 1, posiz + 5) = [P54] 'totale
16. .Cells(m + 1, posiz + 6) = [B56] 'note
17. End With
18. m = m + 2
19. Do Until Sheets("Preventivi").Cells(j, 2) = Empty
20. With Sheets("Archivio")
21. .Cells(m, posiz) = Sheets("Preventivi").Cells(j, 2).Value 'codice
22. .Cells(m, posiz + 1) = Sheets("Preventivi").Cells(j, 3).Value 'descrizione
23. .Cells(m, posiz + 2) = Sheets("Preventivi").Cells(j, 14).Value 'quantità
24. .Cells(m, posiz + 3) = Sheets("Preventivi").Cells(j, 15).Value 'prezzo
25. .Cells(m, posiz + 4) = Sheets("Preventivi").Cells(j, 17).Value 'importo
26. End With
27. j = j + 1: m = m + 1
28. Loop
29. Mt = Mt & "Stampo il Preventivo?" & Chr(13) & Chr(13)
30. rs = MsgBox(prompt:=Mt, Title:="Gestione Preventivi", Buttons:=vbYesNo + vbQuestion)
31. If rs = vbNo Then
32. Exit Sub
33. Else
34. ActiveSheet.PrintOut copies:=1
35. End If
End Sub
 Fig. 3Dalla riga 2 alla riga 17 tramite il ciclo With vengono inseriti i valori presenti nei campi del foglio Preventivi alle coordinate specificate, e scritti nel foglio archivio su 2 righe. Il valore e la procedura di estrazione delle variabili m e posiz è stato visto poco sopra, ricordiamo solo che identificano rispettivamente riga e colonna del foglio Archivio, pertanto con la procedura descritta nel ciclo With viene assegnato il valore presente nei vari campi rappresentati dai rispettivi Range alle coordinate di riga e colonna determinate dai valori delle variabili m e posiz. Per salvare il corpo del preventivo viene usato un ciclo Do Loop. Alla riga 18 la variabile m, che rappresenta la riga iniziale del foglio Archivio che riceve i dati dei documenti, viene incrementata di 2 unità in quanto le prime 2 righe sono dedicate ai dati generali del preventivo (N° documento, data, cliente etc.), e nelle righe successive del foglio Archivio si inseriscono i valori presenti nelle righe del foglio Preventivi usando un ciclo With, utilizzando le variabili m e posiz per identificare le coordinate del foglio Archivio, e la variabile j per identificare il range del foglio Preventivi, che è stata inizializzata con un valore pari a 17 alla riga 1 del listato, che rappresenta la riga iniziale del corpo del preventivo. Dalla riga 29 alla riga 33 viene visualizzato a video il messaggio di figura 1, per chiedere conferma di proseguire con la stampa del documento e alla riga 35 si chiude il ciclo e termina la routine. Ora vediamo il pulsante Richiama che si occupa di recuperare un preventivo dall’archivio e caricare tutti i dati nel foglio Preventivi. Al pulsante è stato assegnato questo codice Codice:
Sub recupera()
FormFM.Show
End Sub
 Fig. 4Da ricordare che i preventivi vengono divisi per periodo e assegnati al mese di emissione nel momento della creazione del documento stesso, pertanto all'attivazione della Form comparirà una casella di selezione denominata “Periodo” che viene popolata col seguente codice Codice:
Private Sub UserForm_Activate()
Dim elemento As String
If ListBox1.ListCount >= 1 Then ListBox1.Clear
i = 1
Do Until Sheets("Archivio").Cells(1, i).Value = Empty
With Sheets("Archivio")
elemento = .Cells(1, i).Value
End With
ListBox1.AddItem elemento
i = i + 8
Loop
ListBox1.ListIndex = 0
svuota_box
End Sub
Codice:
Private Sub svuota_box()
conta = 1
For conta = 1 To 5
Controls("TextBox" & conta) = ""
Next conta
End Sub
Codice:
Private Sub ListBox1_Click()
Dim elemen As String, s As Integer
svuota_box
posiz = (ListBox1.ListIndex + 1) * 8 – 7 ‘calcolo colonna
If ListBox2.ListCount >= 1 Then ListBox2.Clear
s = 2
Do Until Sheets("Archivio").Cells(s, posiz) = Empty
With Sheets("Archivio")
elemen = .Cells(s, posiz).Value
End With
ListBox2.AddItem elemen
s = s + 30
Loop
End Sub
Codice:
Private Sub ListBox2_Click()
p = ListBox2.ListIndex + 1
p = (p * 30) - 29 + 1 riga foglio archivio
TextBox1.Text = Sheets("Archivio").Cells(p, posiz) 'cliente
TextBox2.Text = Sheets("Archivio").Cells(p, posiz + 5).Value 'data prev.
TextBox3.Text = Sheets("Archivio").Cells(p, posiz + 6) 'n° prev.
TextBox4.Text = Format(CDbl(Sheets("Archivio").Cells(p + 1, posiz + 4)), "#,0.00") 'importo euro
TextBox5.Text = Sheets("Archivio").Cells(p + 1, posiz + 2) 'agente
End Sub
Codice:
Private Sub CommandButton1_Click()
FormFM.Hide
svuota_prev
Dim r As Integer
r = 17
Sheets("Setup").[B2] = True 'scrivo flag per salvare modifiche
Sheets("Setup").Range("B3") = p 'scrivo riga
Sheets("Setup").Range("B4") = posiz 'scrivo colonna
Sheets("Preventivi").Range("B17").Select
Sheets("Preventivi").Range("M6") = Sheets("Archivio").Cells(p, posiz) 'cliente
Sheets("Preventivi").Range("M7") = Sheets("Archivio").Cells(p, posiz + 1) 'indirizzo
Sheets("Preventivi").Range("M8") = Sheets("Archivio").Cells(p, posiz + 2) 'città
Sheets("Preventivi").Range("B11") = Sheets("Archivio").Cells(p, posiz + 3) 'pagamento
Sheets("Preventivi").Range("G11") = Sheets("Archivio").Cells(p, posiz + 4) 'banca appoggio
Sheets("Preventivi").Range("M14") = Sheets("Archivio").Cells(p, posiz + 5) 'data documento
Sheets("Preventivi").Range("P14") = Sheets("Archivio").Cells(p, posiz + 6) 'N° documento
Sheets("Preventivi").Range("B14") = Sheets("Archivio").Cells(p + 1, posiz).Value 'P.iva
Sheets("Preventivi").Range("D14") = Sheets("Archivio").Cells(p + 1, posiz + 1).Value 'email
Sheets("Preventivi").Range("H14") = Sheets("Archivio").Cells(p + 1, posiz + 2).Value 'agente
Sheets("Preventivi").Range("J14") = Sheets("Archivio").Cells(p + 1, posiz + 3).Value 'trasporto
Sheets("Preventivi").Range("P50") = Sheets("Archivio").Cells(p + 1, posiz + 4).Value 'Imponibile
Sheets("Preventivi").Range("P52") = Sheets("Archivio").Cells(p + 1, posiz + 5).Value 'iva
Sheets("Preventivi").Range("P54") = Sheets("Archivio").Cells(p + 1, posiz + 6).Value 'Totale
p = p + 2
Do Until Sheets("Archivio").Cells(p, posiz) = Empty
Cells(r, 2) = Sheets("Archivio").Cells(p, posiz) 'codice
Cells(r, 3) = Sheets("Archivio").Cells(p, posiz + 1) 'decrizione
Cells(r, 14) = Sheets("Archivio").Cells(p, posiz + 2) 'quant
Cells(r, 15) = Sheets("Archivio").Cells(p, posiz + 3) 'prezzo
Cells(r, 17) = Sheets("Archivio").Cells(p, posiz + 4) 'importo
r = r + 1: p = p + 1
Loop
Sheets("Preventivi").Range("B17").Select
End Sub
___________________________________
- Il primo fondamento della sicurezza non e' la tecnologia, ma l'attitudine mentale - |
|
|
|
|
01-06-2014, 10.25.41
|
#25 |
|
Senior Member
WT Expert
Registrato: 19-05-2007
Loc.: Verona
Messaggi: 1.302
|
#5
Inserimento Articoli
Vediamo ora come inserire un articolo tramite VBA direttamente nel foglio Preventivi. Essendo il foglio Listino uno dei punti focali della procedura, ricordiamo che è stato diviso per categorie merceologiche ed è strutturato come si vede in figura 1  Fig. 1Ogni categoria ha a disposizione 14 colonne e sono separate da una colonna vuota (quella nera), la riga 1 ospita il titolo della categoria e la riga 2 le etichette delle varie colonne. Dalla riga 3 vengono inseriti gli articoli con i relativi dati. Fatta questa premessa, possiamo inserire gli articoli cliccando sul pulsante Inserisci Articoli che visualizzerà una finestra di dialogo in cui è possibile selezionare la categoria dell’articolo che mostrerà tutti gli articoli della stessa in una casella di riepilogo, che una volta selezionati possono essere inseriti nel foglio Preventivi. La finestra di dialogo è così strutturata  Fig. 2Per popolare il primo Listbox con i nomi delle varie categorie è stato inserito nell’evento UserForm_Activate questo codice: Codice:
Private Sub UserForm_Activate()
1. If [P14] = "" Then MsgBox "Prima devi creare un nuovo documento", vbExclamation: End
2. i = 1
3. Do Until Sheets("Listino").Cells(1, i) = Empty
4. FormArt.ListBox1.AddItem (Sheets("Listino").Cells(1, i).Value)
5. i = i + 15
6. Loop
End Sub
 Fig. 3Dalla riga 2 alla riga 6 tramite un ciclo Do Loop si scorre la riga 1 con un salto di 15 colonne fino a trovare una colonna vuota che determina l’uscita dal ciclo e contestualmente viene riempito il ListBox con i valori trovati nelle colonne. Il procedimento è abbastanza semplice e già visto in altre lezioni, viene usata la variabile i e posta uguale a 1 e con il ciclo Do Loop si scorre tutto il foglio “Listino” nell’intervallo di riga 1 e colonna i, che al primo ciclo i vale 1, per cui la ricerca inizia dalla riga 1 colonna 1, notare che la variabile è stata inserita nell’enunciato come riferimento di colonna, per cui nel ciclo la riga rimarrà fissa mentre varieranno i riferimenti di colonna, in pratica mentre il flusso del programma scorre tutte le colonne della riga 1 vengono inseriti anche i valori che rappresentano il nome della categoria al ListBox, dove FormArt è il nome assegnato alla Userform come si vede in figura  Fig. 4Per rilevare i nomi delle categorie presenti nella riga 1 del foglio Listino viene usata la variabile i in un ciclo, sapendo che il foglio è diviso in colonne, che costituiscono le varie categorie, e ogni categoria è composta da 14 colonne ed è divisa dalla prossima categoria da una colonna vuota (quella nera). Il nome della categoria è collocato nella prima colonna, e le colonne che ci sono tra un nome di categoria e l’altro sono 15 per cui se viene incrementato il valore della variabile i di 15 unità, e considerando che i al primo ciclo vale 1, la seconda categoria si trova alla colonna [i+15] cioè alla 16° colonna, come la terza categoria è situata alla colonna [i+15] cioè [16+15]=31, perché al secondo giro del ciclo la variabile i assume il valore 16. Si ripete tutto questo finchè non viene trovata una colonna vuota [Empty] e il ciclo si ferma. Ora il primo Listbox è stato riempito con i nomi delle categorie, e cliccando su una voce vengono riportati tutti gli articoli in essa inseriti, come visto in figura 2. Per popolare il secondo ListBox è stato inserito nell’evento ListBox1_Clik il seguente codice Codice:
Private Sub ListBox1_Click()
1. posiz = (ListBox1.ListIndex + 1) * 15 - 14 ' calcolo la colonna
2. If ListBox2.ListCount >= 1 Then ListBox2.Clear
3. i = 3
4. Do Until Sheets("Listino").Cells(i, posiz) = Empty
5. With Sheets("Listino")
6. elemen = .Cells(i, posiz + 1)
7. End With
8. ListBox2.AddItem elemen
9. i = i + 1
10. Loop
11. Cancella
End Sub
Codice:
Private Sub ListBox1_Click() posiz = (ListBox1.ListIndex + 1) MsgBox posiz End Sub  Fig. 5Ora è facile intuire che cliccando su una voce del Listbox la funzione riporta la posizione numerica della voce in elenco, in sostanza cliccando sulla prima voce riporta il valore 1, sulla seconda il valore 2 e così di seguito, ritornando al listato originale, risulta che la variabile posiz cliccando sulle voci del Listbox assume il valore calcolato in questo modo Voce 1 = 1*15-14 = 1 Voce 2 = 2*15-14 = 16 Voce 3 = 3*15-14 = 31 Perché i valori 15 e 14? Perché il foglio che raccoglie le categorie degli articoli ha un intervallo di 15 colonne (compresa quella vuota) tra una categoria e l’altra. Per esempio, se l’intervallo fosse stato di 10 colonne si dovrebbe moltiplicare per 10 e sottrarre 9. In definitiva i valori 1-16-31 sono i numeri di colonna in cui sono collocate le categorie e nelle quali si devono scorrere le righe per trovare gli articoli inseriti. Alla riga 2 del listato viene eseguita una “conta” delle voci presenti nel ListBox2 e si verifica che il Listbox2 sia vuoto, per cui se il numero di voci nel Listbox2 sono maggiori o uguali a 1 allora vengono cancellate. Alla riga 3 si pone la variabile i uguale a 3 che rappresenta la riga di inizio in cui cercare gli articoli, dichiarandola con valore = 3 decidiamo di partire dalla terza riga, perché prima riga è destinata al nome della categoria, la seconda alle etichette delle colonne e dalla terza si trovano gli articoli. Il seguito del codice svolge la ricerca degli articoli e li aggiunge nel Listbox Dalla riga 4 alla riga 10 si ripete l’operazione vista per il ListBox1, con la sola differenza che vengono incrementate le righe invece delle colonne finchè non viene trovata una riga vuota [= Empty] e tutte le voci trovate vengono caricate nel Listbox. Da notare che è stata usata la notazione +1, alla riga 6 del listato in quanto è stato preferito caricare nel Listbox2 la descrizione dell’articolo, che è più rappresentativa per riconoscere l’articolo, e si trova nella colonna a fianco di quella processata. Per caricare la colonna processata si deve togliere il valore +1 e il ListBox2 sarebbe stato popolato con il codice dell’articolo invece della descrizione
___________________________________
- Il primo fondamento della sicurezza non e' la tecnologia, ma l'attitudine mentale - |
|
|
|
|
01-06-2014, 10.28.38
|
#26 |
|
Senior Member
WT Expert
Registrato: 19-05-2007
Loc.: Verona
Messaggi: 1.302
|
Il controllo Image e RafEdit Un controllo Image consente di visualizzare delle immagini nella propria applicazione. Per assegnare una foto a questo controllo in fase di progettazione, si utilizza la proprietà Image, inoltre è possibile assegnare un'immagine al controllo Image in fase di esecuzione utilizzando la funzione LoadPicture. Un aspetto importante è quello di inserire un’immagine nel controllo Image o adattare le dimensioni del controllo all'immagine, che determina come sarà visualizzata. Questo può essere fatto usando la proprietà PictureSizeMode come descritto di seguito. La Proprietà PictureSizeMode specifica come viene visualizzata l'immagine, vale a dire, se il controllo Image non ha le stesse dimensione dell’immagine è possibile modificare la modalità di visualizzazione con le proprietà disponibili che sono:
La Proprietà PictureAlignment specifica la posizione relativa o l'allineamento del quadro all'interno del controllo Image. Sono disponibili 5 impostazioni:
Nota: Se l'immagine è impostata su fmSizeModeStretch nella proprietà PictureSizeMode, l'immagine si estende per adattarsi al suo controllo, quindi PictureAlignment non dispone di alcun effetto. Utilizzando la Funzione LoadPicture si assegna un'immagine al controllo Image in fase di esecuzione: si usa la seguente Sintassi: ImageControl.Picture = LoadPicture (percorso) Esempio: Selezionare la foto da visualizzare nel controllo Image dal ListBox1 Codice:
Private Sub UserForm_Initialize ()
ListBox1.AddItem "Immagine1"
ListBox1.AddItem "Immagine2"
ListBox1.AddItem "Immagine3"
ListBox1.AddItem "Immagine4”
End Sub
Private Sub ListBox1_Click ()
If ListBox1.Value = "immagine 1" Then
Image1.Picture = LoadPicture ("C:\Test\Immagini\immagine1.jpg")
ElseIf ListBox1.Value = "immagine2" Then
Image1.Picture = LoadPicture ("C:\Test\Immagini\immagine2.jpg")
ElseIf ListBox1.Value = "immagine3" Then
Image1.Picture = LoadPicture ("C:\Test\Immagini\immagine3.jpg")
ElseIf ListBox1.Value = "immagine4" Then
Image1.Picture = LoadPicture ("C:\Test\Immagini\immagine4.jpg")
End If
End Sub
 Fig. 1Esempio: Selezionare il percorso completo di un'immagine da visualizzare nel controllo Image dal ListBox1 Codice:
Private Sub UserForm_Initialize () Dim img1 As String Dim img2 As String Dim img3 As String Dim img4 As String img1 = "C:\Test\Immagini\immagine1.jpg" img2 = "C:\Test\Immagini\immagine2.jpg" img3 = "C:\Test\Immagini\immagine3.jpg" img4 = "C:\Test\Immagini\immagine4.jpg" ListBox1.AddItem img1 ListBox1.AddItem img2 ListBox1.AddItem img3 ListBox1.AddItem img4 End Sub Private Sub ListBox1_Click () Image1.Picture = LoadPicture (ListBox1.List (ListBox1.ListIndex)) End Sub  Fig. 2Esempio: Visualizzare un'immagine nel pulsante di comando, all'attivazione della UserForm: Codice:
Private Sub UserForm_Initialize ()
CommandButton1.Picture = LoadPicture ("C:\Test\Immagini\img1.jpg")
End Sub
 Fig. 3Esempio: Visualizzare un immagine nel controllo Image cliccando sul pulsante di comando: Codice:
Private Sub CommandButton1_Click ()
With UserForm2
Image1.Picture = LoadPicture ("C:\Test\Immagini\immagine4.jpg")
End With
End Sub
 Fig. 4 Il Metodo GetOpenFilenameQuesto metodo consente all'utente di immettere un nome di file nella finestra di dialogo standard Apri File. Il metodo non apre qualsiasi file, viene visualizzata solo la casella per accettare il nome del file, e restituisce il nome inserito dall'utente o il nome del file selezionato, che potrebbe anche essere un percorso (cioè cartella e nome del file). La sintassi è la seguente:Espressione GetOpenFilename ([FileFilter], [FilterIndex], [Titolo], [ButtonText], [Selezione multipla]) FileFilter è una stringa che specifica i criteri per filtrare i file. Si compone di coppie di stringhe e ogni parte comprende il carattere jolly ed è separato da virgole. Esempio: FileFilter: = "File di testo (txt.), * txt, TIFF (* tif.), * tif, JPEG Files (* jpg.), * jpg” L’esempio seguente di FileFilter specifica 3 criteri di filtri di file (file di testo txt, i file TIFF e file JPEG) e consente all'utente di inserire o selezionare i file con estensione txt, Jpg e tif. Per includere più espressioni in un unico criterio di filtro di file, utilizzare punti e virgola per separare ogni espressione. Esempio: FileFilter: = "JPEG File Interchange Format (* jpg, * jpeg, * jfif; * GPE), * jpg, * jpeg, * jfif; * GPE” E’ possibile utilizzare FileFilter specificando 1 criterio solo di filtro per i file (JPEG) e comprende quattro espressioni che consentono la selezione di file con estensione jpg, jpeg, jfif e GPE. Tralasciando questo argomento sarà di default il filtro "Tutti i file (*. *), *. *". FilterIndex è il criterio di default del filtro dei file specificati dal numero indice che va da 1 al numero di criteri specifici di filters. Omettendo di menzionare FilterIndex, o specificando un numero di indice oltre la sua dotazione, verrà impostato il primo criterio del filtro file. Titolo specifica il titolo della finestra di dialogo che viene visualizzata utilizzando il metodo [i]GetOpenFilename[/i]. Il titolo predefinito è "Open" se non specificato. MultiSelect se impostato a True consente la selezione multipla dei file e se impostato a False, che è anche il valore di default, permette la selezione di un singolo file. Esempio: Usare LoadPicture con il metodo GetOpenFilename per caricare foto in un controllo Image. Codice:
Private Sub UserForm_Initialize() Me.Image1.BackColor = RGB(152, 255, 152) Me.Label1.Caption = "Clicca sulla casella verde per selezionare e caricare un'Immagine" Me.CommandButton1.Caption = "Cliccare per Uscire" End Sub Private Sub Image1_Click() Dim fileName As String fileName = Application.GetOpenFilename(filefilter:="Tiff Files(*.tif;*.tiff),*.tif;*.tiff,JPEG Files (*.jpg;*.jpeg;*.jfif;*.jpe),*.jpg;*.jpeg;*.jfif;*.jpe,Bitmap Files(*.bmp),*.bmp", FilterIndex:=2, Title:="Seleziona un file", MultiSelect:=False) If fileName = "False" Then MsgBox "File non selezionato!" Else Me.Image1.Picture = LoadPicture(fileName) Me.Repaint Me.Label1.Caption = "Immagine Caricata" End If End Sub Private Sub CommandButton1_Click() Unload Me End Sub  Fig. 5 Fig. 6 Fig. 7Esempio: Usare LoadPicture con il metodo GetOpenFilename per caricare foto in un controllo Image Codice:
Private Sub UserForm_Initialize() Me.Image1.BackColor = RGB(152, 255, 152) Me.Label1.Caption = "Clicca sulla casella verde per selezionare e caricare un'Immagine" Me.CommandButton1.Caption = "Cliccare per Uscire" End Sub Private Sub Image1_Click() Dim fltr As String, ttl As String, fileName As String Dim fltrIndx As Integer Dim mltiSlct As Boolean fltr = "Tiff Files(*.tif;*.tiff),*.tif;*.tiff,JPEG Files (*.jpg;*.jpeg;*.jfif;*.jpe),*.jpg;*.jpeg;*.jfif;*.jpe,Bitmap Files(*.bmp),*.bmp" fltrIndx = 2 ttl = "Seleziona un file" mltiSlct = False ChDrive "C" ChDir "C:\Test\Immagini" fileName = Application.GetOpenFilename(fltr, fltrIndx, ttl, , mltiSlct) If fileName <> "False" Then Me.Image1.Picture = LoadPicture(fileName) Me.Repaint Me.Label1.Caption = "Immagine Caricata" End If End Sub Private Sub CommandButton1_Click() Unload Me End Sub Il Controllo RefEditIl controllo RefEdit è disponibile solo in una UserForm e consente all'utente di selezionare una cella o un intervallo di celle del foglio di lavoro, permette anche di digitare direttamente nella casella di testo i riferimenti di cella. Nel campo del controllo RefEdit è visibile l'indirizzo della cella o l'intervallo di celle , che un utente seleziona o digita nel campo stesso. Per ottenere l'indirizzo di una cella o l'intervallo di celle memorizzate in un controllo RefEdit si utilizza la proprietà Value. Esempio: Selezionare una cella nel foglio ed eseguire il codice premendo un pulsante Codice:
Private Sub CommandButton1_Click ()
Dim rngAddress As String
rngAddress = RefEdit1.Value
Range (rngAddress). Value = "Ciao"
Range (rngAddress). Interior.Color = RGB (255, 0, 0)
If MsgBox ("Azione eseguita. Vuoi Uscire?", VbQuestion + vbYesNo) = vbYes Then
Unload Me
End If
End Sub
 Fig. 8 Fig. 9
___________________________________
- Il primo fondamento della sicurezza non e' la tecnologia, ma l'attitudine mentale - |
|
|
|
|
01-06-2014, 10.33.01
|
#27 |
|
Senior Member
WT Expert
Registrato: 19-05-2007
Loc.: Verona
Messaggi: 1.302
|
Esegui macro VBA su un foglio di lavoro protetto Se si esegue una macro che tenta di apportare delle modifiche in un foglio di lavoro protetto si verifica un errore run-time "Errore di run-time '1004 '. Una possibilità per evitare l’errore è quella di rimuovere la protezione del foglio di lavoro, eseguire il codice, e quindi proteggere nuovamente, come illustrato di seguito: Foglio1.Unprotect Password: = "123" Foglio1.Protect Password: = "123" Tuttavia, questo metodo ha alcuni difetti:
Codice:
Sub protezione1 ()
Foglio1.Unprotect Password: = "123"
On Error GoTo ErrHandler
Foglio1.Cells (1, 1) = UCase ("Ciao Mondo")
Foglio1.Cells (2, 1) = 5/0
Foglio1.Cells (3, 1) = Application.Max (24, 112, 66, 4)
Foglio1.Protect Password: = "123"
ErrHandler: Foglio1.Protect Password: = "123"
End Sub
Sub protezione2 ()
Foglio1.Unprotect Password: = "123"
On Error Resume Next
Foglio1.Cells (1, 1) = LCase ("CIAO MONDO")
Foglio1.Cells (2, 1) = 5/0 .
Foglio1.Cells (3, 1) = Application.Min (24, 112, 66, 4)
Foglio1.Protect Password: = "123"
On Error GoTo 0
End Sub
Dichiarazione On Error On Error Resume Next: Specifica che quando si verifica un errore di run-time, il controllo passa all'istruzione immediatamente successiva all'istruzione in cui si è verificato l'errore stesso e l'esecuzione continua da quel punto. On Error GoTo 0: Disattiva l'intercettazione degli errori On Error GoTo Line: Attiva la routine di gestione degli errori che inizia alla riga specificata. On Error GoTo intercetta tutti gli errori. Un modo per eseguire le macro in un foglio di lavoro protetto potrebbe essere quella di utilizzare l'argomento UserInterfaceOnly nel metodo Protect, impostando l'argomento UserInterfaceOnly a True, nella maniera: Foglio1.Protect Password: ="123", UserInterfaceOnly: = True. UserInterfaceOnly è un argomento facoltativo nel metodo Protect e il suo valore predefinito è False. Impostarlo a True significa che la protezione del foglio di lavoro vale solo per l'interfaccia utente e non si applica alle macro e questo permetterà di eseguire tutte le macro nel foglio di lavoro. Se si omette questo argomento, la protezione si applica sia alle macro che all'interfaccia utente. Si può osservare che se si applica il metodo Protect con l'argomento UserInterfaceOnly impostata a True per un foglio di lavoro e quindi si salva la cartella di lavoro, l'intero foglio di lavoro, non solo l'interfaccia, sarà completamente protetto quando si riapre la cartella di lavoro. Per riattivare la protezione di interfaccia utente dopo che la cartella di lavoro è aperta, è necessario ancora una volta applicare il metodo Protect con UserInterfaceOnly impostata su true. Per riattivare la protezione di interfaccia utente dopo che la cartella di lavoro è aperta, è possibile utilizzare l'argomento UserInterfaceOnly nell’evento Open in cui esso viene attivato in tutti i fogli di lavoro o in quelli specificati, ogni volta che la cartella di lavoro è aperta. È inoltre possibile utilizzare l'argomento UserInterfaceOnly in un foglio di lavoro, all'inizio della macro, per abilitare la protezione di interfaccia utente ogni volta che la macro viene eseguita. Vedere esempi riportati di seguito: Codice:
Sub protezione3 ()
Foglio1.Protect Password: = "123", UserInterfaceOnly: = True
Foglio1.Cells (1, 1) = UCase ("Ciao Mondo")
End Sub
Codice:
Private Sub Workbook_Open () Dim ws As Worksheet For Each ws In ThisWorkbook.Worksheets ws.Protect password: = "123", UserInterfaceOnly: = True Next ws End Sub Codice:
Private Sub Workbook_Open () Foglio1.Protect Password: = "123", UserInterfaceOnly: = True Foglio2.Protect Password: = "456", UserInterfaceOnly: = True End Sub Codice:
Sub foglio_nascosto()
Worksheets ("Foglio4"). Visible = xlVeryHidden
End Sub
Codice:
Sub foglio_nascosto()
Dim pswd As String
pswd = Cells (1, 1)
mypass = pswd
pswdMatch = InputBox ("Inserire la password per visualizzare il foglio")
If pswdMatch = pswd Then
Worksheets ("Foglio4"). Visible = True
Else
Exit Sub
End If
End Sub
Sub Protezione5()
Dim passfgl2 As String
passfgl2 = Foglio4.Cells (2, 1)
Foglio2.Protect Password: = passfgl2 , UserInterfaceOnly: = True
Foglio2.Cells (1, 1) = UCase ("Ciao Mondo")
End Sub
Codice:
Sub attiva_filtro1 ()
With Foglio1
. EnableAutoFilter = True
.Protect Password:="123" , contents:=True, UserInterfaceOnly:=True
. AutoFilterMode = False
.Range("A1:B10" ).AutoFilter Field:=1, Criteria1:= "<35"
End With
End Sub
Sub attiva_filtro2 ()
With Foglio1
.Protect Password:="123" , contents:=True, UserInterfaceOnly:=True
.Range("A1:B10" ).AutoFilter
.Range("A1:B10" ).AutoFilter Field:=1, Criteria1:= ">35"
End With
End Sub
Codice:
Sub attiva_gruppo()
With Foglio1
. EnableOutlining = True
.Protect Password:="123" , contents:=True, UserInterfaceOnly:=True
.Rows ("12:14"). Group
‘.Rows (" 12:14 "). Ungroup
End With
End Sub
Metodo Protezione Worksheet senza UserInterfaceOnly Questo metodo Protegge un foglio di lavoro in modo che non può essere modificato. Se sono necessarie modifiche da apportare a un foglio protetto, è possibile utilizzare il metodo Protect di un foglio protetto se viene fornita la password. Inoltre, un altro metodo sarebbe quello di rimuovere la protezione del foglio di lavoro, apportare le modifiche necessarie, e quindi proteggere nuovamente il foglio di lavoro. Vediamo alcuni esempi: Codice:
Sub consenti_ordinamento1 ()
Foglio1.Unprotect Password: = "123"
Foglio1.Range. ("G1: H10") Locked = False
Foglio1.Protect Password: = "123", contents: = True, AllowSorting: = True
Foglio1.Range. ("G1: H10") Sort Key1: = Sheet1.Range ("G1"), Order1: = xlDescending
End Sub
Sub consenti_formattazione1 ()
Foglio1.Protect Password: = "123", AllowFormattingCells: = True
Foglio1.Range. ("G1: H10") Font.Bold = True
Foglio1.Range. ("A1: B10") Font.Color = vbBlue
End Sub
Sub consenti_formattazione2 ()
Foglio1.Protect Password: = "123", AllowFormattingColumns: = True, AllowFormattingRows: = True
Foglio1.Columns (2). ColumnWidth = 25
Foglio1.Rows ("4:5"). RowHeight = 25
End Sub
___________________________________
- Il primo fondamento della sicurezza non e' la tecnologia, ma l'attitudine mentale - |
|
|
|
|
01-06-2014, 10.36.07
|
#28 |
|
Senior Member
WT Expert
Registrato: 19-05-2007
Loc.: Verona
Messaggi: 1.302
|
I Controlli CheckBox - OptionBox e ToggleButton Il valore della proprietà di un CheckBox indica se è selezionato o meno. Un valore True indica che la casella è selezionata, False indica che è deselezionato e il valore Null indica che non è né attivo e né disattivo, e il CheckBox apparirà ombreggiato in questo caso. Per usare le 3 impostazioni si deve impostare Il valore della proprietà TripleState che può essere impostato sia nella finestra Proprietà o utilizzando una macro o codice VBA Esempio: Visualizzare il valore del CheckBox, indicando se è selezionato o in uno stato Null Codice:
Private Sub UserForm_Initialize() With Me.CheckBox1 .TextAlign = fmTextAlignCenter .TripleState = True End With End Sub Private Sub CheckBox1_Change() If CheckBox1.Value = True Then MsgBox "True" ElseIf CheckBox1.Value = False Then MsgBox "False" Else MsgBox "Null" End If End Sub Codice:
Private Sub UserForm_Initialize() Me.TextBox1.Enabled = False End Sub Private Sub CheckBox1_Click() If CheckBox1.Value = True Then TextBox1.Enabled = True Else TextBox1.Enabled = False End If End Sub Il Controllo OptionButton Il controllo optionButton è usato per fare una scelta tra più opzioni ed è indicato anche come Radio Button, che sceglie un'opzione da un gruppo di opzioni che si escludono a vicenda. Se sono presenti vari OptionButtons in una Form e non sono raggruppati, selezionandone uno si deseleziona tutte gli altri presenti nella Form. Tutti gli OptionsButtons all'interno di un gruppo specifico si escludono a vicenda all'interno di quel gruppo e non influenzano la selezione di altre OptionButtons di fuori di tale gruppo, inoltre possono essere raggruppati con le seguenti modalità:
Esempio: Determinare quali controlli all'interno di un Frame vengono selezionati Codice:
Private Sub CommandButton1_Click() Dim ctrl As Control For Each ctrl In Frame1.Controls If ctrl.Value = True Then MsgBox ctrl.Caption End If Next End Sub Codice:
Private Sub CommandButton1_Click () Dim ctrl As Control For Each ctrl In Frame1.Controls If TypeOf ctrl Is msforms.OptionButton Then If ctrl.Value = True Then MsgBox ctrl.Caption & " è selezionato", vbOKOnly, "Seleziona un OptionButton" End If End If Next ctrl End Sub Codice:
Private Sub CommandButton1_Click() Dim ctrl As Control For Each ctrl In Frame1.Controls If TypeOf ctrl Is msforms.CheckBox Then If Not TypeOf ctrl Is msforms.OptionButton Then If ctrl.Value = True Then MsgBox ctrl.Caption & " is selected", vbOKOnly, "Selected CheckBoxes" End If End If End If Next ctrl End Sub Esempio: Determinare quale OptionButton, in una Form, con un particolare GroupName, viene selezionato. Codice:
Private Sub CommandButton1_Click() Dim ctrl As Control For Each ctrl In Me.Controls If TypeOf ctrl Is msforms.OptionButton Then If ctrl.GroupName = "GroupA" Then If ctrl.Value = True Then MsgBox ctrl.Caption & " è selezionato", vbOKOnly, "Seleziona un OptionButton" End If End If End If Next ctrl End Sub Il controllo ToggleButton Il controllo ToggleButton è un controllo che esegue un'azione quando si clicca una volta e il pulsante rimane premuto, e un'azione diversa quando si clicca una seconda volta e si rilascia il pulsante. In sostanza si comporta come un normale interruttore e dispone di due possibilità, On e Off. Si può avere un valore True quando appare come premuto o False quando appare non premuto. ToggleButton sembra un incrocio tra un CheckBox (funzionalità toggle) e un CommandButton (aspetto cliccabile e simili). Nota: ToggleButton può anche avere un valore Null (né selezionato né deselezionato) in cui apparirà ombreggiato, se la proprietà TripleState è impostata su true. [i]Esempio è/i]: Utilizzare un controllo ToggleButton per alternare l'ordinamento tra ordine ascendente o ordine discendente di un intervallo di celle   Quando ToggleButton viene premuto, i dati nella colonna A e B vengono ordinati in ordine crescente e il pulsante viene visualizzato di colore verde, quando viene rilasciato le colonne vengono ordinate in ordine decrescente e il colore del pulsante diventa rosso Codice:
Private Sub UserForm_Initialize()
Dim totalrows As Long
totalrows = Foglio3.Cells(Rows.Count, "A").End(xlUp).Row
Me.ToggleButton1.Value = True
Me.ToggleButton1.Caption = "Ordina in Discendente"
Me.ToggleButton1.Font.Bold = True
Me.ToggleButton1.BackColor = RGB(0, 255, 0)
Foglio3.Range("A2:B" & totalrows).Sort Key1:=Foglio3.Range("A2"), Order1:=xlAscending
End Sub
Private Sub ToggleButton1_Click()
Dim totalrows As Long
totalrows = Foglio3.Cells(Rows.Count, "A").End(xlUp).Row
If Me.ToggleButton1.Value = True Then
Me.ToggleButton1.Caption = "Ordina in Discendente"
Me.ToggleButton1.BackColor = RGB(0, 255, 0)
Foglio3.Range("A2:B" & totalrows).Sort Key1:=Foglio3.Range("A2"), Order1:=xlAscending
ElseIf Me.ToggleButton1.Value = False Then
Me.ToggleButton1.Caption = "Ordina in Ascendente"
Me.ToggleButton1.BackColor = RGB(255, 0, 0)
Foglio3.Range("A2:B" & totalrows).Sort Key1:=Foglio3.Range("A2"), Order1:=xlDescending
End If
End Sub
Codice:
Private Sub ToggleButton1_Click()
If ToggleButton1.Value = True Then
Foglio3.Columns("B").EntireColumn.Hidden = True
Foglio3.Columns("C").EntireColumn.Hidden = False
Else
Foglio3.Columns("B").EntireColumn.Hidden = False
Foglio3.Columns("C").EntireColumn.Hidden = True
End If
End Sub
Private Sub ToggleButton1_Click()
Rows("1:3").Hidden = Not Rows("1:3").Hidden
End Sub
Codice:
Private Sub CheckBox1_Click()
If CheckBox1.Value = True Then
Foglio3.Columns("B").EntireColumn.Hidden = True
Foglio3.Columns("C").EntireColumn.Hidden = False
Else
Foglio3.Columns("B").EntireColumn.Hidden = False
Foglio3.Columns("C").EntireColumn.Hidden = True
End If
End Sub
Private Sub CheckBox1_Click()
Rows("1:3").Hidden = Not Rows("1:3").Hidden
End Sub
___________________________________
- Il primo fondamento della sicurezza non e' la tecnologia, ma l'attitudine mentale - |
|
|
|
|
01-06-2014, 10.46.16
|
#29 |
|
Senior Member
WT Expert
Registrato: 19-05-2007
Loc.: Verona
Messaggi: 1.302
|
Oggetto Application – Metodi e Proprietà L'oggetto Application di Excel rappresenta l'applicazione Microsoft Excel, definita anche applicazione Host. Se l’applicazione Host è Microsoft Word, l’oggetto Application si riferisce e rappresenta l’applicazione Word. Excel presuppone che anche quando non è specificato, il qualificatore dell’oggetto Application non è necessario per essere utilizzato nel codice VBA, perché l'applicazione di default è Excel stesso, a meno che non si vuole fare riferimento ad altre applicazioni esterne (come Microsoft Word o Access) nel codice o se si vuole fare riferimento a Excel da un'altra un'applicazione come Microsoft Word. Tutte le applicazioni Microsoft Office, che utilizzano VBA, hanno un proprio modello di oggetti e durante la scrittura di codice VBA in Microsoft Excel, si prevede di utilizzare gli oggetti forniti dal modello a oggetti di Excel. Il modello a oggetti è una grande gerarchia di tutti gli oggetti utilizzati in VBA e il modello Application si riferisce e contiene i suoi oggetti di programmazione che sono legati gli uni agli altri in una gerarchia. L'intera applicazione Excel è rappresentata dall'oggetto Application che è in cima alla gerarchia di oggetti e scendendo verso il basso è possibile accedere agli oggetti per la cartella di lavoro, i fogli di lavoro e gli Intervalli di celle. Gli oggetti di Excel sono accessibili attraverso oggetti ‘padri’, il foglio di lavoro è il genitore dell'oggetto Range, la cartella di lavoro è l’oggetto padre del foglio di lavoro, e l'oggetto Application è il padre dell'oggetto cartella di lavoro. Brevemente si può dire che l’oggetto Application è la classe principale nel modello a oggetti e ogni volta che si apre Excel, viene istanziato un nuovo oggetto Application. La classe Application possiede metodi e proprietà come:
Proprietà Application.WindowStateLa proprietà WindowState imposta lo stato della finestra dell'applicazione e le opzioni sono xlNormal, xlMaximized (imposta la finestra attiva alla dimensione massima disponibile purché non sia già ingrandita) e xlMinimized. Si noti che queste proprietà non possono essere impostate se la finestra è ingrandita, e le proprietà sono di sola lettura se la finestra è minimizzata Codice:
Sub app_winstat () Application.WindowState = xlNormal Application.Height = 350 Application.Width = 450 End Sub Proprietà Application.DisplayFullScreenUtilizza un valore Booleano e impostata su True, la finestra dell'applicazione è ingrandita alla dimensione massima e la barra del titolo dell'applicazione viene nascosta. sintassi : Application.DisplayFullScreen = True Proprietà Application.DisplayFormulaBar Utilizza un valore Booleano e mostra o nasconde la barra della formula quando è impostato su, rispettivamente, True o False. sintassi : Application.DisplayFormulaBar = False Proprietà Application.Calculation Restituisce o imposta la modalità di calcolo e dispone di 3 impostazioni:
Proprietà Application.EditDirectlyInCell Utilizza un valore booleano e consente o non consente la modifica direttamente nelle celle quando è impostata, rispettivamente a True o False. sintassi : Application.EditDirectlyInCell = False Proprietà Application.ScreenUpdating Utilizza un valore booleano ed è usata quando non si vuole vedere lo schermo seguire le azioni della routine VBA che si sta eseguendo. Se la proprietà ScreenUpdating è impostata su False, l'aggiornamento dello schermo non è visibile, e non sarà in grado di visualizzare ciò che il codice fa, rendendo più veloce l'esecuzione. Quando si disattiva l'aggiornamento dello schermo nelle procedure VBA al termine delle quali si deve impostare la proprietà a True. sintassi : Application.ScreenUpdating = False Proprietà Application.DisplayAlerts Utilizza un valore booleano e durante l'esecuzione di una macro, alcuni avvisi vengono visualizzati da Excel per confermare un’azione durante l'eliminazione di un foglio di lavoro. L'impostazione di questa proprietà su False non visualizzerà alcuna richiesta o avviso e in questo caso si riceverà una risposta predefinita da Excel. Questa proprietà deve essere impostata con il valore predefinito True dopo la procedura termina. sintassi: Application.DisplayAlerts = False Proprietà Application.DefaultFilePath Si usa questa proprietà per ottenere e impostare il percorso predefinito utilizzato da Microsoft Office Excel per caricare e salvare i file. sintassi: Application.DefaultFilePath = "C:\Documenti\Excel" Metodo Application.QuitSi utilizza questo metodo per chiudere l'applicazione Excel. Si noti che dopo la chiusura della cartella di lavoro, la finestra di Excel rimane aperta. Per uscire da Excel si può utilizzare il metodo Quit come illustrato di seguito. sintassi: ThisWorkbook.Close SaveChanges: = True Chiude Excel e poi chiude ThisWorkbook dopo il salvataggio (il metodo Quit non termina Excel) Application.Quit ThisWorkbook.Close SaveChanges: = True Chiude ThisWorkbook, ma non chiude Excel perché viene chiuso con ThisWorkbook senza leggere la linea Application.Quit: ThisWorkbook.Close SaveChanges: = True Application.Quit Metodo Application.OnTime Questo metodo viene utilizzato in VBA per eseguire automaticamente una procedura ad intervalli periodici o in un momento specifico della giornata. Nel seguente esempio, RunTime è una variabile pubblica di tipo Date, che imposta l'intervallo di tempo e la macro denominata MacroAutoRun verrà eseguito automaticamente, a intervalli di tempo programmato di tre secondi, con il metodo OnTime. . sintassi: Application.OnTime RunTime, "MacroAutoRun" Esempio di utilizzo del metodo Application.OnTime: Questa procedura utilizza il metodo OnTime col valore di incremento reperito in una cella a intervalli di tempo specifici, e Arresta la procedura dopo averla eseguita per un determinato numero di volte. Si Imposta l'intervallo di tempo 3 secondi, nel quale la procedura verrà eseguita Codice:
RunTime Public As Date
Dim count As Integer
Sub MacroAutoRun ()
RunTime = + TimeValue ("00:00:03") Now
Application.OnTime RunTime, "MacroAutoRun", True
'si incrementa il valore nella cella A1 del foglio di lavoro attivo) di 5 unità, per ogni volta che la macro si ripete
Cells (1, 1) Valore = Cells (1, 1).Value + 5
count = count + 1
'Interrompere la procedura dopo averla eseguita per 5 volte
If count = 5 Then
Application.OnTime RunTime, "MacroAutoRun", False
count = 0
End If
End Sub
Metodo Application.ActivateMicrosoftAppQuesto metodo attiva un'applicazione Microsoft già in esecuzione oppure crea una nuova istanza dell'applicazione nel caso in cui l'applicazione non è già in esecuzione. Qui di seguito i codici per avviare e attivare, rispettivamente, Word, Access e Power Point:
Metodo Application.GetOpenFilenameIl metodo GetOpenFilename ottiene il nome del file da aprire dall'utente, visualizzando la finestra di dialogo standard Apri. Il file non viene effettivamente aperto, ma restituisce il percorso completo e il nome del file selezionato. La sintassi è la seguente: ApplicationObject.GetOpenFilename (FileFilter, FilterIndex, titolo, ButtonText, MultiSelect) Tutti gli argomenti sono opzionali, ma è necessario specificare l’oggetto Application. L’argomento FileFilter è un valore stringa che specifica i criteri di filtro per il tipo di file che verranno visualizzati nella directory da cui l'utente ottiene il nome del file. Ci sono 4 filtri specificati in FileFilter ed è possibile specificare uno qualsiasi di questi criteri predefiniti utilizzando i numeri di indice da 1 a 4 Si può utilizzare l’argomento Titolo per specificare il titolo della finestra di dialogo. Il titolo predefinito è "Open" se non specificato. L’argomento ButtonText è applicabile solo per i computer che eseguono Excel per Macintosh (Mac) e impostando l'argomento MultiSelect a True si consente la selezione multipla dei file. L'impostazione predefinita è False. E’ possibile utilizzare FileFilter per i file di Excel xlsm, specificando le estensioni in coppie e utilizzando caratteri jolly "Excel Files (*. Xlsm), *. Xlsm" Si può usare FileFilter per estensioni xls, xlsx e XLSM, usando il punto e virgola e i caratteri jolly "Excel Files (* xls,. *. Xlsx,. * Xlsm), * xls, *. Xlsx,. *. Xlsm" Utilizzando FileFilter per estensioni XLSM e file di testo txt elencandoli separatamente nella lista dei tipi di file "Excel Files (*. Xlsm), *. Xlsm, File di testo (*. Txt), *. Txt" Se l'argomento FileFilter viene omesso, per impostazione predefinita assume la sintassi: tutti i file "Tutti i file (*. *), *. *" Esempio: Selezionare e aprire un singolo file, immettere il salvare e chiudere la cartella di lavoro, utilizzando i metodi Application.GetOpenFilename e Workbooks.Open Codice:
Sub GetOpenFilename1 ()
Dim nome_file As Variant
Dim wkbk As Workbook
Dim str_cartella As String
Dim cor_cartella As String
cor_cartella = CurDir
str_cartella = "C:\Test"
'impostata l'unità corrente
ChDrive str_cartella
ChDir str_cartella
nome_file = Application.GetOpennome_file(FileFilter:="Excel .. Files (* xlsm), * xlsm ", Title:="Seleziona un file ")
If nome_file = False Then
MsgBox "Selezionare un file per continuare"
Exit Sub
Else
Workbooks.Open (nome_file)
Set wkbk = ActiveWorkbook
Sheets("Foglio1").Select
wkbk.ActiveSheet.Range("A1") = "Ciao"
wkbk.Save
wkbk.Close
End If
ChDrive cor_cartella
ChDir cor_cartella
End Sub
Codice:
Sub GetOpenFilename2 () Dim nome_file As Variant Dim i As Integer Dim iFiles As Integer 'impostando MultiSelect a True il metodo GetOpenFilename consente la selezione di file multipli nome_file = Application.GetOpenFilename(filefilter:="Excel Files(*.xls;*.xlsx;*.xlsm), *.xls;*.xlsx;*.xlsm", Title:="Seleziona file", MultiSelect:=True) 'Verifica se l'utente fa clic sul pulsante Annulla If IsArray(nome_file) = False Then MsgBox "Seleziona il file per continuare" Exit Sub Else 'Determinare il numero di file da aprire iFiles = UBound(nome_file) - LBound(nome_file) + 1 For i = 1 To iFiles 'Metodo Workbooks.Open apre una cartella di lavoro Workbooks.Open nome_file(i) Next i End If End Sub Codice:
Sub GetOpenFilename3()
Dim fileName As Variant
Dim str_cart As String
Dim wb_dest As Workbook
Dim wb_orig As Workbook
'impostare un percorso da cui selezionare i file nella finestra di dialogo Apri
str_cart = "C:\Test"
'impostare l'unità
ChDrive str_cart
'impostare la directory corrente
ChDir str_cart
fileName = Application.GetOpenFilename(FileFilter:="Excel .. Files (* xlsm), * xlsm ", Title:="Seleziona un file ")
'Se l'utente fa clic sul pulsante Annulla viene visualizzato un avviso a video
If fileName = False Then
MsgBox "Si prega di selezionare un file per continuare"
Exit Sub
Else
'apre una cartella di lavoro
Set wb_orig = Workbooks.Open(fileName)
End If
'Aggiungere una nuova cartella di lavoro, che è la cartella di lavoro di destinazione
Workbooks.Add
'salva la cartella di lavoro di destinazione con un nuovo nome e il tipo di file xlsm
'in Excel 2007-2010 durante l'utilizzo SaveAs, è necessario specificare il parametro FileFormat per salvare un nome di file con estensione xlsm se l'ActiveWorkbook non è un file xlsm
'FileFormat indica che il file contiene macro. È possibile utilizzare FileFormat: = xlOpenXMLWorkbookMacroEnabled o FileFormat: = 52 per salvare un file NON xlsm.
ActiveWorkbook.SaveAs fileName:="newWorkbook.xlsm", FileFormat:=52
Set wb_dest = ActiveWorkbook
'copia il foglio2 dalla cartella di origine alla nuova cartella di destinazione come ultimo foglio
wb_orig.Worksheets("Foglio2").Copy After:=wb_dest.Sheets(Sheets.Count)
'chiude sia le cartelle di lavoro, dopo aver salvato la cartella di destinazione
wb_orig.Close
wb_dest.Close SaveChanges:=True
End Sub
Proprietà e metodi dell'oggetto Application Tali proprietà e metodi il cui utilizzo NON richiede di specificare il qualificatore dell'oggetto Application sono considerati globali. È possibile visualizzare queste proprietà e metodi globali nel Visualizzatore oggetti in VBE dal menu Visualizza - Visualizzatore oggetti, o premendo F2 e scegliendo Excel dall’elenco a discesa delle librerie nel riquadro superiore e quindi scegliendo GLOBALS che appare in alto nella casella Classi. I Casi in cui non è richiesta l’utilizzazione del qualificatore dell’applicazione sono: Proprietà ActiveCellLa proprietà ActiveCell, applicata ad un oggetto Application, restituisce la cella attiva (oggetto Range) del foglio di lavoro visualizzato nella finestra attiva. È inoltre possibile applicare questa proprietà per un oggetto Window specificando la finestra per cercare la cella attiva. Si noti che, in assenza di un foglio di lavoro visualizzato nella finestra, la proprietà avrà esito negativo. Qualsiasi dei seguenti codici possono essere utilizzati in alternativa (si noti che Value è la proprietà predefinita di un oggetto Range) MsgBox "il valore della cella attiva è:" & Application.ActiveCell MsgBox "il valore della cella attiva è:" & ActiveCell MsgBox "il valore della cella attiva è:" & ActiveWindow.ActiveCell MsgBox "il valore della cella attiva è:" & ActiveCell.Value Proprietà ActiveWindowQuesta proprietà restituisce la finestra attiva. La finestra attiva è la finestra attualmente selezionata. Il codice per visualizzare il nome del’[i]ActiveWindow[i] che appare nella barra del titolo è il seguente: MsgBox "La finestra attiva è:" & Application.ActiveWindow.Caption MsgBox "La finestra attiva è:" & ActiveWindow.Caption Proprietà ActiveWorkbookQuesta proprietà restituisce la cartella di lavoro attiva, cioè la cartella di lavoro nella finestra attiva MsgBox "il nome della cartella attiva è" & Application.ActiveWorkbook.Name MsgBox "il nome della cartella attiva è" & ActiveWorkbook.Name Proprietà ThisWorkbookQuesta proprietà viene utilizzata solo dall'interno dell'applicazione Excel e restituisce la cartella di lavoro in cui il codice viene eseguito al momento. MsgBox "Il nome di questa cartella di lavoro è" & Application.ThisWorkbook.Name MsgBox "Il nome di questa cartella di lavoro è" & ThisWorkbook.Name Si noti che sebbene il più delle volte ActiveWorkbook è la stessa ThisWorkbook, ma potrebbe non essere sempre così. La cartella di lavoro attiva può essere diversa da quella di lavoro in cui viene eseguito il codice, come illustrato dal seguente esempio. Codice:
Sub ActiveWorkbook_ThisWorkbook ()
MsgBox "il nome della cartella Attiva è" & ActiveWorkbook.Name
MsgBox "Il nome di questa cartella di lavoro è" & ThisWorkbook.Name
Workbooks ("Book2. xlsm "). Activate
MsgBox "il nome della cartella Attiva è" & ActiveWorkbook.Name
MsgBox "Il nome di questa cartella di lavoro è" & ThisWorkbook.Name
Workbooks ("Book1.xlsm"). Activate
MsgBox "il nome della cartella Attiva è" & ActiveWorkbook.Name
MsgBox "Il nome di questa cartella di lavoro è" & ThisWorkbook.Name
End Sub
Proprietà ActiveSheetLa proprietà ActiveSheet, applicata ad un oggetto Application, restituisce il foglio attivo nella cartella di lavoro attiva. È inoltre possibile applicare questa proprietà per una cartella di lavoro o finestra specificando la cartella di lavoro o la finestra per cercare il foglio attivo. I seguenti codici mostrano il foglio attivo nella cartella di lavoro attiva Msgbox "il nome del foglio attivo è" & Application.ActiveSheet.Name MsgBox "il nome del foglio attivo è" & Application.ActiveWorkbook.ActiveSheet.Name Msgbox "il nome del foglio attivo è" & ActiveSheet.Name MsgBox "il nome del foglio attivo è" & ActiveWorkbook.ActiveSheet.Name Mentre il seguente codice restituisce il foglio attivo nella cartella di lavoro specificata (denominata "Test_vba.xlsm"): MsgBox "il nome del foglio attivo è" & Application.Workbooks ("Test_vba.xlsm"). ActiveSheet.Name Proprietà ActiveChartLa proprietà ActiveChart, applicata ad un oggetto Application, restituisce il grafico attivo nella cartella di lavoro attiva. Nella cartella di lavoro è possibile avere fogli grafici separati e definisce grafici come fogli di lavoro o grafici incorporati che comprende il grafico come un oggetto all'interno di un foglio di lavoro. Un foglio grafico o un grafico incorporato è attivo se è stato selezionato o se è attivato con il metodo Activate. È inoltre possibile applicare la proprietà ActiveChart di una cartella di lavoro o un oggetto Window specificando la cartella di lavoro o la finestra per cercare il grafico attivo. I seguenti codici mostrano il grafico attivo nella cartella di lavoro attiva MsgBox "Il nome del grafico attivo è:" & Application.ActiveChart.Name MsgBox " Il nome del grafico attivo è:" & Application.ActiveWorkbook.ActiveChart.Name MsgBox " Il nome del grafico attivo è:" & ActiveChart.Name MsgBox " Il nome del grafico attivo è:" & ActiveWorkbook.ActiveChart.Name Il seguente codice restituisce il grafico attivo nella cartella di lavoro specificata (denominata " Test_vba.xlsm ") MsgBox " Il nome del grafico attivo è:" & Application.Workbooks ("Test_vba.xlsm ") ActiveChart.Name Proprietà Application.ActivePrinterQuesta proprietà imposta il nome della stampante attiva. Per Impostare una stampante HP LaserJet 0011 su LPT1 come stampante attiva Application.ActivePrinter = "HP LaserJet 0011 su NE02: " ActivePrinter = "HP LaserJet 0011 su NE02: " Per impostare la stampante Adobe PDF sul Ne04 come stampante attiva Application.ActivePrinter = "Adobe PDF su Ne04: " ActivePrinter = "Adobe PDF su Ne04: " Proprietà Selection La proprietà Selection se applicata a un oggetto Application, restituisce l'oggetto che viene selezionato nella finestra attiva. L'oggetto selezionato potrebbe essere un oggetto Range o una singola cella del foglio di lavoro attivo, un oggetto ChartArea nel foglio di lavoro attivo, e così via. È inoltre possibile applicare la proprietà di selezione un oggetto finestra in cui la proprietà restituirà l'oggetto selezionato nella finestra specificata. Presumendo che la selezione corrente sia un oggetto Range nel foglio di lavoro attivo. Per cancellare il contenuto delle celle selezionate nel foglio di lavoro attivo, si può utilizzare uno dei due metodi sotto descritti con o senza il qualificatore di oggetto Application Application.Selection.Clear Selection.Clear Esempio: Selezionare un intervallo di celle per ottenere il tipo di oggetto della selezione e utilizzare la selezione per cambiare colore e grandezza carattere. Codice:
Sub SelectionProperty ()
Range ("A1: C3"). Select
'ottenere il tipo di oggetto della selezione - restituisce "Range"
MsgBox TypeName (Selection)
'cambiare il colore del carattere del campo selezionato
Selection.Font.Color = vbRed
'cambiare la dimensione del carattere dell'intervallo selezionato
Selection.Font.Size = 14
End Sub
Proprietà FogliL’oggetto Sheets si riferisce a tutti i fogli contenuti in una cartella di lavoro, che comprende fogli grafici e fogli di lavoro. Le Schede della struttura, applicate ad un oggetto Application, restituisce un insieme Sheets nella cartella di lavoro attiva. È inoltre possibile applicare questa proprietà per una cartella di lavoro specificando la cartella di lavoro che restituirà una raccolta di fogli di lavoro specificato. Qui di seguito viene illustrato come contare il numero di fogli della cartella di lavoro attiva e restituire il nome di ciascun foglio. Codice:
Sub SheetsCollection () Dim n As Integer 'numero dei fogli nella cartella di lavoro attiva MsgBox " Numero di fogli nella cartella di lavoro attiva sono:" & Application.Sheets.Count MsgBox " Numero di fogli nella cartella di lavoro attiva sono:" & Sheets.Count 'Nome dei fogli in base al valore dell'indice For n = 1 To Sheets.Count MsgBox Sheets(n). Name Next n 'Nome dei fogli scorrendoli tutti nella cartella di lavoro For Each Sheet In Sheets MsgBox Sheet.Name Next End Sub Proprietà IntervalloLa proprietà Range restituisce un oggetto Range (singola cella o intervallo di celle). È possibile utilizzare la sintassi: Range (cell1) . Questo può essere solo un riferimento di tipo A1, ed è possibile utilizzare un operatore di intervallo o l'operatore di unione (es. virgola), oppure può essere un intervallo denominato. È inoltre possibile utilizzare la sintassi: Range (cell1, cell2) - dove cell1 e cell2 sono oggetti che rappresentano l'intervallo di celle contigue che specificano le celle di inizio e fine. Per applicare la proprietà Range di un oggetto Application, è possibile omettere il qualificatore di oggetto. Range (cell1) o utilizzare Application.Range (cell1), entrambi restituiranno l'oggetto Range in ActiveSheet. Per applicare la proprietà Range di un oggetto cartella di lavoro o un oggetto Range, specificare il rispettivo qualificatore oggetto come illustrato di seguito. Proprietà Range applicabili all’oggetto ApplicationQualsiasi dei seguenti codici inseriranno il valore 10 nella cella A1 del foglio attivo (con o senza usare il qualificatore di oggetto Application o digitando ActiveSheet) Application.ActiveSheet.Range ("A1"). Value = 10 ActiveSheet.Range ("A1"). Value = 10 Application.Range ("A1"). Value = 10 Range ("A1"). Value = 10 Il seguente codice inserirà il valore 10 nelle celle A1, A2, A3 e A4 del foglio attivo. La seconda espressione utilizza la sintassi: Range (cell1, cell2): Range ("A1: A4") Valore = 10 Range ("A1", "A4"). Value = 10 Il seguente codice inserirà il valore 10 nelle celle A1, B2 e C4 del foglio attivo (si noti che specificando "Value" dopo il Range non è necessario perché è la proprietà predefinita dell'oggetto Range) Range ("A1, B2, C4") = 10 Il seguente codice inserirà il valore 10 nell’intervallo denominato "pippo" del foglio attivo, vale a dire che è possibile denominare l'intervallo A1 come "pippo" e utilizzare il seguente codice: Range ("pippo") = 10 Proprietà Range applicabili all’oggetto Worksheet Il seguente codice inserirà il testo "Carlo" nella cella A1 del foglio di lavoro denominato "Foglio1": Worksheets ("Foglio1"). Range ("A1") = "Carlo" Proprietà Range applicabili all’oggetto Range Quando la proprietà Range viene applicata a un oggetto Range, la proprietà diventa relativa all'oggetto Range come illustrato di seguito: Codice:
Sub RangeProperty ()
'Selezionare un intervallo nel foglio attivo
Range("C5:E8").Select
'inserisce il valore 10 in C5
Selection.Range("A1") = 10
'inserisce il valore 11 in C6
Selection. Range ("A2") = 11
'inserisce il valore 20 in D5
Selection.Range ("B1") = 20
'inserisce il valore 20 in D6
Selection.Range ("B2") = 21
End Sub
Metodo CalcolaIl metodo Calcola, se applicato a un oggetto Application, calcola tutte le cartelle di lavoro aperte. È inoltre possibile applicare questo metodo a un oggetto foglio di lavoro specificando il foglio di lavoro in una cartella di lavoro; oppure è possibile applicare questo metodo a un intervallo specificando una cella o un intervallo di celle in un foglio di lavoro. Metodo Calcola applicabile all'oggetto ApplicationUtilizzare una delle seguenti righe di codice per calcolare tutte le cartelle di lavoro aperte: Application.Calculate Calculate Metodo Calcola applicabile all'oggetto Worksheet Utilizzare una delle seguenti righe di codice per calcolare un foglio di lavoro specifico (denominato "Foglio1"): Application.Worksheets ("Foglio1"). Calculate Worksheets ("Foglio1"). Calculate Metodo Calcola applicabile all'oggetto RangeUtilizzare una delle seguenti righe di codice per calcolare l'intervallo specificato (celle A5, A6 e A7) in un foglio di lavoro: Application.Worksheets ("Sheet1") Range ("A5: A7"). Calculate. Worksheets ("Foglio1") Range ("A5: A7"). Calculate La seguente riga di codice calcola l'intera colonna (colonna A) in un foglio di lavoro: Worksheets ("Foglio1"). Columns (1). Calculate La seguente riga di codice calcola le celle specifiche A5, A6, B7 e B20 in un foglio di lavoro: Worksheets ("Foglio1"). Range ("A5, A6, B7, B20"). Calculate Utilizzare la seguente riga di codice per calcolare l'intervallo specificato (celle A5, A6 e A7) nel foglio di lavoro attivo: Range ("A5: A7"). Calculate Velocizzare il codice VBA disattivando gli aggiornamenti dello schermo e i calcoli automaticiIn Excel, la modalità di calcolo predefinita è la Modalità Automatica. sintassi: (Application.Calculation = xlCalculationAutomatic), in cui viene calcolata automaticamente ogni cella quando si entra. Quando Excel è in modalità manuale: (Application.Calculation = xlCalculationManual) il calcolo viene effettuato solo quando richiesto dall'utente facendo clic su "Calcola Ora" o premendo F9 oppure cambiando la modalità di calcolo automatico. In modalità automatica, per ciascun nuovo valore immesso da una macro, Excel ricalcolerà tutte le celle che verranno coinvolte dal nuovo valore rallentando così l'esecuzione del codice VBA. Questo può rallentare notevolmente il funzionamento del codice vba, soprattutto nel caso di grandi macro con moli di calcolo significativi. Per accelerare una macro e rendere l'esecuzione più veloce ed efficiente, è tipico degli sviluppatori disattivare il calcolo automatico all'inizio della macro, ricalcolare il foglio di lavoro specifico o l’intervallo di celle utilizzando il metodo Calculate all'interno della macro e poi riportare il calcolo in automatico alla fine del codice. L'esempio seguente disattiva gli aggiornamenti dello schermo e i calcoli automatici e utilizza il metodo Calculate, durante l'esecuzione del codice Codice:
Sub CalculateMethod () 'disattivare Aggiornamenti schermo e calcoli automatici Application.ScreenUpdating = False Application.Calculation = xlCalculationManual ….. altro codice 'Utilizzare il metodo Calculate per calcolare tutte le cartelle di lavoro aperte Application.Calculate 'attivare gli aggiornamenti dello schermo e calcoli automatici Application.ScreenUpdating = True Application.Calculation = xlCalculationAutomatic End Sub
___________________________________
- Il primo fondamento della sicurezza non e' la tecnologia, ma l'attitudine mentale - |
|
|
|
|
01-06-2014, 10.48.29
|
#30 |
|
Senior Member
WT Expert
Registrato: 19-05-2007
Loc.: Verona
Messaggi: 1.302
|
Passaggio di argomenti alle procedure Quando un valore esterno deve essere utilizzato da una procedura per eseguire un'azione, si passa alla procedura da variabile. Queste variabili che sono passate a una procedura sono chiamate argomenti che rappresenta il valore fornito dal codice chiamante a una procedura. Nella sintassi di dichiarazione della procedura compaiono degli elementi racchiusi tra parentesi quadre: sono i parametri o argomenti e quando il set di parentesi, dopo il nome della procedura nella dichiarazione Sub o la dichiarazione Function, sono vuoti, si tratta di un caso in cui la procedura non riceve argomenti. Tuttavia, quando gli argomenti sono passati a una procedura da altre procedure, allora questi sono elencati o dichiarati tra le parentesi. I parametri hanno un ordine posizionale, vanno elencati separati da una virgola e devono rispettare il tipo di dato specificato nella dichiarazione, inoltre possono essere “passati” come valori fissi o tramite variabili. In sostanza occorre dare un nome ad ogni parametro e specificare il tipo di dato che conterrà (come per le variabili), se ne indichiamo più di uno occorre elencarli di seguito separati da una virgola. Tipi di argomenti di datiNell’esempio che segue la dichiarazione della funzione ‘voto’ contiene una variabile di tipo Integer passata come argomento e restituito un valore di tipo String. E’ bene ricordare che solitamente si dichiara il tipo di dati per gli argomenti passati a una procedura, nel caso venisse omessa questa dichiarazione, il tipo di dati predefinito che VBA assegna è di tipo Variant. Codice:
Function voto(votazione As Integer) As String
If votazione >= 80 Then
voto = "A"
ElseIf votazione >= 60 Then
voto = "B"
ElseIf votazione >= 40 Then
voto = "C"
Else
voto = "Pessimo"
End If
End Function
Sub callvoto()
Dim i As Integer
Dim str As String
i = InputBox("Inserisci il voto per Marco")
str = voto(i)
MsgBox "La valutazione di Marco è : " & str
End Sub
Codice:
Function votiPercent(voti As Integer, Totalvoti As Integer) As Double
votiPercent = voti / Totalvoti * 100
votiPercent = Format(votiPercent, "#.##")
End Function
Sub callvoti_1()
Dim voti As Integer
Dim Totalvoti As Integer
Dim pcnt As Double
voti = InputBox("Inserisci Voti")
Totalvoti = InputBox("Inserisci Totale Voti")
pcnt = votiPercent(voti, Totalvoti)
MsgBox "La percentuale è del :" & " " & pcnt & "%"
End Sub
Passaggio di argomenti per valoreQuando si passa un argomento per valore in una procedura, solo una copia di una variabile viene passata e qualsiasi modifica del valore della variabile nella procedura corrente non influenza o modifica la variabile stessa nella sua posizione originale perché la variabile stessa non è accessibile. Per passare un argomento per valore, si deve utilizzare la parola chiave ByVal . Vediamolo con un esempio Codice:
Sub Prova_1() Dim x As Integer x = 5 MsgBox x Call Aggiungi_1 (x) MsgBox x End Sub Sub Aggiungi_1(ByVal i As Integer) i = i + 1 End Sub Codice:
Sub Prova_2() Dim x As Integer x = 5 MsgBox x Call Aggiungi_2 (x) MsgBox x End Sub Sub Aggiungi_2(ByRef i As Integer) i = i + 1 End Sub Mentre una funzione può restituire un unico valore al termine della sua esecuzione, una procedura può prendere in ingresso per riferimento più variabili e modificarne tutti i valori, tuttavia l’uso delle funzioni permette di utilizzare il nome della funzione stessa all’interno di espressioni più complesse Codice:
Function calcola_comm(ByVal comm_tass As Double, ByVal vendite As Currency) As Currency
calcola_comm = comm_tass * vendite
End Function
Sub vendite_marco()
Dim comm_marco As Currency
Dim comm_tass As Double
Dim vendite As Currency
comm_tass = InputBox("Inserisci tasso commissione")
vendite = InputBox("Inserisci Importo Vendite")
comm_marco = calcola_comm(comm_tass, vendite)
MsgBox "La commissione è di" & " " & comm_marco
End Sub
Passaggio di argomenti per riferimentoQuando si passa un argomento per riferimento in una procedura, la variabile stessa accede alla procedura e il valore della variabile viene modificato in modo permanente dalla procedura stessa. Per passare un argomento per riferimento, si deve utilizzare la parola chiave ByRef prima l'argomento da passare, inoltre il passaggio di argomenti per riferimento è anche l'impostazione predefinita in VBA, a meno che non sia esplicitamente specificato di passare un argomento per valore. Codice:
Function numero(ByVal i As Integer) As Long i = 5 numero = i End Function Sub prova_numero() Dim n As Integer MsgBox numero(n) MsgBox n End Sub In questo esempio invece si vede il passaggio di un argomento per riferimento in una procedura utilizzando la parola chiave ByRef Codice:
Function numero_1(ByRef i As Integer) As Long i = 5 numero_1 = i End Function Sub prova_numero_1() Dim n As Integer MsgBox numero_1(n) MsgBox n End Sub Argomenti facoltativiGli argomenti possono essere specificati come facoltativi, utilizzando la parola chiave Optional prima dell'argomento e quando si specifica un argomento con optional, tutti gli argomenti seguenti devono essere specificati come Optional. Si noti che specificando la parola chiave Optional rende un argomento opzionale altrimenti sarà richiesto l'argomento. L'argomento opzionale dovrebbe essere, anche se non necessario, dichiarato come tipo di dati Variant per consentire l'uso della funzione IsMissing che funziona solo quando viene utilizzato con le variabili dichiarate come Variant. La funzione IsMissing viene utilizzata per determinare se l'argomento opzionale è stata accettata nella procedura o meno, in modo da regolarsi di conseguenza nel codice senza restituire un errore. Se l'argomento opzionale non è dichiarato come Variant, la funzione IsMissing non funziona, e all'argomento opzionale verrà assegnato e il valore predefinito per il tipo di dati che è 0 per le variabili di tipo numerico (cioè Integer, Double, etc.) e Nothing per String o variabili di tipo Object. Esempio: Dichiarazione della routine con due argomenti Optional Codice:
Sub dip_nome1(Optional primo As String, Optional secondo As String)
ActiveSheet.Range("A1") = primo
ActiveSheet.Range("B1") = secondo
End Sub
Sub nome_pieno1()
Dim nome1 As String
Dim nome2 As String
nome1 = InputBox("Inserisci il primo Nome")
nome2 = InputBox("Inserisci il secondo Nome")
Call dip_nome1(nome1, nome2)
End Sub
La dichiarazione della routine contiene due argomenti, il secondo argomento è specificato come Optional. Si noti in questo esempio che l'argomento opzionale viene dichiarato come String e non è passato nella procedura, di conseguenza il Range ("B1"), conterrà un riferimento Null dopo aver eseguito la sub dip_nome2 perché all'argomento opzionale verrà assegnato il valore di default per il suo tipo di dati (String), che è Nothing cioè un riferimento Null. Se l'argomento opzionale viene dichiarato come Integer, Range ("B1") conterrà zero dopo l'esecuzione della sub dip_nome2 in quanto all'argomento opzionale verrà assegnato il valore predefinito per il suo tipo di dati (Integer) che è pari a zero. Codice:
Sub dip_nome2(Optional primo As String, Optional secondo As String)
ActiveSheet.Range("A1") = primo
ActiveSheet.Range("B1") = secondo
End Sub
Sub nome_pieno2()
Dim nome1 As String
nome1 = InputBox("Inserisci il primo Nome")
Call dip_nome2(nome1)
End Sub
La dichiarazione della routine contiene due argomenti, il secondo argomento è specificato come Optional. L'argomento opzionale dovrebbe essere (anche se non necessario), dichiarato come tipo di dati Variant per consentire l'uso della funzione IsMissing. La funzione IsMissing viene utilizzata per determinare se l'argomento opzionale è stato approvato nella procedura o meno Codice:
Sub dividi1(primo_n As Integer, Optional secondo_n As Variant)
Dim result As Double
If IsMissing(secondo_n) Then
result = primo_n
Else
result = primo_n / secondo_n
End If
result = Format(result, "#.##")
MsgBox result
End Sub
Sub chiama_dividi1()
Dim numero1 As Integer
numero1 = InputBox("Inserire il primo Numero")
Call dividi1(numero1)
End Sub
La dichiarazione della routine contiene due argomenti, il secondo argomento è specificato come Optional. L'argomento opzionale viene dichiarato come Integer, ma la funzione IsMissing non funzionerà con una variabile non dichiarata come Variant. Quindi all'argomento opzionale verrà assegnato il valore predefinito per il tipo di dati che è 0 per i tipi di dati numerici e il codice restituirà l'errore: Errore di run-time "11": Divisione per zero. Codice:
Sub dividi2(primo_n As Integer, Optional secondo_n As Integer)
Dim result As Double
If IsMissing(secondo_n) Then
result = primo_n
Else
result = primo_n / secondo_n
End If
result = Format(result, "#.##")
MsgBox result
End Sub
Sub chiama_dividi2()
Dim numero_1 As Integer
numero_1 = InputBox("Inserisci il primo Numero")
Call dividi2(numero_1)
End Sub
La dichiarazione della routine contiene due argomenti, il secondo argomento è specificato come Optional. L'argomento opzionale viene dichiarato come stringa, ma la funzione IsMissing non funzionerà con una variabile non dichiarata come tipo di dati Variant. Quindi all'argomento opzionale verrà assegnato il valore predefinito per il tipo di dati che è Nothing (un riferimento Null) per il tipo di dati String e il codice restituirà l'errore: Errore di run-time "13": Tipo non corrispondente. Codice:
Sub dividi3(primo_n As Integer, Optional secondo_n As String)
Dim result As Double
If IsMissing(secondo_n) Then
result = primo_n
Else
result = primo_n / secondo_n
End If
result = Format(result, "#.##")
MsgBox result
End Sub
Sub chiama_dividi3()
Dim numero1 As Integer
numero1 = InputBox("Inserisci il primo Numero")
Call dividi3(numero1)
End Sub
Specificare un valore predefinito per un argomento facoltativoÈ possibile specificare un valore predefinito per un argomento opzionale che sarà utilizzato se l'argomento opzionale non viene passato alla procedura. In questo modo è possibile dichiarare gli argomenti opzionali di qualsiasi tipo di dati e specificare un valore predefinito che sarà utilizzato se l'argomento opzionale viene omesso, evitando l'uso della funzione IsMissing che funziona solo con il tipo di dati Variant. Esempio: Un argomento opzionale non viene passato alla procedura a viene utilizzato un valore predefinito. La dichiarazione della routine contiene due argomenti, il secondo argomento è specificato come Optional. Se il secondo argomento, che è opzionale, non è passato nella procedura un valore predefinito viene utilizzato: Codice:
Sub dividi4(primoN As Integer, Optional secondoN As Integer = 3)
Dim result As Double
result = primoN / secondoN
result = Format(result, "#.##")
MsgBox result
End Sub
Sub calcula_2()
Dim numero1 As Integer
numero1 = InputBox("Inserisci il primo Numero")
Call dividi4(numero1)
End Sub
Passare un numero indefinito di argomenti - parametro Array (ParamArray)Abbiamo visto come dichiarare procedure passando argomenti, tra cui argomenti opzionali, ma comunque sempre limitati al numero di argomenti dichiarati nella procedura. Usando la parola chiave ParamArray sarà consentito passare un numero arbitrario di argomenti alla procedura in modo che vengano accettati un numero indefinito di argomenti. Utilizzare ParamArray quando non si è sicuri del numero preciso di argomenti da passare a una procedura, e potrebbe anche essere conveniente creare un array opzionale (cioè un ParamArray) che passare attraverso il fastidio di dichiarare un gran numero di argomenti opzionali, e quindi utilizzando la funzione IsMissing con ciascuno di essi. Una procedura utilizza le informazioni sotto forma di variabili, costanti ed espressioni per effettuare azioni ogni volta che viene chiamata e tramite la dichiarazione del procedimento si definisce un parametro che consente al codice chiamante (il codice che chiama la procedura) di passare un argomento, o il valore di tale parametro, in modo che ogni volta che la routine viene chiamata il codice chiamante può passare un argomento diverso per lo stesso parametro. Un parametro viene dichiarato come una variabile specificando il nome e il tipo di dati. Dichiarando una matrice di parametri, la procedura può accettare una matrice di valori per un parametro. Una matrice di parametri è così definita utilizzando la parola chiave ParamArray. ParamArray può essere definita in una procedura ed è sempre l'ultimo parametro nell'elenco dei parametri. Un ParamArray è un parametro opzionale e può essere l'unico parametro facoltativo in una procedura e deve essere dichiarato come un array di tipo Variant. Indipendentemente dall'impostazione Option Base per il modulo, LBound di un ParamArray sarà sempre 0 e il valore indice per l'array partirà da 0. ByVal, ByRef o keywords sono opzionali e non possono essere utilizzate con ParamArray. Per accedere al valore di una matrice di parametri si utilizza la funzione UBound per determinare la lunghezza dell'array che vi darà il numero di elementi o valori di indice nella matrice. Nel codice della procedura si può accedere al valore di una matrice di parametri digitando il nome dell'array seguito da un valore di indice (che dovrebbe essere compreso tra 0 e il valore UBound) Esempio: Passare un numero arbitrario di argomenti utilizzando un parametro ParamArray. Codice:
Sub aggiungiN(ParamArray numeri() As Variant) Dim somma As Long Dim i As Long For i = LBound(numeri) To UBound(numeri) somma = somma + numeri(i) Next i MsgBox somma End Sub Sub chiama_aggiungiN() Call aggiungiN(22, 25, 30, 40, 55) End Sub Una routine con un solo argomento richiesto (comm) e quindi permette di passare un numero arbitrario di argomenti utilizzando il parametro ParamArray. Codice:
Sub calcComm(comm As Double, ParamArray venD() As Variant) Dim somma As Double Dim n As Variant For Each n In venD MsgBox n totalComm = totalComm + comm * n Next n MsgBox totalComm End Sub Sub chiama_Comm() Dim c As Double c = 0.3 Call calcComm(c, 100, 200, 300) End Sub Una dichiarazione di routine con due argomenti richiesti (studente e media) e quindi permette di passare un numero arbitrario di argomenti utilizzando il parametro ParamArray. Codice:
Sub media_V(studente As String, media As Double, ParamArray voti() As Variant) Dim n As Variant Dim voto As String Dim T_voti As String For Each n In voti If n >= 80 Then voto = "Eccellente" ElseIf n >= 60 Then voto = "Buono" ElseIf n >= 40 Then voto = "Medio" Else voto = "Bocciato" End If If Len(T_voti) = 0 Then T_voti = voto Else T_voti = T_voti & ", " & voto End If Next n For Each n In voti i = i + 1 somma = somma + n media = somma / i Next n T_voti = """" & T_voti & """" media = Format(media, "#.##") MsgBox studente & " " & "ha voti di tipo " & T_voti & " " & "e una media voti di" & " " & media End Sub Sub chiama_media_V() Dim name As String, av1 As Double name = "Alessio" Call media_V(name, av1, 80, 45, 65) End Sub
___________________________________
- Il primo fondamento della sicurezza non e' la tecnologia, ma l'attitudine mentale - |
|
|
|
 |
| Utenti attualmente attivi che stanno leggendo questa discussione: 1 (0 utenti e 1 ospiti) | |
| Strumenti discussione | |
|
|
Discussioni simili
|
||||
| Discussione | Autore discussione | Forum | Risposte | Ultimo messaggio |
| riserca del corso | rene' | Software applicativo | 1 | 04-04-2008 10.30.22 |
| Formare Gruppo di Studio a Napoli | Scognamiglio | Windows 7/Vista/XP/ 2003 | 0 | 14-02-2008 20.46.49 |
| Corso su DVD di Tedesco | Downloader | Chiacchiere in libertà | 17 | 26-01-2007 08.46.21 |
| Win XP e corso di inglese che non va più | Raboso | Windows 7/Vista/XP/ 2003 | 8 | 11-11-2005 10.16.04 |
| svendo corso Cisco | alxdvc | Internet e Reti locali | 0 | 27-01-2005 12.03.45 |
