{"id":55000347,"date":"2017-02-01T00:00:00","date_gmt":"2020-01-24T15:59:46","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=347"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Ribbons_Teil_III_Interaktion_im_Ribbon","status":"publish","type":"post","link":"https:\/\/access-basics.de\/index.php\/Ribbons_Teil_III_Interaktion_im_Ribbon.html","title":{"rendered":"Ribbons, Teil III: Interaktion im Ribbon"},"content":{"rendered":"

Das Ribbon lässt sich nicht so einfach programmieren wie es bei Menüleisten, Symbolleisten oder Kontextmenüs der Fall war. Diese Elemente ließen sich nach Wunsch mit Objektvariablen referenzieren und zum Beispiel aktivieren oder deaktivieren. Das Ein- oder Ausblenden von Menüs war auch recht einfach. Beim Ribbon gibt es einen alternativen Programmieransatz, bei dem der XML-Code zur Beschreibung des Aussehens des Ribbons und der VBA-Code für seine Steuerung interagieren sollen. Welche Vorbereitungen dazu notwendig sind und wie die Programmierung im Detail aussieht, zeigt dieser Artikel.<\/p>\n

Beispieldatenbank<\/h2>\n

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

Voraussetzungen<\/h2>\n

Beachten Sie, wie im ersten Teil dieser Artikelreihe beschrieben, dass Sie einen Verweis auf die Bibliothek Microsoft Office x.0 Object Library <\/b>benötigen, um das Ribbon zu programmieren.<\/p>\n

Eigenschaften dynamisch gestalten<\/h2>\n

Die Ribbon-Elemente haben eine ganze Reihe von Attributen, die Sie gleich in der XML-Definition des Ribbons festlegen – zum Beispiel den Namen, die Beschriftung, die Größe bei Schaltflächen, den Namen eventuell ausgelöster Callback-Prozeduren und viele mehr. Attribute, die Sie per XML definieren, können Sie später nicht mehr ändern. In vielen Fällen ist das auch sinnvoll. Wer möchte schon den nur intern verwendeten Namen eines Ribbon-Elements ändern<\/p>\n

Bisher haben wir allerdings noch nicht darüber gesprochen, dass sich einige Eigenschaften von Ribbon-Elementen auch zur Laufzeit ändern lassen können beziehungsweise dass Sie deren Werte nicht gleich bei der XML-Definition des Ribbons anlegen, sondern dass die Werte von Attributen auch erst beim Erstellen des Ribbons beziehungsweise beim ersten Anzeigen mithilfe von VBA-Funktionen ermittelt werden können.<\/p>\n

Die Attribute, die das dynamische Abfragen von Werten zur Laufzeit ermöglichen, beginnen in der Regel mit dem Präfix get… <\/b>gefolgt vom Namen des statischen Attributs. Schauen wir uns dies am Beispiel des button<\/b>-Elements an, das wohl das häufigste Ziel von dynamischen Einstellungen sein dürfte – allein, um dieses zu aktivieren oder deaktivieren oder ein- und auszublenden. Hier gibt es etwa die Attribute label<\/b>, visible <\/b>oder enabled<\/b>. Diese können Sie bereits in der XML-Definition festlegen. Wenn Sie dies allerdings erst beim Anzeigen des jeweiligen Elements erledigen wollen, verwenden Sie die Attribute getLabel<\/b>, getVisible <\/b>oder getEnabled <\/b>und hinterlegen für diese den Namen der Callback-Funktion, welche den Wert für das entsprechende Attribut liefert.<\/p>\n

Schauen wir uns dies an einem Beispiel an. Die folgende Ribbon-Definition enthält in einem tab<\/b>-Element ein group<\/b>-Element mit zwei untergeordneten button<\/b>-Elementen. Das erste hat eine statische Bezeichnung, die wir mit dem label<\/b>-Attribut eingestellt haben. Die zweite verwendet das Attribut getLabel <\/b>und gibt dafür den Callback-Namen getLabel <\/b>an:<\/p>\n

<customUI ...>\r\n    <\/span><ribbon>\r\n      <\/span>  <\/span><tabs>\r\n        <\/span>  <\/span>  <\/span><tab id=\"tabInteraktion\" label=\"Interaktion\">\r\n          <\/span>  <\/span>  <\/span>  <\/span><group id=\"grpInteraktion\" label=\"Beispiele\">\r\n            <\/span>  <\/span>  <\/span>  <\/span>  <\/span><button label=\"Statisches Label\"             id=\"btnLabelStatisch\"\/>\r\n            <\/span>  <\/span>  <\/span>  <\/span>  <\/span><button getLabel=\"getLabel\"             id=\"btnLabelDynamisch\"\/>\r\n          <\/span>  <\/span>  <\/span>  <\/span><\/group>\r\n        <\/span>  <\/span>  <\/span><\/tab>\r\n      <\/span>  <\/span><\/tabs>\r\n    <\/span><\/ribbon>\r\n<\/customUI><\/pre>\n
Die VBA-Prozedur, die beim Auslösen des Callback-Ereignisses getLabel<\/b> aufgerufen werden soll, sieht so aus:<\/p>\n
Sub <\/span>getLabel(control As <\/span>IRibbonControl, ByRef label)\r\n    label = \"Dynamisches Label\"\r\nEnd Sub<\/span><\/pre>\n
Sie erwartet zwei Parameter, von denen der zweite namens label <\/b>in diesem einfachen Beispiel der wichtigere ist: Er nimmt schlicht die Zeichenkette entgegen, die als Bezeichnung angezeigt werden soll. Dementsprechend füllen wir die Variable label <\/b>mit dem Wert Dynamisches Label<\/b>. Das Ergebnis finden Sie in Bild 1.<\/p>\n
\"Zwei<\/a><\/p>\n
Bild 1: Zwei Label mit verschiedenen Beschriftungen<\/p>\n
Wann erfolgt der Aufruf<\/h2>\n
Wie schon weiter oben erwähnt, werden die Callback-Ereignisse, deren Name mit get… <\/b>beginnt, bei der Anzeige der jeweiligen Elemente ausgelöst. Um dies zu belegen, haben wir ein zweites tab<\/b>-Element hinzugefügt, dass ein button<\/b>-Element mit dem Wert getLabel <\/b>für das Attribut getLabel <\/b>aufweist:<\/p>\n
<tab id=\"tabMehrInteraktion\"     label=\"Mehr Interaktion ...\">\r\n    <\/span><group id=\"grpBeispiele\" label=\"Beispiele\">\r\n      <\/span>  <\/span><button getLabel=\"getLabel\" id=\"btnDynamisch2\"\/>\r\n    <\/span><\/group>\r\n<\/tab><\/pre>\n
Außerdem müssen wir nun der Anforderung gerecht werden, dass wir nicht mehr nur eine einzige Schaltfläche haben, von der aus das Callback-Ereignis getLabel <\/b>ausgelöst wird, sondern zwei.<\/p>\n
In diesem Fall kommt der erste Parameter der Callback-Prozedur zum Zuge, der mit dem Parameter control <\/b>einen Verweis auf das auslösende Steuerelement liefert. control<\/b> enthält eine Eigenschaft namens ID<\/b>, mit der wir auf den Wert des Attributs id <\/b>der button<\/b>-elemente zugreifen können. Diese prüfen wir in einer Select Case<\/b>-Anweisung und weisen verschiedene Bezeichnungen über den Rückgabeparameter label zu<\/b>:<\/p>\n
Sub <\/span>getLabel(control As <\/span>IRibbonControl, ByRef label)\r\n      <\/span>  <\/span>Select Case control.ID\r\n          <\/span>  <\/span>  <\/span>  <\/span>Case <\/span>\"btnLabelDynamisch\"\r\n              <\/span>  <\/span>  <\/span>  <\/span>  <\/span>  <\/span>label = \"Dynamisches Label\"\r\n          <\/span>  <\/span>  <\/span>  <\/span>Case <\/span>\"btnDynamisch2\"\r\n              <\/span>  <\/span>  <\/span>  <\/span>  <\/span>  <\/span>label = \"Dynamisches Label 2\"\r\n      <\/span>  <\/span>End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
Wenn Sie nun die Datenbank komprimieren und reparieren (schnellster Weg, die Datenbank zu schließen und wieder zu öffnen)  und einen Haltepunkt in die erste Zeile der Prozedur setzen, landen Sie beim Anzeigen des Ribbon-Tabs Interaktion <\/b>in dieser Prozedur und dort im Case<\/b>-Zweig für den Wert btnLabelDynamisch<\/b> (siehe Bild 2).<\/p>\n
\"Ansteuern<\/a><\/p>\n
Bild 2: Ansteuern eines Haltepunktes in einer Callback-Prozedur<\/p>\n
Wechseln Sie danach zum zweiten tab<\/b>-Element des Beispiels, wird getLabel <\/b>wieder ausgelöst – diesmal allerdings für das Element btnDynamisch2<\/b>.<\/p>\n
Label während der Laufzeit aktualisieren<\/h2>\n
Damit haben wir allerdings nur gezeigt, wie wir eine Callback-Eigenschaft beim erstmaligen Anzeigen aufrufen, um ein Attribut zur Laufzeit mit einem Wert zu versehen. Wenn Sie anschließend weitere Male zwischen den beiden tab<\/b>-Elementen hin- und herwechseln, wird die Callback-Prozedur getLabel <\/b>nicht mehr aufgerufen.<\/p>\n
Wenn Sie dies erreichen wollen, um beispielsweise einen regelmäßig aktualisierten Wert wie die Uhrzeit anzuzeigen, müssen Sie den Wert der per get…<\/b>-Prozedur zugewiesenen Attribute ungültig machen. Welche Voraussetzungen dafür erforderlich sind und wie dies gelingt, zeigt der folgende Abschnitt.<\/p>\n
Referenz auf das Ribbon speichern<\/h2>\n
Der wichtigste Schritt, um ein Attribut ungültig zu machen, ist das Speichern einer Objektreferenz auf die aktuell angezeigte Ribbon-Definition. In diesem Fall wollen wir die Uhrzeit in einem label<\/b>-Element in einem weiteren Tab anzeigen, das wir wie folgt definieren:<\/p>\n
<customUI ... onLoad=\"OnLoad_Interaktiv\">\r\n    <\/span><ribbon>\r\n      <\/span>  <\/span><tabs>\r\n        <\/span>  <\/span>...\r\n        <\/span>  <\/span>  <\/span><tab id=\"tabDynamisch\" label=\"Dynamische Werte\">\r\n          <\/span>  <\/span>  <\/span>  <\/span><group id=\"grpUhrzeit\" label=\"Uhrzeit\">\r\n            <\/span>  <\/span>  <\/span>  <\/span>  <\/span><labelControl getLabel=\"getLabel\"             id=\"lblUhrzeit\"\/>\r\n          <\/span>  <\/span>  <\/span>  <\/span><\/group>\r\n        <\/span>  <\/span>  <\/span><\/tab>\r\n      <\/span>  <\/span><\/tabs>\r\n    <\/span><\/ribbon>\r\n<\/customUI><\/pre>\n
Entscheidend ist hier, dass wir für das customUI<\/b>-Element das Attribut onLoad <\/b>mit dem Wert onLoad_Interaktiv <\/b>füllen (Interaktiv <\/b>ist der Name, unter dem wir das Ribbon in der Tabelle USysRibbons <\/b>gespeichert haben):<\/p>\n
<\/pre>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Access [basics]<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 400 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
\n\n\t\t\n\t\t