<\/p>\n
Das mit Access 2007 neu eingeführte Ribbon kommt mit einer Menge interessanter Steuerelemente. Zur Auswahl von Daten gibt es gleich mehrere Kandidaten, von denen wir uns diejenigen ansehen, die sich dynamisch etwa mit den Daten aus Tabellen füllen lassen: Zwei verschiedene Kombinationsfelder und zusätzlich auch noch ein dynamisch zu füllendes Menü, das sich prima für die Datenauswahl zweckentfremden lässt. Dieser Beitrag zeigt, wie Sie Daten aus Tabellen und sonstigen Quellen in diese Steuerelemente füllen und sie zur Anwendungssteuerung benutzen können.<\/b><\/p>\n
Die Vision hinter dem Ribbon und seinen Möglichkeiten ist eindeutig: Durch die viel größere Zahl verschiedener Steuerelemente und die flexibleren gestalterischen Möglichkeiten erlaubt Access dem Benutzer das Auslagern wesentlicher Funktionen der Entwicklungsoberfläche in das Ribbon.<\/p>\n
Neben dem üblichen Aufruf von Formularen, Berichten oder Funktionen über einfache Schaltflächen, wie sie in den Menü- und Symbolleisten älterer Access-Versionen gängig waren, können Sie nun viel einfacher weitere Funktionen auf das Ribbon übertragen. An welchen Stellen macht dies Sinn Zum Beispiel dort, wo der Benutzer nicht nur einfache Formulare zur Anzeige von Daten öffnet, sondern zuvor noch die gewünschten Daten auswählen muss. Dies geschieht in der Regel in folgenden Schritten:<\/p>\n
Alternativ enthält das Detailformular gleich ein Steuerelement zur Auswahl des gewünschten Datensatzes – beispielsweise ein Kombinationsfeld. Normalerweise wird hier aber immer direkt beim Öffnen irgendein Datensatz angezeigt, zum Beispiel das erste Element der Datenherkunft. <\/p>\n
Das ist genau der richtige Einstiegspunkt für die drei Ribbon-Elemente, die in diesem Beitrag genauer beleuchtet werden. Es geht um die Elemente zur Darstellung von Listen, und hier speziell um solche, die dynamisch mit Daten gefüllt werden können. Davon gibt es insgesamt vier – das gallery<\/b>-Element schauen wir uns aber noch einmal in einem späteren Beitrag an:<\/p>\n Rahmenwerk<\/b><\/p>\n Um Platz zu sparen, finden Sie in Listing 1, das ein Beispiel für ein statisches comboBox<\/b>-Element zeigt, letztmalig für diesen Beitrag die Ribbon-Elemente, die für den Aufbau des tab<\/b>-Elements und der group<\/b>-Elemente verantwortlich sind – wir haben diese fett gedruckt, um die betroffenen Elemente hervorzuheben. Einige Erläuterungen zu diesen Basiselementen:<\/p>\n Listing 1: Beispiel für ein statisches comboBox-Steuerelement<\/p>\n Grundlagen zu den oben genannten Elementen finden Sie unter anderem im Beitrag Dynamische Ribbons<\/b> (Shortlink 657).<\/p>\n Das comboBox-Element<\/b><\/p>\n Das comboBox<\/b>-Element zeigt eine Liste von Elementen an. Gleich in Bild 1 sehen Sie ein Feature, das es vom Access-Kombinationsfeld abhebt: Es kann nämlich pro Eintrag ein Icon anzeigen. Der Code für dieses einfache comboBox<\/b>-Element sieht wie in Listing 1 aus. Schauen wir uns die Definition dieses Elements genauer an: Wenn Sie es statisch definieren, also nicht mit den Daten aus einer Tabelle füllen möchten, können Sie die einzelnen Einträge mit dem item<\/b>-Element anlegen.<\/p>\n Bild 1: Ein einfaches statisches comboBox-Element<\/span><\/b><\/p>\n Inhalt der comboBox auswerten<\/b><\/p>\n Damit Sie den Inhalt des comboBox<\/b>-Elements nach der Auswahl auswerten können, müssen Sie für das Attribut onChange <\/b>eine Callback-Funktion festlegen und diese in einem Standardmodul, in unserem Beispiel mdlRibbon<\/b>, definieren.<\/p>\n Die erste Zeile des comboBox<\/b>-Elements sieht dann so aus:<\/p>\n Die folgende Callback-Funktion gibt den Namen des auslösenden Steuerelements sowie den Inhalt der comboBox <\/b>aus:<\/p>\n comboBox dynamisch füllen<\/b><\/p>\n Schauen wir uns gleich an, wie wir statt der beiden statischen Einträge einige Datensätze einer Datenbanktabelle im comboBox<\/b>-Element unterbringen. Die Beispieldatenbank enthält eine Tabelle namens tblAdressen<\/b>, die ein paar Daten zum Experimentieren liefert. Das comboBox<\/b>-Element soll schlicht die Nachnamen aus dieser Tabelle anzeigen. Dazu sind mindestens zwei Callback-Funktionen nötig, und zwar getItemLabel <\/b>und getItemCount<\/b>. Die Definition eines solchen Elements sieht so aus:<\/p>\n Die Callback-Funktion getItemCount <\/b>wird einmal beim Initialisieren des comboBox<\/b>-Elements aufgerufen, die Callback-Funktion getItemLabel <\/b>entsprechend der Anzahl, die Sie mit dem Parameter count <\/b>der Callback-Funktion getItemCount <\/b>zurückgeben. Die Hauptarbeit erledigt dabei die Routine getItemCount<\/b>. Sie speichert die anzuzeigenden Daten in einem Array, das Sie im Kopf des Moduls wie folgt deklarieren:<\/p>\n Die Routine getItemCount <\/b>liefert mit dem Parameter control <\/b>einen Verweis auf das aufrufende Steuerelement. Diesen müssen Sie auswerten, wenn mehrere Steuerelemente die Funktion getItemCount <\/b>aufrufen und Sie diesen Steuerelementen unterschiedliche Daten zurückliefern möchten. Das Prinzip zeigen wir gleich in einer anderen Callback-Funktion.<\/p>\n Die einfache Variante von getItemCount <\/b>geht davon aus, dass alle Aufrufe von unserem Steuerelement mit dem Wert cboDynamic <\/b>für das Attribut id <\/b>kommen. Sie deklariert ein Database<\/b>– und ein Recordset<\/b>-Objekt, die anschließend instanziert und als Quelle für die anzuzeigenden Daten herhalten werden.<\/p>\n Beim Durchlaufen der Datensätze passiert Dreierlei: Das Array strAdressen <\/b>wird jeweils um ein Feld erweitert, dieses wird mit dem Nachnamen des aktuellen Datensatzes gefüllt und schließlich wird die Zählervariable i<\/b>, die in beiden Fällen als Index dient, um eins erhöht. Nach dem Durchlaufen aller Datensätze enthält die Zählervariable gleichzeitig die Anzahl der anzuzeigenden Elemente, weshalb die Funktion diesen Wert dem Parameter count <\/b>zuweisen und dem Ribbon übergeben kann.<\/p>\n Die Anzahl der Aufrufe der zweiten Callback-Funktion namens getItemLabel <\/b>entspricht genau diesem Wert. Die Funktion erhält neben dem obligatorischen Verweis auf das Steuerelement (control<\/b>) noch einen Wert für den Parameter index<\/b>, der beim ersten Aufruf eins beträgt und sich dann mit jedem Aufruf um eins erhöht. Das ist praktisch, denn so lassen sich leicht die anzuzeigenden Daten aus dem Array strAdresssen <\/b>auslesen und dem Rückgabewert label <\/b>zuweisen.<\/p>\n Das Ribbon sieht dann mit der Tabelle aus Bild 2 als Ausgangsmaterial wie in Bild 3 aus.<\/p>\n Bild 2: Datenherkunft für die Beispiele dieses Beitrags<\/span><\/b><\/p>\n Bild 3: Beispiel für eine comboBox, die mit Daten aus einer Tabelle gefüllt wurde<\/span><\/b><\/p>\n Werte aus dem comboBox-Element auslesen<\/b><\/p>\n Das schönste Steuerelement hilft nicht weiter, wenn man nicht per Code auf Benutzereingaben reagieren kann. Wer die Arbeit mit dem Access-Kombinationsfeld gewohnt ist, wird nicht gerade mit Begeisterung auf die beschränkten Möglichkeiten des comboBox<\/b>-Steuerelements reagieren: Es bietet zwar eine Callback-Funktion, die ausgelöst wird, wenn der Benutzer einen Eintrag auswählt, aber dieser liefert als Parameter lediglich den in der comboBox <\/b>angezeigten Text. <\/p>\n <\/p>\n Diesen werten Sie beispielsweise mit dieser Routine aus, wobei die für dieses Steuerelement relevanten Zeilen fett gedruckt sind (die übrigen zeigen, wie Sie unbehandelte Aufrufe anderer Steuerelemente erkennen und behandeln können):<\/p>\n Normalerweise möchte man an dieser Stelle etwas mit den ausgewählten Daten tun, also etwa den gewünschten Datensatz in einem Formular anzeigen. Dazu braucht man, um auf Nummer sicher zugehen, die ID <\/b>des entsprechenden Datensatzes.<\/p>\n Wenn die im comboBox <\/b>angezeigten Texte eindeutig sind, ist dies kein Problem – Sie müssen einfach nur die ID <\/b>mit einer entsprechenden DLookup<\/b>-Anweisung ermitteln und können dann damit weiterarbeiten. Unnötig ist dieser zusätzliche Schritt dennoch – und problematisch wird es zudem, wenn die Einträge der comboBox <\/b>nicht eindeutig sind.<\/p>\n Aktualisieren des comboBox-Elements<\/b><\/p>\n Ein Vorteil des comboBox<\/b>-Elements ist sicher die Eigenschaft invalidateContentOnDrop<\/b>. Stellen Sie diese auf true <\/b>ein, liest comboBox <\/b>die anzuzeigenden Daten bei jedem Aufklappen neu ein. Gerade bei Daten, die sich oft ändern und deren Menge überschaubar ist, macht diese Einstellung Sinn. Wenn Sie den Zeitpunkt der Aktualisierung selbst steuern möchten, verwenden Sie die Invalidate<\/b>– oder die InvalidateControl<\/b>-Methode. Mehr dazu erfahren Sie weiter unten unter Aktualisieren des dropDown<\/b>-Elements; die Vorgehensweise ist bei beiden Steuerelementen gleich.<\/p>\n Texteingabe im comboBox-Element<\/p>\n Im Gegensatz zum gleich beschriebenen dropDown<\/b>-Element kann der Benutzer nicht nur die Einträge des comboBox<\/b>-Elements auswählen, sondern auch eigene Texte eingeben. Die anschließende Betätigung der Eingabetaste führt zum Auslösen der onChange<\/b>-Callback-Funktion, die im Parameter text <\/b>den neu eingegebenen Wert liefert.<\/p>\n Eintrag im comboBox-Element auswählen<\/b><\/p>\n Sie können im comboBox<\/b>-Element keinen Eintrag in dem Sinne vorauswählen, wie es etwa im Access-Kombinationsfeld möglich ist. Stattdessen erlaubt die Callback-Funktion getText <\/b>die Übergabe eines Textes, der beim Anzeigen des comboBox<\/b>-Elements in diesem erscheint. Das Attribut fügen Sie wie folgt ein:<\/p>\n Die Callback-Routine liefert schließlich den gewünschten Ausdruck zurück – hier der Wert des Feldes Nachname <\/b>des ersten Datensatzes der Tabelle tblAdressen<\/b>:<\/p>\n Das dropDown-Element<\/b><\/p>\n Schauen wir uns nun an, was das andere Ribbon-Steuerelement mit Kombinationsfeld-Charakter, das dropDown<\/b>-Element, besser oder weniger gut kann als das comboBox<\/b>-Element.<\/p>\n Bei einem statischen Beispielexemplar fällt zunächst einmal auf, dass man dem dropDown<\/b>-Element nicht nur item<\/b>-Elemente, sondern auch button<\/b>-Elemente unterordnen kann. Die folgende Definition ergibt beispielsweise das dropDown<\/b>-Element aus Bild 4 (in diesem Fall kommen eingebaute Ribbon-Icons zum Einsatz, bei denen Sie einfach nur die imageMso <\/b>angeben müssen):<\/p>\n Bild 4: Beispiel für ein statisches dropDown-Element mit zusätzlicher Schaltfläche<\/span><\/b><\/p>\n dropDown-Element dynamisch füllen<\/b><\/p>\n Das Füllen eines dropDown<\/b>-Elements geschieht fast auf die gleiche Weise wie beim comboBox<\/b>-Element. Der Unterschied ist, dass Sie hier zusätzlich noch eine ID <\/b>pro Eintrag festlegen können – also genau das, was wir tabellenorientiert denkenden Entwickler brauchen. In der Ribbon-Definition sieht dies so aus, wobei zusätzlich zur Definition des comboBox<\/b>-Pendants noch eine Callback-Funktion für getItemID <\/b>und als Ersatz für das fehlende onChange<\/b>-Attribut das onAction<\/b>-Attribut eingesetzt wurde:<\/p>\n Im VBA-Modul legen wir wiederum ein String-Array fest:<\/p>\n Das Zählen der Datensätze und das Füllen des Arrays erfolgt wie bereits weiter oben beschrieben. Allerdings enthält die Datensatzgruppe neben dem Nachnamen des Eintrags auch noch den Inhalt des Primärschlüsselfelds AdresseID<\/b>.<\/p>\n Das String-Array wird über die ReDim<\/b>-Anweisung zweidimensional gestaltet, wobei die eine Dimension die Spalten (hier AdresseID <\/b>und Nachname<\/b>) und die andere die Datensätze aufnimmt.<\/p>\n Das Einlesen der Beschriftung des Eintrags unterscheidet sich vom comboBox<\/b>-Element dadurch, dass hier Informationen aus dem zweidimensionalen Array eingelesen werden, wobei hier die Werte aus der zweiten Spalte an die Reihe kommen:<\/p>\n Neu im Vergleich zum comboBox<\/b>-Element ist beim dropDown<\/b>-Element die Routine getItemID<\/b>, welche die ID <\/b>aus der ersten Spalte der Elemente unseres Arrays ausliest und mit dem Parameter id <\/b>an das Ribbon übergibt:<\/p>\n Gewählten Eintrag im dropDown-Element auslesen<\/b><\/p>\n Ein Klick auf einen der dropDown<\/b>-Einträge löst die Callback-Funktion onAction <\/b>aus. Diese nennen wir in diesem Fall onAction_dropDown<\/b>, weil sie sich durch die Anzahl der Parameter von der onAction<\/b>-Funktion etwa von button<\/b>-Elementen unterscheidet.<\/p>\n Die folgende Beispielroutine zeigt einfach ein Meldungsfenster mit den Inhalten der beiden Parameter selectedID <\/b>und selectedIndex <\/b>an.<\/p>\n Der aus selectedID <\/b>gewonnene Wert entspricht genau dem Wert des Primärschlüsselfeldes des ausgewählten Datensatzes.<\/p>\n Aktualisieren des dropDown-Elements<\/b><\/p>\n Wenn sich die in der Datenherkunft befindlichen Daten ändern, sollen diese änderungen sich auch in den durch das dropDown<\/b>-Steuerelement angezeigten Daten niederschlagen. Im Gegensatz zum comboBox<\/b>-Element bietet das dropDown<\/b>-Element keine Eigenschaft namens invalidateContentOnDrop<\/b>, welche die Daten automatisch beim Aufklappen des Steuerelements neu einliest. Die einzige Alternative ist eine Vorgehensweise, die auch beim comboBox<\/b>-Steuerelement funktioniert. Dazu müssen Sie im onLoad<\/b>-Callback eine entsprechende Variable des Typs IRibbonUI <\/b>mit einem Verweis auf das Ribbon füllen. Diese deklarieren Sie wie folgt:<\/p>\n Den nötigen Einzeiler beim Erzeugen des Ribbons führt diese Callback-Funktion aus:<\/p>\n Das IRibbonUI<\/b>-Objekt stellt zwei Methoden zur Verfügung, mit denen Sie die get…<\/b>-Callback-Funktionen aller Steuerelemente (Invalidate<\/b>) oder nur die eines speziellen Steuerelements (InvalidateControl<\/b>) erneut aufrufen können. Wenn Sie nun den Inhalt der Tabelle tblAdressen <\/b>geändert haben und das dropDown<\/b>-Element diese änderungen beim nächsten Ausklappen berücksichtigen soll, müssen Sie etwa die folgende Anweisung aufrufen:<\/p>\n Diese sorgt für das erneute Aufrufen der get…<\/b>-Callbacks aller Steuerelemente der angegebenen Ribbon-Definition. Wenn Sie das dropDown<\/b>-Element gezielt ansprechen möchten, verwenden Sie diesen Aufruf:<\/p>\n Eintrag in dropDown-Element per Code festlegen<\/b><\/p>\n Im Gegensatz zum comboBox<\/b>-Element, für das Sie prinzipiell nur einen Text voreinstellen, aber keinen der vorhandenen Einträge auswählen können, erlaubt Ihnen das dropDown<\/b>-Element, einen der vorhandenen Einträge per VBA, beziehungsweise über die entsprechende Callback-Funktion auswählen zu lassen. Das Callback-Attribut heißt getSelectedItemID <\/b>und wird in der Ribbon-Definition so angegeben:<\/p>\n In der Callback-Funktion wird einfach nur die erste ID <\/b>der Datenherkunft angegeben:<\/p>\n Es gibt noch eine zweite Möglichkeit, einen Eintrag auszuwählen. Diese bezieht sich nicht auf den in der ID <\/b>des Eintrags gespeicherten Wert, sondern auf den Index, also den Reihenfolge-Wert des Eintrags. Das Callback-Attribut heißt getSelectedItemIndex<\/b> und eine Routine, die jeweils den ersten Eintrag markiert, könnte so aussehen:<\/p>\n Beachten Sie, dass Sie nur eines der beiden Attribute getSelectedItemID <\/b>oder getSelectedItemIndex <\/b>verwenden können.<\/p>\n Weitere Eigenschaften von dropDown- und comboBox-Elementen<\/b><\/p>\n Nachfolgend finden Sie noch weitere Eigenschaften der beiden Kombinationsfeld-Varianten. Das sizeString<\/b>-Attribut legt fest, wie breit ein comboBox<\/b>– oder ein dropDown<\/b>-Steuerelement sein soll. Interessanterweise gibt man hier nicht, wie sonst üblich, eine Zahl ein, um die Breite in der Standardeinheit festzulegen, sondern eine Zeichenkette. Das Kombinationsfeld wird dann exakt so breit ausgelegt, dass der Text genau hineinpasst:<\/p>\n Dem comboBox<\/b>-Element vorbehalten ist das Attribut maxLength<\/b>. Es erwartet einen numerischen Wert, der festlegt, wie viele Zeichen die Eingabe umfassen darf. Die übrigen Attribute sind für die reine Anzeige von Daten nicht relevant und sollen daher an dieser Stelle nicht weiter besprochen werden.<\/p>\n Das dynamicMenu-Element<\/b><\/p>\n Stattdessen kümmern wir uns noch um das dritte Element, mit dem Sie zur Laufzeit Tabelleninhalte anzeigen können.<\/p>\n Dieses Element entpricht bezüglich seiner Möglichkeiten dem menu<\/b>-Element: Sie können also beispielsweise button<\/b>-Elemente oder auch weitere menu<\/b>-Elemente einfügen (siehe Bild 5). Das Exemplar aus der Abbildung wird etwa so definiert:<\/p>\n Bild 5: Ein statisches Menü (menu-Element)<\/span><\/b><\/p>\n Eigentlich wäre der Aufbau dieses XML-Ausdrucks eher uninteressant, würde er nicht die Basis für dynamische Menüs liefern. Das alternative dynamicMenu<\/b>-Element erwartet nämlich als Rückgabewert seiner Callback-Funktion getContent <\/b>genau einen solchen XML-Ausdruck. Das grobe Gerüst dieses Elements sieht so aus:<\/p>\n Wenn die getContent<\/b>-Callback-Funktion zwar vorhanden ist, aber mit dem Parameter content <\/b>keinen Wert zurückliefert, erzeugt dies ein leeres Menü wie in Bild 6:<\/p>\n Bild 6: Ein leeres dynamisches Menü<\/span><\/b><\/p>\n Der mit dem Parameter content <\/b>an das Ribbon übergebene Ausdruck sieht ein klein wenig anders aus als der für ein herkömmliches menu<\/b>-Element – aber auch nur in der ersten Zeile. Diese enthält nämlich nicht die üblichen id<\/b>– und label<\/b>-Tags, sondern sieht so aus:<\/p>\n Den Rest stellen Sie auf beliebige Art und Weise zusammen. Die einfachste Variante ist die Quick“n“Dirty-Stringverknüpfung wie in der Routine aus Listing 2.<\/p>\n Listing 2: Dynamisches Zusammensetzen eines statischen Menü-Elements<\/p>\n Diese Routine erzeugt exakt das Menü, das schon das statische menu<\/b>-Element aus Bild 5 anzeigt.<\/p>\n Nun wollen wir aber kein statisches Menü mit einem dynamicMenu<\/b>-Element nachbauen, sondern dieses mit den Daten aus einer Tabelle füllen. Dabei sind zwei Faktoren wichtig: Erstens sollen die anzuzeigenden Daten im Attribut label <\/b>der unterhalb des Menüs angelegten button<\/b>-Elemente landen und der Wert für das id<\/b>-Attribut muss jeweils eindeutig sein und rekrutiert sich deshalb aus der AdresseID <\/b>des jeweiligen Datensatzes (s. Listing 3). Fehlt nur noch eine winzige Kleinigkeit: Es passiert leider noch überhaupt nichts, wenn Sie einen der Menüeinträge per Mausklick auswählen. Das dynamicMenu<\/b>-Element bietet keine eigene Callback-Funktion für diesen Zweck, was aber auch logisch ist: Immerhin liefern die darunter angeordneten button<\/b>-Elemente ja jedes sein eigenes onAction<\/b>-Attribut. Passen wir also die Anweisung an, welche die einzelnen button<\/b>-Elemente zur XML-Definition hinzufügt – die änderungen sind fett gedruckt (in einer Zeile):<\/p>\n Listing 3: Echte Dynamik im dynamicMenu-Element<\/p>\n\n
<customUI xmlns="http:\/\/schemas.microsoft.com\/office\/2006\/01\/customui" onLoad="OnLoad_Beispiel" loadImage="loadImage">\r\n<ribbon startFromScratch="true">\r\n<tabs>\r\n<tab id="tab0" label="Beispiele für Kombinations- und Auswahlfelder">\r\n<group id="grpSamplesComboBox" label="Beispiele ComboBox">\r\n<comboBox id="cboStatic" label="ComboBox statisch">\r\n<item id="item1" image="chart_area.png" label="Eintrag 1"\/>\r\n<item id="item2" image="printer.png" label="Eintrag 2"\/>\r\n<\/comboBox>\r\n<\/group>\r\n<group id="grpSampleDropDown" label="Beispiele DropDown"\/>\r\n<group id="grpSampleDynamicMenu" label="Beispiel DynamicMenu"\/>\r\n<\/tab>\r\n<\/tabs>\r\n<\/ribbon>\r\n<\/customUI><\/pre>\n
\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2009_04\/RibbonKombis-web-images\/pic001_opt.jpeg\")
<\/p>\n<comboBox id="cboStatic" label="ComboBox statisch" onChange="onChange"><\/pre>\n
Sub onChange(control As IRibbonControl, _\r\n text As String)\r\n MsgBox "Steuerelement: " & control.ID _\r\n & vbCrLf & "text: " & text\r\n End Sub<\/pre>\n
<comboBox id="cboDynamic"\r\nlabel="comboBox dynamisch"\r\ngetItemCount="getItemCount"\r\ngetItemLabel="getItemLabel"\r\nonChange="onChange"\/><\/pre>\n
Dim strAdressen() As String<\/pre>\n
Sub getItemCount(control As IRibbonControl, _\r\n ByRef count)\r\n Dim db As DAO.Database\r\n Dim rst As DAO.Recordset\r\n Dim i As Integer\r\n Set db = CurrentDb\r\n Set rst = db.OpenRecordset("SELECT Nachname\r\n FROM tblAdressen", dbOpenDynaset)\r\n Do While Not rst.EOF\r\n ReDim Preserve strAdressen(i + 1) As _\r\n String\r\n strAdressen(i) = rst!Nachname\r\n i = i + 1\r\n rst.MoveNext\r\n Loop\r\n count = i\r\n End Sub<\/pre>\nSub getItemLabel(control As IRibbonControl, _\r\n index As Integer, ByRef label)\r\n label = strAdressen(index)\r\n End Sub<\/pre>\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2009_04\/RibbonKombis-web-images\/pic002_opt.jpeg\")
<\/p>\n![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2009_04\/RibbonKombis-web-images\/pic003_opt.jpeg\")
<\/p>\nSub onChange(control As IRibbonControl, _\r\n text As String)\r\n Select Case control.id\r\n Case "cboDynamic"\r\n MsgBox text\r\n Case Else\r\n MsgBox "Steuerelement: " _\r\n & control.id & vbCrLf _\r\n & "text: " & text\r\n End Select\r\n End Sub<\/pre>\n
<comboBox id="cboDynamic"\r\nlabel="comboBox dynamisch"\r\n...\r\ngetText="getText"\/><\/pre>\n
Sub getText(control As IRibbonControl, _\r\n ByRef text)\r\n text = DLookup("Nachname", "tblAdressen")\r\n End Sub<\/pre>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2009_04\/RibbonKombis-web-images\/pic004_opt.jpeg\")
<\/p>\n<dropDown id="drpStatic" label="dropDown\r\nstatisch">\r\n<item id="itm1"\r\nimageMso="_3DExtrusionDepth72Classic"\r\nlabel="Eintrag 1"\/>\r\n<item id="itm2"\r\nimageMso="_3DSurfaceMetalClassic"\r\nlabel="Eintrag 2"\/>\r\n<button id="btn1"\r\nimageMso="_3DLightingClassic"\r\nlabel="Button 1"\/>\r\n<\/dropDown><\/pre>\n
<dropDown id="drpDynamic"\r\nlabel="dropDown dynamisch"\r\nonAction="onAction_dropDown"\r\ngetItemCount="getItemCount"\r\ngetItemLabel="getItemLabel"\r\ngetItemID="getItemID"\/><\/pre>\n
Dim strAdressenDropDown() As String<\/pre>\n
Sub getItemCount(control As IRibbonControl, _\r\n ByRef count)\r\n Dim db As DAO.Database\r\n Dim rst As DAO.Recordset\r\n Dim i As Integer\r\n Set db = CurrentDb\r\n Set rst = db.OpenRecordset("SELECT\r\n AdresseID, Nachname FROM tblAdressen", _\r\n dbOpenDynaset)\r\n Do While Not rst.EOF\r\n ReDim Preserve strAdressenDropDown(2, _\r\n i + 1) As String\r\n strAdressenDropDown(1, i) = rst!AdresseID\r\n strAdressenDropDown(2, i) = rst!Nachname\r\n i = i + 1\r\n rst.MoveNext\r\n Loop\r\n count = i\r\n End Sub<\/pre>\nSub getItemLabel(control As IRibbonControl, index As Integer, ByRef label)\r\n label = strAdressenDropDown(2, index)\r\n End Sub<\/pre>\n
Sub getItemID(control As IRibbonControl, _\r\n index As Integer, ByRef id)\r\n id = strAdressenDropDown(1, index)\r\n End Sub<\/pre>\n
Sub onAction_dropDown(control As _\r\n IRibbonControl, selectedId As String, _\r\n selectedIndex As Integer)\r\n MsgBox "selectedID: " & selectedId & vbCrLf _\r\n & "selectedIndex: " & selectedIndex _\r\n & vbCrLf\r\n End Sub<\/pre>\n
Dim objRibbon_Beispiel As IRibbonUI<\/pre>\n
Sub onLoad_Beispiel(ribbon As IRibbonUI)\r\n Set objRibbon_Beispiel = ribbon\r\n End Sub<\/pre>\n
objRibbon_Beispiel.Invalidate<\/pre>\n
objRibbon_Beispiel.InvalidateControl "drpDynamic"<\/pre>\n
getSelectedItemID="getSelectedItemID"<\/pre>\n
Sub getSelectedItemID(control As _\r\n IRibbonControl, ByRef index)\r\n index = DLookup("AdresseID", "tblAdressen")\r\n End Sub<\/pre>\nSub getSelectedItemIndex(control As _\r\n IRibbonControl, ByRef index)\r\n index = 0\r\n End Sub<\/pre>\n
<dropDown id="drpDynamic"\r\nlabel="dropDown dynamisch"\r\n...\r\nsizeString="So breit bin ich!" \/><\/pre>\n
![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2009_04\/RibbonKombis-web-images\/pic005_opt.jpeg\")
<\/p>\n<menu id="mnu" label="Statisches Menü">\r\n<button id="btnMnu1" label="Schaltfläche 1"\/>\r\n<button id="btnMnu2" label="Schaltfläche 2"\/>\r\n<menu id="mnu1" label="Untermenü">\r\n<button id="btn3" label="Schaltfläche 3"\/>\r\n<button id="btn4" label="Schaltfläche 4"\/>\r\n<\/menu>\r\n<\/menu><\/pre>\n
<dynamicMenu id="dnm"\r\nlabel="Dynamisches Menü"\r\ngetContent="getContent"\/><\/pre>\n
![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2009_04\/RibbonKombis-web-images\/pic006_opt.jpeg\")
<\/p>\nSub getContent(control As IRibbonControl, _\r\n ByRef content)\r\n End Sub<\/pre>\n
<menu xmlns="http:\/\/schemas.microsoft.com\/\r\noffice\/2006\/01\/customui"><\/pre>\n
Sub getContent(control As IRibbonControl, ByRef content)\r\n Dim str As String\r\n str = "<menu xmlns=""http:\/\/schemas.microsoft.com\/office\/2006\/01\/customui"">"\r\n str = str & "<button id=""btnMnu1"" label=""Schaltfläche 1""\/>"\r\n str = str & "<button id=""btnMnu2"" label=""Schaltfläche 2""\/>"\r\n str = str & "<menu id=""mnu1"" label=""Untermenü"">"\r\n str = str & "<button id=""btn3"" label=""Schaltfläche 3""\/>"\r\n str = str & "<button id=""btn4"" label=""Schaltfläche 4""\/>"\r\n str = str & "<\/menu>"\r\n str = str & "<\/menu>"\r\n content = str\r\n End Sub<\/pre>\n
Sub getContent(control As IRibbonControl,_ByRef content)\r\n Dim db As DAO.Database\r\n Dim rst As DAO.Recordset\r\n Dim str As String\r\n Set db = CurrentDb\r\n Set rst = db.OpenRecordset("SELECT * FROM tblAdressen", dbOpenDynaset)\r\n str = "<menu xmlns=""http:\/\/schemas.microsoft.com\/office\/2006\/01\/customui"">"\r\n Do While Not rst.EOF\r\n str = str & "<button id=""btnMnu" & rst!AdresseID & """ label=""" & rst!Vorname & " " _\r\n & rst!Nachname & """\/>"\r\n rst.MoveNext\r\n Loop\r\n str = str & "<\/menu>"\r\n content = str\r\n End Sub\r\nstr = str & "<button id=""btnMnu"\r\n& rst!AdresseID & """ label=""" & rst!Vorname\r\n& " " & rst!Nachname & """ onAction=""onAction_DynamicMenu"" tag=""" & rst!AdresseID & """\/>"<\/pre>\n