Auch auf die Anpassung von Kontextmenüs in Outlook sind wir bereits eingegangen – siehe Outlook: Kontextmenüs anpassen <\/b>(www.vbentwickler.de\/369<\/b>).<\/p>\n
In diesem Artikel nun schauen wir uns im Detail an, wie wir die eingebauten Kontextmenü-Befehle in benutzerdefinierte Kontextmenüs einbauen können – zum Beispiel die aus Bild 1.<\/p>\n
![\"Beispiel](\"..\/fileadmin\/_temp_\/2025_01\/pic_462_002.png\")
<\/p>\n
Bild 1: Beispiel für ein eingebautes Kontextmenü<\/span><\/b><\/p>\n Dazu sind die folgenden Schritte nötig:<\/p>\n Der erste Schritt ist relativ aufwendig. Wir können nicht einfach ein Kontextmenü öffnen und dieses beispielsweise anhand des Namens identifizieren. Stattdessen benötigen wir einen anderen Wert, nämlich die ID dieses Eintrags.<\/p>\n An diesen kommen wir jedoch auch nicht so leicht. Es gibt keine Möglichkeit, diese ID direkt auszulesen.<\/p>\n Daher bauen wir uns eine Tabelle und eine Prozedur, um diese Tabelle mit den Informationen zu den Kontextmenü-Einträgen zu füllen.<\/p>\n Die Tabelle heißt tblControls<\/b> und sieht in der Entwurfsansicht wie in Bild 2 aus.<\/p>\n Bild 2: Entwurf der Tabelle zum Speichern der Kontextmenü-Einträge mit Eigenschaften<\/span><\/b><\/p>\n Nachdem wir die Tabelle per Code gefüllt haben, sollte diese etwa wie in Bild 3 aussehen.<\/p>\n Bild 3: Datenblattansicht der Tabelle zum Speichern der Kontextmenü-Einträge mit Eigenschaften<\/span><\/b><\/p>\n Die Prozedur KontextmenuesEinlesen <\/b>aus Listing 1 ist die Hauptprozedur zum Einlesen der Steuerelemente der Kontextmenüs.<\/p>\n Listing 1: Die Prozedur KontextmenuesEinlesen liest die Elemente der ersten Ebene in die Tabelle tblControls ein.<\/span><\/b><\/p>\n Um diese zu nutzen, müssen wir zuvor einen Verweis auf die Bibliothek Microsoft Office 16.0 Object Library <\/b>setzen (siehe Bild 4). Diese enthält das Objektmodell für den Zugriff auf die CommandBar<\/b>-Elemente, also die Menüs.<\/p>\n Bild 4: Verweis auf die Office-Bibliothek<\/span><\/b><\/p>\n Die Prozedur KontextmenuesEinlesen<\/b> startet damit, die Tabelle tblControls <\/b>vollständig zu leeren. Das erledigt sie durch den Aufruf einer DELETE<\/b>-Anweisung. <\/p>\n Danach durchläuft sie in einer äußeren For Each<\/b>-Schleife alle Elemente der CommandBars<\/b>-Auflistung. Diese Auflistung enthält alle Menüleisten der jeweiligen Anwendung. Dazu gehören auch alle benutzerdefinierten Elemente und auch die in den moderneren Office-Versionen (ab 2007) nicht mehr sichtbaren Menü- und Symbolleisten.<\/p>\n Da wir weder an den Steuerelementen der benutzerdefinierten Menüleisten interessiert sind noch an denen, die in früheren Menü- und Symbolleisten angezeigt wurden, schließen wir diese aus.<\/p>\n Die benutzerdefinierten Elemente ignorieren wir in einer If…Then<\/b>-Bedingung, in der wir die Eigenschaft BuiltIn <\/b>des jeweiligen CommandBar<\/b>-Elements untersuchen. Hat diese den Wert True<\/b>, sind wir an der richtigen Stelle.<\/p>\n Den Typ des Menüs prüfen wir in einer Select Case<\/b>-Bedingung, in der wir den Wert der Eigenschaft Type <\/b>des CommandBar<\/b>-Elements mit dem Wert der Konstanten msoBarTypePopup <\/b>vergleichen, was dem Typ für die Kontextmenüs entspricht.<\/p>\n Stoßen wir auf ein solches Kontextmenü, durchlaufen wir in einer weiteren Schleife alle Steuerelemente dieses Menüs. Das erledigen wir in einer For Each<\/b>-Schleife, die alle Elemente von cbr.Controls <\/b>durchläuft und das aktuelle Element jeweils mit der Variablen cbc <\/b>referenziert. cbc <\/b>hat den Datentyp CommandBarControl<\/b>, was erst einmal alle möglichen Steuerelementtypen umfasst.<\/p>\n In dieser Schleife prüfen wir wiederum in einer If…Then<\/b>-Bedingung auf die Eigenschaft BuiltIn<\/b>, denn auch bei den Kontextmenü-Befehlen können sich benutzerdefinierte Elemente eingeschlichen haben. Diese wollen wir jedoch ignorieren.<\/p>\n Damit haben wir ein Steuerelement gefunden, das wir in unserer Tabelle verewigen wollen.<\/p>\n Das erledigen wir mit einer INSERT INTO<\/b>-Anweisung, die einen neuen Datensatz zur Tabelle tblControls <\/b>hinzufügt und dabei die Felder ControlID<\/b>, ControlCaption<\/b>, CommandBar<\/b>, Index<\/b>, ControlTypeID <\/b>und ControlType <\/b>mit den jeweiligen Werten der Eigenschaften füllt.<\/p>\n Die Informationen holen wir aus den folgenden Eigenschaften:<\/p>\n Nach dem Eintragen des neuen Datensatzes für dieses Steuerelement lesen wir die ID des neu hinzugefügten Datensatzes in die Variable lngID <\/b>ein. Diese benötigen wir noch, um bei den untergeordneten Steuerelementen anzugeben, welches das Parent<\/b>-Steuerelement ist.<\/p>\n Schließlich prüfen wir in einer weiteren Select Case<\/b>-Bedingung, welchen Steuerelementtyp unser aktuell bearbeitetes Steuerelement hat. Im Falle von msoControlButton<\/b>, msoControlComboBox<\/b>, msoControlExpandingGrid<\/b>, msoControlEdit <\/b>oder msoControlGrid <\/b>gibt es keine untergeordneten Steuerelemente. Hier soll nichts weiter geschehen.<\/p>\n Die Steuerelemente mit den Typen msoControlPopup<\/b>, msoControlButtonPopup<\/b>, msoControlSplitButtonMRUPopup <\/b>und msoControlSplitButtonPopup <\/b>jedoch können untergeordnete Elemente enthalten und deshalb wollen wir auch diese Elemente noch untersuchen.<\/p>\n Zu diesem Zweck rufen wir eine weitere Funktion namens UntermenuesEinlesen <\/b>auf, der wir einen Verweis auf die aktuelle Datenbank (db<\/b>), den Verweis auf das übergeordnete Steuerelement (cbc<\/b>), die ID des dazu angelegten Datensatzes in der Tabelle tblControls <\/b>und den Namen des übergeordneten Menüs (cbr.Name<\/b>).<\/p>\n Für alle noch verbleibenden Steuerelementtypen geben wir einfach den Wert der entsprechenden Konstanten im Direktbereich auf, damit wir diesen gegebenenfalls noch nachtragen können.<\/p>\n Die Prozedur UntermenuesEinlesen <\/b>wird für alle untergeordneten Elemente von menüartigen Steuerelementen aus aufgerufen und ruft sich auch wieder selbst auf, wenn dabei weitere Steuerelemente mit Kind-Elementen durchlaufen werden (siehe Listing 2).<\/p>\n Listing 2: Die Prozedur UntermenuesEinlesen liest die Elemente der ersten Ebene in die Tabelle tblControls ein.<\/span><\/b><\/p>\n Sie erwartet die bereits oben beschriebenen Parameter und erweitert den Parameter strCommandBarName<\/b> mit dem Namen des übergeordneten Menüs zunächst um den Namen des untergeordneten Elements.<\/p>\n Dann erledigt sie im Prinzip die gleichen Aufgaben wie die oben bereits beschriebene Prozedur KontextmenuesEinlesen<\/b>. Der Unterschied ist, das hier noch das Feld ParentID <\/b>der Tabelle tblControls <\/b>gefüllt wird, und zwar mit dem Primärschüsselwert für das übergeordnete Element.<\/p>\n So könnten wir leicht auf Basis der in der Tabelle gespeicherten Daten die Hierarchie nachbilden. Außerdem ruft die Prozedur sich selbst auf, wenn für ein Steuerelement weitere untergeordnete Steuerelemente gefunden werden.<\/p>\n Schließlich verwenden wir noch eine Funktion namens ControlTypeString<\/b>, der wir den Wert der Konstanten für den Typ eines der Steuerelemente als Parameter übergeben (siehe Listing 3).<\/p>\n Listing 3: Die Funktion ControlTypeString holt die Konstante als Zeichenkette.<\/span><\/b><\/p>\n Diese Funktion prüft in einer Select Case<\/b>-Bedingung den Wert des Parameters und gibt die Bezeichnung der Konstanten wie beispielsweise msoControlButton <\/b>als Ergebnis der Funktion zurück.<\/p>\n Auf diese Weise können wir in der Tabelle einen aussagekräftigeren Wert als nur den Zahlenwert der Konstanten für den Typ des jeweiligen Steuerelements hinterlegen.<\/p>\n Nun wollen wir die benötigten IDs aus der Tabelle auslesen und diese in einem eigenen Kontextmenü einbauen.<\/p>\n Die drei Befehle Ausschneiden<\/b>, Kopieren <\/b>und Einfügen <\/b>finden wir gleich mehrfach in der Tabelle tblControls<\/b>, da diese in fast jedem Kontextmenü vorkommen (siehe Bild 5). Sie haben die IDs 21<\/b>, 19 <\/b>und 22<\/b>.<\/p>\n Bild 5: IDs für die Befehle Ausschneiden, Kopieren und Einfügen<\/span><\/b><\/p>\n Damit stellen wir uns nun ein benutzerdefiniertes Kontextmenü zusammen und zeigen dieses an. Der Code dazu sieht wie folgt aus:<\/p>\n Hier erstellen wir ein neues CommandBar<\/b>-Objekt mit der Add<\/b>-Methode der CommandBars<\/b>-Auflistung.<\/p>\n Dieser übergeben wir den Namen der zu erstellenden Kontextmenüleiste und den Typ (msoBarPopup<\/b>) und geben mit den folgenden Parametern an, dass es keine Menüleiste werden soll und die Kontextmenüleiste temporär erstellt werden soll. Das führt dazu, dass sie nur bis zum Schließen der Datenbank vorhanden ist.<\/p>\n Beim Aufrufen dieser Prozedur erscheint an der Position des Mauszeigers ein Kontextmenü mit den drei Befehlen Ausschneiden<\/b>, Kopieren <\/b>und Einfügen<\/b>.<\/p>\n Auf diese Weise können wir benutzerdefinierte Kontextmenüs leicht um eingebaute Befehle erweitern. Dazu benötigen wir nur die IDs dieser Befehle, die wir in der per Code gefüllten Tabelle leicht auslesen können.<\/p>\n","protected":false},"excerpt":{"rendered":" Wir haben bereits in einigen weiteren Artikel beschrieben, wie wir unseren Anwendungen in Word, Excel oder Access benutzerdefinierte Kontextmenü-Einträge oder sogar vollständige Kontextmenüs hinzufügen können. Was wird dort noch nicht berücksichtigt haben: Manchmal möchte man vielleicht ein eingebautes Element in einem benutzerdefinierten Kontextmenü oder gar ein vollständiges Menü nachbauen, um dann selbst genauer zu steuern, wann dieses angezeigt werden soll. Ein gutes Beispiel sind die Befehle für die Verwendung der Zwischenablage, also Ausschneiden, Kopieren und Einfügen. Es kann sinnvoll sein, diese einem benutzerdefinierten Kontextmenü hinzuzufügen. In diesem Artikel beschreiben wir, wie Du herausfindest, welche Informationen über das eingebaute Kontextmenü-Element benötigst und wie Du dieses in einem benutzerdefinierten Kontextmenü abbildest.<\/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":[66012025,662025,44000038,44000022],"tags":[],"yst_prominent_words":[],"class_list":["post-55000462","post","type-post","status-publish","format-standard","hentry","category-66012025","category-662025","category-Office_programmieren","category-Von_Access_zu_NET"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n
Identifizieren der eingebauten Kontextmenü-Befehle<\/h2>\n
Tabelle zum Speichern der Kontextmenü-Einträge<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2025_01\/pic_462_003.png\")
<\/p>\n![\"Datenblattansicht](\"..\/fileadmin\/_temp_\/2025_01\/pic_462_004.png\")
<\/p>\nHauptprozedur zum Einlesen der Kontextmenü-Elemente<\/h2>\n
Public Sub <\/span>KontextmenuesEinlesen()\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Dim <\/span>cbc As <\/span>CommandBarControl\r\n Dim <\/span>db As <\/span>dao.Database\r\n Dim <\/span>lngID As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblControls\", dbFailOnError\r\n For Each cbr In Application.CommandBars\r\n If <\/span>cbr.BuiltIn = True<\/span> Then<\/span>\r\n Select Case cbr.Type\r\n Case <\/span>msoBarTypePopup\r\n For Each cbc In cbr.Controls\r\n If <\/span>cbc.BuiltIn = True<\/span> Then<\/span>\r\n On Error Resume Next<\/span>\r\n db.Execute \"INSERT INTO tblControls(ControlID, ControlCaption, CommandBar, Index, \" _\r\n \"ControlTypeID, ControlType) VALUES(\" & cbc.Id & \", ''\" & cbc.Caption & \"'', ''\" _\r\n & cbr.Name & \"'', \" & cbc.Index & \", \" & cbc.Type & \", ''\" _\r\n & ControlTypeString(cbc.Type) & \"'')\", dbFailOnError\r\n lngID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n On Error GoTo<\/span> 0\r\n End If<\/span>\r\n Select Case cbc.Type\r\n Case <\/span>msoControlButton, msoControlComboBox, msoControlExpandingGrid, msoControlEdit, _\r\n msoControlGrid\r\n Case <\/span>msoControlPopup, msoControlButtonPopup, msoControlSplitButtonMRUPopup, _\r\n msoControlSplitButtonPopup\r\n Call<\/span> UntermenuesEinlesen(db, cbc, lngID, cbr.Name)\r\n Case Else<\/span>\r\n Debug.Print<\/span> cbc.Type\r\n End Select<\/span>\r\n Next<\/span> cbc\r\n End Select<\/span>\r\n End If<\/span>\r\n Next<\/span> cbr\r\nEnd Sub<\/span><\/pre>\n![\"Verweis](\"..\/fileadmin\/_temp_\/2025_01\/pic_462_001.png\")
<\/p>\n\n
Rekursiver Teil der Prozedur zum Einlesen der Kontextmenü-Elemente<\/h2>\n
Public Sub <\/span>UntermenuesEinlesen(db As <\/span>dao.Database, cbcParent As <\/span>CommandBarControl, lngParentID As Long<\/span>, _\r\n strCommandBarName As String<\/span>)\r\n Dim <\/span>cbc As <\/span>CommandBarControl\r\n Dim <\/span>lngID As Long<\/span>\r\n strCommandBarName = strCommandBarName & \"|\" & cbcParent.Caption\r\n For Each cbc In cbcParent.Controls\r\n If <\/span>cbc.BuiltIn = True<\/span> Then<\/span>\r\n On Error Resume Next<\/span>\r\n db.Execute \"INSERT INTO tblControls(ControlID, ControlCaption, CommandBar, Index, ControlTypeID, \" _\r\n & \"ControlType, ParentID) VALUES(\" & cbc.Id & \", ''\" & cbc.Caption & \"'', ''\" & strCommandBarName _\r\n & \"'', \" & cbc.Index & \", \" & cbc.Type & \", ''\" & ControlTypeString(cbc.Type) & \"'', \" & lngParentID _\r\n & \")\", dbFailOnError\r\n lngID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n On Error GoTo<\/span> 0\r\n End If<\/span>\r\n Select Case cbc.Type\r\n Case <\/span>msoControlButton, msoControlComboBox, msoControlExpandingGrid, msoControlEdit, msoControlGrid\r\n Case <\/span>msoControlPopup, msoControlButtonPopup, msoControlSplitButtonMRUPopup, msoControlSplitButtonPopup\r\n Call<\/span> UntermenuesEinlesen(db, cbc, lngID, strCommandBarName)\r\n Case Else<\/span>\r\n Debug.Print<\/span> cbc.Type\r\n End Select<\/span>\r\n Next<\/span> cbc\r\nEnd Sub<\/span><\/pre>\nFunktion zum Einlesen der Steuerelementtypen als Zeichenkette<\/h2>\n
Public Function <\/span>ControlTypeString(lngControlType As Long<\/span>) As String<\/span>\r\n Select Case lngControlType\r\n Case <\/span>msoControlButton\r\n ControlTypeString = \"msoControlButton\"\r\n Case <\/span>msoControlComboBox\r\n ControlTypeString = \"msoControlComboBox\"\r\n Case <\/span>msoControlExpandingGrid\r\n ControlTypeString = \"msoControlExpandingGrid\"\r\n Case <\/span>msoControlPopup\r\n ControlTypeString = \"msoControlPopup\"\r\n Case <\/span>msoControlButtonPopup\r\n ControlTypeString = \"msoControlButtonPopup\"\r\n Case <\/span>msoControlSplitButtonMRUPopup\r\n ControlTypeString = \"msoControlSplitButtonMRUPopup\"\r\n Case <\/span>msoControlSplitButtonPopup\r\n ControlTypeString = \"msoControlSplitButtonPopup\"\r\n Case <\/span>msoControlEdit\r\n ControlTypeString = \"msoControlEdit\"\r\n Case <\/span>msoControlGrid\r\n ControlTypeString = \"msoControlGrid\"\r\n Case Else<\/span>\r\n Debug.Print<\/span> lngControlType\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\nErmitteln der IDs für eingebaute Befehle im benutzerdefinierten Kontextmenü<\/h2>\n
![\"IDs](\"..\/fileadmin\/_temp_\/2025_01\/pic_462_005.png\")
<\/p>\nPublic Sub <\/span>NeuesKontextmenue()\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n On Error Resume Next<\/span>\r\n CommandBars(\"Benutzerdefiniert\").Delete\r\n On Error GoTo<\/span> 0\r\n Set<\/span> cbr = CommandBars.Add(\"Benutzerdefiniert\", _\r\n msoBarPopup, False, True<\/span>)\r\n cbr.Controls.Add msoControlButton, 21\r\n cbr.Controls.Add msoControlButton, 19\r\n cbr.Controls.Add msoControlButton, 22\r\n cbr.ShowPopup\r\nEnd Sub<\/span><\/pre>\nZusammenfassung und Ausblick<\/h2>\n