<\/p>\n
Erfahren Sie, wie Sie per VBA auf Makros zugreifen, um diese etwa zu dokumentieren, zu erstellen oder anzupassen.<\/p>\n
Makros, VBA<\/p>\n
Access 2000 und höher<\/p>\n
Macroworks00.mdb<\/p>\n
Sascha Trowitzsch, Berlin<\/b><\/p>\n
Wenn Sie Datenbanken von anderen Entwicklern oder aus früheren Schaffensperioden warten oder überarbeiten möchten, stoßen Sie möglicherweise auf Makros. Diese wollen dokumentiert und gegebenenfalls nachbearbeitet werden. Das eine ließe sich mit dem Datenbank-Dokumentierer von Access erledigen, dessen Ausgabe sich aber leider nur auf einen generierten Bericht beschränkt, das andere mit dem Makro-Editor, der sich bisweilen aber als wenig komfortabel erweist. Sollten Sie nun auf die Idee kommen, selbst Routinen zur Dokumentation oder Bearbeitung von Makros zu programmieren, finden Sie hier das richtige Know-how. <\/b><\/p>\n
Gehen wir von der Annahme aus, dass Sie einen Datenbank-Dokumentierer programmieren möchten, wie ihn Access im Prinzip bereits mitbringt (Extras\/Analyse\/Dokumentierer). Die Dokumentation wird von ihm als Access-Bericht erstellt, wobei die Darstellung deutlich zu wünschen übrig lässt. Schöner wäre es, wenn man eine Ausgabe der Dokumentation zum Beispiel in ein Word-Dokument erhielte, um sie anschließend formatieren zu können.<\/p>\n
Die Technik zum Auslesen aller Datenbank-Objekte ist immer ähnlich: Dies lässt sich über die Containers- und Documents-Auflistung des Database-Objects von Access realisieren. Zu jeder Objektart gibt es einen Container. Für Formulare etwa wäre das die Auflistung Database.Containers(„Forms“).Documents. Für Makros lautet die Auflistung Database.Containers(„Scripts“).Documents.<\/p>\n
Mit der For Each-Schleife aus Quellcode 1 erhalten Sie die Objektenamen der Elemente dieser Auflistung.<\/p>\n
Kennt man einmal die Namen der Objekte, dann kann man im nächsten Schritt auch deren einzelne Eigenschaften ermitteln. Formulare beispielsweise lassen sich VBA im Entwurf öffnen; anschließend stehen die Eigenschaften zum Auslesen bereit. Daneben bietet das Access-Objektmodell zu jeder Objektart auch eine Auflistung: Für Formulare die Forms-Auflistung, für Berichte die Reports-Auflistung, für Tabellen die TableDefs, für Abfragen die QueryDefs, und so weiter. <\/p>\n
![](\"..\/fileadmin\/_temp_\/{F01B281B-3EF8-48A8-A1DE-B4FE508FDE44}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Bild 1: Formular Makroassinent der Beispieldatenbank<\/span><\/b><\/p>\n Quellcode 1: Documents-Auflistung für den Datenbank-Container Forms durchlaufen<\/b><\/p>\n Nur eine Auflistung für Makros sucht man vergeblich. Es gibt leider keine und es gibt folglich auch kein Macro-Objekt. Es sieht danach aus, als könne man Makros nicht per VBA dokumentieren.<\/p>\n Da Microsoft es jedoch mit dem eingebauten Dokumentierer vormacht, muss es doch eine Möglichkeit geben – schließlich sind alle Assistenten und eingebauten Tools von Access selbst in Access und VBA programmiert. (Diese befinden sich unter anderem in der eingeklinkten Addin-Datenbank acwztool.mde im Office-Verzeichnis.) <\/p>\n Nachforschungen, wie an die Makros per VBA heranzukommen wäre, führen zur versteckten WizHook-Klasse von Access.<\/p>\n Zunächst stellen wir jedoch den in der Beispieldatenbank enthaltenen Makroassistent (frmMakroassistent) vor, der die nachfolgend betrachteten Routinen zur Dokumentation und Bearbeitung von Makros implementiert.<\/p>\n Mit dem Makroassistent aus Bild 1 lassen sich die Makros einer Datenbank auslesen, bearbeiten und neu erstellen.<\/p>\n Grundlegende Funktionen<\/b><\/p>\n Ein Kombinationsfeld im Formularkopf listet alle Makros der Datenbank auf. Bild 1 zeigt beispielsweise AutoKeys-Makro an. Nach der Auswahl findet man im Detailbereich je eine der im Makro enthaltenen Anweisungen. Der Assistent zeigt diese also nicht in einer Liste an. Mit den Navigations-Buttons links unten kann man in den enthaltenen Makro-Anweisungen blättern.<\/p>\n Die Schaltfläche Löschen dient zum Entfernen eines Makros aus der Datenbank – natürlich nicht, ohne zuvor eine Löschbestätigung einzuholen. <\/p>\n Ein Klick auf Neu… fördert ein Eingabefenster zutage, in das man den Name eines neu anzulegenden Makros eingeben kann. Das Makros wird dann in der Datenbank erstellt und im Datenbankfenster markiert. Danach kann man unmittelbar mit der Eingabe der Aktionen für dieses Makro im Detailbereich beginnen. Gleichzeitig wird die Schaltfläche Speichern aktiv. Wird sie betätigt, schreibt der Assistent alle im Detailbereich angegebenen Aktionen in das neue Makro. (Ein Klick auf den „OK“-Button schließt das Formular lediglich, speichert das Makro aber nicht!)<\/p>\n Auf diese Weise lassen sich auch vorhandene Makros bearbeiten. Sie können also Anweisungen und Argumente überschreiben oder neue mit über die Schaltfläche Neue Aktion hinzugefügen. Der Assistent bietet den Vorteil, dass man mehrere Makros hintereinander bearbeiten oder anlegen kann, ohne diesen zu verlassen, wie es beim eingebauten Access-Makro-Editor der Fall ist.<\/p>\n Die Schaltfläche Doku-Text erzeugt eine Dokumentation des gerade aktiven oder aller in der Datenbank enthaltenen Makros (siehe Bild 2).<\/p>\n <\/b><\/p>\n Bild 2: Einzelnes oder alle Makros mit dem Assitenten dokumentieren<\/span><\/b><\/p>\n Diese Dokumentation wird als Datei macrodoc.txt im Anwendungsverzeichnis ausgegeben und anschließend automatisch in Notepad angezeigt. Die Schaltfläche ruft dazu die Prozedur DocumentMacros() im Modul mdlMacros auf.<\/p>\n Das ist wohl auch jene Prozedur, die Sie am meisten interessieren dürfte, falls Sie einen eigenen Dokumentierer realisieren möchten. Die Prozedur erwartet den Namen des zu analysierenden Makros. Bei einem Aufruf ohne diesen Parameter dokumentiert diese Funktion alle Makros der Datenbank.<\/p>\n Makroargumente bearbeiten<\/b><\/p>\n Das Bearbeiten der Makroargumente erfolgt im Detailbereich des Formulars. Auf der linken Seite kann man in einem Kombinationsfeld die Anweisung für die Aktion auswählen. (Die Datenquelle für dieses Kombinationsfeld ist die Tabelle tblMacroActions.)<\/p>\n Weiterhin kann man Angaben zu Kommentar, Bedingung und Makrogruppe der Aktion machen. Die hier möglichen Angaben entsprechen exakt denen, die Sie auch im Makro-Editor von Access vornehmen würden (siehe Bild 3).<\/p>\n <\/b><\/p>\n Bild 3: Angaben zur Makro-Aktion<\/span><\/b><\/p>\n Sobald im Kombinationsfeld eine Anweisung ausgewählt wird, ändert sich die rechte Seite des Detailbereichs, der die Argumente der Aktion anzeigt. Abhängig von der vorgesehenen Anzahl von Argumenten werden entsprechende Textfelder und\/oder Kombinationsfelder sichtbar (siehe Bild 4).<\/p>\n <\/b><\/p>\n Bild 4: Argumente der Makro-Aktion<\/span><\/b><\/p>\n Wie das funktioniert, wird beim Betrachten der Ereignisprozedur Nach Aktualisierung des Kombinationsfelds Aktion deutlich (cbAction_AfterUpdate).<\/p>\n Dort wird die Sichtbarkeit von bereits im Formular anlegten Text- und Kombinationsfeldern in Abhängigkeit von der Anweisung (ActionID) gesteuert, wobei die Informationen darüber aus der Tabelle tblMacroArguments stammen. Im Entwurf des Formulars sind zunächst keine Textfelder in diesem Bereich sichbar. Das liegt daran, dass die Kombinationsfelder und Textfelder übereinander liegen (siehe Bild 5).<\/p>\n <\/b><\/p>\n Bild 5: übereinander gestapelte Kombinations- und Textfelder in frmMakroassitsent<\/span><\/b><\/p>\n In der Prozedur wird zudem die Datenherkunft der Kombinationsfelder für die Argumente eingestellt. Es führt an dieser Stelle zu weit, die Funktionsweise genauer zu beschreiben. (Das gilt auch für weiteren Code der Beispieldatenbank. Wollte man alle der nicht ganz trivialen Prozeduren und die Interna von Access-Makros genau erläutern, so ließe sich damit gut und gerne ein komplettes Heft füllen. Wer also die Prozeduren für eigene Zwecke verwenden möchte, der kommt um ein Studium des Codes, der allerdings hinreichend kommentiert ist, nicht herum.)<\/p>\n Nachdem Sie die notwendigen Argumente für eine Makroanweisung eingegeben haben, können Sie über die Schaltfläche Neue Aktion die nächste Anweisung anlegen, oder, so vorhanden, mit der rechten Navigationsschaltfläche zur nächsten springen. Zum Schluss betätigen Sie die Speichern-Schaltfläche. Das ist wichtig, denn falls Sie im Makro-Kombinationsfeld im Kopfbereich ein neues Makro auswählen, gehen sonst sämliche Einstellungen des aktuellen Makros verloren.<\/p>\n Eine Aktion innerhalb eines Makro lässt sich übrigens einfach löschen, indem sie Sie auf den Datensatzmarkierer klicken und die Taste ENTF betätigen.<\/p>\n Sie können diesen Assistenten nun einfach benutzen oder ihn als Grundlage für eigene Entwicklungen verwenden. In diesem Fall, oder wenn Sie verstehen möchten, was sich hinter ihm verbirgt, sollten Sie sich die folgenden Absätze zu Gemüte führen, die die Funktionsweise verdeutlichen. <\/p>\n Makros haben die folgenden Eigenschaften:<\/p>\n <\/p>\n Dieser Aufbau spiegelt sich in zwei Tabellen der Beispieldatenbank Macrowork00.mdb wieder.<\/p>\n Die Tabelle tblMacroActions enthält alle möglichen Anweisungen. Das Feld ActionName zeigt die eingedeutschten Namen der Anweisungen. Die Spalte ActionID ist kein Autowert, sondern ein internes Token, das die Anweisung für Access identifiziert. Diese Action-IDs sind zentral und es wird in den Modulen der Datenbank viel damit hantiert. Die letzte Spalte CountOfArguments gibt an, wie viele Parameter die Anweisung erwartet. Die meisten dieser Argumente sind allerdings optional.<\/p>\n Die Tabelle tblMacroArguments ist eine Detailtabelle, die die Argumente zu den einzelnen Anweisungen der Tabelle tblMacroActions auflistet. Die beiden sind wie in Bild 6 miteinander verknüpft.<\/p>\n <\/b><\/p>\n Bild 6: Tabellen und Beziehungen des Makroassistenten<\/span><\/b><\/p>\n In der Tabelle tblMacroArguments bezeichnet das Feld Argument den Namen eines Parameters. ColID ist die Nummer der Parameterzeile in der Reihenfolge, wie sie auch im Makro-Editor erscheint. ComboType gibt an, um welche Art von Parameter es sich handelt. Eine 0 entspricht dabei einen String. Eine 1 oder eine 8 entspricht hier, dass es sich um eine Auswahl (Kombinationsfeld) handelt.<\/p>\n In diesem Fall stehen in der Spalte ComboString die zur Auswahl stehenden Argumente als semikolonseparierter String. Ein Spezialfall ist der ComboType 9, der nur bei der Anweisung AusführenBefehl (RunCommand) vorkommt.<\/p>\n Eine Liste aller möglichen RunCommand-Konstanten und deren Namen findet sich in der Hilfstabelle tblRunCommands12. Neben dem Konstantenwert ID steht in deren Feld Command der Name der Konstante neben der Access-Version, in der sie verfügbar ist.<\/p>\n Ich habe bisher noch keine Möglichkeit gefunden, diese Konstanten per Code in die deutschen Pendants zu übersetzen. (Beispiel: acCmdAppMaximize wäre AnwendungMaximieren)<\/p>\n Die beiden Tabellen tblMacroActions und tblMacroArguments werden übrigens mit der Prozedur CreateActionTables im Modul mdlMacros automatisch gefüllt. Das ist erforderlich, weil jede Access-Version einen anderen Satz von Makroanweisungen mitbringt.<\/p>\n Diese Tabellen werden nun als Hilfstabellen im Makroassistenten eingesetzt.<\/p>\n Der Beitrag WizHook – versteckte Features in Access (Shortlink 358) stellt einige Funktionen der Wizhook-Klasse vor. <\/p>\n Zu vielen findet sich bisher keine Beschreibung im Internet. Stellenweise dokumentiert ist aber die Funktion OpenScript (siehe Bild 7).<\/p>\n Sie bringen diese Methode im Objektkatalog zur Anzeige, indem sie an beliebiger Stelle einen Rechtsklick ausführen und den Kontextmenüeintrag Verborgene Elemente anzeigen aktivieren.<\/p>\n Im Listenfeld links wählen sie dann die ausgegraute Klasse WizHook aus.<\/p>\n <\/b><\/p>\n Bild 7: Die Methode OpenScript der WizHook-Klasse im Objektkatalog<\/span><\/b><\/p>\n Diese Methode ist der Startpunkt für die Arbeit mit Makros ist (ausführliche Informationen zur WizHook-Klasse unter http:\/\/www.team-moeller.de\/access\/tiptrick\/wizhook.html).<\/p>\n Microsoft hat keine der Funktionen der WizHook-Klasse dokumentiert. Was über sie bekannt ist, das ist ausschließlich das Ergebnis von experimentellen Forschungen verschiedener Access-Spezialisten.<\/p>\n Auch zahlreiche Routinen der Beispieldatenbank zu diesem Beitrag sind Eigenentwicklungen auf der Basis von eingehenden Untersuchungen und Tests. Das bedeutet: Es steht ein gewisser Vorbehalt in Bezug auf die Gültigkeit der Routinen und Funktionsbeschreibungen im Raum.<\/p>\n Um es kurz zu machen: Es gibt nur eine Handvoll von Methoden in der WizHook-Klasse, die mit Makros in Verbindung stehen. Neben der erwähnten Methode OpenScript sind dies die folgenden:<\/p>\n Dass diese fünf Methoden reichen sollten, um ein Makro vollständig per VBA zu beschreiben, verwundert.<\/p>\n Tatsächlich sind sie nur eine kleine Auswahl der benötigten Funktionen – und woher die anderen kommen, zeigt das folgenden Kapitel.<\/p>\n Die Datei msaccess.exe legt viele Funktionen (etwa 100) nach außen offen, die sich über API-Aufrufe in VBA verwenden lassen. Die Syntax und Deklarationen solcher API-Funktionen lassen sich indessen mit keinerlei Tools ermitteln, wenn man lediglich den API-Funktionsnamen kennt. Es ist beispielsweise offen, wie viele Parameter eine solche Funktion erwartet.<\/p>\n Nun hat sich Microsoft vor einigen Jahren dazu entschlossen, den Quellcode der in Access 97 eingebauten Assistenten offen zu legen. Er ist nach wie vor unter ftp:\/\/ftp.microsoft.com\/Softlib\/MSLFILES erhältlich (WZMAIN80.exe, WZTOOL80.exe, WZLIB80.exe, WZFUNC97.exe.) Deren Module enthalten auch die gefragten API-Deklarationen. Etwa 15 davon sind für die Arbeit mit Makros relevant. Ein Beispiel:<\/p>\n Diese Funktion schließt ein per WizHook.OpenScript geöffnetes Makro. OpenScript gibt nämlich ein so genanntes Handle zu einem Makro zurück. Dieses Verfahren ist in der Win32-API-Welt weit verbreitet. Das öffnen eines Objekts liefert ein Handle zurück, das es eindeutig identifiziert. Normalerweise muss das geöffnete Objekt dann auch wieder freigegeben werden, indem man das Handle einer Schließfunktion übergibt. Genau das tut die Funktion CloseHscr mit dem Long-Parameter hscr, der das Handle darstellt. <\/p>\n Vielleicht noch ein Wort zur nicht so geläufigen Deklaration der API-Funktion: Es taucht darin der Alias „#20“ auf. Das bedeutet, dass diese Funktion der msaccess.exe nicht über den Funktionsausdruck CloseHscr angesprochen wird – der eigentlich üblichen Syntax -, sondern über die Nummer 20 im Katalog der exportierten Funktionen. Das ist immer dann notwendig, wenn entweder gar kein Funktionsname von einer Exe oder DLL exportiert wird, oder der Funktionsname aufgrund von Sonderzeichen nicht korrekt von VBA übergeben werden kann. Das ist im vorliegenden Beispiel der Fall. <\/p>\n Beim Laden des Formulars wird zunächst ermittelt, ob die erwähnten Makrotabellen mit der gestarteten Version von Access übereinstimmen. In die Datenbank wurde dazu ein benutzerdefiniertes Property accver aufgenommen. Der Inhalt wird mit der aktuell gestarteten Access-Version verglichen (SysCmd(acSysCmdAccessVer)) und bei Abweichung werden die Tabellen mit der Prozedur CreateActionTables neu erstellt.<\/p>\n Danach wird das Auswahlfeld für die Makronamen in der Prozedur FillMacroCombo gefüllt. Dies geschieht, wie bereits in Quellcode 1 dargestellt, mit einem Durchlaufen der Documents-Ausflistung des Datenbank-Containers Scripts. Die Prozedur zeigt übrigens schön, wie sich die WizHook-Methode SortStringArray zum Sortieren eines auf einer Werteliste basierenden Kombinationsfelds verwenden lässt.<\/p>\n Die Auswahl eines Makros im Kombinationsfeld löst das Ereignis cbMacros_AfterUpdate auf, die ihrerseits die Prozedur ScanMacro ausruft. Diese Prozedur ist das Herzstück des Formularcodes. Sie befüllt die Tabelle tblMakros mit den Anweisungen und Argumenten des Makros. Gleichzeitig ist diese Tabelle die Datenherkunft des Formulars selbst. Wie ScanMacro im Groben funktioniert wird, weiter unten in der Beschreibung des Moduls mdlMacros erklärt.<\/p>\n Ein Klick auf die mit Neu… beschriftete Schaltfläche cmdNew startet die Prozedur cmdNew_Click. Diese ruft wiederum die Prozedur CreateMacro im Modul mdlMacros auf. Um ein Makro in einer Datenbank neu zu erzeugen bedient man sich der folgenden Anweisung:<\/p>\n Das öffnet automatisch den Makro-Editor, der mit DoCmd.Close wieder geschlossen wird; gleichzeitig wird dem neuen Makro ein Name zugewiesen (s. Quellcode 2). Wie die Sichtbarkeit der Text- und Kombinationsfelder für die Makroargumente im Detailbereich nach Auswahl einer Anweisung gesteuert wird, das wurde bereits in Kapitel 2 behandelt.<\/p>\n Quellcode 2: Neues Makro erzeugen und benennen<\/b><\/p>\n Interessant ist noch die Ereignisprozedur cmdStore_Click für das Abspeichern der Makroeinstellungen. Hier wird das Formular-Recordset, sprich der Inhalt der Tabelle tblMakros, durchlaufen und die Datensätze jeweils in einem benutzerdefinierten Typ TMakro zwischengespeichert:<\/p>\n Die Argumente (Parameter) einer Makroanweisung sind in diesem Typ einfach im String-Array sArguments untergebracht. Da mehrere Anweisungen pro Makro gespeichert werden sollen, wird ein Array des Typs TMakro erstellt. Es wird schlussendlich der Prozedur WriteMacro des Moduls mdlMacros unter Angabe des Namens des Makros übergeben. Diese Prozedur ist – im Gegensatz zu der zum Auslesen von Makros (ScanMacro beziehungsweise DocumentMacros) – erfreulich knapp geraten.<\/p>\n Nachdem nun bereits mehrmals auf Prozeduren des Moduls mdlMacros der Datenbank verwiesen wurde, sollen abschließend einzelne Elemente der enthaltenen Prozeduren etwas näher beleuchtet werden.<\/p>\n Das Modul mdlMacros lässt sich ohne weiteres in andere Datenbanken übertragen und kann dort seinen Dienst verrichten. Es enthält grundlegende Funktionen wie die Prozedur DocumentMacros.<\/p>\n (Allerdings müssen dann auch die benötigten Tabellen tblRunCommands12, tblMacroActions und tblMacroArguments mitimportiert werden.) <\/p>\n Die im Folgenden beschriebenen Vorgänge lassen sich in den beiden Prozeduren DocumentMacros und WriteMacroSample am Besten nachvollziehen. Vielleicht noch der Hinweis, dass für die zum Einsatz kommenden WizHook-Methoden die Klasse wie immer zu Anfang jeder Prozedur freigeschaltet werden muss:<\/p>\n Makro öffnen<\/b><\/p>\n Um Zugriff auf ein Makro zu erhalten, damit es bearbeitet oder ausgelesen werden kann, kommt die WizHook-Methode OpenScript zur Anwendung:<\/p>\n Von den Parametern für diese Methode sind nur zwei von Interesse: sName ist der Name des Makros, das bearbeitet werden soll und lOpenMode ist der Zugriffsmodus.<\/p>\n Wird für lOpenMode eine 0 übergeben, dann wird das Makro für Lesezugriff geöffnet, mit einer 2 für den Schreibzugriff. Im Erfolgsfall gibt die Funktion einen Wert ungleich 0 zurück.<\/p>\n In hMacro steht dann der Long-Wert des Zugriffs-Handles, das für die weitere Bearbeitung benötigt wird. Am Ende der Prozedur muss dann der Zugriff wieder freigegeben werden:<\/p>\n Der API-Anweisung CloseHscr wird das beim öffnen erhaltene Handle übergeben. Es ist wichtig, dass dieser Parameter korrekt ist. Ein falsches Handle oder eine 0 an dieser Stelle führen meist zum Absturz von Access!<\/p>\n Zeilenweiterschaltung<\/b><\/p>\n Um den Inhalt einer Makroanweisung auslesen oder bearbeiten zu können muss zuerst eine Art Zeiger auf die betreffende Anweisungszeile gesetzt werden. Man kann sich die Anweisungen eines Makros wie ein Recordset vorstellen, dessen Datensätze jeweils die Befehle enthalten. Nach dem öffnen des Makros steht der Zeiger noch vor der ersten Anweisung, weist also ins Leere. Wie bei einem Recordset mit der Methode MoveNext kann man im Makroobjekt mit der API-Funktion hscrNextRow zur nächsten Zeile navigieren:<\/p>\n Der Parameter hMacro ist das beim öffnen erhaltene Zugriffs-Handle. Die beiden anderen sind unwesentlich. Wird diese Funktion nach dem öffnen des Makros ausgeführt, dann befindet man sich in der ersten Anweisungszeile und kann nun deren Inhalt auslesen – oder beschreiben. Um zu den nächsten Zeilen zu schalten ruft man die Funktion wiederholt auf.<\/p>\n Anweisung auslesen<\/b><\/p>\n Auch dazu gibt es keine WizHook-Methode, sondern eine API-Funktion:<\/p>\n Nachdem man mit hScrNextRow zu einer gültigen Zeile geschaltet hat bekommt man mit dieser Funktion eine ID, die mit einer bestimmten Aktion korreliert. Diese ID, hier in der Variablen lActID gespeichert, ist gewissermaßen ein Platzhalter für eine der DoCmd-Methoden von Access. Mit dieser ID kann man zunächst wenig anfangen. Um die Bezeichnung der Aktion zu ermitteln verwendet man eine WizHook-Methode:<\/p>\n Der Funktion wird die zuvor ermittelte Actions-ID übergeben. Man bekommt von ihr die englische Bezeichnung für die Anweisung zurück. Für die ID mit der Nummer 23 etwa ist das OpenForm. Soll die lokalisierte Bezeichnung, also die deutsche, erhalten werden, dann muss man einen anderen Weg beschreiten: Access kennt eine versteckte Methode AppLoadString, die alle lokalisierten Bezeichnungen und Sätze, die in Oberfläche oder Meldungen von Access auftreten können, zurückgibt, wenn man ihr eine Nummer übergibt:<\/p>\n Wer Interesse daran hat, wie die Rückgaben dieser Funktion aussehen, der kann eine Prozedur mit einer Schleife schreiben, die die Nummer von 0 bis ca. 10.000.000 erhöht. Für die meisten Nummern wird ein Leer-String zurückgegeben werden. Wer sich die Ergebnisse genau ansieht wird feststellen, dass ab einer gewissen Nummer die Bezeichnungen für die Makroanweisungen auftauchen. Das kann man sich zunutze machen, um die deutsche Bezeichnung zu ermitteln. (Erschwerend kommt hier allerdings hinzu, dass der Startwert der Nr für die Makrobezeichnungen in allen Access-Versionen unterschiedlich ist. In der Prozedur DocumentMacros ist das genaue Vorgehen detaillierter kommentiert.)<\/p>\n Zurück zur Funktion hscrHetActID: Falls sie den Wert -1 zurückgibt, was keine gültige Action-ID darstellt, dann bedeutet das, dass man sich am Ende der Anweisungszeilen des Makros befindet. Das entspräche in einem Recordset dem Wert Recordset.EOF = True. Das ist also der Indikator dafür, dass man alle Makrozeilen durchlaufen hat. Ein Wert von 0 bedeutet dagegen „Leerzeile“. (Man kann im Makro-Editor zwischen den einzelnen Anweisungszeilen Leerzeilen einfügen, ohne dass sich Access daran stört.)<\/p>\n Nun möchten wir noch wissen, welches die Attribute der Makrozeile sind. Mit der WizHook-Methode GetScriptString kommt man hier weiter:<\/p>\n Die Methode ist keine Funktion, sondern liefert das Ergebnis in der String-Variablen sAttribut zurück. übergeben wird neben dem Makro-Handle die AttributNr. Dabei gibt es die folgende Zuordnung zwischen AttributNr und Anweisungsattribut:<\/p>\n Argumente auslesen<\/b><\/p>\n Wird also GetScriptString eine AttributNr von 3 bis 12 übergeben, dann erhält man die Argumente der Anweisung. Nun ist die Zahl der Parameter, die eine Makroanweisung benötigt, nicht immer gleich. Manche Anweisungen erfordern gar keine. Es ist deshalb zuerst zu ermitteln, wie viele Argumente ausgelesen werden können:<\/p>\n Diese WizHook-Funktion liefert diese Anzahl von Argumenten, wenn ihr eine Action-ID übergeben wird. Anschließend kann die Variable nArgumente für den Zähler einer Schleife verwendet werden, in der die einzelnen Argumente mit GetScriptString gelesen werden.<\/p>\n Damit hat man zwar die einzelnen Argumentwerte, aber noch nicht die Bezeichnungen derselben. Um diese zu ermitteln existiert im Modul mdlMacros eine Hilfsfunktion, der die Action-ID sowie die AttributNr übergeben wird:<\/p>\n Die Hilfsfunktion bedient sich dabei wieder eines API-Aufrufs sowie der erwähnten Access-Methode AppLoadString.<\/p>\n Anweisung schreiben<\/b><\/p>\n Als Pendant zur Funktion hscrGetActID, die eine Action-ID ausliest, kann man mit der API-Anweisung SaveActidHscr eine Action-ID in ein im Schreibmodus geöffnetes Makro schreiben:<\/p>\n lActID ist die Action-ID. Die Zuordnung zwischen Action-ID und der Anweisungsbezeichnung kann übrigens in der Beispieldatenbank auch aus der Tabelle tblMakroActions ersehen werden.<\/p>\n Das Vorgehen, um dem Makro die Attribute und Argumente beizubringen, ist analog zu dem beim Auslesen. Es kommt die WizHook-Methode SaveScriptString zum Einsatz:<\/p>\n Die zu übergebenden Attribut-Nummern entsprechenden weiter oben aufgeführten. Der Argumentwert wird in sArgument immer als String übertragen. Gespeichert werden die Makroeinstellungen erst, wenn das Makro-Handle mit der API-Funktion CloseHscr wieder freigegeben wurde.<\/p>\n Mit dem hier Beschriebenen und der begleitenden Beispieldatenbank Macrowork00.mdb erhalten Sie das Rüstzeug für das Bearbeiten von Makros in Access. Mit dem Makroassistenten haben Sie eine Alternative zum Bearbeiten von Makros mit dem Access-eigenen Editor und zum Dokumentierer. Sie können Makros aus VBA heraus dokumentieren.<\/p>\n In dieser Ausführlichkeit sind nach meiner Kenntnis noch keine Informationen über die Programmierung von Makros im Internet zu finden. Es sollte aber nicht verschwiegen werden, dass die Routinen möglicherweise noch die eine oder andere Unzulänglichkeit aufweisen und kleinere Fehler auftreten können.<\/p>\n Für Tester der Beta-Version von Access 2007 noch ein Hinweis: Das Auslesen von Makros gelingt zwar mit den beschriebenen Prozeduren, nicht jedoch das Schreiben, weil in Access 2007 Beta die Möglichkeiten rund um Makros von Microsoft deutlich ausgeweitet und überarbeitet wurden.<\/p>\n Enthaltene Beispieldateien:<\/p>\n macrowork00.mdb<\/p>\nSub ShowFormNames()\r\n Dim dbs As Database\r\n Dim oDoc As DAO.Document\r\n Set dbs = CurrentDb\r\n For Each oDoc In _ dbs.Containers(\"Forms\").Documents\r\n Debug.Print oDoc.Name\r\n Next oDoc\r\nEnd Sub<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{F01B281B-3EF8-48A8-A1DE-B4FE508FDE44}\/pic002.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{F01B281B-3EF8-48A8-A1DE-B4FE508FDE44}\/pic003.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{F01B281B-3EF8-48A8-A1DE-B4FE508FDE44}\/pic004.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{F01B281B-3EF8-48A8-A1DE-B4FE508FDE44}\/pic005.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{F01B281B-3EF8-48A8-A1DE-B4FE508FDE44}\/pic006.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{F01B281B-3EF8-48A8-A1DE-B4FE508FDE44}\/pic007.png\")
<\/p>\nDeclare Sub CloseHscr Lib \"msaccess.exe\" Alias \"#20\" (ByVal hscr As Long)<\/pre>\n
RunCommand acCmdNewObjectMacro<\/pre>\n
RunCommand acCmdNewObjectMacro\r\nsTmpName = CurrentObjectName\r\nDoCmd.Save acMacro, sTmpName\r\nDoCmd.Close acMacro, sTmpName, acSaveYes\r\nDoCmd.Rename MacroName, acMacro, sTmpName<\/pre>\n
Public Type TMacro\r\n sGroup As String\r\n sComment As String\r\n sCondition As String\r\n lCommand As Long\r\n bHasArgs As Boolean\r\n sArguments() As String\r\nEnd Type<\/pre>\n
WizHook.Key = 51488399<\/pre>\n
hMacro = WizHook.OpenScript(sName, sLabel, lOpenMode, lExtra, lVersion)<\/pre>\n
CloseHscr hMacro<\/pre>\n
Call hScrNextRow(hMacro, False, False)<\/pre>\n
lActID = hScrGetActID(hMacro)<\/pre>\n
sAktion = WizHook.NameFromActid(lActID)<\/pre>\n
sBezeichnung = AppLoadString (Nr)<\/pre>\n
WizHook.GetScriptString(hMacro, AttributNr, sAttribut)<\/pre>\n
nArgumente = WizHook.ArgsOfActid(lActID)<\/pre>\n
Argumentbezeichnung = NameOfActionIDsArg (lActID, AttributNr +3)<\/pre>\n
SaveActidHscr hMacro, lActID<\/pre>\n
WizHook.SaveScriptString hMacro, AttributNr, sArgument<\/pre>\n
Downloads zu diesem Beitrag<\/h3>\n