<\/p>\n
Im Beitrag „Access-Add-In mit VSTO“ haben Sie erfahren, wie Sie aus einer der bestehenden Vorlagen für Outlook-, Word- oder Excel-Add-Ins ein Access-Add-In zaubern. In diesem Beitrag nun wollen wir uns ansehen, wie Sie von einem solchen Add-In auf die Objekte der Datenbank und auch auf die darin enthaltenen Daten zugreifen können. Damit erhalten Sie die Grundlage, viele interessante und praktische Add-Ins für Access zu bauen.<\/b><\/p>\n
Wenn Sie ein Add-In für eine Access-Anwendung programmieren, wollen Sie damit nicht irgendwelche Funktionen ausführen, sondern solche, welche die Funktionen von Access oder die Daten der aktuellen Datenbank nutzen. Dazu müssen Sie innerhalb des Visual Studio-Projekts auf die Access-Instanz zugreifen können, von der aus das Add-In gestartet wurde. Darüber können Sie dann die Daten der aktuell geladenen Datenbank lesen.<\/p>\n
Wie aber kommen wir an die Access-Instanz Das ist, im Vergleich zu früheren Vorgehensweisen in Zusammenhang mit COM-Add-Ins für Office-Anwendungen, wesentlich leichter geworden. Genau genommen stellt die Klasse ThisAddIn.Designer.vb <\/b>dieses Objekt über die Variable Application <\/b>zur Verfügung (s. Bild 1). Weiter unten finden Sie dann in der gleichen Klasse die Methode Initialize, welche die Application-Eigenschaft mit einem Verweis auf die als Host verwendete Datei füllt.<\/p>\n
![\"Variable](\"..\/fileadmin\/_temp_\/2017_04\/pic_1094_001_.png\")
<\/p>\n
Bild 1: Variable zur Bereitstellung des Application-Objekts<\/span><\/b><\/p>\n Dies ist der Hintergrund, für uns ist aber vielmehr wichtig, dass wir über Application <\/b>jederzeit die als Host dienende Access-Anwendung referenzieren können. Dies schauen wir uns an einem einfachen Beispiel an, wobei wir das im Beitrag Access-Add-In mit VSTO <\/b>(www.access-im-unternehmen.de\/1092<\/b>) erstellte Visual Basic-Add-In als Grundlage verwenden, das Sie auch im Download zum vorliegenden Beitrag finden.<\/p>\n Hier fügen wir der Methode ThisAddIn_Startup <\/b>im Klassenmodul ThisAddIn.vb <\/b>einfach eine Anweisung hinzu, welche den Namen der mit dem Application<\/b>-Objekt gelieferten Anwendung liefert:<\/p>\n Dies zeigt beim öffnen von Access nach dem Starten des Add-Ins (und später auch beim öffnen ohne vorheriges Starten des Add-Ins, das ja dann weiterhin über die Registry aufgerufen wird) eine Meldung mit dem Namen Microsoft Access <\/b>an. Wer früher einmal COM-Add-Ins für Access programmiert hat, weiß, dass damit mehr benutzerdefinierter Aufwand verbunden war.<\/p>\n Etwas komplizierter wird es, wenn Sie vom Add-In aus die geöffnete Datenbank referenzieren möchten. Das Problem dabei ist, dass das Add-In ja bereits beim Starten von Access geladen wird und über die Objektvariable Application <\/b>verfügbar ist. Zu diesem Zeitpunkt ist aber noch keine Access-Datenbank in Access geöffnet. Dies geschieht erst später. Wir müssen also einen Weg finden, um zu erkennen, wann Access eine Datenbankdatei öffnet, und diese dann referenzieren. Wir probieren zuerst einmal aus, was geschieht, wenn wir die Methode ThisAddIn_Startup <\/b>wie folgt ausstatten:<\/p>\n Damit das MessageBox<\/b>-Objekt verfügbar ist, fügen Sie noch den folgenden Verweis auf den Namespace System.Windows.Forms <\/b>hinzu:<\/p>\n Die Prozedur prüft nun mit CurrentDb Is Nothing<\/b>, ob es eine aktuelle Datenbankdatei gibt, und liefert eine entsprechende Meldung. Das Ergebnis: Wenn man Access ohne Datenbank öffnet, hat CurrentDb <\/b>den Wert Nothing<\/b>, wenn man es direkt mit einer Datenbank startet, enthält CurrentDb <\/b>einen Verweis auf die geladene Datenbank. Dann gibt die MessageBox.Show<\/b>-Methode den Pfad zur geladenen Datenbank aus. Wenn wir allerdings Access starten und erst dann eine Datenbank öffnen, erkennt das Add-In zwar beim Starten von Access, dass noch keine Datenbank geöffnet ist, aber wenn wir dann nachträglich eine Datenbank öffnen, löst dies kein Ereignis mehr aus, aufgrund dessen wir erkennen könnten, dass eine Datenbank geöffnet wurde.<\/p>\n Warum aber müssen wir so genau wissen, ob gerade eine Datenbank geladen ist oder nicht Ganz einfach: Wir wollen ja beispielsweise über das Ribbon Funktionen anbieten, mit denen der Benutzer auf die Objekte oder Daten der aktuellen Datenbank zugreifen kann. Wir könnten zwar einfach beim Betätigen der entsprechenden Elemente prüfen, ob aktuell eine Datenbank geöffnet ist, und gegebenenfalls eine Meldung ausgeben, dass die Funktion nur bei geöffneter Datenbank zur Verfügung steht. Aber schicker wäre es natürlich, wenn solche Schaltflächen deaktiviert sind, wenn die Funktionen nicht zur Verfügung stehen.<\/p>\n Wir wollen nun einen Timer zum Add-In hinzufügen, der in jeder Sekunde einmal prüft, ob eine Datenbank geöffnet ist. Wenn eine Datenbank geöffnet ist, soll ein Meldungsfenster erscheinen und den Pfad zur geöffneten Datenbank anzeigen. Dazu fügen wir der Klasse ThisAddIn.vb <\/b>folgenden Verweis auf den Namespace SystemThreading.Tasks <\/b>hinzu:<\/p>\n Wir benötigen eine Boolean<\/b>-Variable namens Loaded<\/b>, welche den Zustand speichert, ob eine Datenbank geladen ist oder nicht:<\/p>\n Schließlich erweitern wir die Methode ThisAddIn_Startup <\/b>so, dass diese einen Timer auf Basis der gleichnamigen Klasse erstellt, der alle 1.000 Millisekunden aufgerufen werden soll. Für diese Klasse legen wir einen Handler an, der durch das Ereignis Elapsed <\/b>des Timers ausgelöst wird und die Methode HandleTimer <\/b>aufruft. Dann starten wir den Timer mit der Start<\/b>-Methode:<\/p>\n Die als Ereignishandler festgelegte Prozedur HandleTimer <\/b>sieht wie in Listing 1 aus. Für VBA-erprobte Entwickler sieht der Aufbau etwas gewöhnungsbedürftig aus. Es handelt sich dabei um eine sogenannte asynchron laufende Methode, die mehrfach aufgerufen werden kann, auch wenn die aktuelle Instanz noch nicht abgearbeitet ist. So können wir die Methode tatsächlich jede Sekunde aufrufen, auch wenn der Benutzer noch nicht die durch den vorherigen Aufruf angezeigte MessageBox <\/b>geschlossen hat. Das kann dann schnell unübersichtlich werden, wenn man nicht sauber codiert hat und plötzlich eine MessageBox nach der anderen auf dem Bildschirm erscheint. Für den Fall, dass Ihnen das einmal geschieht, können Sie schnell zu Visual Studio wechseln und dort Umschalt + F5 <\/b>klicken – dann ist der Spuk vorbei. Falls Sie das Add-In gerade nicht im Kontext des Debuggens von Visual Studio aus gestartet haben, müssen Sie wohl den Task-Manager bemühen.<\/p>\n Listing 1: Ereignisprozedur, die nach Ablauf des Timers ausgelöst wird<\/span><\/b><\/p>\n Nun zu der Methode: Sie enthält innerhalb der Anweisung Await Task.Run <\/b>eine weitere Methode, die bei jedem Aufruf ausgeführt wird. Diese Methode prüft, ob eine Datenbank geladen ist (Application.CurrentDb Is Nothing<\/b>). Ist das nicht der Fall, prüft sie den Wert der Variablen Loaded <\/b>und stellt diesen im Falle des Wertes True <\/b>auf False <\/b>ein. Beim öffnen von Access ohne Datenbank geschieht also nichts weiter – CurrentDb <\/b>ist Nothing <\/b>und Loaded <\/b>hat den Wert False<\/b>.<\/p>\n Interessant wird es, wenn eine Datenbank geöffnet wird. Dann ist CurrentDb <\/b>nicht mehr Nothing <\/b>und der Else<\/b>-Teil der äußeren If…Then<\/b>-Bedingung wird aufgerufen. Loaded <\/b>hat bis dahin den Wert False <\/b>und wird auf True <\/b>eingestellt. Außerdem gibt die Methode als Zeichen, dass sie erkannt hat, dass eine Datenbank geladen wurde, den Namen der Datenbank per MessageBox aus. Beim nächsten Durchgang wird dann, weil CurrentDb <\/b>nicht Nothing <\/b>ist, wieder der Else<\/b>-Teil der äußeren Bedingung angesteuert. Diesmal hat Loaded <\/b>aber den Wert False<\/b>, weshalb die MessageBox <\/b>nicht erneut angezeigt wird.<\/p>\n Was machen wir nun mit dieser Methode, die nach dem öffnen einer Datenbank eine MessageBox anzeigt Wir können zum Beispiel statt des öffnens der MessageBox Code ausführen, der dafür sorgt, dass die gewünschten Ribbon-Elemente, die wir für die Bearbeitung der Datenbank hinzufügen, aktiviert oder deaktiviert werden. Das schauen wir uns einmal an einer einzelnen Ribbon-Schaltfläche an.<\/p>\n Um eine Ribbon-Definition hinzuzufügen, die alle Elemente des Access-Ribbons abbilden kann, können wir leider nicht das Element Menüband (Visueller Designer) <\/b>des Dialogs Neues Element hinzufügen <\/b>nutzen, das wir mit dem Kontextmenü-Befehl Hinzufügen|Neues Element… <\/b>des Projekt-Elements im Projektmappen-Explorer öffnen. Stattdessen fügen wir das Element Menüband (XML) <\/b>hinzu, für das wir den Namen Ribbon_Access.vb <\/b>festlegen (s. Bild 2).<\/p>\n Bild 2: Anlegen des Elements Menüband (XML)<\/span><\/b><\/p>\n Aus der damit hinzugefügten Datei Ribbon_Access.vb <\/b>kopieren wir die dort noch auskommentierte Methode CreateRibbonExtensibilityObject <\/b>in das Klassenmodul ThisAddIn.vb <\/b>und entfernen die Kommentarzeichen:<\/p>\n Diese Methode wird beim Starten des Add-Ins automatisch ausgeführt. Einzelheiten zum Erstellen eines Ribbons über das Element Menüband (XML) <\/b>finden Sie im Beitrag COM-Add-In-Ribbons mit dem XML-Designer <\/b>(www.access-im-unternehmen.de\/1093<\/b>).<\/p>\n Unser Add-In soll nun sowohl eine Funktion enthalten, die sich auf die Anwendung selbst bezieht, als auch eine, welche auf die Daten einer geladenen Datenbank zugreift. Auf diese Weise erhalten Sie eine gute Ausgangsposition für selbst programmierte Add-Ins.<\/p>\n Die geplanten Funktionen sind in dem Ribbon-Tab aus Bild 3 abgebildet. Die linke Gruppe enthält zwei Schaltflächen, mit denen der Benutzer den Navigationsbereich ein- und ausblenden kann. Die rechte Gruppe enthält eine Schaltfläche, welche einen Dialog zur Anzeige aller Tabellen der aktuell geöffneten Datenbank liefern soll. Diese Schaltfläche soll natürlich nur aktiviert sein, wenn Access überhaupt eine Datenbank geladen hat.<\/p>\n Bild 3: Unsere selbst erstellten Ribbon-Befehle<\/span><\/b><\/p>\n Die Definition des Ribbons sieht wie in Listing 2 aus. Die erste Gruppe enthält die Schaltflächen btnNavigationsbereichEinblenden <\/b>und btnNavigationsbereichAusblenden<\/b>. Beide sind mit einer onAction<\/b>-Callback-Eigenschaft und einem Bild ausgestattet. Die Bilder werden mit der image<\/b>-Eigenschaft angegeben. Für das Laden der Bilder ist die im Element customUI <\/b>im Attribut loadImage<\/b> angegebene Methode verantwortlich (mehr zum Laden von Bildern im Beitrag COM-Add-In-Ribbons mit dem XML-Designer<\/b>, www.access-im-unternehmen.de\/1093<\/b>). Die zweite Gruppe enthält die Schaltfläche btnTabellen<\/b>, die ebenfalls eine onAction<\/b>-Eigenschaft sowie zusätzlich die Callback-Eigenschaft getEnabled <\/b>enthält.<\/p>\n Listing 2: Definition des Beispielribbons<\/span><\/b><\/p>\n Diese Schaltfläche soll ja nur aktiviert sein, wenn Access gerade eine geladene Datenbank enthält. Wie wir dies ermitteln, haben Sie weiter oben erfahren – wir starten per Timer jede Sekunde eine Prozedur, die prüft, ob CurrentDb <\/b>den Wert Nothing <\/b>hat. Wie können wir diese nun nutzen, um die Schaltfläche btnTabellen <\/b>abhängig vom Ergebnis zu aktivieren oder zu deaktivieren Zusammengefasst gehen wir so vor: Wir fügen der Klasse Ribbon_Access.vb <\/b>eine Eigenschaft hinzu, welche den Zustand erfasst (Datenbank geladen\/nicht geladen). Diese wird von der Callback-Funktion getEnabled <\/b>ausgewertet. Noch dazu machen wir in der Klasse Ribbon_Access.vb<\/b> aus dem IRibbonUI<\/b>-Objekt Ribbon <\/b>eine Eigenschaft gleichen Namens, auf die wir von außen zugreifen können. Damit können wir dann der Klasse Ribbon_Access.vb <\/b>von außen sowohl den Zustand Datenbank geladen\/nicht geladen mitgeben als auch dafür sorgen, dass die Methode get-Enabled <\/b>ausgelöst wird – nämlich durch Aufrufen der Invalidate<\/b>-Methode des IRibbonUI<\/b>-Objekts. Damit wir von der Klasse This-AddIn <\/b>allerdings überhaupt auf das IRibbonUI<\/b>-Objekt zugreifen können, müssen wir dieses noch irgendwie innerhalb dieser Klasse referenzieren. Unter Visual Basic 2015 wäre es sogar möglich, dafür ein Modul mit einer öffentlichen Variablen anzulegen, aber diesen Weg wollen wir hier gezielt nicht gehen. Schauen wir uns den resultierenden Code an!<\/p>\n <\/p>\n Die Klasse ThisAddIn.vb <\/b>enthält zwei automatisch ausgelöste Methoden, nämlich CreateRibbonExtensibility <\/b>und ThisAddIn_Startup <\/b>– und zwar in dieser Reihenfolge. Wir deklarieren eine Variable des Typs Ribbon_Access<\/b>, mit der wir die in CreateRibbonExtensibility <\/b>erzeugte und als Funktionswert zurückgegebene Instanz der Klasse Ribbon_Access.vb <\/b>speichern:<\/p>\n Der Funktion CreateRibbonExtensibility <\/b>fügen wir dann eine Anweisung hinzu, welche die neu erzeugte Instanz von Ribbon_Access <\/b>in der Variablen objRibbon <\/b>speichert. Der Inhalt dieser Variablen wird dann als Funktionswert zurückgegeben:<\/p>\n Der in objRibbon <\/b>gespeicherten Instanz der Klasse Ribbon_Access.vb <\/b>wollen wir auch einen Verweis auf die Access-Anwendung, also Application<\/b>, übergeben. Das hat den Hintergrund, dass wir darin auch auf die Methoden von Access zugreifen wollen. Daher fügen wir in der Methode ThisAddIn_Startup<\/b>, die ja nach dem Erstellen von Ribbon_Access <\/b>ausgelöst wird, noch eine Zeile hinzu, welche die Eigenschaft Application <\/b>der Klasse Ribbon_Access.vb <\/b>mit dem Verweis aus der Objektvariablen Application <\/b>füllt:<\/p>\n Unsere weiter oben vorgestellte Timer<\/b>-Methode HandleTimer <\/b>ist auch von den änderungen betroffen. In dem If<\/b>-Zweig, in dem wir feststellen, dass keine Datenbank geladen ist, stellen wir die Eigenschaft DatenbankGeladen <\/b>der in objRibbon <\/b>gespeicherten Instanz der Klasse Ribbon_Access <\/b>auf False <\/b>ein. Danach rufen wir die Invalidate<\/b>-Methode der ribbon<\/b>-Eigenschaft von objRibbon <\/b>auf:<\/p>\n Im Else<\/b>-Teil dann, wo die Datenbank geladen ist, stellen wir DatenbankGeladen <\/b>auf True <\/b>ein und rufen wieder die Invalidate<\/b>-Methode auf:<\/p>\n Das Ganze verlangt natürlich nun nach der Erläuterung der änderungen in der Klasse Ribbon_Access<\/b>. Hier brauchen wir erstmal den Namespace für Access:<\/p>\n Dann benötigen wir statt Private Ribbon As Office.IRib-bon-UI <\/b>eine private Variable des Typs IRibbonUI<\/b>, die wir per Property <\/b>nach außen schreib- und lesbar machen:<\/p>\n Das gleiche Konstrukt legen wir für die Boolean-Variable an, die den Zustand beschreibt, ob eine Datenbank geladen ist:<\/p>\n Und schließlich noch eine Property für das Access.Application<\/b>-Objekt:<\/p>\n Wegen des geänderten Variablennamens für die Variable des Typs IRibbonUI <\/b>müssen wir die Methode Ribbon_Load <\/b>ändern:<\/p>\n Die Methode GetEnabled <\/b>schließlich aktiviert oder deaktiviert die Schaltfläche btnTabellen <\/b>in Abhängigkeit vom Wert der privaten Variablen _datenbankGeladen<\/b>:<\/p>\n Damit kommen wir zur Implementierung der Ereignisse, die beim Anklicken der einzelnen Ribbon-Elemente ausgelöst werden. Diese finden wir in der onAction<\/b>-Prozedur, die wie in Listing 3 aussieht.<\/p>\n Listing 3: Durch die Schaltflächen ausgelöste Funktionen<\/span><\/b><\/p>\n Diese Prozedur prüft wieder, von welcher Schaltfläche sie ausgelöst wurde. Im Falle von btnNavigationsbereichEinblenden <\/b>verwendet sie die über die Eigenschaft Application <\/b>der Klasse Ribbon_Access <\/b>übergebene Referenz auf die als Host dienende Access-Anwendung. Diese ist in der lokalen Variablen _application <\/b>gespeichert. über dieses Element können wir auf all die eingebauten Objekte von Access zugreifen, also zum Beispiel das DoCmd<\/b>-Objekt.<\/p>\n Dieses bietet die Methode SelectObject <\/b>an, mit der wir den Navigationsbereich einblenden. Dieser Methode übergeben wir als ersten Parameter den Typ des zu selektierenden Objekts (eine Tabelle) und als zweiten den Namen dieser Tabelle, wobei wir hier keine Tabelle explizit selektieren wollen und somit vbNullString <\/b>übergeben, was letztendlich den Navigationsbereich einblendet, ohne überhaupt ein Objekt zu selektieren – dies alles in Ermangelung einer einfachen Methode, um den Navigationsbereich direkt einzublenden.<\/p>\n Sollte der Benutzer hingegen die Schaltfläche btnNavigationsbereichAusblenden <\/b>angeklickt haben, führt onAction <\/b>gleich zwei Anweisungen aus. Die erste selektiert genau wie bei btnNavigationsbereichEinblenden <\/b>den Navigationsbereich. Die zweite ruft die Methode RunCommand <\/b>auf und übergibt dieser den Wert acCmdWindowHide <\/b>als Parameter. Dadurch wird das aktuell markierte Objekt, in diesem Fall der Navigationsbereich, als versteckt markiert. Wie Bild 4 zeigt, mit gutem Erfolg!<\/p>\n Bild 4: Schaltfläche zum Ausblenden des Navigationsbereichs<\/span><\/b><\/p>\n Damit kommen wir zum abschließenden Beispiel, in dem wir einen Dialog öffnen wollen, der auf die Daten der aktuellen Datenbank zugreift. Das wollen wir in diesem Fall auf einfache Weise tun, also etwa ohne vorherige Auswahl der anzuzeigenden Tabelle. Wir wählen daher die Tabelle MSysObjects <\/b>aus und wollen die Namen aller Tabellen, die in dieser Tabelle aufgelistet werden, in einem Listenfeld anzeigen. Ein Doppelklick auf einen der Einträge soll dann die entsprechende Tabelle öffnen.<\/p>\n Dazu brauchen wir natürlich erstmal ein Benutzeroberflächen-Element in der Art eines Formulars. Der Dialog Neues Element hinzufügen <\/b>bietet dazu allein das Element Windows Form <\/b>an. Ich arbeite aber grundsätzlich mit WPF. Für WPF steht allerdings nur ein Element namens Benutzersteuerelement (WPF) <\/b>zur Verfügung. Dieses können wir jedoch leicht in ein Element des Typs Private Sub <\/span>ThisAddIn_Startup() Handles Me.Startup\r\n MessageBox.Show(\"Application.Name: \" + Application.Name)\r\nEnd Sub<\/span><\/pre>\nGeöffnete Datenbank referenzieren<\/h2>\n
Private Sub <\/span>ThisAddIn_Startup() Handles Me.Startup\r\n If <\/span>Application.CurrentDb Is Nothing Then<\/span>\r\n MessageBox.Show(\"DB ist nicht geladen.\")\r\n Else<\/span>\r\n MessageBox.Show(\"DB: \" + Application.CurrentDb.Name)\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nImports System.Windows.Forms<\/pre>\n
Timer mit Datenbankerkennung<\/h2>\n
Imports System.Threading.Tasks<\/pre>\n
Private <\/span>Loaded As Boolean<\/span><\/pre>\nPrivate Sub <\/span>ThisAddIn_Startup() Handles Me.Startup\r\n Dim <\/span>timer As <\/span>System.Timers.Timer\r\n timer = New<\/span> System.Timers.Timer(1000)\r\n AddHandler timer.Elapsed, AddressOf HandleTimer\r\n With<\/span> timer\r\n .Start()\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>Async Sub HandleTimer(sender As Object<\/span>, e As <\/span>EventArgs)\r\n Await Task.Run(\r\n Sub()\r\n If <\/span>Application.CurrentDb Is Nothing Then<\/span>\r\n If <\/span>Loaded = True<\/span> Then<\/span>\r\n Loaded = False<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n If <\/span>Loaded = False<\/span> Then<\/span>\r\n Loaded = True<\/span>\r\n MessageBox.Show(\"Geladen: \" + Application.CurrentDb.Name + \" \" + Loaded.ToString())\r\n End If<\/span>\r\n End If<\/span>\r\n End Sub\r\n )\r\nEnd Sub<\/span><\/pre>\nRibbon hinzufügen<\/h2>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2017_04\/pic_1094_002.png\")
<\/p>\nProtected Overrides Function _\r\n CreateRibbonExtensibilityObject() _\r\n As <\/span>Microsoft.Office.Core.IRibbonExtensibility\r\n Return New<\/span> Ribbon_Access()\r\nEnd Function<\/span><\/pre>\nFunktionen hinzufügen<\/h2>\n
![\"Unsere](\"..\/fileadmin\/_temp_\/2017_04\/pic_1094_003.png\")
<\/p>\n<xml version=\"1.0\" encoding=\"UTF-8\">\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\" onLoad=\"Ribbon_Load\" loadImage=\"loadImage\">\r\n <ribbon>\r\n <tabs>\r\n <tab id=\"tabAddIn\" label=\"COM-Add-In\">\r\n <group id=\"grpAnwendung\" label=\"Anwendung\">\r\n <button id=\"btnNavigationsbereichEinblenden\" label=\"Navigationsbereich einblenden\" onAction=\"onAction\"\r\n image=\"window_sidebar\" size=\"large\"\/>\r\n <button id=\"btnNavigationsbereichAusblenden\" label=\"Navigationsbereich ausblenden\" onAction=\"onAction\" \r\n image=\"window_sidebar_delete\" size=\"large\"\/>\r\n <\/group>\r\n <group id=\"grpDatenbank\" label=\"Datenbank\">\r\n <button id=\"btnTabellen\" label=\"Tabellen anzeigen\" onAction=\"onAction\" image=\"tables\" size=\"large\" \r\n getEnabled=\"getEnabled\"\/>\r\n <\/group>\r\n <\/tab>\r\n <\/tabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n
Aktivieren und deaktivieren der Schaltfläche btnTabellen<\/h2>\n
Ribbon in ThisAddIn.vb referenzieren<\/h2>\n
Private <\/span>objRibbon As <\/span>Ribbon_Access<\/pre>\nProtected Overrides Function _\r\n CreateRibbonExtensibilityObject() _\r\n As <\/span>Microsoft.Office.Core.IRibbonExtensibility\r\n objRibbon = New<\/span> Ribbon_Access()\r\n Return objRibbon\r\nEnd Function<\/span><\/pre>\nPrivate Sub <\/span>ThisAddIn_Startup() Handles Me.Startup\r\n Dim <\/span>timer As <\/span>System.Timers.Timer\r\n objRibbon.Application = Application\r\n timer = New<\/span> System.Timers.Timer(1000)\r\n AddHandler timer.Elapsed, AddressOf HandleTimer\r\n With<\/span> timer\r\n .Start()\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>Async Sub HandleTimer(sender As Object<\/span>, _\r\n e As <\/span>EventArgs)\r\n Await Task.Run(\r\n Sub()\r\n If <\/span>Application.CurrentDb Is Nothing Then<\/span>\r\n If <\/span>Loaded = True<\/span> Then<\/span>\r\n Loaded = False<\/span>\r\n objRibbon.DatenbankGeladen = False<\/span>\r\n objRibbon.ribbon.Invalidate()\r\n End If<\/span>\r\n ...<\/pre>\n ...\r\n Else<\/span>\r\n If <\/span>Loaded = False<\/span> Then<\/span>\r\n Loaded = True<\/span>\r\n objRibbon.DatenbankGeladen = True<\/span>\r\n objRibbon.ribbon.Invalidate()\r\n End If<\/span>\r\n End If<\/span>\r\n End Sub\r\n )\r\nEnd Sub<\/span><\/pre>\nImports Access = Microsoft.Office.Interop.Access<\/pre>\n
Private <\/span>_ribbon As <\/span>Office.IRibbonUI\r\nPublic Property <\/span>Ribbon As <\/span>Office.IRibbonUI\r\n Get\r\n Return _ribbon\r\n End Get\r\n Set(value As <\/span>Office.IRibbonUI)\r\n _ribbon = value\r\n End Set<\/span>\r\nEnd Property<\/span><\/pre>\nPrivate <\/span>_datenbankGeladen As Boolean<\/span>\r\nPublic Property <\/span>DatenbankGeladen() As Boolean<\/span>\r\n Get\r\n Return _DatenbankGeladen\r\n End Get\r\n Set(value As Boolean<\/span>)\r\n _DatenbankGeladen = value\r\n End Set<\/span>\r\nEnd Property<\/span><\/pre>\nPrivate <\/span>_application As <\/span>Access.Application\r\nPublic Property <\/span>Application As <\/span>Access.Application\r\n Get\r\n Return _application\r\n End Get\r\n Set(value As <\/span>Access.Application)\r\n _application = value\r\n End Set<\/span>\r\nEnd Property<\/span><\/pre>\nPublic Sub <\/span>Ribbon_Load(ByVal ribbonUI As <\/span>Office.IRibbonUI)\r\n _ribbon = ribbonUI\r\nEnd Sub<\/span><\/pre>\nFunction <\/span>GetEnabled(control As <\/span>Office.IRibbonControl) _\r\n As Boolean<\/span>\r\n Select Case control.Id\r\n Case <\/span>\"btnTabellen\"\r\n GetEnabled = _datenbankGeladen\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\nFunktionen des Add-Ins<\/h2>\n
Public Sub <\/span>onAction(ctl As <\/span>Office.IRibbonControl)\r\n Dim <\/span>objWindow As <\/span>Tabellenauswahl\r\n Select Case ctl.Id\r\n Case <\/span>\"btnAnwendungsbefehl\"\r\n Ribbon.Invalidate()\r\n Case <\/span>\"btnNavigationsbereichEinblenden\"\r\n _application.DoCmd.SelectObject(Access.AcObjectType.acTable, vbNullString, True<\/span>)\r\n Case <\/span>\"btnNavigationsbereichAusblenden\"\r\n _application.DoCmd.SelectObject(Access.AcObjectType.acTable, vbNullString, True<\/span>)\r\n _application.DoCmd.RunCommand(Access.AcCommand.acCmdWindowHide)\r\n Case <\/span>\"btnTabellen\"\r\n \/\/objWindow = New<\/span> UserControl1(_application) ... werden später erläutert!\r\n \/\/objWindow.Show()\r\n \/\/objWindow.Topmost = True<\/span>\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Schaltfläche](\"..\/fileadmin\/_temp_\/2017_04\/pic_1094_004.png\")
<\/p>\nDatenzugriff per Add-In<\/h2>\n