<\/p>\n
André Minhorst, Duisburg und Sascha Trowitzsch, Berlin<\/b><\/p>\n
Je ernsthafter man mit Access arbeitet, desto mehr verlagert sich der Schwerpunkt der Arbeit vom Access-Fenster auf die VBA-Entwicklungsumgebung. Und wie es mit einem Arbeitsplatz so ist, sollte man ihn sich so angenehm wie möglich gestalten – das gilt auch für die Programme, mit denen man arbeitet. Und das umso mehr, wenn sich tatsächlich die Möglichkeit dazu ergibt. Die VBA-Entwicklungsumgebung lässt sich beliebig erweitern, wenn man das Know-how dazu besitzt. Das finden Sie hier und ein praktisches Beispiel gleich dazu: Ab jetzt können Sie durch den Code springen, wie Sie möchten – mit dem CodeHistory-Tool finden Sie schnell wieder zurück.<\/b><\/p>\nHinweis<\/h3>\n
Die Beispieldateien befinden sich in der .zip-Datei AIU_CodeHistory.zip. Zwei Verzeichnisse enthalten je eine Version des Quellcodes mit und eine ohne Kommentare. Sie finden die Datei auf der Heft-CD oder im Internet unter http:\/\/www.access-im-unternehmen.de unter dem Shortlink 278. Grundlagen und verwandte Themen finden Sie in den Beiträgen Per VBA auf VBA-Code zugreifen, Shortlink 277 und Erweitern der VBA-Entwicklungsumgebung, Shortlink 237. <\/p>\n
Die VBA-Entwicklungsumgebung lässt sich um verschiedene Elemente erweitern. Bei diesen Elementen handelt es sich um COM-AddIns, die nach ihrer Installation beim Start der Entwicklungsumgebung automatisch erkannt und den Voreinstellungen entsprechend entweder direkt geladen werden oder erst über den Add-In-Manager aktiviert werden müssen.<\/p>\n
Für die VBA-Entwicklungsumgebung gibt es mehrere Möglichkeiten, eine Erweiterung zu integrieren. Interessant sind dabei die Varianten zum Starten beziehungsweise Anzeigen des Add-Ins und wie es sich in die Entwicklungsumgebung einfügt. Die einfachste Variante ist ein Add-In, das nach dem Laden im Add-Ins-Menü zur Verfügung steht und eine Operation ausführt, für die keine Benutzeroberfläche benötigt wird – beispielsweise das automatische Hinzufügen von Code anstelle der Einfügemarke.<\/p>\n
Darüber hinaus gibt es sowohl für den Aufruf als auch für den Grad der Interaktion mit dem Benutzer einige Varianten. Für den Aufruf eines Add-Ins bietet sich neben dem Add-Ins-Menü ein Eintrag in ein anderes bestehendes Menü (dabei kann es sich auch um ein Kontextmenü handeln) oder gar die Erstellung einer eigenen Menüleiste an.<\/p>\n
Was die Interaktion mit dem Benutzer betrifft, so gibt es neben den Add-Ins, die ihren Dienst ohne Rückfragen erledigen, solche, die zusätzliche Benutzereingaben für ihre Arbeit benötigen. Dabei kann die Art der Interaktion von Meldungsfenster und Eingabefenster bis hin zu mehreren Benutzerformularen reichen.<\/p>\n
Immer präsent (wenn nicht gerade ausgeblendet) sind die „Toolwindows“. Sie kennen bereits einige Beispiele für diese in der Entwicklungsumgebung verankerbaren Fenster: Das Direktfenster ist eines und auch der Projekt-Explorer, das überwachungsfenster und das Eigenschaftsfenster sind Toolwindows.<\/p>\n
Diese Fenster haben gemeinsam, dass sie sowohl frei schweben als auch an den Rahmen des Editorfensters oder andere Toolwindows angedockt werden können. Der wichtigste Unterschied zu den Benutzerformularen ist die ständige Sichtbarkeit dieser Fenster.<\/p>\n
![](\"..\/fileadmin\/_temp_\/{D9EC351A-2B00-4B15-9A53-A53CAB9C318B}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Bild 1: Festlegen des Ladeverhaltens von COM-Add-Ins<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 2: Aktivieren des CodeHistory-Tools<\/span><\/b><\/p>\n Toolwindows sind das Thema dieses Beitrags: Sie erfahren, wie Sie diese erstellen, installieren und aktivieren oder deaktivieren. Leider lassen sich Toolwindows nicht mit Access erstellen; Sie benötigen dazu Microsoft Visual Basic 6 (Visual Studio 6). Sollten Sie nicht in Besitz dieses Tools sein, können Sie immerhin das hier vorgestellte Tool für die Entwicklung mit der VBA-Entwicklungsoberfläche verwenden.<\/p>\n Der Entwicklungsprozess eines Toolwindows lässt sich grob in die Erstellung des Gerüsts mit den grundlegenden Elementen, das unter anderem die Funktionalität zum Einklinken in die Benutzeroberfläche sowie ein jungfräuliches Toolwindow enthält und das Aufsetzen der eigentlichen Funktionalität aufteilen.<\/p>\n Den ersten Teil haben wir bereits für Sie erledigt: Auf der Heft-CD finden Sie ein VB-Projekt mit dem Quellcode für das Gerüst eines Toolwindows. Der erste Teil dieses Beitrags enthält eine Beschreibung der enthaltenen Komponenten. Auch für die Schritte vom leeren Gerüst zum fertigen Toolwindow ist gesorgt: Sie finden sowohl das komplette Projekt im Quellcode als auch die fertige .dll für den Soforteinsatz auf der Heft-CD. Leider, und das ist die schlechte Nachricht, würde eine ausführliche Vorstellung des Tools mit dem enthaltenen Quellcode circa ein bis zwei komplette Magazine verschlingen, sodass wir den Quellcode nur auszugweise im Beitrag vorstellen können. Der in den Beispieldateien enthaltene Quellcode ist allerdings sehr gut dokumentiert.<\/p>\n In den nachfolgenden Abschnitten erfahren Sie, wie Sie COM-Add-Ins verfügbar machen und wie das Beispiel-Add-In funktioniert.<\/p>\n Den Add-In-Manager können Sie in der VBA-Entwicklungsumgebung über den Menüeintrag Add-Ins\/Add-In-Manager… starten.<\/p>\n Der Add-In-Manager aus Bild 1 zeigt bereits das weiter unten in diesem Beitrag vorgestellte VBA-CodeHistory-Tool an. Um das Tool zu aktivieren, das heißt, es in der VBA-Entwicklungsumgebung sichtbar zu machen, sind zwei Schritte nötig: Aktivieren Sie die Option Geladen\/Entladen und wählen Sie nach dem Schließen des Dialogs den neuen Eintrag im Add-Ins-Menü aus (siehe Bild 2).<\/p>\n <\/b><\/p>\n Bild 3: Anzeigen der Definition einer Prozedur<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 4: Liste bereits besuchter Codestellen<\/span><\/b><\/p>\n Möglicherweise kennen Sie selbst das Dilemma: Sie durchforsten die Prozeduren und Module einer VBA-Anwendung, um zu verstehen, wie diese funktioniert. Egal ob es sich um eine eigene Entwicklung oder um das Produkt eines anderen Entwicklers handelt – wenn Sie länger nicht mehr oder noch gar nicht hineingeschaut haben, müssen Sie sich zuerst in die Struktur einarbeiten. Sie starten also mit einer Prozedur, die durch eine bestimmte Schaltfläche aufgerufen wird und untersuchen dessen Funktion. Dabei finden Sie mehrere weitere Prozeduraufrufe – also schnell hinterher und die entsprechenden Module in weiteren Codefenstern aufrufen. Die Entwicklungsumgebung stellt geeignete Mittel dafür zur Verfügung – etwa den Kontextmenüeintrag Definition beim Rechtsklick auf den Aufruf der gewünschten Prozedur (siehe Bild 3).<\/p>\n Das ganze Spiel machen Sie noch zwei oder drei Mal, dann möchten Sie vielleicht zur Ausgangprozedur zurückkehren – aber in welchem Modul war die noch Mal Hier kommt das CodeHistory-Tool ins Spiel. Es speichert Positionen im Code so, dass Sie mühelos per Mausklick auf einen Eintrag zur entsprechenden Stelle zurückkehren können.<\/p>\n Das CodeHistory-Tool zeichnet Informationen über Code-Zeilen auf, die Sie mit der Maus „besucht“ haben und gibt diese in einer Liste aus (siehe Bild 4). Mit einem Mausklick auf einen der Einträge öffnen Sie das Modul mit der entsprechenden Codestelle und zeigen diese an.<\/p>\n Das Toolwindow mit der Liste der gemerkten Positionen im Code zeigt den Namen des Projekts, den Modulnamen, die Zeile und den Prozedurnamen an. Zusätzlich finden Sie ganz links ein Sternchen (*) – auf diese Weise markierte Einträge werden dauerhaft gespeichert und bei der nächsten Sitzung wieder geladen.<\/p>\n Die Schaltflächen im oberen Bereich haben folgende Funktionen:<\/p>\n Wenn jede Zeile, in die Sie die Einfügemarke setzen, zur Liste hinzugefügt würde, wäre diese bald voll. Der Sinn dieses Tools ist vielmehr, markante Sprünge zu speichern und das Zurückspringen an diese Stellen zu ermöglichen. Das Speichern einer Position erfolgt in folgenden Fällen, wobei Sie die ersten beiden Optionen im entsprechenden Dialog deaktivieren können:<\/p>\n <\/b><\/p>\n Bild 5: Kontextmenüeinträge des CodeHistory-Tools<\/span><\/b><\/p>\n Nachdem Sie einige Positionen aufgezeichnet haben, möchten Sie gezielt zu der einen oder anderen zurückspringen – vielleicht möchten Sie aber auch einfach den zurückgelegten Weg nachvollziehen. Das Tool bietet einige Möglichkeiten zum Navigieren an:<\/p>\n <\/b><\/p>\n Bild 6: Diese Schnellauswahl zeigen Sie per Kontextmenü an.<\/span><\/b><\/p>\n Mit der Schaltfläche Einstellungen des Toolwindows können Sie einen Dialog zum ändern der Einstellungen öffnen (siehe Bild 7).<\/p>\n Die erste Option legt fest, wie viele Zeilen eine Zeile von der zuvor gespeicherten Position entfernt sein muss, damit das Tool diese automatisch speichert. Die standardmäßig eingestellten 40 Zeilen entsprechen ungefähr einer Bildschirmseite, somit wird eine Zeile, die mehr als eine Bildschirmseite als die vorherige entfernt liegt, automatisch gespeichert. Der kleinste einstellbare Wert, den dieses Optionsfeld annimmt, ist 3.<\/p>\n <\/p>\n Mit der zweiten Option legen Sie fest, wie viele Positionen sich das Tool merken soll. Ist die angegebene Anzahl erreicht, schmeißt das Tool die ältesten Einträge aus der Liste. Mit der Option Sprungstellen automatisch merken geben Sie an, ob das Tool sich Positionen automatisch entsprechend Ihrer Angabe in für die Option Anzahl Codezeilen merken oder dies nur nach Aufforderung über den entsprechenden Kontextmenübefehl oder die dafür vorgesehene Tastenkombination tun soll.<\/p>\n Mit der Option Sprungstellen dauerhaft merken legen Sie fest, dass die automatisch vermerkten Stellen über die aktuelle Sitzung hinaus gespeichert werden sollen, so dass sie beim nächsten Laden des VBA-Projekts wieder verfügbar sind. Diese Codestellen sind dann in der Liste mit einem Sternchen versehen. Dieses dauerhafte Speichern lässt sich auch ausschalten, indem der Haken bei der Option Sprungstellen beim Beenden speichern deaktiviert wird.<\/p>\n Das CodeHistory-Tool speichert die Einträge zu jeder Datenbank in einer eigenen Textdatei im gleichen Verzeichnis, in dem sich auch die .dll-Datei befindet. Da dies bei häufigem Arbeiten mit Access schnell eine größere Menge von Dateien hervorrufen kann, wählen Sie für die Installation des Tools besser ein eigenes Verzeichnis – und zwar ein anderes, als das für .dll-Dateien übliche Verzeichnis c:\\windows\\system32. <\/p>\n <\/b><\/p>\n Bild 7: Einstellungen des CodeHistory-Tools<\/span><\/b><\/p>\n Für die Erstellung von Toolwindows benötigen Sie Microsoft Visual Studio und Visual Basic-Kenntnisse. Wenn Sie bisher nur mit Access und VBA gearbeitet haben, müssen Sie sich ein wenig umstellen: Die Entwicklung mit Visual Basic scheint weniger intuitiv zu sein und das Erstellen von Benutzerformularen geht anfangs nicht so flott von der Hand wie unter Access. Die mit der nachfolgend beschriebenen Technik erstellten Toolwindows lassen sich mit der VBA-Entwicklungsumgebung ab Version 2000 verwenden – Sie erinnern sich, das war der Start einer gemeinsamen VBA-Entwicklungsoberfläche für alle Office-Anwendungen. Dementsprechend können Sie COM-Add-Ins auch in Word, Excel und Co. verwenden – allerdings nur, wenn diese nicht speziell auf den Einsatz mit Access ausgelegt sind. Für das hier vorgestellte CodeHistory-Tool gilt das nicht, es ist universell einsetzbar.<\/p>\n Für die Entwicklung von COM-Add-Ins gibt es in Microsoft Visual Basic eine spezielle Vorlage namens Addin. Wenn Sie ein neues Projekt auf Basis dieser Vorlage erstellen, legt Visual Basic direkt Verweise auf einige benötigte Bibliotheken an (Menüeintrag Projekt\/Verweise, s. Abb. 8).<\/p>\n <\/b><\/p>\n Bild 8: Notwendige Verweise für COM-Add-Ins<\/span><\/b><\/p>\n Außerdem stellt diese Vorlage bereits zwei Objekte bereit, die Sie im Projektexplorer vorfinden (Strg + R, s. Abb. 9).<\/p>\n Mit dem Connect-Objekt finden Sie dort auch schon das für die Verwendung eines COM-Add-Ins wichtigste Element. Um dessen Funktionsweise zu erläutern, sind einige Vorbemerkungen erforderlich:<\/p>\n Beim Erzeugen der .dll-Datei mit dem Menübefehl Datei ( MyAddin.dll erstellen… (der Name der .dll-Datei entspricht dem Projektnamen und kann leicht geändert werden) wird auf dem aktuellen Rechner direkt ein Eintrag über das COM-Add-In in der Registry vorgenommen.<\/p>\n Anwendungen, die grundsätzlich COM-Add-Ins einbinden (Visual Studio, Visual Studio for Applications, Access …), durchsuchen beim Start den Bereich in der Registry, in dem die COM-Add-Ins eingetragen sind, und laden die für sie vorgesehenen Add-Ins. Die COM-Add-Ins sind dann über den jeweiligen Add-In-Manager aufrufbar – in der VBA-Entwicklungsumgebung etwa wie in Bild 1.<\/p>\n <\/b><\/p>\n Bild 9: Per Vorlage bereitgestellte Objekte<\/span><\/b><\/p>\n Nun sollen die COM-Add-Ins ja nicht irgendwelche nebenläufigen Aufgaben erledigen, sondern konkret mit der jeweiligen Benutzungsumgebung zusammenhängende Unterstützung bieten.<\/p>\n Dazu ist eine bestimmte Art von Interaktion zwischen der Benutzungsoberfläche und dem COM-Add-In erforderlich. Die Benutzungsoberfläche muss dem COM-Add-In beim Aufruf mitteilen, wer sie ist, damit das COM-Add-In seine Dienste dort anbieten kann.<\/p>\n Das erfolgt etwa über Einträge in bestehenden oder neuen Menüleisten (wie bereits im Beitrag Erweiterung der VBA-Entwicklungsumgebung in Ausgabe 5\/2004 beschrieben) oder durch Bereitstellung eines Toolwindows, das nachfolgend beschrieben wird.<\/p>\n Neben diesen Bedienelementen löst das COM-Add-In natürlich entsprechende Ereignisse aus, die beim Betätigen der Bedienelemente ausgelöst werden.<\/p>\n Das Anlegen der Bedienelemente und der Ereignisse erfolgt – und damit schließt sich der Kreis – in oben erwähntem Connect-Modul.<\/p>\n Das Connect-Modul hat zwei Ansichten: ein spezielles Eigenschaftsfenster und ein herkömmliches Code-Fenster. Ersteres dient zum Einstellen folgender wichtiger Eigenschaften (siehe Bild 10):<\/p>\n <\/b><\/p>\n Bild 10: Eigenschaften des Connect-Objekts<\/span><\/b><\/p>\n Das Code-Modul legt mit einigen Ereignisprozeduren fest, wie sich das COM-Add-In in verschiedenen Situationen verhalten soll.<\/p>\n Das Ereignis OnConnection ruft die Ereignisprozedur AddinInstance_OnConnection auf. Das Ereignis wird ausgelöst, wenn das anfängliche Ladeverhalten auf Startup eingestellt ist und die VBA-Entwicklungsumgebung gestartet wird oder wenn das anfängliche Ladeverhalten auf None eingestellt ist und Sie die Option Geladen\/Entladen im Add-In-Manager aktivieren (siehe Bild 1).<\/p>\n Das OnConnection-Ereignis enthält den Code beziehungsweise den Aufruf weiterer Routinen, die das Add-In betriebsbereit machen. Das kann verschiedene Aktionen umfassen:<\/p>\n Eventuell benötigen Menüleisten, Schaltflächen oder Toolwindows weitere Daten – beispielsweise weil das Toolwindow projekt- oder datenbankabhängige Informationen anzeigen soll.<\/p>\n Die dazu notwendigen Routinen werden von dem für das Toolwindow verwendeten VB-Benutzerdokument selbst gestartet.<\/p>\n Wenn es eine Ereignisprozedur gibt, die beim Verbinden der VBA-Entwicklungsumgebung mit dem COM-Add-In gestartet wird, muss es natürlich auch ein Pendant für das Beenden der Verbindung geben. Das entsprechende Ereignis heißt OnDisconnection und löst die Ereignisprozedur AddinInstance_OnDisconnection aus.<\/p>\n In diesem Ereignis können Sie Code und Routinenaufrufe für das Wiederherstellen des vorgefundenen Zustands unterbringen. Dazu gehören die folgenden Aktionen:<\/p>\n Beim Schließen des Toolwindows sind gegebenenfalls weitere Aktionen notwendig, um änderungen an den im Toolwindow angezeigten Daten zu speichern.<\/p>\n Die entsprechenden Routinen können in der Terminate-Ereignisprozedur des Codemoduls des Toolwindows untergebracht werden.<\/p>\n Je nach der Art des COM-Add-Ins sind spezielle Menüs und Schaltflächen mehr oder weniger wichtig für dessen Verwendung.<\/p>\n Wenn Sie ein COM-Add-In verwenden, das nicht über eine ständig sichtbare Benutzungsoberfläche wie ein Toolwindow verfügt, können Sie dessen Funktionen praktisch nur über Menüschaltflächen aufrufen (Tastenkombinationen sind natürlich auch möglich, aber gute Ergonomie setzt dafür erstmal eine Schaltfläche voraus).<\/p>\n Wenn ein Toolwindow vorhanden ist, wird dieses die benötigten Steuerelemente bereitstellen; möglicherweise ist das Anbieten weiterer Möglichkeiten zum Aufrufen der vorhandenen Funktionen sinnvoll – Menüschaltflächen speziell in den entsprechenden Kontextmenüs sind hier besonders geeignet.<\/p>\n Das Anlegen von Menüs und Schaltflächen erfolgt per Code. Dabei verwendet man die gleichen Methoden wie auch beim Anlegen von Menüelementen in der Access-Umgebung. Ausführliche Hinweise dazu finden Sie im Beitrag Dynamische Menüs mit VBA, Ausgabe 4\/2003.<\/p>\n Der große Unterschied zwischen dem Anlegen von Menüs auf die im genannten Beitrag beschriebene Art und in COM-Add-Ins ist folgender:<\/p>\n In einer Datenbank-Anwendung speichern Sie die beim Klicken auf die Menüschaltflächen auszuführenden Routinen einfach als öffentliche Function-Prozeduren.<\/p>\n Beim Einbinden eines COM-Add-Ins wäre das auch möglich. Allerdings möchten Sie ja keine in der Datenbank gespeicherte Prozedur aufrufen, sondern eine, die das COM-Add-In bereitstellt – und auf die darin enthaltenen Methoden können Sie von Access aus nicht so einfach zugreifen.<\/p>\n Deshalb legen Sie im Code des COM-Add-Ins Ereignisse und entsprechende Ereignisprozeduren an, die auf das Betätigen der Menüschaltflächen „lauschen“.<\/p>\n In der Praxis sieht das folgendermaßen aus:<\/p>\n Zunächst legen Sie eine neue (Menü-) Schaltfläche an, beispielsweise die für das Aufrufen des Toolwindows des CodeHistory-Tools (siehe Bild 2). Das Anlegen dieses Eintrags erfolgt mit den Methoden der Office-Objektbibliothek.<\/p>\n Nun müssen Sie das COM-Add-In nur noch dazu bewegen, dass es beim Klick auf diese Schaltfläche die gewünschte Methode des COM-Add-Ins ausführt.<\/p>\n Dazu deklarieren Sie zunächst eine entsprechende Objektvariable für das Ereignis im Kopf des Codemoduls des Connect-Objekts:<\/p>\n In der Routine, die beim Verbinden der VBA-Entwicklungsumgebung mit dem COM-Add-In aufgerufen wird, müssen Sie das Event-Objekt nun noch dem richtigen Steuerelement der Menüleiste zuweisen:<\/p>\n Hier sind einige Erläuterungen notwendig. Die AddCmbButton-Methode ist eine Hilfsfunktion, die das Anlegen eines Menüelements kapselt. Sie erwartet den Namen des Hauptmenüs, des Untermenüs, in das die Schaltfläche eingefügt werden soll, die Beschriftung der Schaltfläche sowie Angaben über das anzuzeigende Symbol, ob die Schaltfläche standardmäßig aktiviert ist und ob die Schaltfläche die erste einer neuen Gruppe ist.<\/p>\n AddCmbButton liefert einen Objektverweis auf das Schaltflächenobjekt zurück und speichert ihn in der Variablen cmdmen.<\/p>\n Die folgende Anweisung sorgt dafür, dass die Ereignisse der Schaltfläche an das weiter oben deklarierte Event-Objekt weitergeleitet werden. Dadurch können Sie im Code des COM-Add-Ins die entsprechenden Ereignisprozeduren festlegen.<\/p>\n Für die Schaltfläche, die Sie mit obigen Anweisungen im Add-Ins-Menü erstellt haben, verwenden Sie etwa folgende Ereignisprozedur:<\/p>\n Die einzige Anweisung dieser Prozedur stellt die Sichtbarkeit des Toolwindows auf True ein.<\/p>\n Die Ereignisprozeduren müssen Sie übrigens jeweils in dem Modul als „Private“-Routinen speichern, in dem auch die Events selbst deklariert sind.<\/p>\n <\/b><\/p>\n Bild 11: Per COM-Add-In erstellte Einträge im Kontextmenü des Codefensters<\/span><\/b><\/p>\n Auf ähnliche Weise werden weitere Anweisungen erstellt, mit denen Sie innerhalb des aktuellen Codefensters die Befehle des CodeHistory-Tools aufrufen können (siehe Bild 11). Wenn Sie selbst weitere Einträge in Kontextmenüs erzeugen möchten, müssen Sie lediglich den Namen des jeweiligen Kontextmenüs herausfinden. Der Name des Kontextmenüs für das Codefenster lautet beispielsweise Code Window. Wenn Sie die Hilfsfunktion AddCmbButton aus dem Beispiel-Add-In verwenden möchten, müssten Sie folgende Anweisungen verwenden, um diesem Kontextmenü einen neuen Eintrag hinzuzufügen:<\/p>\n Sie können jedem COM-Add-In beliebig viele VB-Benutzerformulare hinzufügen und damit beispielsweise für die Durchführung der Funktionen notwendige Informationen sammeln.<\/p>\n Bei manchen Anwendungen macht es allerdings Sinn, dass deren Benutzungsschnittstelle die ganze Zeit sichtbar ist. Das ist zum Beispiel bei dem Prozedurbrowser so, den Sie gegebenenfalls im Beitrag Prozedurbrowser für den VBA-Editor kennen gelernt haben (weitere Hinweise auf der ersten Seite dieses Beitrags).<\/p>\n Dieses Tool zeigt sämtliche modulweiten Deklarationen sowie die Namen der Function-, Sub- und Property-Prozeduren des aktuellen Moduls an und springt bei Bedarf auf das entsprechende Element im Codemodul.<\/p>\n Um ein Toolwindow zu verwenden, müssen Sie ein so genanntes Benutzerdokument zum Projekt hinzufügen. Dazu verwenden Sie den Kontextmenüeintrag Hinzufügen\/Benutzerdokument. <\/p>\n Ein Benutzerdokument lässt sich genauso wie ein herkömmliches Formular mit Steuerelementen und Code bestücken und enthält auch die gleichen Ereignisse (siehe Bild 12).<\/p>\n Zum Toolwindow wird das Benutzerdokument erst durch eine Spezialbehandlung: Zunächst deklarieren Sie für diesen Bestandteil der Benutzeroberfläche eine öffentliche Variable in einem Standardmodul:<\/p>\n <\/b><\/p>\n Bild 12: Beispiel für ein Userdocument<\/span><\/b><\/p>\n Anschließend verwenden Sie etwa folgende Anweisung, um das Benutzerdokument in ein Toolwindow einzuhüllen (in einer Zeile):<\/p>\n Dabei ist VBAApp eine Objektvariable für die Anwendung, die das COM-Add-In verwendet (also die VBA-Entwicklungsumgebung), strAppTitle der Projektname, strTitle die Titelzeile, die das Toolwindow anzeigen soll, strGUID ein Identifikations-String, über den das COM-Add-In eindeutig identifiziert werden kann und dToolDoc gibt einen Verweis auf das Benutzerdokument selbst zurück. Wenn Sie das Beispiel-COM-Add-In als Basis für Eigenkreationen verwenden, müssen Sie eine neue GUID anlegen – die Hilfsfunktion CreateGUID() im Modul mdlMain des VB-Projekts ermittelt die entsprechende Zeichenkette für Sie.<\/p>\n Mit tWindow und dToolDock haben Sie nun zwei Objekte, über die Sie das Toolwindow steuern können: Das tWindow bildet den „Rahmen“ und bietet die für die Fenster in der VBA-Entwicklungsumgebung verfügbaren Methoden und Eigenschaften wie Visible, Height, Width, Top oder Left. dToolDoc stellt die sich im Codemodul des Benutzerdokuments befindliche Funktionalität zur Verfügung.<\/p>\n Ein wichtiges Thema ist das Speichern der Einstellungen des COM-Add-Ins. Zu diesen Einstellungen gehört etwa eine Eigenschaft, die den Zustand des Toolwindows beim Schließen der VBA-Entwicklungsumgebung beschreibt (zum Beispiel die Sichtbarkeit), um beim erneuten öffnen den vorherigen Zustand wiederherzustellen. Für solche Informationen bietet sich die Registry an und Visual Basic stellt zwei Funktionen für das Lesen und Schreiben von Daten in einem speziell für solche Anwendungen vorgesehenen Bereich zur Verfügung. Diesen Bereich finden Sie beispielsweise für das CodeHistory-Tool unter dem folgenden Schlüssel:<\/p>\n HKEY_CURRENT_USER\\Software\\VB and VBA Program Settings\\VBA AddIns\\VBACodeHistory<\/p>\n Die Funktion zum Ermitteln eines Wertes aus diesem Bereich heißt GetSetting. Sie hat folgende Syntax:<\/p>\n Um einen Wert namens DisplayOnConnect unter dem oben angegebenen Ort zu lesen, verwenden Sie folgenden Ausdruck:<\/p>\n Der für den Parameter Default angegebene Wert wird zurückgegeben, wenn der Schlüssel keinen Wert enthält. Um diesen Wert beispielsweise beim Schließen in die Registry zu schreiben, verwenden Sie die SaveSetting-Funktion mit folgender Syntax:<\/p>\n Das sich auf der Heft-CD befindende Beispiel für ein Toolwindow enthält unter anderem den kompletten Quellcode. Aus Platzgründen ist es leider nicht möglich, alle Funktionen ausführlich zu erläutern; das gilt auch für einige Funktionen, die nicht speziell für das CodeHistory-Tool, sondern für alle COM-Add-Ins interessant sind. Dazu gehören die Folgenden:<\/p>\n Einige dieser Funktionen sind in der Datei „anmerkungen.html“ erläutert, die im Projektordner zu finden ist und die direkt aus dem VB-Projekt heraus aufgerufen werden kann. (Projektexplorer ( Verbundene Dokumente\/anmerkungen.html)<\/p>\n Zum Installieren eines COM-Add-Ins müssen Sie lediglich die .dll in einem beliebigen Verzeichnis auf der Festplatte des Zielrechners speichern und registrieren.<\/p>\n Zum Registrieren öffnen Sie den Ausführen-Dialog (Start\/Ausführen) und geben die folgende Anweisung ein:<\/p>\n Die Hilfsanwendung regsvr32.exe befindet sich im Systemverzeichnis jeder Windows-Installation. Sie trägt automatisch alle Informationen in die Registry ein, die zum Start des Addins in der vorgesehenen Anwendung – hier der VBA-Editor – notwendig sind. Diese Informationen holt sich die Hilfsanwendung aus der DLL selbst.<\/p>\n Wer COM-Addins weitergeben oder vertreiben will, der sollte zumindest diesen Vorgang der Registrierung in einer Readme-Datei erläutern. Noch besser liefern Sie eine Batchdatei zur Registrierung mit aus, die ins gleiche Verzeichnis wie die .dll-Datei entpackt oder gespeichert wird und folgenden einfachen Inhalt hat:<\/p>\n In diesem Zusammenhang sollte auch noch auf Systemvoraussetzungen für das Addin hingewiesen werden: Für die Verwendung der .dll-Datei muss sich die aktuelle Version der Visual Basic-Runtime-Bibliothek (msvbvm60.dll) auf dem System befinden. Das ist bei einigen älteren Rechnern unter Umständen nicht der Fall. Ein Link zu einer Download-Quelle für diese Runtime (zum Beispiel bei Microsoft) wäre hier nützlich. Zum Zeitpunkt der Drucklegung dieses Magazins gab es beispielsweise unter folgendem Link eine aktuelle Version: http:\/\/support.microsoft.com\/kb\/823746\/de<\/p>\n Das VBACodeHistory-Addin arbeitet mit der VBA-Entwicklungsumgebung von Microsoft Office 2000, XP und 2003 zusammen. Eine Office-Installation ist daher Voraussetzung für den Einsatz dieses COM-Add-Ins. Ein weiterer Grund für das zwingende Vorhandensein von Office ist, dass das hier beschriebene Tool das Listbox-Steuerelement aus der MS Forms-Bibliothek benutzt (weitere Informationen in der Datei anmerkungen.html auf der Heft-CD).<\/p>\n Mit den hier beschriebenen Grundlagen können Sie sich austoben – entsprechende Ideen und VB-Fertigkeiten vorausgesetzt, können Sie sich mit COM-Add-Ins die eine oder andere Programmiertätigkeit erleichtern.<\/p>\n","protected":false},"excerpt":{"rendered":" Je ernsthafter man mit Access arbeitet, desto mehr verlagert sich der Schwerpunkt der Arbeit vom Access-Fenster auf die VBA-Ent¬wick¬lungs¬um¬ge¬bung. Und wie es mit einem Arbeitsplatz so ist, sollte man ihn sich so angenehm wie möglich gestalten – das gilt auch für die Programme, mit denen man arbeitet. Und das umso mehr, wenn sich tatsächlich die Möglichkeit dazu ergibt. Die VBA-Entwicklungsumgebung lässt sich beliebig erweitern, wenn man das Know-how dazu besitzt. Das finden Sie hier und ein praktisches Beispiel gleich dazu: Ab jetzt können Sie durch den Code springen, wie Sie möchten – mit dem CodeHistory-Tool finden Sie schnell wieder zurück.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662005,66032005,44000025],"tags":[],"class_list":["post-55000278","post","type-post","status-publish","format-standard","hentry","category-662005","category-66032005","category-VBA_und_Programmiertechniken"],"yoast_head":"\n![](\"..\/fileadmin\/_temp_\/{D9EC351A-2B00-4B15-9A53-A53CAB9C318B}\/pic002.png\")
<\/p>\nToolwindows<\/h2>\n
Add-Ins verfügbar machen<\/h2>\n
![](\"..\/fileadmin\/_temp_\/{D9EC351A-2B00-4B15-9A53-A53CAB9C318B}\/pic003.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{D9EC351A-2B00-4B15-9A53-A53CAB9C318B}\/pic004.png\")
<\/p>\nFunktionen des CodeHistory-Tools<\/h2>\n
Aufzeichnen von Positionen<\/h2>\n
Wann wird eine Position gespeichert<\/h3>\n
![](\"..\/fileadmin\/_temp_\/{D9EC351A-2B00-4B15-9A53-A53CAB9C318B}\/pic005.png\")
<\/p>\nNavigieren zwischen den Positionen<\/h2>\n
![](\"..\/fileadmin\/_temp_\/{D9EC351A-2B00-4B15-9A53-A53CAB9C318B}\/pic006.png\")
<\/p>\nOptionen des Tools<\/h2>\n
Praxis-Tipp<\/h3>\n
![](\"..\/fileadmin\/_temp_\/{D9EC351A-2B00-4B15-9A53-A53CAB9C318B}\/pic007.png\")
<\/p>\nProgrammierung von COM-Add-Ins für den VBA-Editor<\/h2>\n
![](\"..\/fileadmin\/_temp_\/{D9EC351A-2B00-4B15-9A53-A53CAB9C318B}\/pic008.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{D9EC351A-2B00-4B15-9A53-A53CAB9C318B}\/pic009.png\")
<\/p>\nInteraktion<\/h3>\n
Das Connect-Modul eines COM-Add-Ins<\/h2>\n
![](\"..\/fileadmin\/_temp_\/{D9EC351A-2B00-4B15-9A53-A53CAB9C318B}\/pic010.png\")
<\/p>\nStarten des COM-Add-Ins<\/h3>\n
Was passiert im OnConnection-Ereignis<\/h3>\n
Sauberes Beenden des COM-Add-Ins<\/h3>\n
Menüs und Schaltflächen<\/h2>\n
Anlegen neuer Elemente<\/h3>\n
Public WithEvents menEvent As VBIDE.CommandBarEvents<\/pre>\n
Set cmbmen = AddCmbButton(strTB, _ \"Add-&Ins\", strTitle, 103, True)\r\nSet Me.menEvent = _ VBAApp.Events.CommandBarEvents(cmbmen)<\/pre>\n
Private Sub menEvent_Click( _ ByVal CommandBarControl As Object, _ handled As Boolean, _ CancelDefault As Boolean)\r\n tWindow.Visible = True\r\nEnd Sub<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{D9EC351A-2B00-4B15-9A53-A53CAB9C318B}\/pic011.png\")
<\/p>\nNeue Einträge in Kontextmenüs<\/h3>\n
Set cmbmen = AddCmbButton( _ \"Code Window\", \"\", strPopup1, 103, _ True, True)\r\nSet Me.popupEvent1 = _ VBAApp.Events.CommandBarEvents(cmbmen)<\/pre>\n
Toolwindow erstellen<\/h3>\n
Public tWindow As VBIDE.Window<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{D9EC351A-2B00-4B15-9A53-A53CAB9C318B}\/pic012.png\")
<\/p>\nSet tWindow = VBAApp.Windows.CreateToolWindow(AddInInst, strAppTitle & \".UDHistory\", strTitle, strGUID$, dToolDoc)<\/pre>\n
Sicherung der Einstellungen des COM-Add-Ins<\/h2>\n
GetSetting(AppName As String, Section As String, Key As String, [Default])<\/pre>\n
GetSetting(\"VBA AddIns\", \"VBACodeHistory\", \"DisplayOnConnect\", \"0\")<\/pre>\n
SaveSetting(AppName As String, Section As String, Key As String, Setting As String)<\/pre>\n
Weitere Features<\/h2>\n
regsvr32.exe \"<Pfad>\\VBACodeHistory.dll\"<\/pre>\n
regsvr32 VBACodeHistory.dll<\/pre>\n