{"id":55000435,"date":"2024-08-01T00:00:00","date_gmt":"2024-08-14T14:45:54","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=435"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Menues_per_VBA_programmieren","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Menues_per_VBA_programmieren\/","title":{"rendered":"Menüs per VBA programmieren"},"content":{"rendered":"

\"\"Das Menüsystem des VBA-Editors lässt sich über die Benutzeroberfläche bereits einfach anpassen. Das haben wir im Artikel “Menüsystem im VBA-Editor anpassen” (www.vbentwickler.de\/434) gezeigt. Außerdem haben wir uns im Artikel “Kontextmenüs per VBA programmieren” (www.vbentwickler.de\/368) bereits angeschaut, wie wir per VBA Kontextmenüs erstellen und anpassen können. Es fehlen also noch die Informationen, wie wir die eigentlichen Menüleisten und Symbolleisten mit VBA programmieren können. Wie das gelingt, schauen wir uns im vorliegenden Artikel an. Wir zeigen, wie vorhandene Menüs angepasst und wie neue Menüs erstellt werden können. <\/b><\/p>\n

Warum haben wir eigentlichen einen eigenen Artikel zum Thema Kontextmenüs per VBA programmieren veröffentlicht und nicht direkt etwas weiter ausgeholt und die Menü- und Symbolleisten ebenfalls beschrieben? Weil es damals darum ging, die Benutzeroberfläche der Office-Anwendungen zu erweitern.<\/p>\n

Und da diese bekanntlich seit Office 2007 keine Menü- und Symbolleisten mehr verwenden, sondern das Ribbon, haben wir uns auf die Kontextmenüs beschränkt.<\/p>\n

Das wirft nun die Frage auf, warum wir uns dann jetzt mit den Menü- und Symbolleisten beschäftigen wollen. Nun: Es gibt noch das gallische Dorf unter den Microsoft-Anwendungen, in denen noch Menü- und Symbolleisten verwendet werden.<\/p>\n

Dabei handelt es sich um die Anwendung, mit der wir täglich arbeiten: den VBA-Editor. Dieser verwendet noch das gute, alte Menü- und Symbolleistensystem, das jüngere VBA-Entwickler möglicherweise von Office selbst gar nicht mehr kennen.<\/p>\n

Und da wir beispielsweise mit twinBASIC den VBA-Editor erweitern wollen und das Menüsystem nun einmal der Hauptort zum Unterbringen von Steuerelementen zum Aufrufen der Funktionen der entsprechenden COM-Add-Ins ist, schauen wir uns nun doch noch einmal die Grundlagen zu den Menü- und Symbolleisten an.<\/p>\n

Office-Verweis sinnvoll<\/h2>\n

Dazu ist es sinnvoll, dem VBA-Projekt erst einmal einen Verweis auf die Bibliothek Microsoft Office 16.0 Object Library <\/b>hinzuzufügen.<\/p>\n

Das erledigen wir über den Verweise-Dialog, den wir über den Menüeintrag Extras|Verweise<\/b> des VBA-Editors öffnen (siehe Bild 1).<\/p>\n

\"Hinzufügen<\/p>\n

Bild 1: Hinzufügen eines Verweises auf die Office-Bibliothek<\/span><\/b><\/p>\n

Alles ist eine Symbolleiste<\/h2>\n

Um direkt zu Beginn eine Begrifflichkeit zu klären: Im Sinne von VBA sind sowohl Menüleisten, Symbolleisten als auch Kontextmenüs alles Symbolleisten, unter VBA CommandBar <\/b>genannt.<\/p>\n

Menüleisten und Kontextmenüs unterscheiden sich nur durch bestimmte Eigenschaften von den anderen Elementen.<\/p>\n

Symbolleisten durchlaufen<\/h2>\n

Mit der Office-Bibliothek holen wir uns das Objektmodell zum Verwalten von CommandBar<\/b>-Elementen in das VBA-Projekt. <\/p>\n

Vom VBA-Editor aus können wir gleich zwei CommandBars<\/b>-Auflistungen durchlaufen, nämlich die des VBA-Editors als auch die der jeweiligen Host-Anwendung – also beispielsweise Access, Excel, Outlook, PowerPoint oder Word.<\/p>\n

Die folgende Prozedur gibt zuerst alle Elemente des VBA-Editors aus (referenziert mit VBE.CommandBars<\/b>) und dann die Elemente der aktuellen Host-Anwendung, hier Access (referenziert mit Access.Commandbars<\/b>):<\/p>\n

Public Sub <\/span>AlleCommandbars()\r\n     Dim <\/span>cbr As <\/span>CommandBar\r\n     For Each cbr In VBE.CommandBars\r\n         Debug.Print<\/span> \"VBA-Editor: \" & cbr.Name\r\n     Next<\/span> cbr\r\n     For Each cbr In Access.CommandBars\r\n         Debug.Print<\/span> \"Access: \" & cbr.Name\r\n     Next<\/span> cbr\r\nEnd Sub<\/span><\/pre>\n
Wir wollen hier besonderes Augenmerk auf die Elemente des VBA-Editors legen. Die Menge ist überschaubar, wie Bild 2 zeigt.<\/p>\n
\"Alle<\/p>\n
Bild 2: Alle Symbolleisten des VBA-Editors<\/span><\/b><\/p>\n
Unterscheidung der Symbolleisten nach Typ<\/h2>\n
Wie aber können wir nun die Menüleisten, Symbolleisten und Kontextmenüleisten voneinander unterscheiden?<\/p>\n
Dabei hilft uns die Eigenschaft Type<\/b>. Sie liefert uns verschiedene Werte (0<\/b>, 1 <\/b>und 2<\/b>). Wie finden wir heraus, welcher Wert welche Bedeutung hat? Da IntelliSense uns hier keine Hinweise gibt, schauen wir im Objektkatalog nach.<\/p>\n
Hier finden wir, wenn wir unter Klassen das CommandBar<\/b>-Element selektieren und in den Elementen den Eintrag Type<\/b>, die Information, dass es sich hierbei um die Auflistung msoBarType<\/b> handelt (siehe Bild 3).<\/p>\n
\"Ermitteln<\/p>\n
Bild 3: Ermitteln des Typs einer Eigenschaft<\/span><\/b><\/p>\n
Ein Klick auf diese Auflistung zeigt direkt die Elemente dieser Auflistung und somit die möglichen Werte (siehe Bild 4). Klicken wir diese nacheinander an, erhalten wir die folgenden Zahlenwerte samt zugehörigen Konstanten plus Bedeutung:<\/p>\n
\"Ermitteln<\/p>\n
Bild 4: Ermitteln der Werte eines Eigenschaft<\/span><\/b><\/p>\n
    \n
  • 0 <\/b>(msoBarTypeNormal<\/b>): Symbolleiste<\/li>\n
  • 1 <\/b>(msoBarTypeMenuBar<\/b>): Menüleiste<\/li>\n
  • 2 <\/b>(msoBarTypePopup<\/b>): Kontextmenü<\/li>\n<\/ul>\n
    Diese Werte können wir uns gleich merken, denn wir benötigen diese später zum Anlegen neuer CommandBar<\/b>-Elemente.<\/p>\n
    Passen wir also unsere Prozedur zur Ausgabe der VBA-Editor-Symbolleisten wie folgt an:<\/p>\n
    Public Sub <\/span>AlleCommandbars()\r\n     Dim <\/span>cbr As <\/span>CommandBar\r\n     For Each cbr In VBE.CommandBars\r\n         Select Case cbr.Type\r\n             Case <\/span>msoBarTypeNormal\r\n                 Debug.Print<\/span> \"Symbolleiste: \" & cbr.Name\r\n             Case <\/span>msoBarTypeMenuBar\r\n                 Debug.Print<\/span> \"Menüleiste:   \" & cbr.Name\r\n             Case <\/span>msoBarTypePopup\r\n                 Debug.Print<\/span> \"Kontextmenü:  \" & cbr.Name\r\n         End Select<\/span>\r\n     Next<\/span> cbr\r\nEnd Sub<\/span><\/pre>\n
    Damit erhalten wir bereits genauere Informationen darüber, welche Typ ein CommandBar<\/b>-Objekt hat (siehe Bild 5).<\/p>\n
    \"CommandBar-Typ<\/p>\n
    Bild 5: CommandBar-Typ plus Name<\/span><\/b><\/p>\n
    Position von CommandBar-Elementen ermitteln und festlegen<\/h2>\n
    In Bild 6 haben wir Symbolleisten am oberen, linken, unteren und rechten Rand und außerdem eine freischwebendes Symbolleiste. Diese haben wir dort einfach per Drag and Drop platziert. Die Position können wir nun per VBA auslesen und auch setzen. Dazu verwenden wie die folgenden Eigenschaften:<\/p>\n
    \"Verschiedene<\/p>\n
    Bild 6: Verschiedene Positionen für Symbolleisten <\/span><\/b><\/p>\n
      \n
    • Position<\/b>: Liefert eine Konstante für die aktuelle Position zurück.<\/li>\n
    • Left<\/b>: Gibt den Abstand vom linken Fensterrand an.<\/li>\n
    • Top<\/b>: Gibt den Abstand vom oberen Fensterrand an.<\/li>\n
    • Width<\/b>: Gibt die Breite des CommandBar<\/b>-Objekts an.<\/li>\n
    • Height<\/b>: Gibt die Höhe des CommandBar<\/b>-Objekts an.<\/li>\n<\/ul>\n
      Für die Eigenschaft Position <\/b>gibt es die folgenden Werte:<\/p>\n
        \n
      • msoBarBottom<\/b>: Das CommandBar<\/b>-Objekt ist am unteren Rand verankert.<\/li>\n
      • msoBarFloating<\/b>: Das CommandBar-Objekt ist frei schwebend.<\/li>\n
      • msoBarLeft<\/b>: Das CommandBar<\/b>-Objekt ist am linken Rand verankert.<\/li>\n
      • msoBarMenuBar<\/b>: Das CommandBar<\/b>-Objekt ist eine Menüleiste und somit als oberstes Element oben verankert.<\/li>\n
      • msoBarPopup<\/b>: Das CommandBar<\/b>-Objekt ist ein Kontextmenü.<\/li>\n
      • msoBarRight<\/b>: Das CommandBar<\/b>-Objekt ist am rechten Rand verankert.<\/li>\n
      • msoBarTop<\/b>: Das CommandBar<\/b>-Objekt ist am oberen Rand verankert.<\/li>\n<\/ul>\n
        Du wirst vielleicht feststellen, dass wir hier einige Übereinstimmungen mit den Werten der Eigenschaft Type <\/b>des CommandBar<\/b>-Elements haben.<\/p>\n
        Das hängt damit zusammen, dass die Werte für Position <\/b>wohl eigentlich nur für die frei platzierbaren Symbolleisten (Typ msoBarTypeNormal<\/b>) vorgesehen sind.<\/p>\n
        Damit man für Position <\/b>aber auch für Typ msoBarTypeMenuBar<\/b> oder msoBarTypePopup<\/b> auch Werte hat, wurden die beiden Einstellungen msoBarMenuBar <\/b>und msoBarPopup <\/b>hinzugefügt. <\/p>\n
        Dabei ist anzumerken, dass CommandBars <\/b>des Typs msoBarTypeMenuBar <\/b>für Position <\/b>immer den Wert msoBarMenuBar <\/b>aufweisen und solche des Typs msoBarTypePopup <\/b>immer den Wert msoBarPopup<\/b>.<\/p>\n
        Weitere Eigenschaften der CommandBar-Klasse<\/h2>\n
        Die CommandBar<\/b>-Klasse liefert und noch weitere Eigenschaften:<\/p>\n
          \n
        • Application<\/b>: Soll eigentlich den Verweis der übergeordneten Anwendung liefern, was aber in diesem Fall fehlschlägt.<\/li>\n
        • AdaptiveMenu<\/b>: Gibt an, ob das Menü nur die am häufigsten verwendeten Befehle anzeigen soll. Diese Eigenschaft war nur in Office bis Version 2003 verfügbar, im VBA-Editor hat sie keine Funktion.<\/li>\n
        • Builtin<\/b>: Gibt an, ob ein CommandBar<\/b>-Objekt eingebaut (True<\/b>) oder benutzerdefiniert ist (False<\/b>)<\/li>\n
        • Context<\/b>: Liefert für CommandBar<\/b>-Objekt im VBA-Editor keinen Wert.<\/li>\n
        • Controls<\/b>: Liefert die Auflistung der Steuerelemente des CommandBar<\/b>-Elements.<\/li>\n
        • Creator<\/b>: Gibt einen Long<\/b>-Wert zurück, der eine 32-Bit-Zahl darstellt, die die Anwendung identifiziert, die die CommandBar<\/b>-Instanz erstellt hat. Für Microsoft Excel ist dieser Wert beispielsweise 1480803660<\/b>, für Microsoft Access 1279872325 <\/b>und für den VBA-Editor 1398031698<\/b>.<\/li>\n
        • Enabled<\/b>: Gibt an, ob das CommandBar<\/b>-Element aktiviert ist oder aktiviert oder deaktiviert dieses durch Setzen des Wertes True <\/b>oder False<\/b>.<\/li>\n
        • Index<\/b>: Liefert eine Index-Wert innerhalb der CommandBars<\/b>-Auflistung.<\/li>\n
        • Name<\/b>: Enthält den Standardnamen des CommandBar<\/b>-Objekts (auf Englisch)<\/li>\n
        • NameLocal<\/b>: Enthält den an die jeweils eingestellte Sprache angepassten Namen.<\/li>\n
        • Parent<\/b>: Gibt einen Objektverweis auf das übergeordnete Element zurück, im Falle von CommandBars <\/b>im VBA-Editor also ein Verweis auf das Objekt VBE<\/b>.<\/li>\n
        • Protection<\/b>: Gibt den Schutzstatus des CommandBar<\/b>-Elements an. In diesem Fall erhalten wir für die VBE-Symbolleisten Werte wie 0<\/b>, 8<\/b>, 22 <\/b>oder 23 <\/b>zurück. Diese entsprechen Kombinationen der folgenden Werte: msoBarNoProtection <\/b>(0<\/b>), msoBarNoCustomize <\/b>(1<\/b>), msoBarNoResize <\/b>(2<\/b>), msoBarNoMove <\/b>(4<\/b>), msoBarNoChangeVisible <\/b>(8<\/b>), msoBarNoChangeDock <\/b>(16<\/b>), msoBarNoVerticalDock <\/b>(32<\/b>) und msoBarNoHorizontalDock <\/b>(64<\/b>)<\/li>\n
        • RowIndex<\/b>: Gibt bei CommandBar<\/b>-Elementen, die verankert sind, einen Index für die vertikale Anordnung an.<\/li>\n
        • Visible<\/b>: Gibt an, ob ein CommandBar<\/b>-Element sichtbar ist oder nicht. Kann auch zum Ein- und Ausblenden von CommandBar<\/b>-Elementen verwendet werden.<\/li>\n<\/ul>\n
          Methoden der CommandBar-Klasse<\/h2>\n
          Die CommandBar<\/b>-Klasse stellt die folgenden Methoden bereit, mit denen wir zum Beispiel CommandBar<\/b>-Objekte löschen oder zurücksetzen können:<\/p>\n
            \n
          • Delete<\/b>: Löscht das CommandBar<\/b>-Element.<\/li>\n
          • FindControl<\/b>: Sucht nach einem bestimmten Steuerelement im aktuellen CommandBar<\/b>-Element. Dabei können die folgenden optionalen Suchparameter zum Einsatz kommen: Type <\/b>(Wert aus der Auflistung MsoControlType<\/b>, gibt den Typ des Steuerelements an), Id<\/b> (gibt die ID des Steuerelements an), Tag <\/b>(gibt den Tag des Steuerelements an), Visible <\/b>(gibt an, ob das Steuerelement sichtbar ist), Recursive <\/b>(gibt an, ob die Suche rekursiv durchgeführt werden soll)<\/li>\n
          • Reset<\/b>: Setzt das CommandBar<\/b>-Element in den Anfangszustand zurück.<\/li>\n
          • ShowPopup<\/b>: Zeigt das CommandBar<\/b>-Element als Kontextmenü an.<\/li>\n<\/ul>\n
            Symbolleisten-CommandBar per VBA erstellen<\/h2>\n
            Mit der folgenden Prozedur erstellen wir ein einfaches CommandBar<\/b>-Objekt als Symbolleiste:<\/p>\n
            Public Sub <\/span>CreateCommandBar_Symbolleiste()\r\n     Dim <\/span>cbr As <\/span>CommandBar\r\n     Set<\/span> cbr = VBE.CommandBars.Add()\r\n     With<\/span> cbr\r\n         .Position = msoBarTop\r\n         .Name = \"Beispielsymbolleiste\"\r\n         .Visible = True<\/span>\r\n     End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
            Dies legt eine einfache Symbolleiste an. Das legen wir durch Setzen von Position auf den Wert msoBarTop <\/b>fest.<\/p>\n
            Menüleisten-CommandBar per VBA erstellen<\/h2>\n
            Wenn wir ein MenuBar <\/b>erstellen wollen, also die Hauptmenüleiste, dann müssten wir den Parameter MenuBar <\/b>beim Erstellen auf den Wert True <\/b>einstellen. Das erledigen wir mit der folgenden Prozedur:<\/p>\n
            Public Sub <\/span>CreateCommandBar_Menueleiste()\r\n     Dim <\/span>cbr As <\/span>CommandBar\r\n     Set<\/span> cbr = VBE.CommandBars.Add(, , True<\/span>)\r\n     With<\/span> cbr\r\n         .Name = \"Beispielmenueleiste\"\r\n         .Visible = True<\/span>\r\n     End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
            Dadurch wird gleichzeitig die eigentliche Menüleiste ausgeblendet. Der Hintergrund: Wir können jeweils nur eine Menüleiste verwenden. Die eingebaute Menüleiste blenden wir so wieder ein:<\/p>\n
            VBE.CommandBars(\"Menüleiste\").Visible = True<\/span><\/pre>\n
            Kontextmenü-CommandBar per VBA erstellen<\/h2>\n
            Wenn wir ein Kontextmenü benötigen, stellen wir Position direkt in der Add<\/b>-Methode auf msoBarPopup <\/b>ein. Nachdem wir den Namen festgelegt haben, können wir das Kontextmenü direkt mit der ShowPopup<\/b>-Methode anzeigen.<\/p>\n
            Damit erhalten wir allerdings nur ein leeres Quadrat, denn wir haben ja noch keine Steuerelemente hinzugefügt:<\/p>\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     With<\/span> cbr\r\n         .Name = \"Kontextmenueleiste\"\r\n         .ShowPopup\r\n     End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
            CommandBar löschen<\/h2>\n
            Ein einzelnes CommandBar<\/b>-Element löschen wir mit der Delete<\/b>-Methode der CommandBar<\/b>-Objektvariablen.<\/p>\n
            Dies gelingt nur für benutzerdefinierte CommandBar<\/b>-Elemente, also solche, die wir selbst eingebaut haben:<\/p>\n
            cbr.Delete<\/pre>\n
            Alle benutzerdefinierten CommandBar-Elemente löschen<\/h2>\n
            Wenn wir einmal alle benutzerdefinieren Elemente entfernen wollen, können wir das mit einer Prozedur wie der folgenden erledigen.<\/p>\n
            Diese durchläuft alle CommandBar<\/b>-Elemente des VBA-Editors und prüft mit der Eigenschaft Builtin<\/b>, ob dieses ein eingebautes oder benutzerdefiniertes CommandBar<\/b>-Element ist. Für benutzerdefinierte CommandBar<\/b>-Elemente ruft sie die Delete<\/b>-Methode auf:<\/p>\n
            Public Sub <\/span>DeleteUserdefinedCommandbars()\r\n     Dim <\/span>cbr As <\/span>CommandBar\r\n     For Each cbr In VBE.CommandBars\r\n         If <\/span>cbr.BuiltIn = False<\/span> Then<\/span>\r\n             Debug.Print<\/span> \"Delete \" & cbr.Name\r\n             cbr.Delete\r\n         End If<\/span>\r\n     Next<\/span> cbr\r\nEnd Sub<\/span><\/pre>\n
            Zusammenfassung und Ausblick<\/h2>\n
            Dieser Artikel zeigt, wie wir vorhandene CommandBar<\/b>-Elemente durchlaufen, wie wir CommandBars anlegen und wie wir diese wieder löschen können. Außerdem haben wir die drei verschiedenen Typen von Menüs vorgestellt: die Symbolleiste, die Menüleiste und die Kontextmenüs. Wir haben gezeigt, wir die unterschiedlichen Typen von CommandBars per VBA erzeugt werden können. Außerdem hast Du alle relevanten Eigenschaften der CommandBar<\/b>-Klasse kennengelernt.<\/p>\n
            In einem weiteren Artikel namens Menü-Steuerelemente per VBA programmieren <\/b>(www.vbentwickler.de\/436<\/b>) schauen wir uns noch an, wie wir die eigentlich interessanten Elemente hinzufügen – die Schaltflächen und die anderen Steuerelemente. Wobei die Schaltflächen wohl 99% aller Steuerelemente in CommandBar<\/b>-Elementen ausmachen dürften.<\/p>\n","protected":false},"excerpt":{"rendered":"
            Das Menüsystem des VBA-Editors lässt sich über die Benutzeroberfläche bereits einfach anpassen. Das haben wir im Artikel “Menüsystem im VBA-Editor anpassen” (www.vbentwickler.de\/434)  gezeigt. Außerdem haben wir uns im Artikel “Kontextmenüs per VBA programmieren” (www.vbentwickler.de\/368) bereits angeschaut, wie wir per VBA Kontextmenüs erstellen und anpassen können. Es fehlen also noch die Informationen, wie wir die eigentlichen Menüleisten und Symbolleisten mit VBA programmieren können. Wie das gelingt, schauen wir uns im vorliegenden Artikel an. Wir zeigen, wie vorhandene Menüs angepasst und wie neue Menüs erstellt werden können. <\/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":[662024,66042024,44000037],"tags":[],"yst_prominent_words":[],"class_list":["post-55000435","post","type-post","status-publish","format-standard","hentry","category-662024","category-66042024","category-VBAEditor_programmieren"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000435","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/comments?post=55000435"}],"version-history":[{"count":0,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000435\/revisions"}],"wp:attachment":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/media?parent=55000435"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/categories?post=55000435"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/tags?post=55000435"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/yst_prominent_words?post=55000435"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}