<\/p>\n
Die Programmierung des TreeView-Steuerelements haben wir bereits in vielen Beiträgen dokumentiert. Dort haben wir auch gezeigt, wie Sie Befehle für spezielle Elementtypen im TreeView in Kontextmenüs unterbringen, die beim Rechtsklick auf die jeweiligen Elemente angezeigt werden. Es gibt noch eine andere Möglichkeit, solche Befehle abhängig vom Elementtyp abzubilden: als Ribbon-Einträge. Wie das gelingt, zeigt der vorliegende Beitrag.<\/b><\/p>\n
Beispieldatenbank<\/b><\/p>\n
Im Beitrag TreeView mit Kontextmenü <\/b>(www.access-im-unternehmen.de\/1243<\/b>) haben wir bereits Vorarbeiten für diesen Beitrag geleistet und ein funktionsfähiges TreeView<\/b>-Steuerelement mit den Daten aus den beiden Tabellen tblKunden <\/b>und tblProjekte <\/b>gefüllt.<\/p>\n
Dort haben wir beschrieben, wie Sie die Daten im TreeView mit Kontextmenü-Einträgen anpassen können. Im vorliegenden Beitrag wollen wir nun zeigen, wie Sie die entsprechenden Befehle in einem Ribbon unterbringen, das nur dann angezeigt wird, wenn der Benutzer auf ein Element eines bestimmten Typs klickt – also beispielsweise auf ein Kunden-Element oder ein Projekt-Element.<\/p>\n
Das Ribbon soll dann die gleichen Befehle anzeigen, die auch das Kontextmenü zu dem entsprechenden Eintrag anzeigt und die gleichen Funktionen auslösen (siehe Bild 1). Wir beginnen mit der Beispieldatenbank TreeViewMitRibbon.accdb<\/b>.<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2020_04\/pic_1244_001.png\")
<\/p>\n
Bild 1: Die Befehle dieses Kontextmenüs wollen wir im Ribbon anzeigen, wenn der Benutzer einen der Einträge im TreeView anklickt.<\/span><\/b><\/p>\n Tabelle für die Ribbon-Definitionen anlegen<\/b><\/p>\n Wenn Sie Ribbons anzeigen möchten, benötigen Sie eine Tabelle namens USysRibbons<\/b>, die nach einem bestimmten Schema aufgebaut ist und die Ribbon-Definitionen aufnimmt. Diese Tabelle enthält die folgenden drei Felder:<\/p>\n Die Tabelle mit dem Namen USysRibbons <\/b>wird aufgrund des Präfixes USys…<\/b> als Systemobjekt erkannt und wird nur angezeigt, wenn Sie in den Navigationsoptionen von Access die Option Systemobjekte anzeigen <\/b>aktivieren. <\/p>\n Diese Tabelle füllen wir dann gleich mit den gewünschten Ribbon-Definitionen (siehe Bild 2). Mit der ersten möchten wir erreichen, dass beim Anklicken eines der Kunde<\/b>-Elemente im TreeView<\/b>-Steuerelement ein kontextabhängiges Ribbon-Tab zum Ribbon hinzugefügt wird.<\/p>\n Bild 2: Die Tabelle USysRibbons mit den Ribbon-Definitionen<\/span><\/b><\/p>\n Deshalb deklarieren wir dieses wie in Listing 1. Das Element customUI <\/b>enthält zwei Callback-Attribute:<\/p>\n Listing 1: Definition des ersten Ribbons, das beim Anklicken eines Kunden angezeigt werden soll<\/span><\/b><\/p>\n Das ribbon-Element könnte man mit dem Attribut startFromScratch=“true“<\/b> ausstatten, wenn man möchte, dass alle anderen und eingebauten Elemente des Ribbons beim Anzeigen ausgeblendet werden. Wir wollen dem Benutzer aber hier die Möglichkeit geben, dennoch die Befehle in den übrigen Ribbon-Tabs zu verwenden.<\/p>\n Um Ribbon-Tabs so anzuzeigen, dass sie nur im Kontext mit einem bestimmten Formular oder Element erscheinen, verwenden wir nicht die üblicherweise genutzte tabs<\/b>-Auflistung, sondern das Element contextualTabs<\/b>. Dieses geht meist einher mit dem untergeordneten Element tabSet<\/b>, dem wir über das Attribut idMso <\/b>mit dem Wert TabSetFormReportExtensibility <\/b>die Information mitgeben, dass es gemeinsam mit Formularen oder Berichten angezeigt wird.<\/p>\n Danach folgt ein herkömmliches tab<\/b>-Element mit der Beschriftung Kunden<\/b>, darunter zwei group<\/b>-Elemente. Das erste erhält die Beschriftung Kunde<\/b>, das zweite die Beschriftung Zwischenablage<\/b>. Die erste Gruppe enthält die drei Befehle Kunde löschen<\/b>, Neues Projekt <\/b>und Umbenennen<\/b>. Für alle button<\/b>-Elemente legen wir über das Attribut image <\/b>den Namen des für diese Schaltfläche anzuzeigenden Bildes fest.<\/p>\n Außerdem stellen wir mit size=“large“ <\/b>ein, dass große Schaltflächen angezeigt werden sollen. Schließlich erhalten alle Schaltflächen das Attribut onAction <\/b>mit dem Namen der Callback-Funktion, die beim Anklicken der Schaltfläche aufgerufen werden soll. Warum erhalten alle Schaltflächen den Aufruf der gleichen Callback-Funktion namens onAction<\/b> Weil diese als Parameter den Namen des aufrufenden Elements erhält und wir in dieser Prozedur prüfen, von welchem Element der Aufruf kommt und die entsprechenden Befehle ausführen.<\/p>\n Dies soll ein Ribbon wie in Bild 3 ergeben. In den folgenden Abschnitten sehen wir uns an, wie wir das realisieren.<\/p>\n Bild 3: Das Ribbon zu den Kundeneinträgen im TreeView-Steuerelement<\/span><\/b><\/p>\n Ribbon-Verweis speichern<\/b><\/p>\n Wie oben erwähnt, soll beim Laden des Ribbons ein Verweis auf die Ribbon-Definition in einer Variablen gespeichert werden. Für diesen und anderen Ribbon-relevanten Code legen wir ein neues Modul namens mdlRibbons <\/b>an. Diesem fügen wir als Erstes eine Variable für unser soeben definiertes Ribbon hinzu:<\/p>\n Dann können wir auch schon die Callback-Funktion implementieren, die wir für das Attribut onLoad <\/b>des customUI<\/b>-Elements der Ribbon-Definition angegeben haben. Diese sieht wie folgt aus:<\/p>\n Callback zum Zuweisen von Bildern<\/b><\/p>\n Danach legen wir die Callback-Prozedur an, die wir für das Callback-Attribut loadImage <\/b>hinterlegt haben. Diese finden Sie in Listing 2. Die Prozedur erhält den für das Attribut image des jeweiligen Steuerelements angegebenen Namen des Bildes.<\/p>\n Listing 2: Callback-Prozedur zum Laden der Bilder in die Ribbon-Schaltflächen<\/span><\/b><\/p>\n Sie wird für jedes Steuer-element, das dieses Attribut enthält, einmal aufgerufen. Die Prozedur greift auf Bilddateien zu, die in der Tabelle MSysResources <\/b>hinterlegt sein müssen. Wie Sie diese dort hinterlegen, haben wir bereits im Beitrag TreeView mit Kontextmenü <\/b>(www.access-im-unternehmen.de\/1243<\/b>) kurz beschrieben – in diesem Fall verwenden wir allerdings Bilder im Format 32 x 32 statt 16 x 16.<\/p>\n Die Funktion prüft mit einem Aufruf der DLookup<\/b>-Funktion, ob sich in der Tabelle MSysResources <\/b>ein Datensatz befindet, dessen Feld Name <\/b>den Namen des Bildes aufweist und schreibt den gegebenenfalls gefundenen Primärschlüsselwert in die Variable lngID<\/b>. Die Datensätze in der Tabelle MSysResources <\/b>sehen etwa wie in Bild 4 aus.<\/p>\n Bild 4: Die Tabelle MSysResources mit den Bildern für das Ribbon<\/span><\/b><\/p>\n Hier kann es zu einem Fehler kommen, wenn die Tabelle MSysResources <\/b>gar nicht vorhanden ist. Der Fehler hat die Nummer 3078<\/b>. Tritt dieser Fehler auf, zeigt die Prozedur eine entsprechende Fehlermeldung an und die Prozedur wird beendet.<\/p>\n Anderenfalls prüft die Prozedur, ob lngID <\/b>den Wert 0 <\/b>hat. Das ist der Fall, falls die DLookup<\/b>-Funktion keinen passenden Datensatz gefunden hat.<\/p>\n Auch in diesem Fall erscheint eine Meldung, die tunlichst während der Entwicklung der Anwendung auftreten sollte, damit der Entwickler die fehlenden Bilddateien zur Tabelle MSysResources<\/b> hinzufügen kann.<\/p>\n Ist lngID <\/b>jedoch nicht 0<\/b>, dann wurde ein passender Datensatz gefunden. Dann übergeben wir den Namen des Steuerelements an die Funktion PicFromSharedResource_Ribbon<\/b>, welche ein Objekt des Typs StdPicture <\/b>zurückgibt. Dieses wird dann als Ergebnis der Callback-Funktion dem auslösenden Steuer-element zugewiesen.<\/p>\n <\/p>\n Die Funktion PicFromSharedResource_Ribbon <\/b>und einige andere nützliche Bildfunktionen finden Sie im Modul mdlRibbonImages<\/b>.<\/p>\n Damit haben wir nun folgende Dinge erledigt:<\/p>\n Ribbon anzeigen, wenn Kunde den Fokus im TreeView-Steuerelement erhält<\/b><\/p>\n Nun geht es weiter. Wir müssen dafür sorgen, dass dieses Ribbon angezeigt wird, sobald der Benutzer im TreeView<\/b>-Steuerelement des Formulars frmKundenProjekte <\/b>auf eines der Kunden<\/b>-Elemente klickt.<\/p>\n Aber wie wollen wir das erledigen Immerhin gibt es nur die folgenden beiden Möglichkeiten, überhaupt für die Anzeige von Ribbons zu sorgen, deren Definitionen in der Tabelle USysRibbons <\/b>gespeichert sind:<\/p>\n Bild 5: Einstellen des Anwendungsribbons<\/span><\/b><\/p>\n Die erste Option fällt flach, weil man diese zwar zur Laufzeit neu einstellen kann, die Änderung aber erst nach einem Neustart der Access-Anwendung wirksam wird.<\/p>\n Bleibt die zweite Option – können wir damit mehr anfangen Ja, denn das Ribbon eines Formulars oder Berichts kann man auch zur Laufzeit ändern. Stellt man per VBA die Eigenschaft RibbonName<\/b> eines Formulars oder Berichts auf einen neuen Wert ein, dann wird die angegebene Ribbon-Definition auch direkt angewendet.<\/p>\n Nun zählen wir eins und eins zusammen und probieren es so, dass wir das Ereignis abfangen, das beim Anklicken eines TreeView<\/b>-Elements ausgelöst wird, dort prüfen, welchen Elementtyp der Benutzer gerade angeklickt hat und in Abhängigkeit davon das entsprechende Ribbon anzeigen – indem wir die Eigenschaft RibbonName <\/b>anpassen.<\/p>\n Zweites Ribbon hinzufügen<\/b><\/p>\n Bevor wir das erledigen, fügen wir noch das zweite Ribbon hinzu, das beim Anklicken eines Projekts angezeigt werden soll. Wenn wir nur einen Elementtyp im TreeView<\/b>-Steuerelement haben, brauchen wir den ganzen Aufwand gar nicht in dieser Form zu betreiben.<\/p>\n Die Definition des zweiten Ribbons für die Projekte finden Sie in Listing 3.<\/p>\n Listing 3: Dieses Ribbon soll angezeigt werden, wenn der Benutzer ein Element des Typs Projekt anklickt.<\/span><\/b><\/p>\n Ein wichtiger Unterschied zwischen den beiden Ribbon-Definitionen ist, dass die zweite eine andere Callback-Methode für das Callback-Attribut onLoad <\/b>festlegt, nämlich in diesem Fall OnLoad_RibbonProjekt<\/b>.<\/p>\n Für die zweite Ribbon-Definition müssen wir nämlich eine zweite Variable mit einem Verweis füllen, damit wir unabhängig auf die beiden Ribbons zugreifen können. Die Variable deklarieren wir wie folgt: <\/p>\n Als Callback-Methode definieren wir diese Prozedur, welche die Variable objRibbon_RibbonProjekt <\/b>mit dem IRibbonUI<\/b>-Objekt füllt:<\/p>\n Ribbons scharf schalten<\/b><\/p>\n Wenn Sie die beiden Ribbon-Definitionen in die Tabelle USysRibbons <\/b>eingetragen haben, sind diese noch nicht verfügbar. Das heißt, wenn Sie nun einen der beiden Ribbon-Namen RibbonKunde <\/b>oder RibbonProjekt <\/b>für die Eigenschaft Name des Menübands <\/b>des Formulars eintragen, wird dieses beim Öffnen des Formulars noch nicht angezeigt. Der Grund ist, dass die Ribbon-Definitionen aus der Tabelle einmal „scharf geschaltet“ werden müssen, und das geschieht beim Start der Anwendung.<\/p>\n Zu diesem Zeitpunkt durchsucht Access die Tabelle USysRibbons <\/b>und hält die Einträge für die Auswahl in den Access-Optionen und für die Eigenschaft Name des Menübands <\/b>bereit. Erst dann können Sie diese Einträge auch für die Eigenschaft auswählen.<\/p>\n Damit können wir uns nun darum kümmern, dass die Ribbons beim Anklicken der entsprechenden Elemente des TreeView<\/b>-Steuerelements aktiviert und angezeigt werden.<\/p>\n Ribbon, wechsle dich<\/b><\/p>\n Das richtige Ereignis für diesen Zweck ist das Click<\/b>-Ereignis des TreeView<\/b>-Steuerelements. Dieses legen Sie an, indem Sie das Klassenmodul des Formulars öffnen und im Codefenster im linken Kombinationsfeld den Eintrag ctlTreeView <\/b>auswählen und im rechten Kombinationsfeld den Eintrag Click<\/b>. Dies legt automatisch die Ereignisprozedur ctlTreeView_Click<\/b> an (siehe Bild 6). <\/p>\n Bild 6: Anlegen der Ereignisprozedur ctlTreeView_Click<\/span><\/b><\/p>\n Die so angelegte Prozedur füllen wir wie in Listing 4 mit Code. Die Prozedur referenziert zunächst über die Eigenschaft SelectedItem <\/b>das aktuell markierte Element und speichert den Verweis in der Objektvariablen objNode<\/b>.<\/p>\n Listing 4: Das Click-Ereignis stellt die RibbonName-Eigenschaft auf das gewünschte Ribbon ein.<\/span><\/b><\/p>\n Dann prüft sie, ob überhaupt ein Element markiert ist. Das ist eigentlich nur der Fall, wenn die zugrunde liegende Tabelle tblKunden <\/b>keine Datensätze enthält – aber wir wollen den Fall dennoch abbilden. In diesem Fall wird der Else<\/b>-Zweig der If…Then<\/b>-Bedingung ausgeführt und die Eigenschaft RibbonName <\/b>des Formulars auf eine leere Zeichenkette eingestellt.<\/p>\n Anderenfalls kann das aktuell markierte Element des TreeView<\/b>-Steuerelements entweder ein Kunden- oder ein Projekt-Element sein. Das prüfen wir anhand des ersten Buchstabens der Key<\/b>-Eigenschaft. Entspricht dieser dem Buchstaben k<\/b>, handelt es sich um einen Kunden, im Falle von p <\/b>um ein Projekt.<\/p>\n Im Falle eines Kunden-Elements stellt die Prozedur die Eigenschaft RibbonName <\/b>auf den Wert RibbonKunde <\/b>ein. Und es folgt noch eine weitere Anweisung, die schließlich erklärt, warum wir einen Verweis auf das Ribbon in der Variablen objRibbon_RibbonKunde <\/b>gespeichert haben: Weil wir dessen Methode ActivateTab <\/b>nutzen müssen, um das nun eingeblendete Ribbon-Tab auch zum aktiven Ribbon-Tab zu machen.<\/p>\n Wenn wir das nicht erledigen würden, sähe das Ribbon nach der einfachen Einstellung der Eigenschaft wie in Bild 7 aus.<\/p>\n Bild 7: Ribbon nur nach Einblendung des kontextsensitiven Ribbon-Tabs …<\/span><\/b><\/p>\n Nach dem Aufruf der Methode ActivateTab <\/b>mit dem Namen des Ribbon-Tabs aus der Ribbon-Definition sieht das Ribbon jedoch wie gewünscht aus – siehe Bild 8.<\/p>\n Bild 8: … und nach dem Aktivieren dieses Tabs.<\/span><\/b><\/p>\n Auf die gleiche Weise verläuft der zweite Zweig der Select Case<\/b>-Bedingung, die das Ribbon für die Projekt<\/b>-Elemente aufruft. Dieses Ribbon sieht nach der Aktivierung schließlich wie in Bild 9 aus.<\/p>\n Bild 9: Das Ribbon für die Projekt-Elemente<\/span><\/b><\/p>\n Optimierung<\/b><\/p>\n Nun kommt es in manchen Access-Versionen dazu, dass das IRibbonUI<\/b>-Objekt nicht gefunden werden kann. Offenbar geschieht das Füllen des Objekts über die Callback-Methode (zum Beispiel onLoad_RibbonKunde<\/b>) nicht schnell genug, sodass wir direkt nach dem Füllen noch nicht auf die Methode ActivateTab <\/b>dieses Objekts zugreifen können.<\/p>\n Für diesen Fall haben wir eine kleine Optimierung vorgesehen, die vor dem Aufruf der ActivateTab<\/b>-Methode mit On Error Resume Next <\/b>die Fehlerbehandlung deaktiviert (siehe Listing 5). Auf diese Weise wirft die ActivateTab<\/b>-Methode auch dann keinen Fehler, wenn objRibbon_RibbonKunde <\/b>noch nicht vorhanden ist.<\/p>\n Listing 5: Verbesserung des Ereignisses ctlTreeView_Click<\/span><\/b><\/p>\n Stattdessen fragen wir nach der ActivateTab<\/b>-Methode ab, ob Err.Number <\/b>nicht mehr den Wert 0 <\/b>hat, also ob ein Fehler aufgetreten ist. In diesem Fall stellen wir die Eigenschaft TimerInterval <\/b>des Formulars auf den Wert 300 <\/b>ein, was dazu führt, dass die Ereignisprozedur, die durch das Ereignis Bei Zeitgeber <\/b>ausgelöst wird, in 300 Millisekunden ausgelöst wird.<\/p>\n Was aber geschieht in dieser Prozedur, die wir ja bisher noch gar nicht angelegt haben Diese Prozedur sieht wie folgt aus:<\/p>\n Sie stellt also erst einmal die Eigenschaft Zeitgeberintervall <\/b>wieder auf den Wert 0 <\/b>ein, was bewirkt, dass diese Ereignisprozedur zunächst erst einmal nicht wieder aufgerufen wird. Dann ruft sie einfach erneut die Prozedur ctlTreeView_Click <\/b>auf. Mittlerweile dürfte mit den 300 Millisekunden genügend Zeit vergangen sein, dass die Objektvariable objRibbon_Kunde <\/b>mit dem Verweis auf das Ribbon gefüllt ist und wir die Methode ActivateTab <\/b>aufrufen können.<\/p>\n Ribbon aktivieren beim Öffnen des Formulars<\/b><\/p>\n Wenn der Benutzer das Formular öffnet, klickt er ja nicht direkt einen Eintrag im TreeView<\/b>-Steuerelement an. Damit dennoch direkt der erste Eintrag in diesem Steuer-element markiert ist und das passende Ribbon angezeigt wird, erweitern wir die Ereignisprozedur, die beim Öffnen des Formulars ausgelöst wird, um wenige Zeilen:<\/p>\n Nach dem Aufruf der Prozedur FillTreeView <\/b>prüfen wir, ob das Steuer-element überhaupt Elemente enthält. Ist das der Fall, markieren wir das erste Element, indem wir es der Eigenschaft SelectedItem <\/b>zuweisen.<\/p>\n Dann stellen wir wieder die Eigenschaft Zeitgeberintervall <\/b>auf den Wert 300 <\/b>ein, damit die Ereignisprozedur Bei Zeitgeber <\/b>nach 300 Millisekunden ausgelöst wird und dann die Ereignisprozedur ctlTreeView_Click <\/b>aufruft. Dies sorgt dann für die Anzeige des Ribbons für das erste Element.<\/p>\n Schaltflächen mit Ereignissen füllen<\/b><\/p>\n Damit die Ribbon-Schaltflächen auch etwas bewirken, haben wir für diese das Attribut onAction <\/b>auf die Callback-Funktion onAction <\/b>eingestellt. Diese Callback-Funktion fügen wir ebenfalls zum Modul mdlRibbons <\/b>hinzu. Die Funktion erhält mit dem Parameter control <\/b>ein Objekt des Typs IRibbonControl<\/b>. Dieses bietet interessante Eigenschaften, zum Beispiel die Eigenschaft ID<\/b>. Diese liefert den Namen des auslösenden Steuerelements, auf das wir in der Callback-Funktion aus Listing 6 dann mit control.ID <\/b>zugreifen.<\/p>\n Listing 6: Diese Prozedur wird beim Anklicken von Ribbon-Schaltflächen ausgelöst<\/span><\/b><\/p>\n Hier haben wir in einer Select Case<\/b>-Bedingung für jede Schaltfläche einen eigenen Case<\/b>-Zweig eingetragen, der jeweils in einer Meldung anzeigt, welche Schaltfläche der Benutzer angeklickt hat. Diese MsgBox<\/b>-Anweisungen können Sie durch die gewünschten Anweisungen oder auch durch Aufrufe entsprechender Prozeduren ersetzen.<\/p>\n Alternative: Ribbon komplett neu aufbauen<\/b><\/p>\n In einer zweiten Beispieldatenbank namens TreeViewMitRibbon_StartFromScratch.accdb <\/b>haben wir eine Alternative zur vorherigen Variante implementiert. Hier haben wir das Ribbon so definiert, dass die vorhandenen Elemente mit dem Attribut startFromScratch=“true“ <\/b>entfernt werden und nur das von uns definierte tab<\/b>-Element erscheint.<\/p>\n Damit sparen wir uns erstens die contextualTabs<\/b>-Elemente und auch das zeitverzögerte Einstellen des kontextsensitiven tab<\/b>-Elements. Das Ergebnis soll wie in Bild 10 aussehen.<\/p>\n Bild 10: Komplett neues Tab statt ContextualTab<\/span><\/b><\/p>\n Die Ribbon-Definition sieht in gekürzter Form wie in Listing 7 aus.<\/p>\n\n
![\"Die](\"..\/fileadmin\/_temp_\/2020_04\/pic_1244_002.png\")
<\/p>\n<xml version=\"1.0\">\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\" onLoad=\"OnLoad_RibbonKunde\"\r\n loadImage=\"loadImage\">\r\n <ribbon>\r\n <contextualTabs>\r\n <tabSet<\/span> idMso=\"TabSetFormReportExtensibility\">\r\n <tab id=\"tabKunde\" label=\"Kunden\">\r\n <group id=\"grpKunde\" label=\"Kunde\">\r\n <button image=\"user_delete_32\" label=\"Kunde löschen\" id=\"btnKundeLoeschen\" onAction=\"onAction\" \r\n size=\"large\"\/>\r\n <button image=\"folder2_plus_32\" label=\"Neues Projekt\" id=\"btnNeuesProjekt\" onAction=\"onAction\" \r\n size=\"large\"\/>\r\n <button onAction=\"onAction\" size=\"large\" image=\"edit_32\" label=\"Umbenennen\" id=\"btnKundeUmbenennen\"\/>\r\n <\/group>\r\n <group id=\"grpZwischenablage\" label=\"Zwischenablage\">\r\n <button id=\"btnAusschneiden\" image=\"cut_32\" label=\"Ausschneiden\" onAction=\"onAction\" size=\"large\"\/>\r\n <button id=\"btnKopieren\" image=\"copy_32\" label=\"Kopieren\" onAction=\"onAction\" size=\"large\"\/>\r\n <button image=\"clipboard_paste_32\" label=\"Einfügen\" id=\"btnEinfuegen\" onAction=\"onAction\" size=\"large\"\/>\r\n <\/group>\r\n <\/tab>\r\n <\/tabSet>\r\n <\/contextualTabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n\n
![\"Das](\"..\/fileadmin\/_temp_\/2020_04\/pic_1244_003.png\")
<\/p>\nPublic <\/span>objRibbon_RibbonKunde As <\/span>IRibbonUI<\/pre>\nSub <\/span>onLoad_RibbonKunde(ribbon As <\/span>IRibbonUI)\r\n Set<\/span> objRibbon_RibbonKunde = ribbon\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>loadImage(control, ByRef image)\r\n Dim <\/span>lngID As Long<\/span>\r\n On Error Resume Next<\/span>\r\n lngID = Nz(DLookup(\"ID\", \"MSysResources\", \"Name = '\" & control & \"'\"), 0)\r\n If <\/span>Err.Number = 3078 Then<\/span>\r\n MsgBox<\/span> \"Die Tabelle 'MSysResources' mit den Images für die Anzeige im Ribbon fehlt.\" & vbCrLf<\/span> _\r\n & \"Fügen Sie die Images mit dem Ribbon-Admin hinzu\", vbOKOnly + vbExclamation, _\r\n \"Tabelle MSysResources fehlt\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n If <\/span>lngID = 0 Then<\/span>\r\n MsgBox<\/span> \"Das Image '\" & control & \"' ist nicht in der Tabelle MSysResources vorhanden. \" & vbCrLf<\/span> _\r\n & \"Fügen Sie dieses über den Kontextmenüeintrag 'Benutzerdefiniertes Image hinzufügen' \" & vbCrLf<\/span> _\r\n & \"des image-Attributs des entsprechenden Ribbon-Steuerelements hinzu.\"\r\n Else<\/span>\r\n Set<\/span> image = PicFromSharedResource_Ribbon(CStr(control))\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2020_04\/pic_1244_004.png\")
<\/p>\n\n
\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2020_04\/pic_1244_005.png\")
<\/p>\n<xml version=\"1.0\">\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\" onLoad=\"OnLoad_RibbonProjekt\" \r\n loadImage=\"loadImage\">\r\n <ribbon>\r\n <contextualTabs>\r\n <tabSet<\/span> idMso=\"TabSetFormReportExtensibility\">\r\n <tab id=\"tabProjekte\" label=\"Projekte\">\r\n <group id=\"grpProjekt\" label=\"Projekt\">\r\n <button id=\"btnProjektLoeschen\" image=\"folder2_delete_32\" getEnabled=\"getEnabled\" \r\n label=\"Projekt löschen\" onAction=\"onAction\" size=\"large\"\/>\r\n <button id=\"btnProjektUmbenennen\" image=\"edit_32\" label=\"Projekt umbenennen\" onAction=\"onAction\" \r\n size=\"large\"\/>\r\n <\/group>\r\n <group id=\"grpZwischenablage\" label=\"Zwischenablage\">\r\n <button id=\"btnAusschneiden\" image=\"cut_32\" label=\"Ausschneiden\" onAction=\"onAction\" size=\"large\"\/>\r\n <button id=\"btnKopieren\" image=\"copy_32\" label=\"Kopieren\" onAction=\"onAction\" size=\"large\"\/>\r\n <button id=\"btnEinfuegen\" image=\"clipboard_paste_32\" label=\"Einfügen\" onAction=\"onAction\" size=\"large\"\/>\r\n <\/group>\r\n <\/tab>\r\n <\/tabSet>\r\n <\/contextualTabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\nPublic <\/span>objRibbon_RibbonProjekt As <\/span>IRibbonUI<\/pre>\nSub <\/span>onLoad_RibbonProjekt(ribbon As <\/span>IRibbonUI)\r\n Set<\/span> objRibbon_RibbonProjekt = ribbon\r\nEnd Sub<\/span><\/pre>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2020_04\/pic_1244_006.png\")
<\/p>\nPublic Sub <\/span>ctlTreeview_Click()\r\n Dim <\/span>objNode As <\/span>MSComctlLib.Node\r\n Set<\/span> objNode = objTreeView.SelectedItem\r\n If <\/span>Not<\/span> objNode Is Nothing Then<\/span>\r\n Select Case Left<\/span>(objNode.Key, 1)\r\n Case <\/span>\"k\"\r\n Me.RibbonName = \"RibbonKunde\"\r\n objRibbon_RibbonKunde.ActivateTab \"tabKunde\"\r\n Case <\/span>\"p\"\r\n Me.RibbonName = \"RibbonProjekt\"\r\n objRibbon_RibbonProjekt.ActivateTab \"tabProjekte\"\r\n End Select<\/span>\r\n Else<\/span>\r\n Me.RibbonName = \"\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Ribbon](\"..\/fileadmin\/_temp_\/2020_04\/pic_1244_007.png\")
<\/p>\n![\"...](\"..\/fileadmin\/_temp_\/2020_04\/pic_1244_008.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2020_04\/pic_1244_009.png\")
<\/p>\nPublic Sub <\/span>ctlTreeview_Click()\r\n Dim <\/span>objNode As <\/span>MSComctlLib.Node\r\n Set<\/span> objNode = objTreeView.SelectedItem\r\n If <\/span>Not<\/span> objNode Is Nothing Then<\/span>\r\n Select Case Left<\/span>(objNode.Key, 1)\r\n Case <\/span>\"k\"\r\n Me.RibbonName = \"RibbonKunde\"\r\n On Error Resume Next<\/span>\r\n objRibbon_RibbonKunde.ActivateTab \"tabKunde\"\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n Me.TimerInterval = 300\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n Case <\/span>\"p\"\r\n Me.RibbonName = \"RibbonProjekt\"\r\n On Error Resume Next<\/span>\r\n objRibbon_RibbonProjekt.ActivateTab \"tabProjekte\"\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n Me.TimerInterval = 300\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n End Select<\/span>\r\n Else<\/span>\r\n Me.RibbonName = \"\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Timer()\r\n Me.TimerInterval = 0\r\n ctlTreeview_Click\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objTreeView = Me!ctlTreeView.Object\r\n With<\/span> objTreeView\r\n .Appearance = ccFlat\r\n .BorderStyle = ccNone\r\n .LineStyle = tvwRootLines\r\n .Style = tvwTreelinesPlusMinusPictureText\r\n End With<\/span>\r\n FillTreeView\r\n If <\/span>Not<\/span> objTreeView.Nodes.count = 0 Then<\/span>\r\n objTreeView.SelectedItem = objTreeView.Nodes(1)\r\n Me.TimerInterval = 300\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nSub <\/span>onAction(control As <\/span>IRibbonControl)\r\n Select Case control.ID\r\n Case <\/span>\"btnKundeLoeschen\"\r\n MsgBox<\/span> \"Schaltfläche 'btnKundenLoeschen' angeklickt\"\r\n Case <\/span>\"btnNeuesProjekt\"\r\n MsgBox<\/span> \"Schaltfläche 'btnNeuesProjekt' angeklickt\"\r\n Case <\/span>\"btnKundeUmbenennen\"\r\n MsgBox<\/span> \"Schaltfläche 'btnKundeUmbenennen' angeklickt\"\r\n Case <\/span>\"btnAusschneiden\"\r\n MsgBox<\/span> \"Schaltfläche 'btnAusschneiden' angeklickt\"\r\n Case <\/span>\"btnKopieren\"\r\n MsgBox<\/span> \"Schaltfläche 'btnKopieren' angeklickt\"\r\n Case <\/span>\"btnEinfuegen\"\r\n MsgBox<\/span> \"Schaltfläche 'btnEinfuegen' angeklickt\"\r\n Case <\/span>\"btnProjektLoeschen\"\r\n MsgBox<\/span> \"Schaltfläche 'btnProjektLoeschen' angeklickt\"\r\n Case <\/span>\"btnProjektUmbenennen\"\r\n MsgBox<\/span> \"Schaltfläche 'btnProjektUmbenennen' angeklickt\"\r\n Case Else<\/span>\r\n Debug.Print<\/span> \"Unbehandeltes Ribbon-Ereignis für: \" & control.ID\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Komplett](\"..\/fileadmin\/_temp_\/2020_04\/pic_1244_010.png\")
<\/p>\n<xml version=\"1.0\">\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\" onLoad=\"OnLoad_RibbonKunde\"\r\n loadImage=\"loadImage\">\r\n <ribbon startFromScratch=\"true\">\r\n <tabs>\r\n <tab id=\"tabKunde\" label=\"Kunden\">\r\n <group id=\"grpKunde\" label=\"Kunde\">\r\n <button image=\"user_delete_32\" label=\"Kunde löschen\" id=\"btnKundeLoeschen\" onAction=\"onAction\" \r\n size=\"large\"\/>\r\n ...\r\n <\/tab>\r\n <\/tabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n