<\/p>\n
Vor sehr langer Zeit (2003) gab es für die Office-Anwendungen noch die Möglichkeit, Menüleisten, Symbolleisten und Kontextmenüs über die Benutzeroberfläche anzupassen. Die Menüleisten und Symbolleisten sind seit der Version 2007 Geschichte, und damit ist auch der Editor für die Gestaltung dieser Elemente verschwunden. Allerdings gibt es noch die Kontextmenüs, und diese lassen sich auch noch anpassen – zum Beispiel, um eigene Befehle hinzuzufügen. Diese könnten beispielsweise Teil von Add-Ins, COM-Add-Ins oder auch von Dokumenten sein. In diesem Artikel zeigen wir, wie man vorhandene Kontextmenüs bearbeitet oder eigene Kontextmenüs anlegt und diese bei Bedarf aufruft.<\/b><\/p>\nUnterschiede zwischen Outlook und den übrigen Office-Anwendungen<\/h2>\n
Zwischen Outlook und den übrigen Office-Anwendungen gibt es einen entscheidenden Unterschied für die individuelle Anpassungen von Kontextmenüs: Während wir unter Word, Excel, Access oder PowerPoint das Objektmodell aus der Bibliothek Microsoft Office x.0 Object Library <\/b>nutzen können, um die gewünschten Anpassungen vorzunehmen, ist dies in Outlook nicht möglich. Hier sind die Kontextmenüs bereits Bestandteil des Ribbons. Änderungen der Kontextmenüs müssen wir in Outlook daher über die Ribbondefinition vornehmen, und zwar über die Einträge im Unterelement contextMenus<\/b>. Dieses Thema behandeln wir im vorliegenden Artikel nicht, aber wir gehen im Detail darauf in einem weiteren Artikel namens Kontextmenüs in Outlook anpassen <\/b>(www.vbentwickler.de\/369<\/b>) ein.<\/p>\nBeispieldateien<\/h2>\n
Da die CommandBars sich in den verschiedenen Office-Anwendungen Access, Excel und Word leicht unterschiedlich verhalten, haben wir jeweils eine Beispieldatei für jede Anwendung bereitgestellt:<\/p>\n
Um die Kontextmenüs anzupassen, benötigen wir Elemente der Bibliothek Microsoft Office x.0 Object Library<\/b>. Diese ist in beispielsweise in den VBA-Projekten von Word und Excel bereits referenziert, nicht jedoch unter Access oder in anderen Projekten auf Basis von Visual Studio oder twinBASIC. Damit wir die Bibliothek etwa in Access unter Einsatz von IntelliSense nutzen können, fügen wir einen Verweis auf diese Bibliothek hinzu. Dazu öffnen wir zunächst den VBA-Editor der jeweiligen Anwendung, beispielsweise mit der Tastenkombination Alt + F11<\/b>. Im VBA-Editor zeigen wir mit dem Menübefehl Extras|Verweise <\/b>den Verweise<\/b>-Dialog an. Hier selektieren Sie den Eintrag aus Bild 1 und fügen diese so hinzu.<\/p>\n
![\"Aktivieren](\"..\/fileadmin\/_temp_\/2023_03\/pic_368_001.png\")
<\/p>\n
Bild 1: Aktivieren des Verweises auf die Bibliothek Microsoft Office x.0 Object Library<\/span><\/b><\/p>\n Zeigen wir nun mit F2 <\/b>den Objektkatalog an, können wir dort die Bibliothek Office <\/b>auswählen und finden dort beispielsweise die Auflistung CommandBars<\/b> vor (siehe Bild 2). Diese bietet bereits einige interessante Elemente an. Unter anderem können wir damit die Anzahl aller aktuell verfügbaren CommandBar<\/b>-Elemente ausgeben:<\/p>\n Bild 2: Die CommandBars-Auflistung im Objektkatalog<\/span><\/b><\/p>\n Das liefert beispielsweise für Access die Anzahl von 247 CommandBar<\/b>-Elemente, unter Excel immerhin noch 199 Einträge. Ob es sich dabei ausschließlich um Kontextmenüs handelt, finden wir gleich heraus. Unter Access können wir direkt auf die CommandBars<\/b>-Auflistung zugreifen, unter Excel und Word müssen wir einen Verweis auf die Application<\/b>-Klasse voranstellen. Bei dem Zugriff von COM-Add-Ins aus ist dies ohnehin obligatorisch, mehr dazu zeigen wir in einem Beispiel in einem weiteren Artikel namens Kontextmenü per COM-Add-In anpassen <\/b>(www.vbentwickler.de\/370<\/b>).<\/p>\n Mit den folgenden Zeilen aus der Prozedur CommandBarsDurchlaufen <\/b>geben wir die Namen aller CommandBar<\/b>-Elemente im Direktbereich des VBA-Editors aus:<\/p>\n Das Gleiche gelingt auch per For…Next<\/b>-Schleife über den 1-basierten Index:<\/p>\n Die Ausgabe können wir noch verfeinern, indem wir zwei weitere Eigenschaften ausgeben lassen:<\/p>\n Die erste hier verwendete Eigenschaft lautet Type<\/b>. Type <\/b>kann einen der folgenden drei Werte liefern:<\/p>\n Die ersten beiden Typen sind für unsere Zwecke nicht relevant. Bei diesen handelt es sich um die Typen der bis Office 2003 verwendeten Elemente, die dort angezeigt wurden, wo jetzt das Ribbon erscheint. Interessant wird es, wenn die Eigenschaft Type <\/b>den Wert 2 <\/b>liefert. Geben wie also nun alle Kontextmenüs aus und lassen uns, da wir deren Anzahl nicht über die Count<\/b>-Eigenschaft bestimmen können, mit der Zählervariablen i <\/b>den Index ausgeben:<\/p>\n Lassen wir die Prozedur unter Access laufen, erhalten wir 138 Kontextmenüs, unter Excel nur 67.<\/p>\n Mit der bereits verwendeten Eigenschaft BuiltIn <\/b>können wir einen Boolean<\/b>-Wert ausgeben, der angibt, ob es sich um ein eingebautes Kontextmenü handelt. Damit können wir die eingebauten Kontextmenüs von denen unterscheiden, die wir selbst per VBA hinzufügen.<\/p>\n Wozu sollten wir überhaupt wissen wollen, welche eingebauten Kontextmenü die jeweiligen Anwendungen anbieten? Weil es geschehen kann, dass wir nicht gleich ein vollständiges Kontextmenü mit neuen Funktionen hinzufügen wollen, sondern nur einzelne Funktionen, die in bestehenden Kontextmenüs angezeigt werden sollen.<\/p>\n Wenn wir beispielsweise unter Excel eine Funktion hinzufügen wollen, die nur im Zusammenhang mit einer Zelle angezeigt werden soll – also wenn der Benutzer mit der rechten Maustaste auf eine Zelle klickt – dann müssen wir den Namen dieses Kontextmenüs herausfinden und passen dann dieses Kontextmenü an.<\/p>\n Den Namen eines Kontextmenüs kann man auf mehrere Arten ermitteln. Die erste ist die Ausgabe der Namen aller Kontextmenüs der jeweiligen Anwendung. Dazu führen wir die obige Prozedur zum Durchlaufen aller Kontextmenüs in der jeweiligen Anwendung aus. In vielen Fällen können wir schon am Namen des Kontextmenüs erkennen, wann dieses angezeigt wird.<\/p>\n Im Falle von Excel und einem Kontextmenü für eine Zelle werden wir schnell fündig – das Kontextmenü heißt Cell<\/b> (siehe Bild 3).<\/p>\n Bild 3: Ausgabe der Kontextmenüs von Excel<\/span><\/b><\/p>\n Unter anderen Anwendungen wie Access ist es teilweise schwierig, das richtige Kontextmenü aufgrund der Benennung zu finden. In diesem Fall kommt eine zweite Technik zum Zuge.<\/p>\n Unter Excel nutzen wir zu Beispielzwecken wie beschrieben die Kontextmenüs Cell<\/b> oder Column<\/b>. In der Beispieldatei für Word schauen wir uns in den Beispielen das Kontextmenü Text <\/b>an, das beim Rechtsklick auf normalen Text im Dokument erscheint. In der Beispieldatei für Access verwenden wir das Kontextmenüs eines Elements des Navigationsbereichs namens Navigation Pane object Pop-up<\/b>.<\/p>\n Dabei greifen wir einer Technik vor, die wir weiter unten noch genauer erläutern. Wir fügen jedem Kontextmenü eine Schaltfläche hinzu, für deren Beschriftung wir den Namen des CommandBar<\/b>-Elements festlegen. Dabei durchlaufen wir wieder alle Elemente der CommandBars<\/b>-Auflistung und rufen jeweils für die Controls<\/b>-Auflistung die Add<\/b>-Methode auf. Dieser übergeben wir als ersten Parameter den Typ des zu erstellenden Steuerelements, in diesem Fall msoControlButton <\/b>für eine Schaltfläche. Außerdem hinterlegen wir für den letzten Parameter Temporary <\/b>den Wert True<\/b>. Dies sorgt dafür, dass die angelegten Steuerelemente nur für die aktuelle Session der jeweiligen Anwendung angezeigt werden und bei einem weiteren Start nicht erneut erscheinen:<\/p>\n Führen wir diese Prozedur aus und zeigen mit der rechten Maustaste eines der Kontextmenüs der Anwendung an, liefert dieses in einem neuen Eintrag den Namen des Kontextmenüs (siehe Bild 4).<\/p>\n Bild 4: Name eines CommandBar-Elements als Schaltflächenbeschriftung<\/span><\/b><\/p>\n Mit dem Namen eines Kontextmenüs können wir gezielt auf das jeweilige Kontextmenü zugreifen und dessen Elemente bearbeiten oder neue Elemente hinzufügen.<\/p>\n Wir schauen uns dies zunächst beim Ausgeben der Steuerelemente eines Kontextmenüs an. Die folgende Prozedur referenziert das Kontextmenü Column <\/b>von Excel (wenn Du den in einer anderen Anwendung ausprobieren möchtest, gib den Namen eines dort vorhandenen Steuerelements an). Dann durchläuft die Prozedur alle Elemente der Controls<\/b>-Auflistung des CommandBar<\/b>-Elements. Wichtig ist, dass wir die Laufvariable ctl <\/b>mit dem Typ Object <\/b>deklarieren. Der Hintergrund ist, dass die Controls<\/b>-Auflistung verschiedene Steuerelementtypen enthalten kann. Deshalb geben wir im Folgenden direkt den Wert der Eigenschaft Type <\/b>des jeweiligen Steuerelements aus. Noch eine bessere Methode, um den Typ zu ermitteln, ist die Ausgabe von TypeName(ctl):<\/b><\/p>\n Die Ausgabe für das Column<\/b>-Kontextmenü lautet:<\/p>\n Es gibt eine ganze Reihe von Steuerelementtypen, die Du im Objektkatalog unter der Auflistung msoControlType <\/b>einsehen kannst. Wir können jedoch nur einige wenige nutzen. Unter den eingebauten Steuerelementen finden wir eine ganze Reihe verschiedener Typen, aber wir können nur drei davon mit der Add-Methode zur Controls-Auflistung hinzufügen:<\/p>\n Das erledigen wir beispielhaft mit der folgenden Prozedur. Hier fügen wir nicht nur die drei verschiedenen Typen hinzu, sondern zeigen gleich noch das angepasste Kontextmenü mit der Methode ShowPopup <\/b>an:<\/p>\n Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>Das Objektmodell zum Anpassen von Kontextmenüs<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2023_03\/pic_368_002.png\")
<\/p>\nDebug.Print<\/span> \"Anzahl Commandbars: \" _\r\n & Application.CommandBars.Count<\/pre>\nCommandBar-Elemente durchlaufen<\/h2>\n
Dim <\/span>cbr As <\/span>CommandBar\r\nFor Each cbr In Application.CommandBars\r\n Debug.Print<\/span> cbr.Name\r\nNext<\/span> cbr<\/pre>\nDim <\/span>cbr As <\/span>CommandBar\r\nDim <\/span>i As Integer<\/span>\r\nFor i = 1 To Application.CommandBars.Count\r\n Set<\/span> cbr = Application.CommandBars.Item(i)\r\n Debug.Print<\/span> cbr.Name\r\nNext<\/span> i<\/pre>\nDebug.Print<\/span> cbr.Name, cbr.Type, cbr.BuiltIn<\/pre>\nTyp eines CommandBar-Elements ermitteln<\/h2>\n
\n
Dim <\/span>cbr As <\/span>CommandBar\r\nDim <\/span>i As Integer<\/span>\r\nFor Each cbr In Application.CommandBars\r\n If <\/span>cbr.Type = msoBarTypePopup Then<\/span>\r\n i = i + 1\r\n Debug.Print<\/span> i, cbr.Name, cbr.BuiltIn\r\n End If<\/span>\r\nNext<\/span> cbr<\/pre>\nEingebaute oder benutzerdefinierte Kontextmenüs<\/h2>\n
Wozu die eingebauten Kontextmenüs nutzen?<\/h2>\n
Namen eines Kontextmenüs herausfinden<\/h2>\n
![\"Ausgabe](\"..\/fileadmin\/_temp_\/2023_03\/pic_368_003.png\")
<\/p>\nBeispielkontextmenüs in den anderen Anwendungen<\/h2>\n
Name des Kontextmenüs in das Kontextmenü schreiben<\/h2>\n
Public Sub <\/span>NameInKontextmenuesSchreiben()\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Dim <\/span>cbb As <\/span>CommandBarButton\r\n Dim <\/span>i As Integer<\/span>\r\n For Each cbr In Application.CommandBars\r\n If <\/span>cbr.Type = msoBarTypePopup Then<\/span>\r\n Set<\/span> cbb = cbr.Controls.Add( _\r\n msoControlButton, , , , True<\/span>)\r\n cbb.Caption = cbr.Name\r\n End If<\/span>\r\n Next<\/span> cbr\r\nEnd Sub<\/span><\/pre>\n![\"Name](\"..\/fileadmin\/_temp_\/2023_03\/pic_368_004.png\")
<\/p>\nElemente von Kontextmenüs ausgeben<\/h2>\n
Public Sub <\/span>ElementeEinesKontextmenuesAusgeben()\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Dim <\/span>ctl As Object<\/span>\r\n Set<\/span> cbr = Application.CommandBars(\"Column\")\r\n For Each ctl In cbr.Controls\r\n Debug.Print<\/span> ctl.Caption, ctl.Type, TypeName(ctl)\r\n Next<\/span> ctl\r\nEnd Sub<\/span><\/pre>\nAuss&chneiden 1 CommandBarButton\r\nK&opieren 1 CommandBarButton\r\nEinfü&gen 1 CommandBarButton\r\nInhalte einfü&gen... 1 CommandBarButton\r\nTabelle e&infügen 1 CommandBarButton\r\n&Datentyp 10 CommandBarPopup\r\nZellen &einfügen 1 CommandBarButton\r\nZellen l&öschen 1 CommandBarButton\r\nInhal&te löschen 1 CommandBarButton\r\nZellen &formatieren... 1 CommandBarButton\r\nSpalten&breite... 1 CommandBarButton\r\n&Ausblenden 1 CommandBarButton\r\nEinb&lenden 1 CommandBarButton\r\n&Links entfernen 1 CommandBarButton\r\nÄnderun&gen anzeigen 1 CommandBarButton<\/pre>\n
\n
Public Sub <\/span>ElementeAnlegen()\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Dim <\/span>ctl As Object<\/span>\r\n Set<\/span> cbr = Application.CommandBars(\"Column\")\r\n Set<\/span> ctl = cbr.Controls.Add(1, , , , True<\/span>)\r\n ctl.Caption = \"msoControlButton\"\r\n Set<\/span> ctl = cbr.Controls.Add(4, , , , True<\/span>)\r\n ctl.Caption = \"msoControlComboBox\"\r\n Set<\/span> ctl = cbr.Controls.Add(10, , , , True<\/span>)\r\n ctl.Caption = \"msoControlPopup\"\r\n cbr.ShowPopup\r\nEnd Sub<\/span><\/pre>\n
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t