Newsgroup: it.comp.appl.access
Titolo: Sistema per avviare script VBA da stringa testo

Ho appena visto questo esempio, in dot net, che mostra un frammento di 
codice in grado di avviare una funzione definita come righe di codice 
dentro una textbox
In sostanza, il programma eseguibile puo' avviare uno script di codice 
ed eseguirlo
 
http://www.planet-source-code.com/vb/scripts/ShowCode.asp?txtCodeId=967&lngWId=10
 
 
Ritengo questo esempio molto interessante perche' permette di aprire un 
programma ad una serie di funzionalita' non previste inizialmente
La domanda sorge spontaGnea: ma si puo' fare con Access l'avvio di 
codice contenuto in una text box (o un file) ?
RobertoA

 contenuto in una text box (o un file) ?
 
Buongiorno RobertoA,
 
Spero di aver capito bene: non è nulla di complicato, io lo faccio 
salvando un file temporaneo:
 
'creo il file .vbs
Open "MioFileVbs" For Output As #1
Print #1, "Prima riga del file vbs"
Print #1, "seconda riga..."
Print #1, "etc..."
Close #1
ShellExecute Application.hWndAccessApp, "open", "MioFileVbs", 
vbNullString, vbNullString, SW_RESTORE  'SW_SHOWNORMAL
 
 
 
La ShellExecute è una funzione API che esegue un file in base alla sua 
estensione (utile, ad esempio, per aprire file pdf...)
 
Declare Function ShellExecute Lib "shell32.dll" Alias "ShellExecuteA" 
(ByVal hWnd As Long, ByVal lpOperation As String, ByVal lpFile As 
String, ByVal lpParameters As String, ByVal lpDirectory As String, 
ByVal nShowCmd As Long) As Long
'Parameter Description
'----------------------------------------------------------------------------
'hwnd          Identifies the parent window. This window receives any
'              message boxes an application produces (for example, for 
error
'              reporting).
'
'lpOperation   Points to a null-terminated string specifying the 
operation
'              to perform. This string can be "open" or "print." If 
this
'              parameter is NULL, "open" is the default value.
'
'lpFile        Points to a null-terminated string specifying the file
'              to open.
'
'lpParameters  Points to a null-terminated string specifying parameters
'              passed to the application when the lpFile parameter
'              specifies an executable file. If lpFile points to a 
string
'              specifying a document file, this parameter is NULL.
'
'lpDirectory   Points to a null-terminated string specifying the 
default
'              directory.
'
'nShowCmd      Specifies whether the application window is to be shown 
when
'              the application is opened.
 
            'per il parametro nShowCmd:
                Public Const SW_HIDE = 0
                    'Hides the window and passes activation to another 
window.
                Public Const SW_SHOWNORMAL = 1
                    'Activates and displays a window If the window is 
minimized or maximized,
                    'Windows restores it to its original size and 
position (same as SW_RESTORE).
                Public Const SW_SHOWMINIMIZED = 2
                    'Activates a window and displays it as an icon.
                Public Const SW_SHOWMAXIMIZED = 3
                    'Activates a window and displays it as a maximized 
window.
                Public Const SW_SHOWNOACTIVATE = 4
                    'Displays a window in its most recent size and 
position. The window that is currently active remains active.
                Public Const SW_SHOW = 5
                    'Activates a window and displays it in its current 
size and position.
                Public Const SW_MINIMIZE = 6
                    'Minimizes the specified window and activates the 
top-level window in the system’s list.
                Public Const SW_SHOWMINNOACTIVE = 7
                    'Displays a window as an icon. The window that is 
currently active remains active.
                Public Const SW_SHOWNA = 8
                    'Displays a window in its current state. The window 
that is currently active remains active.
                Public Const SW_RESTORE = 9
                    'Same as SW_SHOWNORMAL.

 nShowCmd As Long) As Long
 
Ringrazio per la risposta, ma non e' proprio questo l'obiettivo che 
desideravo raggiungere
Il tuo esempio mostra chiaramente come avviare una sequenza di comandi, 
da una shell esterna al programma 'avviante', non c'e' nessun contatto 
con il codice all'interno del programma iniziale
Mentre il codice indicato nel post iniziale ha piena 'visibilita' di 
tutte le procedure disponibili all'interno del programma avviante
Lo script aggiuntivo puo' estendere le funzioni del programma principale

 Lo script aggiuntivo puo' estendere le funzioni del programma principale
 
Ciao,
Beh, puoi creare una maschera con una casella di testo nella quale 
scrivi le righe di programma vbs. Poi, con un tasto, lanci l'esecuzione 
del vbs...
(spero di aver capito l'esigenza)
Ciao


Si, si potrebbe
Sarebbe la stessa cosa dell'avvio codice vbs da file di testo
Quello che mi manca e' come far interagire il codice nello script con le 
procedure contenute nel programma 'avviante'
 
Ad esempio, nel programma avviante dispongo di due procedure
- avvia script esterno
- stampa report fattura n.X
 
Bon, avviando il programma, ed eseguendo la procedura -avvia script 
esterno, il programma 'avviante' lancera' in esecuzione il codice 
scritto nel file di testo esterno
Vorrei che fosse possibile, da codice script esterno, lanciare la 
procedura -stampa report fattura(13)
Mi sono capito ?
 
 


se hai solo l'esigenza di fare qualcosa al termine dello script c'è il 
modo di attendere la fine dell'esecuzione prima di passare 
all'istruzione successiva vba
 
se invece l'istruzione successiva dipende dallo script stesso
esempio stampare un report con un parametro generato dallo script
 
io farei cosi
dalla maschera access avvio lo script e attivo il timer con intervallo 
di 1000 ms
sul evento timer imposto che se è presente un file pippo.txt in una 
certa cartella avvio la stampa del report.
File che ovviamente non c'è
 
quindi nel file di script come ultima riga metto di creare il file 
pippo.txt con dentro il parametro che serve a vba
 
Vba a questo punto trova il file, mette a 0 il timer, legge il 
contenuto, ricava il parametro, stampa il report in base al parametro
cancella pippo.txt
 
ciao
BFS
 
 
 
 
 
 


Ringrazio per la risposta
Ma non funziona cosi
Nel senso che il programma 'avviante' non conosce a priori il contenuto 
dello script, e quindi non e' che puo' predisporsi a leggere il numero 
della fattura da stampare, mica lo sa che dentro lo script c'e' l'avvio 
della procedura 'stampa report'
Il punto focale e' come fare per 'aggiungere' del codice vba ad un mde 
gia' bello, chiuso e funzionante
Come nell'esempio ad inizio 3d
 

Hai pensato ad usare i PARAMETERS CMD che recuperi all'avvio...
Passi una stringa con separatore la soliti ed hai n possibilità...
 
Forse ho capito male...
@Alex


Se passi dei parametri all'avvio, il programma avviato deve attendersi 
qualcosa e sapere gia' come usarli
Quello che volevo realizzare io e' altra cosa
E' la possibilita' di aggiungere delle procedure scritte in codice vba, 
DOPO che il programma principale e' stato avviato
Nell'esempio indicato ad inizio 3d, una cosa del tipo
 
---------------------
If TextBox1.Text.Trim <> "" Then
                 If TextBox2.Text.Trim <> "" Then
                     If TextBox3.Text.Trim <> "" Then
                         Dim VBP As New VBCodeProvider()
                         Dim CVB As System.CodeDom.Compiler.ICodeCompiler
                         CVB = VBP.CreateCompiler
                         Dim PM As New 
System.CodeDom.Compiler.CompilerParameters()
                         'set PM.GenerateExecutable = True to create exe 
instead of the following
                         PM.GenerateInMemory = True
                         '  PM.GenerateExecutable = True
                         'note it saves it in a temporary folder "user 
temp folder"
                         'also note you could enhance this by pulling 
the namespace info
                         'and class name from the code instead of having 
seperate vars for them.
                         PM.OutputAssembly = TextBox2.Text & ".dll"
                         PM.MainClass = TextBox3.Text
                         PM.IncludeDebugInformation = True
 
                         Dim ASM As System.Reflection.Assembly
                         'I believe this is to get all the assemblies of 
the current
                         'application and add them as references to the 
new assembly
                         For Each ASM In 
AppDomain.CurrentDomain.GetAssemblies()
                             PM.ReferencedAssemblies.Add(ASM.Location)
                         Next
 
                         'here we do the deed
                         Dim Results As 
System.CodeDom.Compiler.CompilerResults
                         Results = CVB.CompileAssemblyFromSource(PM, 
TextBox1.Text)
 
                         'this is just to list out all the errors if any
                         Dim Err As System.CodeDom.Compiler.CompilerError
                         For Each err In Results.Errors
                             ListBox1.Items.Add("Number " & 
err.ErrorNumber & " Text " & err.ErrorText & " Line " & err.Line)
                         Next
 
                         'now we create an instance of the assembly 
newly created
                         'and set it to an object notice this is also a 
good example of late binding
 
                         Dim RunObj As New Object()
                         Dim vArgs() As Object
 
                         RunObj = 
Results.CompiledAssembly.CreateInstance(TextBox2.Text & "." & 
TextBox3.Text, False, Reflection.BindingFlags.CreateInstance, Nothing, 
vArgs, Nothing, Nothing)
                         If Not RunObj Is Nothing Then
                             'now we call the sub in the object
                             RunObj.showmsg()
                         Else
                             MsgBox("Compile Failed")
                         End If
 
                     Else
                             MsgBox("Provide Class Name")
                         End If
                     Else
                         MsgBox("Provide App Name")
                     End If
                 Else
                 MsgBox("Provide Code Dammit")
             End If