{"id":55000543,"date":"2021-12-01T00:00:00","date_gmt":"2021-12-01T00:00:00","guid":{"rendered":"http:\/\/access-basics.de\/543"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Ribbon_anpassen_Teil_2_","status":"publish","type":"post","link":"https:\/\/access-basics.de\/index.php\/Ribbon_anpassen_Teil_2_.html","title":{"rendered":"Ribbon anpassen, Teil 2"},"content":{"rendered":"

Das Ribbon, in der deutschen Version von Office auch Menüband genannt, ist die Menüleiste für Office-Anwendungen und somit auch für Access. Sie können die Befehle im Ribbon jedoch nicht nur während der Entwicklung von Access-Anwendungen nutzen, sondern dieses für eigene Anwendungen so anpassen, dass der Benutzer die Funktionen dieser Anwendung darüber aufrufen kann. Dabei können Sie die eingebauten Elemente sogar weitgehend ausblenden, sodass man Ihrer Anwendung nur noch an wenigen Stellen ansieht, dass es sich überhaupt um eine Access-Anwendung handelt. Diese Artikelreihe liefert alle Informationen, die Sie für die Arbeit mit dem Ribbon und für seine Anpassung und Programmierung benötigen. Dabei lernen Sie auch alle Steuerelemente und ihre Eigenschaften kennen.<\/p>\n

Beispieldatenbank<\/h2>\n

Die Beispiele dieses Artikels finden Sie in der Datenbank 2106_RibbonAnpassen.accdb<\/b>.<\/p>\n

Das dynamicMenu-Element<\/h2>\n

Dieses Element nimmt eine besondere Rolle unter den Ribbonelementen ein, denn Sie können nicht nur einzelne Attribute mit get…<\/b>-Attributen manipulieren, sondern Sie können den gesamten Inhalt des Menüs per VBA im XML-Format zusammensetzen und an ein spezielles Callbackattribut zurückgeben.<\/p>\n

Das Beispiel finden Sie in der Tabelle USysRibbons <\/b>unter dem Namen Beispiel dynamicMenu<\/b>. Der Code befindet sich im Modul mdlRibbonsDynamicMenu<\/b>.<\/p>\n

Das Attribut zum Füllen des Elements heißt getContent <\/b>und wir betten dieses wie folgt in das dynamicMenu<\/b>-Element ein:<\/p>\n

<group id=\"grp0\" label=\"Beispiel dynamicMenu\">\r\n   <dynamicMenu id=\"dyn\" label=\"Dynamic Menu:\"                               getContent=\"getContent\" \/>\r\n<\/group><\/pre>\n
Eine sehr einfache Variante der dadurch aufgerufenen Callbackprozedur getContent<\/b> sieht wie in Listing 1 aus.<\/p>\n
Sub <\/span>getContent(control As <\/span>IRibbonControl, ByRef content)\r\n     Dim <\/span>strXML As String<\/span>\r\n     Dim <\/span>i As Integer<\/span>\r\n     strXML = \"<menu xmlns=\"\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\"\">\"\r\n     For i = 1 To 10\r\n         strXML = strXML & \"<button id=\"\"btn\" & i & \"\"\" label=\"\"Button \" & i & \"\"\"\/>\"\r\n     Next<\/span> i\r\n     strXML = strXML & \"<\/menu>\"\r\n     content = strXML\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Beispiel für ein dynamicMenu-Element<\/p>\n
Die Prozedur erhält einen Verweis auf das auslösende dynamicMenu<\/b>-Element als Parameter und erhält einen weiteren Parameter namens content<\/b>, der den Inhalt des dynamicMenu<\/b>-Elements entgegennimmt.<\/p>\n
Sie füllt sukzessive eine Variable namens strXML<\/b>. Die erste Zeile enthält das menu<\/b>-Element:<\/p>\n
<menu xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\"><\/pre>\n
Sie durchläuft eine Schleife von 1 <\/b>bis 10<\/b>, in der Sie Einträge wie die folgenden zu der ersten Zeile hinzufügt:<\/p>\n
<button id=\"btn1\" label=\"Button 1\"\/>\r\n<button id=\"btn2\" label=\"Button 2\"\/>\r\n<button id=\"btn3\" label=\"Button 3\"\/>\r\n...\r\n<button id=\"btn10\" label=\"Button 10\"\/><\/pre>\n
Schließlich hängt die Prozedur noch die abschließende Zeile mit dem schließenden menu<\/b>-Element an:<\/p>\n
<\/menu><\/pre>\n
Schließlich gibt die Prozedur das in strXML <\/b>zusammengestellte Ergebnis mit dem Parameter content <\/b>zurück. Das Ergebnis dieses Beispiels finden Sie in Bild 1.<\/p>\n
\"dynamicMenu-Element\"<\/a><\/p>\n
Bild 1: dynamicMenu-Element<\/p>\n
dynamicMenu-Element aus der Datenbank füllen<\/h2>\n
Genau wie über eine Schleife können Sie das dynamicMenu<\/b>-Element auch mit den Daten einer Tabelle aus der Datenbank füllen. Um den Spaß zu erhöhen, machen wir das gleich mal mit zwei Ebenen – Kategorien und Artikeln. Das Ergebnis soll wie in Bild 2 aussehen und ein Klick auf einen der Artikel soll auch noch ein Formular öffnen, das diesen Artikel anzeigt.<\/p>\n
\"dynamicMenu-Element<\/a><\/p>\n
Bild 2: dynamicMenu-Element mit Kategorien und Artikeln<\/p>\n
Das Beispiel finden Sie in der Tabelle USysRibbons <\/b>unter dem Namen Beispiel dynamicMenu aus Datenbank<\/b>. Der Code befindet sich im Modul mdlRibbonsDynamicMenu<\/b>.<\/p>\n
Die Prozedur, die durch das Callbackattribut getContent <\/b>ausgelöst wird, finden Sie in Listing 2. Die Prozedur referenziert mit der Variablen db <\/b>das aktuelle Database<\/b>-Objekt und mit rstKategorien <\/b>ein Recordset auf Basis der Tabelle tblKategorien<\/b>. Sie erstellt dann zunächst das umschließende menu<\/b>-Element und steigt dann in eine Do While<\/b>-Schleife über alle Kategorien ein. Darin fügt sie zunächst für jede Kategorie ein neues menu<\/b>-Element hinzu und legt seine Attribute fest. id <\/b>erhält den Buchstaben k <\/b>und die KategorieID<\/b>, label <\/b>erhält den Kategorienamen und image <\/b>den Wert folder<\/b>.<\/p>\n
Sub <\/span>dynKategorienUndArtikel_getContent(control As <\/span>IRibbonControl, ByRef content)\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     Dim <\/span>rstKategorien As <\/span>DAO.Recordset\r\n     Dim <\/span>rstArtikel As <\/span>DAO.Recordset\r\n     Dim <\/span>strXML As String<\/span>\r\n     Dim <\/span>i As Integer<\/span>\r\n     Set<\/span> db = CurrentDb\r\n     Set<\/span> rstKategorien = db.OpenRecordset(\"SELECT * FROM tblKategorien\", dbOpenDynaset)\r\n     strXML = \"<menu xmlns=\"\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\"\">\" & vbCrLf<\/span>\r\n     Do While<\/span> Not<\/span> rstKategorien.EOF\r\n         strXML = strXML & \"  <menu id=\"\"k\" & rstKategorien!KategorieID & \"\"\" label=\"\"\" & rstKategorien!Kategoriename _\r\n             & \"\"\" image=\"\"folder\"\">\" & vbCrLf<\/span>\r\n         Set<\/span> rstArtikel = db.OpenRecordset(\"SELECT * FROM tblArtikel WHERE KategorieID = \" & rstKategorien!KategorieID, dbOpenDynaset)\r\n         Do While<\/span> Not<\/span> rstArtikel.EOF\r\n             strXML = strXML & \"    <button id=\"\"a\" & rstArtikel!ArtikelID & \"\"\" label=\"\"\" & rstArtikel!Artikelname _\r\n                 & \"\"\" onAction=\"\"btnArticle_onAction\"\" tag=\"\"\" & rstArtikel!ArtikelID & \"\"\" image=\"\"form\"\"\/>\" & vbCrLf<\/span>\r\n             rstArtikel.MoveNext<\/span>\r\n         Loop<\/span>\r\n         strXML = strXML & \"  <\/menu>\" & vbCrLf<\/span>\r\n         rstKategorien.MoveNext<\/span>\r\n     Loop<\/span>\r\n     strXML = strXML & \"<\/menu>\"\r\n     content = strXML\r\nEnd Sub<\/span><\/pre>\n
Listing 2: Beispiel zum Füllen eines dynamicMenu-Elements aus den Daten einer Datenbank<\/p>\n
Danach erstellt die Prozedur ein Recordset, das alle Datensätze der Tabelle tblArtikel <\/b>enthält, die zur aktuellen Kategorie aus der übergeordneten Schleife gehören. Diese durchläuft die Prozedur ebenfalls in einer Do While<\/b>-Schleife. Hier legt sie jeweils ein button<\/b>-Element für den aktuellen Artikel an. Die id <\/b>erhält den Buchstaben a <\/b>und die Artikel-ID, das label <\/b>den Artikelnamen und das Attribut onAction <\/b>den Prozedurnamen btnArticle_onAction<\/b>. Und damit wir beim Anklicken des button<\/b>-Elements wissen, welchen Artikel der Benutzer überhaupt angeklickt hat, hinterlegen wir für das tag<\/b>-Attribut noch den Primärschlüsselwert des jeweiligen Artikels.<\/p>\n
Sind alle Artikel einer Kategorie durchlaufen, fügt die Prozedur das schließende menu<\/b>-Element hinzu und schreitet mit der nächsten Kategorie voran. Auf diese Weise werden alle Kategorien und Artikel eingefügt, bevor das schließende menu<\/b>-Element folgt und die Prozedur den Inhalt von strXML <\/b>mit dem Parameter content <\/b>zurückgibt.<\/p>\n
Das Ergebnis sieht in gekürzter Form wie in Listing 3 aus.<\/p>\n
<menu xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\">\r\n   <menu id=\"k1\" label=\"Getränke\" image=\"folder\">\r\n     <button id=\"a1\" label=\"Chai\" onAction=\"btnArticle_onAction\" tag=\"1\" image=\"form\"\/>\r\n     <button id=\"a2\" label=\"Chang\" onAction=\"btnArticle_onAction\" tag=\"2\" image=\"form\"\/>\r\n     ...\r\n   <\/menu>\r\n   <menu id=\"k2\" label=\"Gewürze\" image=\"folder\">\r\n     <button id=\"a3\" label=\"Aniseed Syrup\" onAction=\"btnArticle_onAction\" tag=\"3\" image=\"form\"\/>\r\n     <button id=\"a4\" label=\"Chef Anton's Cajun Seasoning\" onAction=\"btnArticle_onAction\" tag=\"4\" image=\"form\"\/>\r\n     ...\r\n   <\/menu>\r\n   ...\r\n<\/menu><\/pre>\n
Listing 3: Der von der Prozedur dynKategorienUndArtikel_getContent erzeugte XML-Ausdruck (gekürzt)<\/p>\n
Anzeigen des Formulars mit dem gewählten Artikel<\/h2>\n
Für das Callbackattribut btnArticle_onAction <\/b>hinterlegen wir die folgende Prozedur:<\/p>\n
Sub <\/span>btnArticle_onAction(control As <\/span><\/span>IRibbonControl)\r\n     Dim <\/span>lngArtikelID As Long<\/span><\/span>\r\n     lngArtikelID = control.Tag\r\n     DoCmd.OpenForm \"frmArtikel\",            WhereCondition:=\"ArtikelID = \" & lngArtikelID\r\nEnd Sub<\/span><\/pre>\n
Diese Prozedur ermittelt aus der Eigenschaft tag <\/b>des Parameters control <\/b>den Primärschüsselwert des Artikels, den der Benutzer angeklickt hat. Diesen fügen wir dann über die Variable lngArtikel <\/b>als Vergleichswert in die WhereCondition <\/b>der DoCmd.OpenForm<\/b>-Methode ein.<\/p>\n
Sie können auch Menü-Einträge zum Hinzufügen neuer Kategorien oder Artikel hinzufügen – hier ergeben sich eine Menge neuer Ideen!<\/p>\n
dynamicMenu zur Laufzeit aktualisieren<\/h2>\n
Bisher wird das dynamicMenu<\/b>-Element beim ersten Aufruf per VBA zusammengestellt. Was aber, wenn der Benutzer bei der Arbeit mit der Datenbank neue Kategorien oder neue Artikel anlegt oder die vorhandenen Daten ändert oder löscht Dann sollte auch das Menü beim nächsten Aufruf neu zusammengestellt werden.<\/p>\n
Was wir dazu brauchen, ist wiederum ein Attribut namens onLoad <\/b>für das customUI<\/b>-Element und dafür eine Ereignisprozedur, welche die Ribbondefinition per IRibbonUI<\/b>-Variable referenziert.<\/p>\n
Für diese können wir dann zu gegebener Zeit die Invalidate<\/b>– oder die InvalidateControl<\/b>-Methode aufrufen.<\/p>\n
Also erweitern wir customUI <\/b>um das onLoad<\/b>-Attribut:<\/p>\n
<customUI ... loadImage=\"loadImage\"   onLoad=\"onLoad_dynamicMenu\"><\/pre>\n
Die Callbackprozedur implementieren wir wie folgt:<\/p>\n
Sub <\/span>onLoad_dynamicMenu(ribbon As <\/span><\/span>IRibbonUI)\r\n     Set<\/span> objRibbon_DynamicMenu = ribbon\r\nEnd Sub<\/span><\/pre>\n
Die Deklaration der benötigten Variablen lautet:<\/p>\n
Public <\/span>objRibbon_DynamicMenu As <\/span><\/span>IRibbonUI<\/pre>\n
Um das Ribbon beispielsweise nach dem Ändern eines Datensatzes im Formular frmArtikel <\/b>neu zu laden, fügen wir für das Ereignis Nach Aktualisierung <\/b>des Formulars die folgende Ereignisprozedur hinzu:<\/p>\n
Private Sub <\/span>Form_AfterUpdate()\r\n     objRibbon_DynamicMenu.Invalidate\r\nEnd Sub<\/span><\/pre>\n
Damit wird das dynamicMenu <\/b>nach Änderungen an einem Artikel im Formular frmArtikel <\/b>neu gefüllt.<\/p>\n
Das gallery-Element<\/h2>\n
Mit dem gallery<\/b>-Element können Sie Elemente nicht nur untereinander, sondern unter- und nebeneinander anzeigen. Dazu teilen Sie dem gallery<\/b>-Element mit den Attributen columns <\/b>und rows <\/b>mit, wie die enthaltenen Elemente dargestellt werden sollen.<\/p>\n
Das Beispiel finden Sie in der Tabelle USysRibbons <\/b>unter dem Namen Beispiel gallery<\/b>. Der Code befindet sich im Modul mdlRibbonsGallery<\/b>.<\/p>\n
Hier ist ein Beispiel für ein sehr einfaches gallery<\/b>-Element mit zwei mal zwei Elementen:<\/p>\n
<group id=\"grp0\" label=\"Beispiel gallery\">\r\n   <gallery id=\"gal\" label=\"Galerie\" rows=\"2\" \r\n       columns=\"2\">\r\n     <item id=\"itm1\" label=\"Element 1\" \/>\r\n     <item id=\"itm2\" label=\"Element 2\" \/>\r\n     <item id=\"itm3\" label=\"Element 3\" \/>\r\n     <item id=\"itm4\" label=\"Element 4\" \/>\r\n   <\/gallery>\r\n<\/group><\/pre>\n
Dieses sieht wie in Bild 3 aus. Die Elemente werden also zuerst zeilenweise hinzugefügt und dann untereinander. Dabei geben die Werte für die beiden Attribute rows<\/b> und columns <\/b>lediglich an, wie groß der Platz für das gallery<\/b>-Element berechnet wird. Sie legen damit keine Obergrenze für die anzeigbaren Elemente fest. Wenn Sie mehr Elemente hinzufügen, also in dem durch rows <\/b>und columns <\/b>festgelegten Platz angezeigt werden können, erscheint eine Bildlaufleiste und die übrigen Elemente werden unten angehängt (siehe Bild 4).<\/p>\n
\"gallery-Element\"<\/a><\/p>\n
Bild 3: gallery-Element<\/p>\n
\"gallery-Element<\/a><\/p>\n
Bild 4: gallery-Element mit Bildlaufleiste<\/p>\n
Das gallery<\/b>-Element hat noch zwei interessante Eigenschaften:<\/p>\n