Im Artikel “Menüs per VBA programmieren” (www.vbentwickler.de\/435) haben wir uns bereits angesehen, wie wir die Menüstruktur selbst im VBA-Editor per VBA programmieren können. Damit wissen wir nun, wie wir Hauptmenüleisten, Symbolleisten und Kontextmenüs erstellen und anzeigen können. Es fehlt allerdings noch das Salz in der Suppe, nämlich die Steuerelemente auf diesen Menüs. Welche es gibt und wie man diese hinzufügt und mit Aktionen versieht, schauen wir uns in diesem Artikel an.<\/b><\/p>\n
Wer den VBA-Editor mit eigenen Funktionen erweitern will und das beispielsweise mit COM-Add-Ins auf Basis von twinBASIC realisiert, möchte die hinzugefügten Funktionen auch auf irgendeine Weise für den Benutzer zugänglich machen. Dazu bietet sich das Menüsystem an. Damit können wir in der Menüleiste, den Symbolleisten und in Kontextmenüs Befehle zum Aufrufen der benutzerdefinierten Funktionen hinzufügen. Allerdings brauchen wir hier nicht nur die entsprechenden Elemente, sondern wir müssen auch noch Steuerelemente hinzufügen. Dies werden meist einfache Schaltflächen sein. Wir schauen uns allerdings in diesem Artikel alle der wenigen verfügbaren Steuerelemente für die Menüs des VBA-Editors an.<\/p>\n
Dem CommandBar<\/b>-Element können wir die folgenden Steuerelemente hinzufügen:<\/p>\n Um ein solches Steuerelement hinzuzufügen, verwenden wir die Add<\/b>-Methode der Controls<\/b>-Auflistung des CommandBar<\/b>-Objekts. Das folgende, einfache Beispiel fügt einfach jeweils ein Element des jeweiligen Typs zu einer neu erstellten Symbolleiste hinzu:<\/p>\n Die Prozedur löscht zunächst eine gegebenenfalls bereits von einem vorherigen Test vorhandene Symbolleiste namens Symbolleiste mit Controls <\/b>aus der CommandBars<\/b>-Auflistung. Für den Fall, dass dieses noch nicht angelegt oder zuvor auf andere Art und Weise gelöscht wurde, deaktivieren wir die eingebaute Fehlerbehandlung, damit dann kein Fehler ausgelöst wird.<\/p>\n Dann legt sie ein neues CommandBar<\/b>-Objekt mit diesem Namen an. Anschließend fügen wir mit der Add<\/b>-Methode der Controls<\/b>-Auflistung zunächst eine Schaltfläche mit dem Typ msoControlButton <\/b>an und stellen dafür die Beschriftung ein. Damit diese auch erscheint, legen wir die Eigenschaft Style <\/b>auf den Wert msoButtonCaption <\/b>fest.<\/p>\n Danach legt die Prozedur ein Auswahlfeld an und verwendet dazu den Typ msoControlComboBox <\/b>als ersten Parameter der Add<\/b>-Methode. Diesem fügen wir auch gleich ein erstes Element hinzu.<\/p>\n Schließlich folgt noch ein Untermenü mit dem Typ msoControlPopup<\/b>. Für dieses brauchen wir den Style nicht auf msoButtonCaption <\/b>festzulegen, die Beschriftung wird automatisch angezeigt.<\/p>\n Das Ergebnis sehen wir in Bild 1.<\/p>\n Bild 1: Beispiel für Steuerelemente im CommandBar<\/span><\/b><\/p>\n Nachdem wir eine Schaltfläche zu einem CommandBar<\/b>-Element hinzufügt haben, ist erst einmal wichtig, dass wir dem Benutzer mitteilen, wozu er diese Schaltfläche verwenden kann. Dazu können wir primär Symbole und\/oder Texte verwenden. Den Text stellen wir immer mit der Eigenschaft Caption <\/b>ein. Damit die Beschriftung überhaupt sichtbar ist, müssen wir die Style<\/b>-Eigenschaft auf den entsprechenden Wert einstellen. Dazu haben wir die folgenden Möglichkeiten:<\/p>\n Wer bereits einmal Menüleisten für die verschiedenen Office-Anwendungen mit der Version 2003 und älter programmiert hat oder auch Kontextmenüs für die aktuellen Versionen, der kennt die OnAction<\/b>-Eigenschaft. Für diese Eigenschaft eines CommandBarButton<\/b>-Objekts hinterlegt man den Namen einer öffentlichen VBA-Prozedur, die durch das Anklicken des Menüpunktes ausgelöst werden soll.<\/p>\n Dies funktioniert bei der Programmierung von Menüs für den VBA-Editor so nicht mehr. Hier müssen wir ein Ereignis programmieren. Leider können wir Ereignisse nur innerhalb von Klassenmodulen implementieren und nicht in Standardmodulen. Wir benötigen also eine Klasse, die einen Verweis auf unser CommandBarButton<\/b>-Objekt enthält und in der wir die Ereignisprozedur implementieren.<\/p>\n Diese Klasse heißt clsCommandBarButton <\/b>und sieht wie in Listing 1 aus. Hier definieren wir als Erstes eine Objektvariable, mit der wir das CommandBarButton<\/b>-Objekt referenzieren wollen. Wir fügen der Deklaration das Schlüsselwort WithEvents <\/b>hinzu, damit wir die Ereignisse dieses Objekts innerhalb der aktuellen Klasse implementieren können.<\/p>\n Listing 1: Klassenmodul für die Ereignisse von CommandBarButton-Ereignissen<\/span><\/b><\/p>\n Damit wir von außen einen Verweis auf das CommandBarButton<\/b>-Objekt übergeben können, für das wir das Ereignis implementieren wollen, fügen wir eine Property Set<\/b>-Methode hinzu. Diese nimmt einen Verweis auf das CommandBarButton<\/b>-Element entgegen. Außerdem fügen wir noch eine Property Get<\/b>-Prozedur hinzu, mit der wir den Verweis auf dieses Steuerelement abfragen können.<\/p>\n Um schließlich die Ereignisprozedur zu implementieren, wählen wir im linken Kombinationsfeld des Codefensters den Eintrag m_CommandBarButton <\/b>aus und den dann im rechten Fenster erscheinenden Eintrag Click<\/b> (siehe Bild 2). Dies legt die Ereignisprozedur m_CommandBarButton_Click <\/b>an, der wir im Beispiel einfach eine Meldungsfenster-Funktion hinzugefügt haben.<\/p>\n Bild 2: Anlegen der Ereignisprozedur für das Click-Ereignis<\/span><\/b><\/p>\n Nun müssen wir noch das CommandBarButton<\/b>-Objekt in einem Menü anzeigen, eine neue Instanz der Klasse clsCommandBarButton <\/b>erzeugen und schließlich das Menü mit der Schaltfläche anzeigen.<\/p>\n Um zu verhindern, dass die Instanz der Klasse clsCommandBarButton <\/b>nach dem Durchlaufen der Prozedur zum Erstellen der CommandBar mit dem CommandBarButton verloren geht, weil wir die mit einer Variablen innerhalb der Prozedur referenziert haben, verschieben wir diese Deklaration mit der folgende Anweisung nach außen (siehe Modul mdlCommandBarButtonMitEvent<\/b>):<\/p>\n Die Prozedur selbst findest Du in Listing 2.<\/p>\n Listing 2: Anlegen eines CommandBarButtons mit Ereignis<\/span><\/b><\/p>\n Diese deklariert ein CommandBar<\/b>– und ein CommandBarButton<\/b>-Element. Dann löscht sie eine eventuell bereits unter dem Namen CommandBarButtonMitEvent <\/b>vorhandene Menüleiste und legt diese erneut an. Dann fügt sie mit der Add<\/b>-Methode der Controls<\/b>-Auflistung ein neues CommandBarButton<\/b>-Element hinzu und stellt den Stil und die Beschriftung des Steuerelements ein.<\/p>\n Dann folgen die für die Ereignisprozedur wichtigen Schritte: Wir legen ein neues Objekt auf Basis der Klasse clsCommandBarButton<\/b> an und weisen der Eigenschaft CommandBarButton <\/b>einen Verweis auf das soeben erstellte CommandBarButton<\/b>-Objekt zu. Schließlich blenden wir das Menü noch ein.<\/p>\n Klicken wir danach auf das einzige Steuerelement, erscheint die gewünschte Meldungsbox (siehe Bild 3).<\/p>\n Bild 3: Menü mit CommandBarButton und Ereignis<\/span><\/b><\/p>\n Während wir den Text auf einfache Weise mit der Caption-Eigenschaft zuweisen können, sieht das bei Symbolen schon anders aus. Hier haben wir grundsätzlich zwei Möglichkeiten:<\/p>\n Der Einbau eingebauter Symbole ist etwas einfacher, weil wir keinen eigenen VBA-Code benötigen, um erst vorhandene Dateien in StdPicture<\/b>-Objekte umwandeln zu müssen. Allerdings macht es dann Sinn, sich gut mit den eingebauten Symbolen auszukennen. Die eingebauten Symbole haben jeweils eine eindeutige Nummer, die wir über die Eigenschaft FaceId <\/b>ermitteln können. Was wir also brauchen, ist eine Übersicht aller Icons mit den jeweiligen Werten für die Eigenschaft FaceId<\/b>. Diese erhalten wir am einfachsten, indem wir eine neue Symbolleiste erstellen, der wir alle Symbole der eingebauten Schaltflächen hinzufügen.<\/p>\n Dies erledigen wir in der Prozedur AlleEingebautenIcons<\/b> aus Listing 3.<\/p>\n Listing 3: Funktion zum Schreiben aller Icons in eine Symbolleiste<\/span><\/b><\/p>\n Hier finden wir gleich ein spannendes Beispiel für den Fall, dass wir viele Steuerelemente in einer Menüleiste mit einem Ereignis ausstatten wollen, das beim Anklicken die gleiche Funktion ausführen soll – gegebenenfalls noch mit kleinen Varianten durch spezielle Eigenschaften des CommandBarButton<\/b>-Elements.<\/p>\n Grundlage für diese Prozedur ist, dass es FaceId<\/b>-Werte gibt, die bis 6.000 reichen. Wir wollen all diese Werte einmal durchlaufen und in ein einziges CommandBar<\/b>-Objekt schreiben. Allerdings liefern nicht alle Werte von FaceId <\/b>tatsächlich ein Symbol. Deshalb wollen wir diejenigen, für die kein Symbol hinterlegt ist, auch nicht in das Menü aufnehmen. Daher haben wir – wir probieren dies hier in einer Access-Datenbank aus – eine Tabelle angelegt, in welcher wir die FaceId<\/b>-Werte speichern, die kein Symbol enthalten (wir hätten das auch andersherum machen können, haben uns aber für diese Variante entschieden).<\/p>\n Um die Steuerelemente ohne Symbol für die FaceId <\/b>in die Tabelle tblEmptyFaceIds <\/b>zu schreiben, haben wir wiederum eine Klasse mit einer Ereignisprozedur angelegt. Diese ist grundsätzlich genauso aufgebaut wie die zuvor beschriebene Klasse clsCommandBarButton<\/b>.<\/p>\n Sie heißt jedoch clsCommandBarButtonFaceID <\/b>und enthält die folgende Ereignisprozedur:<\/p>\n Diese trägt einen neuen Datensatz mit der FaceId <\/b>in die Tabelle tblEmptyFaceIDs <\/b>ein.<\/p>\n Diese Klasse deklarieren wir nun innerhalb der Prozedur und nicht außerhalb wie im vorherigen Beispiel. Warum das? Weil wir mehr als eine Instanz dieser Klasse anlegen – genau genommen zunächst einmal 6.000 Stück. Und da wir keine 6.000 Variablen deklarieren wollen, deklarieren wir nur eine temporäre. Die erzeugten Objekte fügen wir dann einer Collection hinzu, die wir wie folgt im Kopf des Standardmoduls deklarieren:<\/p>\n Die Collection initialisieren wir im nächsten Schritt. Dann löschen wir das Menü namens AlleIcons <\/b>vorsichtshalber, um es im nächsten Schritt gleich wieder anzulegen. Dann durchlaufen wir in einer Schleife die Werte von 1 bis 6.000 und prüfen zunächst per DLookup<\/b>, ob die FaceId <\/b>nicht leer ist und bereits in der Tabelle tblEmptyFaceIDs <\/b>eingetragen ist. Ist das nicht der Fall, legen wir ein neues CommandBarButton<\/b>-Element an und stellen die Eigenschaft FaceId <\/b>auf den aktuellen Wert der Laufvariablen l <\/b>ein. Außerdem legen wir den ToolTipText <\/b>und die Eigenschaft Tag <\/b>auf den Wert dieser Variablen fest.<\/p>\n Schließlich legen wir ein neues Objekt der Klasse clsCommandBarButtonFaceIdD <\/b>an und weisen seiner Eigenschaft CommandBarButton <\/b>die Schaltfläche aus cbb <\/b>zu. Diese Objektvariable fügen wir dann mit der Add<\/b>-Methode der Collection colCommandBarButtons <\/b>zu.<\/p>\n Beim ersten Start sieht die in der Breite angepasste Menüleiste noch recht lückenhaft aus (siehe Bild 4).<\/p>\n Bild 4: Alle FaceId-Elemente – auch solche ohne Symbol<\/span><\/b><\/p>\n Wenn wir nun eine der Schaltflächen ohne Icon anklicken, wird diese in die Tabelle tblEmptyFaceIds <\/b>eingetragen und beim nächsten Öffnen des Menüs nicht mehr berücksichtigt.<\/p>\n Nach einigen Minuten Arbeit, die Du nicht mehr zu erledigen braucht, da ich das schon gemacht habe, wird das Menü nur noch mit CommandBarButton<\/b>-Elementen gefüllt, die ein Symbol aufweisen (siehe Bild 5).<\/p>\n Bild 5: Alle Icon-Symbole<\/span><\/b><\/p>\n Sicher gibt es hier das eine oder andere doppelte Icon, doch insgesamt kannst Du diese Übersicht prima nutzen, um ein für Deinen Anwendungszweck passendes Icon herauszusuchen.<\/p>\n Der zweite Weg ist, benutzerdefinierte Symbole einzufügen. Das geht grundsätzlich, ist aber mit einigen Hindernissen versehen. Das CommandBarButton<\/b>-Element bietet dazu zwei Eigenschaften an:<\/p>\n Der Teil mit der Transparenz funktioniert nicht optimal – in der Regel sieht man leichte Ausfransungen in den Randbereichen. Eine bessere Lösung wäre daher, in Abhängigkeit von der Menge der benötigten Icons, die Idee, die Icons direkt mit einem grauen Hintergrund in der entsprechenden Farbe zu versehen. Insgesamt schauen wir das Hinzufügen benutzerdefinierter Icons in einem weiteren Artikel namens Icons für Kontextmenübefehle <\/b>(www.vbentwickler.de\/371<\/b>) an.<\/p>\n Manche CommandBars enthalten recht viele Elemente, sodass eine Gruppierung nach bestimmten Elementen sinnvoll ist. Dazu können wir einen Trennstrich nutzen, den wir auf einfache Weise einfügen können. Dazu brauchen wir lediglich die Eigenschaft BeginGroup <\/b>für das erste Element der Gruppe auf True <\/b>einzustellen.<\/p>\n Wir können in unseren eigenen Menüleisten auch eingebaute Befehle hinzufügen. Genau genommen ist das gar keine so schlechte Idee. Vielleicht benötigst Du nur wenige Befehle der eingebauten Menü- und Symbolleisten und möchtest Dir eine einzige anlegen, die alle für Deinen täglichen Programmieralltag wichtigen Elemente enthält und nur noch diese nutzen.<\/p>\n Ein eingebautes Element kannst Du mit der folgenden Anweisung zu einem CommandBar<\/b>-Element hinzufügen – hier für ein Kontextmenü:<\/p>\n Damit zeigen wir ein Kontextmenü mit einem eingebauten Element wie in Bild 6 an.<\/p>\n Bild 6: Anzeigen eines eingebauten Elements im Kontextmenü<\/span><\/b><\/p>\n Um gezielt eingebaute Elemente in ein benutzerdefiniertes Menü einzubauen, benötigen wir also die ID des jeweiligen Elements. Dazu erstellen wir uns eine kleine Hilfstabelle (siehe Bild 7).<\/p>\n Bild 7: Tabelle zum Speichern von Controls und ihren IDs<\/span><\/b><\/p>\n Diese Tabelle füllen wir mit drei Prozeduren, von denen wir zunächst die erste aus Listing 4 aufrufen. Diese durchläuft zunächst alle Elemente der CommandBars<\/b>-Auflistung für den VBA-Editor und referenziert das jeweils aktuelle Element mit der Variablen cbr<\/b>.<\/p>\n Listing 4: Durchlaufen aller Elemente der obersten Ebene der CommandBar-Elemente<\/span><\/b><\/p>\n Dann prüft sie mit der Eigenschaft BuiltIn<\/b>, ob das jeweilige Element ein eingebautes Element ist.<\/p>\n Nur diese Elemente interessieren uns. Also durchlaufen wir für diese alle Steuerelemente im CommandBar <\/b>in einer weiteren For Each<\/b>-Schleife und referenzieren das jeweilige Steuerelement mit der Variablen ctl<\/b>.<\/p>\n Hier prüfen wir in einer Select Case<\/b>-Bedingung mit der TypeName<\/b>-Funktion für das ctl<\/b>-Element, ob es sich bei dem Steuerelement um eines der Typen CommandBarButton<\/b>, CommandBarComboBox <\/b>oder CommandBarControl <\/b>handelt. Falls ja, rufen wir die Prozedur WriteControl <\/b>auf, die einen Verweis auf das Steuerelement entgegennimmt (siehe Listing 5).<\/p>\n Listing 5: Schreiben der Control-Eigenschaften in die Tabelle tblControls<\/span><\/b><\/p>\n Diese liest die ID, die Beschriftung und den Typ in die Variablen lngID<\/b>, strCaption <\/b>und strType <\/b>ein. Dann stellt sie eine SQL-Anweisung zusammen, welche die Informationen zu dem Steuerelement in die Tabelle tblControls <\/b>schreibt.<\/p>\n Sollte es sich nicht um einen der genannten Steuerelementtyp handeln, bleibt noch der Typ CommandBarPopup <\/b>übrig, den wir im nächsten Case<\/b>-Zweig behandeln. Da ein Untermenü auch wieder Untermenüs enthalten kann und so weiter, wollen wir dazu eine rekursiv definierte Funktion nutzen. Diese finden wir in Listing 6.<\/p>\n\n
Public Sub <\/span>AddControls()\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Dim <\/span>cbb As <\/span>CommandBarButton\r\n Dim <\/span>cbc As <\/span>CommandBarComboBox\r\n Dim <\/span>cbp As <\/span>CommandBarPopup\r\n On Error Resume Next<\/span>\r\n VBE.CommandBars(\"Symbolleiste mit Controls\").Delete\r\n On Error GoTo<\/span> 0\r\n Set<\/span> cbr = VBE.CommandBars.Add( _\r\n \"Symbolleiste mit Controls\")\r\n With<\/span> cbr\r\n Set<\/span> cbb = cbr.Controls.Add(msoControlButton)\r\n With<\/span> cbb\r\n .Caption = \"Button\"\r\n .Style = msoButtonCaption\r\n End With<\/span>\r\n Set<\/span> cbc = cbr.Controls.Add(msoControlComboBox)\r\n With<\/span> cbc\r\n .Caption = \"ComboBox\"\r\n End With<\/span>\r\n Set<\/span> cbp = cbr.Controls.Add(msoControlPopup)\r\n With<\/span> cbp\r\n .Caption = \"Popup\"\r\n End With<\/span>\r\n .Visible = True<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Beispiel](\"..\/fileadmin\/_temp_\/2024_04\/pic_436_007.png\")
<\/p>\nSchaltflächen im CommandBar-Element<\/h2>\n
\n
Ereignisse von Schaltflächen programmieren<\/h2>\n
Private <\/span>WithEvents m_CommandBarButton As <\/span>CommandBarButton\r\nPublic Property Set<\/span> <\/span>CommandBarButton(cbb As <\/span>CommandBarButton)\r\n Set<\/span> m_CommandBarButton = cbb\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>CommandBarButton() As <\/span>CommandBarButton\r\n Set<\/span> CommandBarButton = m_CommandBarButton\r\nEnd Property<\/span>\r\nPrivate Sub <\/span>m_CommandBarButton_Click(ByVal Ctrl As <\/span>Office.CommandBarButton, CancelDefault As Boolean<\/span>)\r\n MsgBox<\/span> \"CommandBarButton ''\" & m_CommandBarButton.Caption & \"'' angeklickt.\"\r\nEnd Sub<\/span><\/pre>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2024_04\/pic_436_002.png\")
<\/p>\nDim <\/span>objCommandBarButton As <\/span>clsCommandBarButton<\/pre>\nDim <\/span>objCommandBarButton As <\/span>clsCommandBarButton\r\nPublic Sub <\/span>CommandBarButtonMitEvent()\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Dim <\/span>cbb As <\/span>CommandBarButton\r\n On Error Resume Next<\/span>\r\n VBE.CommandBars(\"CommandBarButtonMitEvent\").Delete\r\n On Error GoTo<\/span> 0\r\n Set<\/span> cbr = VBE.CommandBars.Add(\"CommandBarButtonMitEvent\")\r\n With<\/span> cbr\r\n Set<\/span> cbb = cbr.Controls.Add(msoControlButton)\r\n With<\/span> cbb\r\n .Style = msoButtonCaption\r\n .Caption = \"Button mit Ereignis\"\r\n End With<\/span>\r\n Set<\/span> objCommandBarButton = New<\/span> clsCommandBarButton\r\n Set<\/span> objCommandBarButton.CommandBarButton = cbb\r\n End With<\/span>\r\n cbr.Visible = True<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Menü](\"..\/fileadmin\/_temp_\/2024_04\/pic_436_003.png\")
<\/p>\nSymbole in Schaltflächen<\/h2>\n
\n
Eingebaute Symbole hinzufügen<\/h2>\n
Public Sub <\/span>AlleEingebautenIconsNachID()\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Dim <\/span>cbb As <\/span>CommandBarButton\r\n Dim <\/span>l As Long<\/span>\r\n Dim <\/span>objCommandBarButton As <\/span>clsCommandBarButtonFaceID\r\n Set<\/span> colCommandBarButtons = New<\/span> Collection\r\n On Error Resume Next<\/span>\r\n VBE.CommandBars(\"AlleIcons\").Delete\r\n On Error GoTo<\/span> 0\r\n Set<\/span> cbr = VBE.CommandBars.Add(\"AlleIcons\")\r\n With<\/span> cbr\r\n For l = 1 To 6000\r\n If <\/span>IsNull(DLookup(\"FaceID\", \"tblEmptyFaceIDs\", \"FaceID = \" & l)) Then<\/span>\r\n Set<\/span> cbb = cbr.Controls.Add(msoControlButton)\r\n With<\/span> cbb\r\n .FaceId = l\r\n .TooltipText = l\r\n .Tag = l\r\n End With<\/span>\r\n Set<\/span> objCommandBarButton = New<\/span> clsCommandBarButtonFaceID\r\n Set<\/span> objCommandBarButton.CommandBarButton = cbb\r\n colCommandBarButtons.Add objCommandBarButton\r\n End If<\/span>\r\n Next<\/span> l\r\n End With<\/span>\r\n cbr.Visible = True<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>m_CommandBarButton_Click(ByVal Ctrl As <\/span>_\r\n Office.CommandBarButton, CancelDefault As Boolean<\/span>)\r\n CurrentDb.Execute \"INSERT INTO \" _\r\n & \"tblEmptyFaceIDs(FaceID) VALUES(\" _\r\n & m_CommandBarButton.Tag & \")\", dbFailOnError\r\nEnd Sub<\/span><\/pre>\nPublic <\/span>colCommandBarButtons As <\/span>Collection<\/pre>\n![\"Alle](\"..\/fileadmin\/_temp_\/2024_04\/pic_436_004.png\")
<\/p>\n![\"Alle](\"..\/fileadmin\/_temp_\/2024_04\/pic_436_001.png\")
<\/p>\nBenutzerdefinierte Symbole hinzufügen<\/h2>\n
\n
Optische Unterteilung: BeginGroup<\/h2>\n
Vorhandene Schaltflächen in eigenen Menüs wiederverwenden<\/h2>\n
Public Sub <\/span>CreateCommandBar_Kontextmenue()\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Set<\/span> cbr = VBE.CommandBars.Add(, msoBarPopup)\r\n On Error Resume Next<\/span>\r\n VBE.CommandBars(\"Kontextmenueleiste\").Delete\r\n On Error GoTo<\/span> 0\r\n With<\/span> cbr\r\n .Name = \"Kontextmenueleiste\"\r\n .Controls.Add , 19\r\n .ShowPopup\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Anzeigen](\"..\/fileadmin\/_temp_\/2024_04\/pic_436_005.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2024_04\/pic_436_006.png\")
<\/p>\nPublic Sub <\/span>EingebauteBefehle()\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Dim <\/span>ctl As Object<\/span>\r\n For Each cbr In VBE.CommandBars\r\n If <\/span>cbr.BuiltIn Then<\/span>\r\n For Each ctl In cbr.Controls\r\n If <\/span>ctl.BuiltIn Then<\/span>\r\n Select Case TypeName(ctl)\r\n Case <\/span>\"CommandBarButton\", \"CommandBarComboBox\", \"CommandBarControl\"\r\n Call<\/span> WriteControl(ctl)\r\n Case <\/span>\"CommandBarPopup\"\r\n Call<\/span> EingebauteBefehle_Rek(ctl)\r\n End Select<\/span>\r\n End If<\/span>\r\n Next<\/span> ctl\r\n End If<\/span>\r\n Next<\/span> cbr\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>WriteControl(ctl As Object<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>lngID As Long<\/span>\r\n Dim <\/span>strCaption As String<\/span>\r\n Dim <\/span>strType As String<\/span>\r\n Dim <\/span>strSQL As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n lngID = ctl.Id\r\n strCaption = ctl.Caption\r\n strType = TypeName(ctl)\r\n strSQL = \"INSERT INTO tblControls(ControlID, ControlCaption, ControlType) VALUES(\" & ctl.Id & \", ''\" _\r\n & Replace<\/span>(ctl.Caption, \"&\", \"\") & \"'', ''\" & strType & \"'')\"\r\n On Error Resume Next<\/span>\r\n db.Execute strSQL, dbFailOnError\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>EingebauteBefehle_Rek(ctlPopup As Object<\/span>)\r\n Dim <\/span>ctl As Object<\/span>\r\n For Each ctl In ctlPopup.Controls\r\n If <\/span>ctl.BuiltIn = True<\/span> Then<\/span>\r\n Select Case TypeName(ctl)\r\n