![\"Erstellen](\"..\/fileadmin\/_temp_\/2021_05\/pic_1327_001.png\")
<\/p>\nEs gibt einige Access-Optionen, die man immer wieder nutzt. In meinem Fall ist es zum Beispiel die Einstellung, ob Formulare nun als überlappende Fenster oder als Dokumente im Registerkartenformat angezeigt werden sollen. Sicher haben Sie ähnliche Einstellungen, die Sie oft ändern oder die Sie vielleicht einfach nur schnell einsehen möchten – was bei dem mittlerweile recht umfangreich gewordenen Optionen-Dialog schon einige Sekunden kosten kann. Warum also nicht ein COM-Add-In bauen, das die Informationen der wichtigsten Access-Einstellungen immer direkt im Ribbon anzeigt – anstatt irgendwo versteckt im Optionen-Dialog Und da wir mit twinBASIC auch noch ein praktisches Tool zum Erstellen von COM-Add-Ins zur Hand haben, können wir direkt loslegen!<\/b><\/p>\nVoraussetzung: Visual Studio Code und twinBASIC<\/h2>\n
Wenn Sie dauerhafte Ergänzungen oder Änderungen am Ribbon vornehmen wollen, benötigen Sie ein COM-Add-In. Eine andere Möglichkeit gibt es nur, wenn Sie mit den eingebauten Funktionen zum Anpassen der Benutzeroberfläche arbeiten wollen – und die sind bei Weitem nicht ausreichend.<\/p>\n
Ein COM-Add-In konnten Sie früher mit Visual Studio 6 bauen, heutzutage mit Visual Studio .NET. Das ist allerdings nicht besonders komfortabel und erfordert umfangreichere Softwarevoraussetzungen als Visual Studio 6 gebaute COM-Add-Ins. Seit kurzem gibt es allerdings eine Erweiterung namens twinBASIC für Visual Studio Code, mit der Sie zum Beispiel COM-Add-Ins für Access und den VBA-Editor programmieren können. Wie das geht, haben wir bereits in den Beiträgen twinBASIC – VB\/VBA mit moderner Umgebung <\/b>(www.access-im-unternehmen.de\/1303<\/b>), twinBASIC – COM-Add-Ins für Access <\/b>(www.access-im-unternehmen.de\/1306<\/b>) und anderen erläutert.<\/p>\n
Im erstgenannten Beitrag erfahren Sie alles über die Installation, in letzterem die Grundlagen für das Erstellen von COM-Add-Ins. Details zu diesen Themen finden Sie in den genannten Beiträgen.<\/p>\n
Um ein neues COM-Add-In anzulegen, klicken Sie in Visual Studio Code links auf das twinBASIC-Symbol. Es erscheint eine Liste mit Projektvorlagen, wo Sie die Vorlage Sample 5 MyCOMAddin <\/b>auswählen (siehe Bild 1).<\/p>\n
<\/p>\n
Bild 1: Erstellen eines neuen COM-Add-Ins<\/span><\/b><\/p>\n Anschließend erscheint ein Dialog, in dem Sie die anzulegende Datei samt Verzeichnis auswählen. Hier geben wir amvAccessOptionsGoRibbon.twinproj <\/b>an.<\/p>\n Dies fügt einige Dateien zum gewählten Verzeichnis hinzu, von denen die folgenden für uns interessant sind:<\/p>\n Das Projekt wird allerdings auch direkt in Visual Studio Code angezeigt.<\/p>\n Mit der Vorlage erhalten Sie bereits fast alles, was Sie benötigen:<\/p>\n Dementsprechend brauchen Sie nur zwei Schritte zu erledigen, damit das COM-Add-In läuft:<\/p>\n Bild 2: COM-Add-In kompilieren<\/span><\/b><\/p>\n Wenn Sie nun eine Access-Datenbank öffnen, erscheint ein neuer Eintrag namens twinBASIC Test <\/b>im Ribbon mit einer eigenen Schaltfläche (siehe Bild 3).<\/p>\n Bild 3: Das COM-Add-In ist nach wenigen Mausklicks einsatzbereit<\/span><\/b><\/p>\n Im Gegensatz zu dem COM-Add-In, das wir wie im Beitrag twinBASIC – COM-Add-Ins für Access <\/b>erstellt haben, kann twinBASIC nun auch benutzerdefinierte Icons anzeigen. Wie Sie diese hinzufügen und über entsprechende Callback-Funktionen aufrufen, zeigen wir im Beitrag Benutzerdefinierte Bilder in twinBASIC <\/b>(www.access-im-unternehmen.de\/1325<\/b>).<\/p>\n Da wir wissen, dass wir das COM-Add-In mit Access einsetzen wollen, können wir eine Objektvariable speziell zum Aufnehmen der aktuellen Access-Instanz deklarieren:<\/p>\n Außerdem weisen wir diese in der Prozedur OnConnection <\/b>wie folgt gezielt zu:<\/p>\n Hier tragen wir den mit dem Parameter Application <\/b>übergebenen Verweis auf die aktuelle Access-Instanz in die Variable objAccess <\/b>ein.<\/p>\n Um Optionen mit dem Ribbon einzustellen, benötigen wir mehr als nur ein paar Schaltflächen. Immerhin wollen wir ja vor dem Ändern einer Option auch wissen, wie ihr aktueller Wert lautet! Also benötigen wir Steuerelemente wie Kontrollkästchen, Textfelder et cetera.<\/p>\n Da wir diese dynamisch einlesen und auch anpassen wollen, stellen wir ihre Werte zu Beginn mit entsprechenden Callback-Funktionen ein. Später ändern wir diese dann über das Ribbon und sorgen dafür, dass die Änderungen sich auch in den entsprechenden Access-Optionen niederschlagen.<\/p>\n Wir beginnen mit einer ersten Option, um uns den Ablauf anzusehen. Dies soll der Titel der Access-Anwendung sein. Der Vorteil gegenüber einigen anderen Optionen ist, dass wir Änderungen direkt in der Titelleiste angezeigt bekommen – im Gegensatz zu vielen anderen Optionen, die sich erst beim erneuten Öffnen der Datenbankanwendung zeigen.<\/p>\n Also fügen wir der Ribbon-Definition ein Textfeld hinzu. Danach sieht Prozedur GetCustomUI <\/b>zur Definition des Ribbons wie in Listing 1 aus. Hier finden wir statt der bisher vorhandenen Schaltfläche ein editBox<\/b>-Element. Für dieses haben wir die Eigenschaft label <\/b>auf Datenbanktitel <\/b>und maxLength <\/b>auf 255 <\/b>eingestellt. Letztere sorgt dafür, dass der Titel die maximale Zeichenzahl von 255 <\/b>nicht überschreitet. Damit die editBox<\/b>-Steuerelemente breit genug dargestellt werden, setzen wir außerdem das Attribut sizeString <\/b>auf den Wert xxxxxxxxxxxxxxxxxxxxxxxxx<\/b>. Außerdem haben wir gleich zwei Callback-Attribute definiert:<\/p>\n Listing 1: Einlesen des Ribbons mit dem Textfeld zum Festlegen des Datenbanktitels<\/span><\/b><\/p>\n Die Callback-Funktion getText<\/b> wird ausgelöst, wenn das Ribbon geladen oder wenn per Code eine der Methoden Invalidate <\/b>oder InvalidateControl <\/b>der in einer Variablen gespeicherten Ribbon-Instanz ausgelöst wird und das Steuerelement danach erstmals sichtbar wird.<\/p>\n Sie erhält als ersten Parameter einen Verweis auf das aufrufende Steuerelement. Der zweite Parameter erwartet die im editBox<\/b>-Steuerelement anzuzeigende Zeichenkette.<\/p>\n Wenn Sie die Prozedur wie nachfolgend in das twinBASIC-Projekt einfügen, werden einige Elemente rot unterstrichen. Das liegt daran, dass wir noch keinen Verweis auf die DAO-Bibliothek hinzugefügt haben:<\/p>\n Das holen wir nach, indem wir in twinBASIC zum Bereich Settings <\/b>wechseln und dort unter COM Type Library \/ Active X References <\/b>einen Verweis auf die Bibliothek Microsoft Office 16.0 Access Database Engine Object Library [v12.0] <\/b>hinzufügen (siehe Bild 4). Danach unbedingt mit Strg + S <\/b>speichern, damit die Änderungen wirksam werden!<\/p>\n Bild 4: Hinzufügen eines Verweises auf die DAO-Bibliothek<\/span><\/b><\/p>\n Danach sind fast alle roten Unterstreichungen verschwunden, nur eine nicht – die unter CurrentDb<\/b>. CurrentDb <\/b>ist auch keine Eigenschaft der DAO-Bibliothek, sondern der Access-Bibliothek.<\/p>\n Also fügen wir auch diese noch mit dem Eintrag Microsoft Access 16.0 Object Library [v9.0] <\/b>hinzu. Nach dem erneuten Speichern können wir uns nun den Code der Prozedur getText <\/b>ohne rote Unterstreichungen ansehen.<\/p>\n Die Prozedur deaktiviert zunächst die eingebaute Fehlerbehandlung und ruft den Wert der Eigenschaft AppTitle <\/b>des Database<\/b>-Objekts der aktuellen Datenbank ab. Die Fehlerbehandlung deaktivieren wir dabei, weil ein Fehler ausgelöst wird, wenn diese Eigenschaft noch nicht oder nicht mehr vorhanden ist. Sie ist nur vorhanden, wenn diese bereits durch den Benutzer über den Optionen-Dialog von Access gesetzt wurde (oder per Code, wie wir gleich demonstrieren).<\/p>\n Danach aktivieren wir die Fehlerbehandlung wieder und prüfen per If…Then<\/b>-Bedingung, ob prp <\/b>eine Eigenschaft zugewiesen wurde.<\/p>\n Das ist nur der Fall, wenn die Eigenschaft aktuell vorhanden ist. Ist prp <\/b>leer, übergeben wir die Zeichenkette Wie schon im Beitrag twinBASIC – COM-Add-Ins für Access <\/b>festgestellt, sehen wir auch hier wieder eine andere Signatur für die Callback-Funktion. Sie lautet hier:<\/p>\n Unter VBA würde diese lauten:<\/p>\n Die hier verwendete Signatur ist die gleiche, die wir auch in einem VB6-COM-Add-In nutzen würden. Da twinBASIC zum Nachfolger von VB6 avanciert und wir noch weitere Tools damit entwickeln werden, stellen wir in einem weiteren Beitrag namens Ribbon: Callback-Signaturen für VBA und VB6 <\/b>(www.access-im-unternehmen.de\/1324<\/b>) die Unterschiede vor.<\/p>\n Mit der gleichen Eigenschaft beschäftigt sich die Callback-Funktion onChange<\/b> (siehe Listing 2). Diese hat die gleichen Parameter. Allerdings wird sie ausgelöst, wenn der Benutzer den im editBox<\/b>-Steuerelement enthaltenen Text ändert und die Änderung beispielsweise durch Verlassen des Textfeldes abschließt. Dementsprechend ist der zweite Parameter text <\/b>diesmal auch kein Rückgabeparameter, sondern er liefert den neu vom Benutzer eingegebenen Text. <\/p>\n Listing 2: Ändern einer Option nach Änderung im Ribbon<\/span><\/b><\/p>\n Den Inhalt von text <\/b>prüft die Prozedur zunächst in einer If…Then<\/b>-Bedingung. Es kann sein, dass der Benutzer das editBox<\/b>-Steuerelement komplett geleert hat, dann soll auch der Titel geleert werden. Das funktioniert allerdings nur in der gewünschten Form, indem wir die Eigenschaft AppTitle <\/b>wieder löschen. Das erledigt die Prozedur im If<\/b>-Teil der Bedingung mit der Delete<\/b>-Methode der Properties<\/b>-Auflistung.<\/p>\n Hat der Benutzer jedoch einen Titel mit mindestens einem Zeichen eingegeben, dann wollen wir die Eigenschaft AppTitle <\/b>auf diesen Wert einstellen. Dazu versucht die Prozedur, nach vorheriger Deaktivierung der Fehlerbehandlung, die Eigenschaft mit der Variablen prp <\/b>zu referenzieren. Ist dabei ein Fehler aufgetreten, erstellt die Prozedur die Eigenschaft neu und hängt diese an die Auflistung Properties <\/b>des Database<\/b>-Objekts der aktuellen Datenbank an.<\/p>\n Ist die Eigenschaft bereits vorhanden, stellt die Prozedur diese lediglich auf den Wert aus dem Parameter text <\/b>ein.<\/p>\n In jedem Fall soll die Anzeige der Titelleiste anschließend aktualisiert werden, was die Methode RefreshTitleBar <\/b>des Application<\/b>-Objekts der aktuellen Access-Instanz erledigt. Diese haben wir ja zuvor in die Variable objAccess <\/b>eingelesen.<\/p>\n Nachdem Sie die Ribbon-Definition in der Prozedur GetCustomUI angepasst und die beiden Callback-Funktionen hinzugefügt haben, können Sie die Änderungen speichern und das COM-Add-In neu kompilieren. Das Ergebnis der Kompilierung finden Sie übrigens unten in Visual Studio Code in der Debugging-Console.<\/p>\n <\/p>\n Wenn Sie danach eine Access-Datenbank öffnen, finden Sie ein neues Tab namens Optionen <\/b>im Ribbon. Klicken Sie es an, erscheint die von uns hinzugefügte Option zum Einstellen des Datenbanktitels (siehe Bild 5). Dieses zeigt direkt beim Öffnen den aktuellen Wert an – bei einer Datenbank, für die Sie noch keinen Anwendungstitel eingestellt haben, beispielsweise Bild 5: Die erste Access-Option im Access-Ribbon<\/span><\/b><\/p>\n Wir wollen gleich die nächste Option aus dem Optionen-Dialog ermitteln und ausprobieren, nämlich das Definieren eines Anwendungssymbosl. Hier haben wir die zusätzliche Herausforderung, dass wir einen Datei auswählen<\/b>-Dialog hinzufügen wollen. Also benötigen wir nicht nur ein editBox<\/b>-Steuerelement, sondern daneben auch noch ein button<\/b>-Element. Damit diese nebeneinander erscheinen, fassen wir die beiden Elemente in einem box<\/b>-Element zusammen. Die notwendige Erweiterung der Prozedur GetCustomUI<\/b> sehen Sie in Listing 3.<\/p>\n Listing 3: Erweiterung der Ribbon-Definition für das Anpassen des Anwendungssymbols <\/span><\/b><\/p>\n Bei Ereignisprozeduren von Formularen, Berichten oder Steuerelementen wird für jedes Ereignis eines jeden Elements eine neue Prozedur erstellt, die den Namen des Elements, einen Unterstrich und die Bezeichnung des Ereignisses als Bezeichnung trägt. Bei Callback-Funktionen des Ribbons hat es sich eingebürgert, dass man zum Beispiel für das Ereignis onAction <\/b>nur eine Callback-Funktion namens onAction <\/b>definiert. Diese ermittelt dann über den Parameter control <\/b>und dessen Eigenschaft id <\/b>den Namen des aufrufenden Steuerelements. In einer Select Case<\/b>-Bedingung wird dann der Name ausgewertet und in den Case<\/b>-Zweigen finden sich dann die Anweisungen, die für das jeweilige Steuerelement ausgeführt werden sollen.<\/p>\n Sie können natürlich auch beispielsweise für das onAction<\/b>-Attribut eines Elements namens btnBeispiel <\/b>einen Wert wie btnBeispiel_OnAction <\/b>anlegen und eine entsprechende Callback-Funktion hinterlegen. Je nachdem, wie umfangreich das Ribbon ist und wie aufwendig der Code, kann dies die bessere Variante sein. Wir haben für die Lösung dieses Beitrags entschieden, die letztere Variante mit individuellen Callback-Funktionen je Steuerelement zu nutzen.<\/p>\n Das heißt zunächst, dass wir die bereits erstellten Callback-Funktion umbenennen. Aus der GetText<\/b>-Funktion für das Textfeld txtTitle <\/b>wird nun:<\/p>\n Die gleiche Änderung nehmen wir für die Callback-Funktion OnChange <\/b>für das Textfeld txtTitle <\/b>vor:<\/p>\n Dementsprechend passen wir auch noch den Aufruf der Callback-Funktionen des editBox<\/b>-Steuerelements txtTitle <\/b>in den entsprechenden Attributen an:<\/p>\n In den XML-Definitionen für die Steuerelemente im Ribbon verwenden wir direkt die entsprechenden neuen Bezeichnungen:<\/p>\n Die Prozedur btnChooseSymbol_onAction<\/b> wird aufgerufen, wenn der Benutzer die Schaltfläche mit den drei Punkten betätigt (siehe Listing 4). Sie referenziert das Database<\/b>-Objekt der aktuell geöffneten Datenbank und ermittelt als Startverzeichnis für den Dateiauswahl-Dialog das aktuelle Datenbankverzeichnis. Dieses landet in strStartDir<\/b>. Dann verwendet es die Funktion OpenFileName<\/b>, um einen Dateiauswahl-Dialog anzuzeigen. Mit diesem kann der Benutzer ein neues Anwendungssymbol auswählen.<\/p>\n Listing 4: Auswahl eines neuen Icons<\/span><\/b><\/p>\n Anschließend haben wir eine Funktion eingebaut, die sogar den eigentlichen Optionen-Dialog noch etwas verbessert: Die Prozedur fragt den Benutzer, ob er das gewählte Icon gleich in das Anwendungsverzeichnis kopieren will. In diesem Fall schreibt die Prozedur den reinen Dateinamen in die Variable strTemp<\/b>. Dann erstellt sie eine Instanz der Klasse FileSystemDialog <\/b>und führt ihre Methode CopyFile <\/b>aus, wodurch die vom Benutzer ausgewählte Datei in das Anwendungsverzeichnis kopiert wird. Schließlich stellen wir strIcon <\/b>auf den Wert von strTemp <\/b>ein, da wir den Pfad nicht mehr benötigen, wenn sich das Icon im gleichen Verzeichnis wie die Access-Datenbank befindet.<\/p>\n Danach prüft die Prozedur, ob die Property AppIcon <\/b>bereits vorhanden ist und legt diese gegebenenfalls an, wobei die ermittelte Icon-Datei aus strIcon <\/b>als neuer Wert übergeben wird. Ist AppIcon <\/b>bereits vorhanden, weist die Prozedur lediglich den neuen Wert zu.<\/p>\n Schließlich folgt noch ein wichtiger Schritt: die Aktualisierung der Anzeige mit dem neuen Icon. Das erledigen wir mit der Methode InvalidateControl <\/b>für das Steuerelement txtIcon<\/b> wie folgt, bevor wir die Anzeige der Titelleiste aktualisieren:<\/p>\n Um diese Anweisung auszuführen, sind allerdings noch ein paar Schritte erforderlich. Zum Beispiel gibt es noch keine Variable namens objRibbon<\/b>. Diese deklarieren wir als modulweit gültige Variable wie folgt:<\/p>\n Diese Variable muss beim ersten Anzeigen des Ribbons gefüllt werden. Dazu hinterlegen wir für das Attribut onLoad <\/b>des CustomUI<\/b>-Elements den Namen der aufzurufenden Callback-Prozedur, hier onLoad<\/b>:<\/p>\n\n
Was bietet die Vorlage<\/h2>\n
\n
COM-Add-In zum Laufen bringen<\/h2>\n
\n
![\"COM-Add-In](\"..\/fileadmin\/_temp_\/2021_05\/pic_1327_002.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2021_05\/pic_1327_003.png\")
<\/p>\nCOM-Add-In vorbereiten<\/h2>\n
Private <\/span>objAccess As <\/span>Access.Application<\/pre>\nSub <\/span>OnConnection(ByVal Application As Object<\/span>, _\r\n ByVal ConnectMode As <\/span>ext_ConnectMode, _\r\n ByVal AddInInst As Object<\/span>, _\r\n ByRef custom As Variant<\/span>()) _\r\n Implements IDTExtensibility2.OnConnection\r\n Set<\/span> objAccess = Application\r\nEnd Sub<\/span><\/pre>\nOptionen mit dem Ribbon einstellen<\/h2>\n
Private Function <\/span>GetCustomUI(ByVal RibbonID As String<\/span>) As String<\/span> _\r\n Implements IRibbonExtensibility.GetCustomUI\r\n Dim <\/span>strXML As String<\/span>\r\n strXML &= \"<xml version=\"1.0\">\" & vbCrLf<\/span>\r\n strXML &= \"<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\">\" & vbCrLf<\/span>\r\n strXML &= \" <ribbon>\" & vbCrLf<\/span>\r\n strXML &= \" <tabs>\" & vbCrLf<\/span>\r\n strXML &= \" <tab id=\"tabOptions\" label=\"Optionen\">\" & vbCrLf<\/span>\r\n strXML &= \" <group id=\"grpThisDatabase\" label=\"<Aktuelle Datenbank>\">\" & vbCrLf<\/span>\r\n strXML &= \" <editBox label=\"Datenbanktitel:\"id=\"txtTitle\" maxLength=\"255\" \" _\r\n & \" sizeString=\"xxxxxxxxxxxxxxxxxxxxxxxxx\" getText=\"getText\" onChange=\"onChange\"\/>\" & vbCrLf<\/span>\r\n strXML &= \" <\/group>\" & vbCrLf<\/span>\r\n strXML &= \" <\/tab>\" & vbCrLf<\/span>\r\n strXML &= \" <\/tabs>\" & vbCrLf<\/span>\r\n strXML &= \" <\/ribbon>\" & vbCrLf<\/span>\r\n strXML &= \"<\/customUI>\" & vbCrLf<\/span>\r\n Return strXML\r\nEnd Function<\/span><\/pre>\n\n
Einlesen des aktuellen Datenbanktitels<\/h2>\n
Function <\/span>GetText(control As <\/span>IRibbonControl) As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>prp As <\/span>DAO.Property\r\n Dim <\/span>strText As String<\/span>\r\n On Error Resume Next<\/span>\r\n Set<\/span> db = objAccess.CurrentDb\r\n Set<\/span> prp = db.Properties(\"AppTitle\")\r\n On Error GoTo<\/span> 0\r\n If <\/span>prp Is Nothing Then<\/span>\r\n strText = \"<Kein Titel>\"\r\n Else<\/span>\r\n strText = prp.Value\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n GetText = strText\r\nEnd Function<\/span><\/pre>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2021_05\/pic_1327_004.png\")
<\/p>\nAndere Callback-Signatur in twinBASIC-Ribbons<\/h2>\n
Function <\/span>GetText(control As <\/span>IRibbonControl) As String<\/span><\/pre>\nSub <\/span>getText(control As <\/span>IRibbonControl, ByRef text)<\/pre>\nSpeichern des geänderten Datenbanktitels<\/h2>\n
Sub <\/span>OnChange(control As <\/span>IRibbonControl, text As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>prp As <\/span>DAO.Property\r\n Set<\/span> db = objAccess.CurrentDb\r\n If <\/span>Len<\/span>(text) = 0 Then<\/span>\r\n db.Properties.Delete \"AppTitle\"\r\n Else<\/span>\r\n On Error Resume Next<\/span>\r\n Set<\/span> prp = db.Properties(\"AppTitle\")\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n Set<\/span> prp = db.CreateProperty(\"AppTitle\", dbText, text)\r\n db.Properties.Append prp\r\n Else<\/span>\r\n prp.Value = text\r\n End If<\/span>\r\n End If<\/span>\r\n objAccess.RefreshTitleBar\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2021_05\/pic_1327_005.png\")
<\/p>\nOption zum Ändern des Anwendungssymbols<\/h2>\n
Private Function <\/span>GetCustomUI(ByVal RibbonID As String<\/span>) As String<\/span> _\r\n Implements IRibbonExtensibility.GetCustomUI\r\n ...\r\n strXML &= \" <editBox label=\"Anwendungstitel:\" id=\"txtTitle\" maxLength=\"255\" getText=\"getText\"\" _\r\n & \" onChange=\"onChange\"\/>\" & vbCrLf<\/span>\r\n strXML &= \" <box id=\"box1\">\" & vbCrLf<\/span>\r\n strXML &= \" <editBox label=\"Anwendungssymbol:\" id=\"txtIcon\" maxLength=\"255\"\" _\r\n & \" getText=\"getText\" onChange=\"onChange\"\/>\" & vbCrLf<\/span>\r\n strXML &= \" <button screentip=\"Symbol auswählen ...\" label=\"...\" id=\"btnChooseSymbol\"\" _\r\n & \" onAction=\"onAction\"\/>\" & vbCrLf<\/span>\r\n strXML &= \" <\/box>\" & vbCrLf<\/span>\r\n ...\r\nEnd Function<\/span><\/pre>\nEigene Callback-Prozedur für gleiche Attribute für jedes Steuerelement<\/h2>\n
Function <\/span>txtTitle_GetText(control As <\/span>IRibbonControl) As String<\/span>\r\n ...\r\nEnd Function<\/span><\/pre>\nSub <\/span>txtTitle_OnChange(control As <\/span>IRibbonControl, text As String<\/span>)\r\n ...\r\nEnd Sub<\/span><\/pre>\n<editBox label=\"Anwendungstitel:\" id=\"txtTitle\" maxLength=\"255\" getText=\"txtTitle_getText\" onChange=\"txtTitle_onChange\"\/><\/pre>\n
Ribbon-Steuerelemente für das Anwendungssymbol<\/h2>\n
<editBox label=\"Anwendungssymbol:\" id=\"txtIcon\" maxLength=\"255\" getText=\"txtIcon_getText\" onChange=\"txtIcon_onChange\"\/>\r\n<button screentip=\"Symbol auswählen ...\" label=\"...\" id=\"btnChooseSymbol\" onAction=\"btnChooseSymbol_onAction\"\/><\/pre>\n
Auswahl eines neuen Icons<\/h2>\n
Sub <\/span>btnChooseSymbol_onAction(control As <\/span>IRibbonControl)\r\n Dim <\/span>strStartDir As String<\/span>\r\n Dim <\/span>strIcon As String<\/span>\r\n Dim <\/span>prp As <\/span>DAO.Property\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strTemp As String<\/span>\r\n Dim <\/span>objFSO As <\/span>FileSystemObject\r\n Set<\/span> db = objAccess.CurrentDb\r\n strStartDir = objAccess.CurrentProject.Path\r\n strIcon = OpenFileName(strStartDir, \"Icon auswählen\", \"Bilddateien (*.ico, *.png, *.bmp)\")\r\n If <\/span>Len<\/span>(strIcon) > 0 Then<\/span>\r\n If <\/span>MsgBox<\/span>(\"Icon in Anwendungsverzeichnis kopieren\", vbYesNo + vbQuestion) = vbYes Then<\/span>\r\n strTemp = mid(strIcon, InStrRev<\/span>(strIcon, \"\\\")+1)\r\n Set<\/span> objFSO = CreateObject(\"Scripting.FileSystemObject\")\r\n objFSO.CopyFile strIcon, objAccess.CurrentProject.Path & \"\\\"\r\n strIcon = strTemp\r\n End If<\/span>\r\n On Error Resume Next<\/span>\r\n Set<\/span> prp = db.Properties(\"AppIcon\")\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n Set<\/span> prp = db.CreateProperty(\"AppIcon\", dbText, strIcon)\r\n db.Properties.Append prp\r\n Else<\/span>\r\n prp.Value = strIcon\r\n End If<\/span>\r\n objRibbon.InvalidateControl \"txtIcon\"\r\n objAccess.RefreshTitleBar\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nobjRibbon.InvalidateControl \"txtIcon\"<\/pre>\n
Private <\/span>objRibbon As <\/span>IRibbonUI<\/pre>\nPrivate Function <\/span>GetCustomUI(ByVal RibbonID As String<\/span>) As String<\/span> Implements IRibbonExtensibility.GetCustomUI\r\n ...\r\n strXML &= \"<customUI ... onLoad=\"onLoad\">\" & vbCrLf<\/span>\r\n ...\r\nEnd Function<\/span><\/pre>\n