<\/p>\n
Access besteht nicht nur aus einer einzigen Anwendungsdatei, sondern auch noch aus einer Reihe weiterer wichtiger Dateien wie etwa den Bibliotheken VBA, DAO oder ADODB oder Add-In-Datenbanken, die Funktionen zu Access hinzufügen. In diesem Beitrag sehen wir uns diese Dateien an und schauen, welche Informationen sich aus diesen gewinnen lassen. Außerdem gibt es eine Reihe VBA-Funktionen, mit denen Sie beispielsweise die Speicherorte dieser Dateien ermitteln können.<\/b><\/p>\n
MSAccess.exe<\/b><\/p>\n
Die Datei MSAccess.exe <\/b>wird aufgerufen, wenn der Benutzer Access startet – sei es über einen Eintrag im Startmenü, über einen zur Taskleiste hinzugefügten Eintrag oder auch durch das Starten einer Datei mit einer entsprechenden Dateiendung wie beispielsweise .mdb<\/b>, .accdb <\/b>et cetera.<\/p>\n
Sie liegt in der Version Access 2010, 32bit unter Windows 7 im Verzeichnis C:\\Program Files (x86)\\Microsoft Office\\Office14<\/b>, in anderen Versionen von Access unterscheidet sich der Name des letzten Verzeichnisses (unter Access 2013 etwa Office15).<\/p>\n
Wenn Sie die 64bit-Variante installieren, was nicht empfehlenswert ist (hier werden beispielsweise keine der ActiveX-Steuerelemente der Bibliothek MSCOMCTL.ocx <\/b>unterstützt), landet diese im Verzeichnis C:\\Program Files\\Microsoft Office\\Office14<\/b>.<\/p>\n
MSAccess.exe suchen<\/b><\/p>\n
Wenn Sie die Datei MSAccess.exe <\/b>nicht finden, können Sie diese mit einem VBA-Befehl ermitteln, den Sie beispielsweise im Direktbereich des VBA-Editors absetzen:<\/p>\n Access-Version ermitteln<\/b><\/p>\n Wenn Sie schon die Funktion SysCmd<\/b> nutzen, können Sie auch gleich die Version der geöffneten Access-Anwendung ausgeben lassen:<\/p>\n Benutzer und Gruppen<\/b><\/p>\n In früheren Access-Versionen (bis Access 2003) konnten Sie noch eine Access-interne Benutzer- und Gruppenverwaltung verwenden. Daher nur der Vollständigkeit halber hier die Funktion zum Ermitteln des Standortes der aktuell verwendeten Arbeitsgruppeninformationsdatei, die solche Informationen speicherte:<\/p>\n Wie man sieht, gibt es diese Datei immer noch – Sie kann allerdings nicht mehr zur Sicherung der Access-Objekte und Daten genutzt werden (sicher war diese ohnehin schon längst nicht mehr). Wer seine Daten wirklich sichern will, verwendet ein System wie den Microsoft SQL Server oder MySQL.<\/p>\n Runtime oder Vollversion<\/b><\/p>\n Für eine Anwendung kann es wichtig sein, neben der Version einer Access-Anwendung auch noch zu erkennen, ob es sich um die Vollversion oder um die Runtime-Version handelt. Wenn Sie beispielsweise zur Laufzeit dynamisch Formulare oder Berichte anpassen, benötigen Sie unbedingt die Vollversion – unter der Runtime-Version können Sie keine änderungen am Entwurf der Datenbankobjekte vornehmen. Daher kommt uns die folgende Funktion sehr gelegen:<\/p>\n Access als Runtime starten<\/b><\/p>\n Apropos Runtime: Sie müssen nicht die Runtime-Version von Access installieren, um den Großteil der Runtime-Einschränkungen zu testen. Dazu reicht je nach Access-Version auch eine der folgenden Aktionen aus:<\/p>\n Für den Aufruf des Runtime-Modus über die Befehlszeile geben Sie erst den Pfad zur MSAccess.exe<\/b>, dann den Pfad zu der zu öffnenden Datenbankdatei und schließlich den Befehlszeilenparameter an:<\/p>\n Dafür müssen Sie übrigens nicht umständlich eine Windows-Verknüpfung anlegen. Eine Datei mit der Dateiendung .bat <\/b>(etwa Start.bat<\/b>) reicht völlig aus.<\/p>\n Access erscheint dann in der für die Runtime üblichen spartanischen Ausstattung, die nach benutzerdefinierten Menüleisten\/Ribbons oder einem übersichtsformular zum Aufruf der Formulare und Funktionen verlangt (s. Bild 1).<\/p>\n Bild 1: Start der Runtime-Version von Access<\/span><\/b><\/p>\n Access als Administrator starten<\/b><\/p>\n Wenn Sie Access mit Administratorrechten starten müssen, obwohl Sie aktuell nicht als Administrator angemeldet sind, können Sie dies über eine entsprechende Verknüpfung oder über die Datei MSAccess.exe <\/b>selbst erledigen.<\/p>\n Klicken Sie einfach bei gedrückter Umschalttaste mit der rechten Maustaste auf die Datei und wählen Sie dann den Eintrag Als Administrator ausführen <\/b>aus dem Kontextmenü aus. Access startet nun mit Administratorrechten (s. Bild 2).<\/p>\n Bild 2: Access mit Administratorrechten starten<\/span><\/b><\/p>\n Access als anderer Benutzer starten<\/b><\/p>\n Gelegentlich wollen Sie vielleicht testen, wie Ihre Anwendung arbeitet, wenn Sie sich unter einem anderen Windows-Konto anmelden. Dann heißt es, den aktuellen Benutzer abmelden, sich unter dem Konto des neuen Benutzers anmelden, die Tests ausführen, wieder abmelden und unter dem zunächst verwendeten Konto wieder anmelden.<\/p>\n Das machen Sie allerdings nur so, wenn Sie zu viel Zeit haben. Wenn Ihnen die Prozedur zu aufwendig ist, können Sie sich nämlich über einen weiteren Kontextmenü-Eintrag namens Als anderer Benutzer ausführen <\/b>unter dem anderen Benutzerkonto anmelden und Access in diesem Kontext ausführen.<\/p>\n Aber wo steckt dieser Kontextmenü-Eintrag – im Screenshot des vorherigen Beispiels ist dieser doch nicht zu finden<\/p>\n Nun: Dieser Eintrag erscheint nur, wenn Sie das Kontextmenü der Datei MSAccess.exe <\/b>selbst bei gedrückter Umschalttaste aufrufen.<\/p>\n Das gelingt beispielsweise über das Startmenü, wenn Sie im Suchen-Feld den Begriff MSAccess.exe <\/b>eingeben (s. Bild 3).<\/p>\n Bild 3: MSAccess.exe über die Suche im Startmenü auffinden<\/span><\/b><\/p>\n Alternativ navigieren Sie im Windows Explorer zu der entsprechenden Datei (s. Bild 4).<\/p>\n Bild 4: Starten von Access als anderer Benutzer über das Kontextmenü von MSAccess.exe im Windows Explorer<\/span><\/b><\/p>\n Anschließend erscheint dann ein Anmeldedialog, mit dem Sie Benutzername und Kennwort des betroffenen Benutzers eingeben (s. Bild 5). Anschließend wird Access im Kontext dieses Benutzers gestartet.<\/p>\n Bild 5: Benutzer und Kennwort zum Starten von Access eingeben<\/span><\/b><\/p>\n Aktuelle Datenbankdatei<\/b><\/p>\n Auch zur aktuellen Datenbankdatei können Sie per VBA eine ganze Reihe Informationen herauskitzeln.<\/p>\n Die Access-Bibliothek bietet einige Informationen, aber auch die DAO-Bibliothek bietet Möglichkeiten für den Zugriff etwa auf den Pfad zur aktuell geöffneten Access-Datenbank.<\/p>\n Bis mit Access 2002 das CurrentProject<\/b>-Objekt eingeführt wurde, lieferte allein das CurrentDb<\/b>-Objekt Informationen über die Herkunft der Datenbankdatei. Die Eigenschaft Name <\/b>lieferte nämlich den kompletten Pfad der mit CurrentDb <\/b>referenzierten, also der aktuell geöffneten Datenbankdatei:<\/p>\n Wer bis Access 2002 nur den Namen oder den Pfad ermitteln wollte, musste sich mit einer Hilfsfunktion begnügen.<\/p>\n Den Namen einer Datei auf Basis des kompletten Pfades liefert bekanntlich die Dir<\/b>-Funktion:<\/p>\n Wenn man von der mit CurrentDb.Name <\/b>ermittelten Zeichenkette hinten eine Zeichenkette abschneidet, deren Länge der Länge des Dateinamens entspricht, erhält man das Verzeichnis inklusive abschließendem Backslash:<\/p>\n <\/p>\n Seit Access 2002 erledigen Sie solche Aufgaben mit verschiedenen Eigenschaften des Objekts CurrentProject<\/b>. Das Verzeichnis liefert die Eigenschaft Path<\/b>:<\/p>\n Mit Name <\/b>ermitteln Sie allein den Dateinamen:<\/p>\n Sie können den kompletten Pfad aus beiden Eigenschaften zusammensetzen, aber auch einfach FullName <\/b>nutzen:<\/p>\n Wenn Sie den Pfad aus dem Verzeichnis und dem Dateinamen zusammensetzen möchten, vergessen Sie nicht, einen Backslash zwischen beiden Ausdrücken einzufügen. Gleiches gilt auch, wenn Sie CurrentProject.Path <\/b>nutzen, um auf andere Dateien im gleichen Verzeichnis zuzugreifen – also etwa so:<\/p>\n Bibliotheken<\/b><\/p>\n Wenn Sie mit VBA arbeiten, setzen Sie vermutlich nicht nur Befehle aus der VBA-Bibliothek ein, sondern auch solche etwa aus den Bibliotheken Microsoft DAO 3.6 Object Library <\/b>et cetera (s. Bild 6). Gelegentlich muss man wissen, wo sich die zugrunde liegenden Dateien befinden – beispielsweise um die Version abzufragen und zu prüfen, ob man die aktuellste Version verwendet (dies war zuletzt in Zusammenhang mit der Bibliothek MSCOMCTL.OCX <\/b>interessant).<\/p>\n Bild 6: Das Verweise-Fenster<\/span><\/b><\/p>\n Informationen dazu, wie Sie die Pfade der per Verweis referenzierten Dateien erhalten, finden Sie im Beitrag Bibliotheken und Verweise untersuchen <\/b>(www.access-im-unternehmen.de\/913<\/b>).<\/p>\n Weitere Informationen dank Wizhook<\/b><\/p>\n Es gibt unter Access eine nicht dokumentierte Klasse namens WizHook<\/b>. Man muss diese Klasse nicht instanzieren und kann sie lediglich nutzen, wenn man vorher die Eigenschaft Key <\/b>der Klasse auf einen bestimmten Wert einstellt, und zwar wie folgt:<\/p>\n Die Wizhook<\/b>-Klasse wird offensichtlich für interne Dinge verwendet, ist aber von verschiedenen Programmierern untersucht und im Internet beschrieben worden. Für das Thema dieses Beitrags liefert sie einige interessante Informationen, die wir uns in den folgenden Abschnitten ansehen werden.<\/p>\n Assistenten-Datenbanken<\/b><\/p>\n Access bietet eine ganze Reihe eingebauter Assistenten an, sogenannte Wizards.<\/p>\n Viele davon sind reine Access-Formulare mit VBA-Programmierung, die allerdings in einer geschützten .mde<\/b>– oder .accde<\/b>-Datenbank liegen. Woher ich das weiß Nun, das können Sie selbst herausfinden. öffnen Sie eine Datenbank, die eine verknüpfte Tabelle enthält. Starten Sie dann den Tabellenverknüpfungs-Manager (s. Bild 7).<\/p>\n Bild 7: Der Tabellenverknüpfungs-Manager ist ein Access-Formular.<\/span><\/b><\/p>\n Wenn Sie nun zum VBA-Editor wechseln und einen Blick auf den Projekt-Explorer werfen, stellen Sie fest, dass sich dem VBA-Projekt der aktuellen Datenbank noch ein weiteres hinzugesellt hat – nämlich das mit dem Formular, das den Assistenten darstellt (s. Bild 8).<\/p>\n Bild 8: Hinweis auf eine weitere Access-Datenbank<\/span><\/b><\/p>\n Dort findet sich eine ganze Reihe von Formular-Klassenmodulen, Standardmodulen und weiteren Klassenmodulen, die sich allerdings leider nicht öffnen lassen, da es sich um eine .mde<\/b>\/.accde<\/b>-Datenbank handelt.<\/p>\n Aber wo finden wir diese Datenbank Wenn Sie den Tabellenverknüpfungs-Manager wieder schließen, befindet sich das zusätzliche VBA-Projekt immer noch im Projekt-Explorer. Sie können es dann durch Anklicken aktivieren und im Direktbereich die folgende Anweisung absetzen:<\/p>\n Der Name hilft uns noch nicht weiter. Wir möchten den vollständigen Pfad kennen, den die Eigenschaft FileName <\/b>liefert:<\/p>\n Diese Datenbank können Sie nun öffnen und sich zumindest die Formulare ansehen, die sich öffnen lassen – nachdem Sie jeweils ein oder zwei Fehlermeldungen weggeklickt haben.<\/p>\n Pfad zur acwztool per Wizhook ermitteln<\/b><\/p>\n Die vorherige Ermittlung des Speicherortes ist etwas umständlich. Sie hätten das auch mit einer der Funktionen der Wizhook<\/b>-Klasse erledigen können. Dann würden Sie die folgenden beiden Anweisungen im Direktbereich absetzen:<\/p>\n Da die Datei bei den neueren Access-Versionen auf .accde <\/b>statt auf .mde <\/b>endet, geben wir gleich beide Varianten hintereinander aus.<\/p>\n Auf die gleiche Art können Sie auch noch auf die Speicherorte der übrigen Tool-Datenbanken von Access zugreifen, die Sie in Bild 9 finden.<\/p>\n Bild 9: Tool-Datenbanken von Access<\/span><\/b><\/p>\n Access-Benutzerverzeichnis ermitteln<\/b><\/p>\n Auf die gleiche Weise ermitteln Sie das Benutzerverzeichnis des aktuellen Benutzers. Das ist das Verzeichnis, in dem beispielsweise früher Arbeitsgruppendateien abgelegt wurden. Heute landen dort zum Beispiel Template-Dateien. Das Verzeichnis liefert der folgende Aufruf – vorheriges Einstellen der Key<\/b>-Eigenschaft nicht vergessen:<\/p>\n Auf ADP prüfen<\/b><\/p>\n Gerade wenn Sie Access-Add-Ins entwickeln, ist es manchmal hilfreich, die Art der Access-Datenbank zu kennen. Neben den herkömmlichen Access-Datenbanken gibt es ja auch noch die Access-Projekte (.adp<\/b>) zur direkten Anbindung an den SQL Server (allerdings von Microsoft abgekündigt). Die Funktion AdpUIDPwd <\/b>liefert den Wert True<\/b>, wenn es sich bei der Datenbank um eine .adp<\/b>-Datei handelt. Neben dieser Information können Sie damit auch noch den Namen und das Kennwort des aktuellen Benutzers abfragen, wenn Sie als Parameter zwei entsprechende Variablen übergeben und diese anschließend auslesen:<\/p>\n Add-In-Verzeichnis<\/b><\/p>\n Ebenfalls für Add-In-Entwickler ist die Kenntnis des Add-In-Verzeichnisses interessant – vor allem, da sich dieses je nach Access- und Windows-Version unterscheiden kann. Während der Entwickler dieses normalerweise noch selbst finden sollte, kann die folgende Funktion für den Einsatz eines Add-Ins beim Kunden gute Dienste leisten. Wenn dieser nämlich einmal eine Add-In-Datenbank manuell ersetzen soll, hat er normalerweise Mühe, das passende Verzeichnis zu finden. Mit dem folgenden Aufruf der Funktion OfficeAddInDir <\/b>findet er dieses im Nu:<\/p>\n Formular mit allen Funktionen<\/b><\/p>\n Alle VBA-Funktionen, die wir in diesem Beitrag vorgestellt haben, finden Sie im Formular frmAccessFunktionen<\/b> (s. Bild 10).<\/p>\n Bild 10: Funktionen in einem Formular in der übersicht<\/span><\/b><\/p>\n Die Felder werden durch die Prozedur gefüllt, die das Ereignis Beim Laden <\/b>des Formulars auslöst (s. Listing 1). Dabei reicht in der Regel die einfache Zuweisung des Funktionsergebnisses aus.<\/p>\n Listing 1: Anzeigen der Funktionen aus diesem Beitrag in einem Formular<\/span><\/b><\/p>\n Assistenten manipulieren<\/b><\/p>\n Wenn Sie schon wissen, dass es sich bei einigen Assisten von Access um reine Access-Formulare aus geschützten Datenbanken handelt, dann sollten Sie dies auch nutzen. Sie können diese nämlich manipulieren. Dies zeigen wir am Beispiel des Tabellenverknüpfungs-Managers. Hier soll beispielsweise direkt nach dem öffnen das Kontrollkästchen Immer zur Eingabe eines neuen Speicherorts auffordern <\/b>aktiviert sein.<\/p>\n Da es sich um ein herkömmliches Formular handelt, können wir über die Forms<\/b>-Auflistung auf das Formular und über dessen Controls<\/b>-Auflistung auch auf seine Steuerelemente und seine Eigenschaften zugreifen. Da sollte es kein Problem sein, ein Kontrollkästchen anzuhaken.<\/p>\n öffnen lässt sich der Dialog mit diesem VBA-Befehl:<\/p>\n Dummerweise wird das Formular aber als modaler Dialog geöffnet. Das bedeutet, dass eventuell nachfolgender Code in der gleichen Prozedur erst ausgeführt wird, wenn der Benutzer das Formular schon wieder geschlossen hat.<\/p>\n Aber auch das bekommen wir hin: Wir benutzen schlicht und einfach das Timer<\/b>-Ereignis, das wir wenige Millisekunden nach dem Anzeigen des Tabellenverknüpfungs-Managers ausführen lassen – dies geschieht unabhängig davon, ob die Prozedur, die das modale Formular geöffnet hat, gerade in Warteposition ist.<\/p>\n Dazu erstellen Sie ein neues Formular und statten es mit einer einzigen Schaltfläche aus (s. Bild 11). Diese stellt das TimerInterval <\/b>auf 100 Millisekunden ein und setzt außerdem eine Variable namens bolNot-Open <\/b>auf den Wert True<\/b>. Diese Variable deklarieren wir modulweit, also im Kopf des Klassenmoduls des Formulars:<\/p>\n Bild 11: Tabellenverknüpfungs-Manager manipuliert öffnen<\/span><\/b><\/p>\n Die Prozedur, die beim Anklicken der Schaltfläche im Formular ausgeführt wird, finden Sie in Listing 2. Fehlt noch die Timer<\/b>-Prozedur. Diese prüft zunächst, ob das Formular att_frmMain <\/b>überhaupt geöffnet ist. Falls ja, stellt Sie den Wert des Kontrollkästchens chkAlwaysPrompt <\/b>auf den Wert True <\/b>ein. Außerdem erhält die Variable bolNotOpen <\/b>den Wert True<\/b>. Dies sorgt dafür, dass der Teil der Prozedur, der das Kontrollkästchen einstellt, nur einmal ausgeführt wird. Der Benutzer könnte das Kontrollkästchen wohl wieder deaktivieren, aber es würde immer automatisch aktiviert werden (s. Listing 3).<\/p>\n Listing 2: öffnen des Tabellenverknüpfungs-Managers<\/span><\/b><\/p>\n Und woher wissen wir, wie das Kontrollkästchen heißt, das wir einstellen müssen Ganz einfach: Die Routine FormularAnalysieren<\/b>, die wir in der Prozedur Form_Timer <\/b>aufrufen, gibt alle Steuerelemente dieses Formulars im Direktbereich aus. Da die Steuerelemente nach gängigen Konventionen benannt sind, finden Sie relativ schnell den Namen des gewünschten Steuerelements in der Ausgabe im Direktbereich (s. Listing 4).<\/p>\n Listing 4: Auflisten aller Steuerelemente eines Formulars<\/span><\/b><\/p>\n Bildimport mit vorgegebenem Pfad starten<\/b><\/p>\n Wenn Sie einem Formular ein neues Bild hinzufügen, zeigt Access den Grafik einfügen<\/b>-Dialog aus Bild 12 an. Dieser offeriert in den seltensten Fällen gleich beim öffnen das Verzeichnis, das die gewünschten Bilder enthält. Aber das ist kein Problem: Sie können das Verzeichnis vorab einstellen. Dazu müssen Sie lediglich der Option Default Database Directory <\/b>das gewünschte Verzeichnis mit der Methode SetOption <\/b>zuweisen.<\/p>\n Bild 12: Grafik mit vorgegebenem Verzeichnis auswählen<\/span><\/b><\/p>\n Listing 5 zeigt, wie Sie zunächst das aktuell in dieser Option gespeicherte Verzeichnis in einer temporären Variablen namens strCurdirTemp <\/b>speichern. Dann ändern Sie das Verzeichnis auf das Verzeichnis der aktuellen Datenbank, das Sie mit der Eigenschaft Path <\/b>des Objekts CurrentProject <\/b>ermitteln. Der Befehl RunCommand acCmdInsertPicture<\/b> öffnet schließlich den gewünschten Dialog. Anschließend legen Sie wieder den vorherigen Wert für die Eigenschaft fest.<\/p>\nDebug.Print<\/span> SysCmd(acSysCmdAccessDir)\r\nC:\\Program Files (x86)\\Microsoft Office\\Office14\\<\/pre>\nDebug.Print<\/span> SysCmd(acSysCmdAccessVer)\r\n14.0<\/pre>\nDebug.Print<\/span> SysCmd( acSysCmdGetWorkgroupFile)\r\nC:\\Users\\Andre\\AppData\\Roaming\\Microsoft\\Access\\System.mdw<\/pre>\nDebug.Print<\/span> SysCmd(acSysCmdRuntime)\r\nFalsch<\/pre>\n\n
\"C:\\Program Files (x86)\\Microsoft Office\\Office14\\MSAccess.exe\" \r\n\"c:\\Daten\\Fachmagazine\\AccessImUnternehmen\\2013\\06\\\r\nAccessfunktionen\\Accessfunktionen.mdb\" \/Runtime<\/pre>\n
![\"Start](\"..\/fileadmin\/_temp_\/2013_06\/pic_909_001.png\")
<\/p>\n![\"Access](\"..\/fileadmin\/_temp_\/2013_06\/pic_909_002.png\")
<\/p>\n![\"MSAccess.exe](\"..\/fileadmin\/_temp_\/2013_06\/pic_909_003.png\")
<\/p>\n![\"Starten](\"..\/fileadmin\/_temp_\/2013_06\/pic_909_004.png\")
<\/p>\n![\"Benutzer](\"..\/fileadmin\/_temp_\/2013_06\/pic_909_005.png\")
<\/p>\nDebug.Print<\/span> CurrentDb.Name\r\nC:\\Daten\\Fachmagazine\\AccessImUnternehmen\\2013\\06\\Accessfunktionen\\Accessfunktionen.mdb<\/pre>\n Dir(CurrentDb.Name)\r\nAccessfunktionen.mdb<\/pre>\n
Left<\/span>(CurrentDb.Name,Len<\/span>(CurrentDb.Name)-Len<\/span>(Dir(CurrentDb.Name)))\r\nC:\\Daten\\Fachmagazine\\AccessImUnternehmen\\2013\\06\\Accessfunktionen\\<\/pre>\n CurrentProject.Path\r\nC:\\Daten\\Fachmagazine\\AccessImUnternehmen\\2013\\06\\Accessfunktionen<\/pre>\n
CurrentProject.Name\r\nAccessfunktionen.mdb<\/pre>\n
CurrentProject.FullName\r\nC:\\Daten\\Fachmagazine\\AccessImUnternehmen\\2013\\06\\Accessfunktionen\\Accessfunktionen.mdb<\/pre>\n
CurrentProject.Path & \"\\\" & CurrentProject.Name<\/pre>\n
![\"Das](\"..\/fileadmin\/_temp_\/2013_06\/pic_909_006.png\")
<\/p>\nWizHook.Key = 51488399<\/pre>\n
![\"Der](\"..\/fileadmin\/_temp_\/2013_06\/pic_909_008.png\")
<\/p>\n![\"Hinweis](\"..\/fileadmin\/_temp_\/2013_06\/pic_909_007.png\")
<\/p>\n VBE.ActiveVBProject.Name\r\nacwztool<\/pre>\n
VBE.ActiveVBProject.FileName\r\nC:\\PROGRAM FILES (X86)\\MICROSOFT OFFICE\\OFFICE14\\ACCWIZ\\ACWZTOOL.ACCDE<\/pre>\n
WizHook.Key = 51488399\r\nDebug.Print<\/span> WizHook. AccessWizFilePath(\"utility.mda\") _\r\n & WizHook.AccessWizFilePath (\"utility.accda\")\r\nC:\\Program Files (x86)\\Microsoft Office\\Office14\\ACCWIZ\\UTILITY.ACCDA<\/pre>\n![\"Tool-Datenbanken](\"..\/fileadmin\/_temp_\/2013_06\/pic_909_009.png\")
<\/p>\n WizHook.AccessUserDataDir\r\nC:\\Users\\Andre\\AppData\\Roaming\\Microsoft\\Access\\<\/pre>\n
Dim <\/span>strBenutzer As String<\/span>\r\nDim <\/span>strKennwort As String<\/span>\r\nDebug.Print<\/span> WizHook.AdpUIDPwd(strBenutzer, strKennwort)\r\nDebug.Print<\/span> strBenutzer\r\nDebug.Print<\/span> strKennwort<\/pre>\nWizHook.Key = 51488399\r\n WizHook.OfficeAddInDir\r\nC:\\Users\\Andre\\AppData\\Roaming\\Microsoft\\AddIns\\<\/pre>\n
![\"Funktionen](\"..\/fileadmin\/_temp_\/2013_06\/pic_909_010.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n Dim <\/span>strBenutzer As String<\/span>\r\n Dim <\/span>strKennwort As String<\/span>\r\n Me!txtMSAccessExe = SysCmd(acSysCmdAccessDir)\r\n Me!txtAccessversion = SysCmd(acSysCmdAccessVer)\r\n Me!txtArbeitsgruppeninformationsdatei = SysCmd(acSysCmdGetWorkgroupFile)\r\n Me!ctlRuntime = SysCmd(acSysCmdRuntime)\r\n Me!txtDateiname = CurrentProject.Name\r\n Me!txtVerzeichnis = CurrentProject.Path\r\n Me!txtPfad = CurrentDb.Name\r\n WizHook.Key = 51488399\r\n Me!txtUtility = WizHook.AccessWizFilePath(\"utility.mda\") _\r\n & WizHook.AccessWizFilePath(\"utility.accda\")\r\n Me!txtacwzlib = WizHook.AccessWizFilePath(\"acwzlib.mde\") _\r\n & WizHook.AccessWizFilePath(\"acwzlib.accde\")\r\n Me!txtacwzmain = WizHook.AccessWizFilePath(\"acwzmain.mde\") _\r\n & WizHook.AccessWizFilePath(\"acwzmain.accde\")\r\n Me!txtacwztool = WizHook.AccessWizFilePath(\"acwztool.mde\") _\r\n & WizHook.AccessWizFilePath(\"acwztool.accde\")\r\n Me!txtBenutzer = WizHook.AccessUserDataDir\r\n Me!chkADP = WizHook.AdpUIDPwd(strBenutzer, strKennwort)\r\n Me!txtUserADP = strBenutzer\r\n Me!txtPWDADP = strKennwort\r\n Me!txtAddInVerzeichnis = WizHook.OfficeAddInDir\r\nEnd Sub<\/span><\/pre>\nRunCommand acCmdLinkedTableManager<\/pre>\n
![\"Tabellenverknüpfungs-Manager](\"..\/fileadmin\/_temp_\/2013_06\/pic_909_011.png\")
<\/p>\nDim <\/span>bolNotOpen As Boolean<\/span><\/pre>\nPrivate Sub <\/span>cmdTabellenverknuepfungsmanagerOeffnen_Click()\r\n Me.TimerInterval = 100\r\n bolNotOpen = False<\/span>\r\n RunCommand acCmdLinkedTableManager\r\n Me.TimerInterval = 0\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>FormularAnalysieren(strFormular As String<\/span>)\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>ctl As <\/span>Control\r\n Set<\/span> frm = Forms(strFormular)\r\n For Each ctl In frm.Controls\r\n Debug.Print<\/span> ctl.Name\r\n Next<\/span> ctl\r\nEnd Sub<\/span><\/pre>\n![\"Grafik](\"..\/fileadmin\/_temp_\/2013_06\/pic_909_012.png\")
<\/p>\nPublic Sub <\/span>BildEinfuegen()\r\n Dim <\/span>strCurdirTemp As String<\/span>\r\n Dim <\/span>strOption As String<\/span>\r\n strOption = \"Default Database Directory\"\r\n strCurdirTemp = GetOption(strOption)\r\n SetOption strOption, CurrentProject.Path\r\n On Error Resume Next<\/span>\r\n RunCommand acCmdInsertPicture\r\n On Error GoTo<\/span> 0\r\n SetOption strOption, strCurdirTemp\r\n On Error Resume Next<\/span>\r\n RunCommand acCmdInsertPicture\r\n On Error GoTo<\/span> 0\r\nEnd Sub<\/span><\/pre>\n