<\/p>\n
Im Beitrag „Ribbonklassen“ (www.access-im-unternehmen.de\/1069) haben wir Klassen für die Anzeige von Ribbons und den enthaltenen Steuer-elementen eingeführt, die wir in „Kundenverwaltung mit Ribbon, Teil I“ (www.access-im-unternehmen.de\/1091) in eine Anwendung eingebaut haben. Ein Leser fragte nun, ob man damit nicht auch benutzerabhängige Ribbons anzeigen kann. Natürlich geht das – wie es funktioniert, zeigt der vorliegende Beitrag. Darüber hinaus erweitern wir unser Beispiel noch um ein paar neue Elemente.<\/b><\/p>\nBenutzerdefinierte Ribbon-Einträge<\/h2>\n
Im ersten Beispiel wollen wir das Ribbon, das mit dem Formular frmKundenuebersicht <\/b>angezeigt wird, in Abhängigkeit vom angemeldeten Benutzer die Schaltfläche zum Löschen eines Kunden aktiviert oder deaktiviert.<\/p>\n
Zu diesem Zweck wollen wir nun keine Benutzerverwaltung zur Anwendung hinzufügen, sondern zeigen einfach beim öffnen der Anwendung ein Meldungsfenster an, das den Benutzer fragt, ob er ein Administrator ist oder nicht.<\/p>\n
Nur Administratoren sollen Kunden löschen dürfen. Das Ergebnis dieser Abfrage speichern wir dann in einer temporären Variablen (TempVar<\/b>).<\/p>\n
Dazu ändern wir die beim öffnen durch das AutoExec<\/b>-Makro aufgerufene Prozedur wie in Listing 1. Mit der MsgBox<\/b>-Funktion ermitteln wir den Wert für die lokale Boolean<\/b>-Variable bolAdministrator<\/b>, deren Inhalt wir dann in die neu zu erstellende TempVar<\/b>-Variable mit dem Namen IstAdministrator <\/b>schreiben.<\/p>\n Listing 1: Speichern des Benutzer-Status beim öffnen der Anwendung<\/span><\/b><\/p>\n In der Code behind-Klasse des Formulars frmKundenuebersicht <\/b>ist eine kleine änderung am Code notwendig. Sie müssen lediglich die Prozedur Form_Load<\/b>, die beim Laden des Formulars ausgelöst wird, wie folgt erweitern:<\/p>\n Die Prozedur prüft nach dem Erstellen des Ribbons durch die Prozedur CreateRibbon<\/b>, ob die TempVars<\/b>-Variable IstAdministrator <\/b>den Wert True <\/b>enthält. Falls ja, wird die Eigenschaft Enabled <\/b>des Objekts btnKundeLoeschen <\/b>auf True <\/b>eingestellt, sonst auf den Wert False<\/b>.<\/p>\n Die kürzere Variante dieses Konstrukts sieht so aus:<\/p>\n Wenn Sie beim öffnen der Anwendung nun die Meldung mit der Frage nach Administrator oder Benutzer mit Benutzer <\/b>beantworten, sieht das Formular frmKundenübersicht <\/b>wie in Bild 1 aus – mit deaktivierter Schaltfläche Kunde löschen<\/b>.<\/p>\n Bild 1: Deaktivierte Löschen-Schaltfläche<\/span><\/b><\/p>\n Warum können Sie die Eigenschaft Enabled <\/b>nicht gleich beim Definieren auf False <\/b>einstellen In unserem Beispiel geschieht Folgendes: Sie erstellen das Ribbon mit seinen Tabs, Groups und Buttons. Für die Buttons wird dabei, soweit nicht anders angegeben, die get…<\/b>-Version eines Attributs angegeben. Sie können also beispielsweise zum Festlegen eines Bildes, das sich nicht ändern soll, die image<\/b>-Eigenschaft nutzen:<\/p>\n Dies resultiert dann in der folgenden Definition:<\/p>\n Oder Sie wollen das Bild zur Laufzeit dynamisch zuweisen. Dann stellen Sie einfach noch keinen festen Wert für die Eigenschaft Image <\/b>ein:<\/p>\n In diesem Fall erzeugen die Ribbon-Klassen den folgenden XML-Code für das Element:<\/p>\n Sie sehen, dass hier nicht mehr die Eigenschaft image <\/b>verwendet wird, sondern die Eigenschaft getImage<\/b>. Damit wird das Bild auch nicht mehr direkt festgelegt, sondern Sie können es zu einem späteren Zeitpunkt über die Eigenschaft Image <\/b>der Objektvariablen für das Element einstellen.<\/p>\n Wichtig ist also der Zeitpunkt, zu dem Sie die Eigenschaft Image <\/b>füllen – vor dem Erstellen der Ribbon-Definition durch die Methode GetRibbon <\/b>der Klasse Ribbons <\/b>oder erst danach. Vorher wird das Image über das Attribut image <\/b>fest eingebunden, nachher wird es über die Callback-Methode getImage <\/b>ermittelt.<\/p>\n Das Gleiche gilt auch für die beiden Eigenschaft Visible <\/b>und Enabled<\/b>. Deshalb dürfen Sie, wenn Sie Visible <\/b>oder Enabled <\/b>später dynamisch setzen wollen, die entsprechende Eigenschaft nicht vor dem Erstellen der Ribbon-Definition setzen, sondern erst danach.<\/p>\n Was ist der Unterschied Theoretisch könnte man auch einfach immer die get…<\/b>-Attribute nutzen und die Werte bei jedem neuen Einblenden des Ribbons erneut abrufen. Allerdings kostet auch dies Performance, und warum sollten wir, wenn ein Element feste Attribute wie etwa Bilder hat, Zeit vergeuden – auch wenn es nur sehr wenig Zeit ist<\/p>\n Wenn Sie sich die Kunde löschen<\/b>-Schaltfläche ansehen und entscheiden wollen, ob diese abhängig vom jeweiligen Benutzer entweder per Definition oder dynamisch aktiviert oder deaktiviert werden soll, gibt es beispielsweise nur einen praktischen Ansatz: Sie sollten diese vor der Definition mit btnKundeLoeschen.Enabled <\/b>entsprechend des aktuellen Benutzers einstellen. Wenn Sie sich für die dynamische Variante entschieden, kann die Enabled-Eigenschaft später jederzeit per Code geändert werden – Sie müssen dann dort immer nochmals prüfen, ob der aktuelle Benutzer diese Schaltfläche überhaupt verwenden darf. <\/p>\n Damit kommen wir zu den im ersten Teil dieser Beitragsreihe versprochenen Funktionen, denn wir haben dort ja zunächst einige Schaltflächen im Ribbon zum Formular frmKundenuebersicht<\/b> angelegt. Mit diesen wollen wir die folgenden Aktionen durchführen:<\/p>\n Die erste Aufgabe erfordert keine Vorarbeiten, denn wir können den Dialog zum Anlegen eines neuen Kunden direkt öffnen und dem Benutzer die Möglichkeit geben, den neuen Kunden zu bearbeiten.<\/p>\n Nach dem Klick auf die OK<\/b>-Schaltfläche soll das Formular geschlossen und das Formular frmKundenuebersicht <\/b>aktualisiert werden.<\/p>\n Die zweite und die dritte Aufgabe erfordern es, dass der Benutzer einen der Kunden im Formular frmKundenuebersicht <\/b>markiert hat. Aber ist das überhaupt nötig Momentan können wir mindestens noch neue Datensätze über die letzte Zeile der Datenblattansicht hinzufügen (s. Bild 2). Da wir aber ein eigenes Formular für das Anlegen und Bearbeiten von Kunden einsetzen wollen, das auch Aufgaben wie die Validierung der eingegebenen Daten ausführen könnte, sollten wir die Möglichkeit der Eingabe neuer Datensätze unterbinden.<\/p>\n Bild 2: Aktuell können noch neue Einträge zum Formular frmKundenuebersicht hinzugefügt werden.<\/span><\/b><\/p>\n Dazu stellen Sie in den Eigenschaften des Formulars die Eigenschaft Anfügen zulassen <\/b>auf den Wert Nein <\/b>ein. Da wir auch zum Bearbeiten ein entsprechendes Detailformular öffnen wollen, können Sie auch die Eigenschaft Bearbeitungen zulassen <\/b>auf Nein <\/b>einstellen. Und schließlich soll auch das Löschen nur über die entsprechende Ribbon-Schaltfläche geschehen, sodass auch Löschen zulassen <\/b>den Wert Nein <\/b>erhält (s. Bild 3).<\/p>\n Bild 3: Löschen, Bearbeiten und Anlegen von Daten im Formular frmKundenuebersicht verhindern<\/span><\/b><\/p>\n Müssen wir also noch prüfen, ob ein Artikel markiert ist, bevor der Benutzer auf eine der Schaltflächen Kunde bearbeiten <\/b>oder Kunde löschen <\/b>klickt Ja, denn es gibt noch eine einzige Möglichkeit, bei der kein Datensatz markiert ist – dann nämlich, wenn die zugrunde liegende Tabelle tblKunden <\/b>überhaupt keinen Datensatz enthält.<\/p>\n <\/p>\n Wir sollten also dafür sorgen, dass eine entsprechende Meldung erscheint, wenn der Benutzer eine der beiden Schaltflächen Kunde bearbeiten <\/b>oder Kunde löschen <\/b>klickt, während kein Kunden-Datensatz markiert ist. Wobei dieser Ansatz nicht ganz ergonomisch ist, denn warum sollte der Benutzer überhaupt einen der Befehle anklicken können, obwohl wir die beiden Schaltflächen auch einfach deaktivieren könnten Immerhin haben wir mit unseren Ribbon-Klassen ja für eine einfache Steuerung dieser Elemente per VBA gesorgt.<\/p>\n Welches Ereignis aber nutzen wir, um zu prüfen, ob sich aktuell ein Datensatz in der Tabelle befindet oder nicht Der erste Ansatz wäre die Ereigniseigenschaft Beim Anzeigen<\/b>, die bei jedem Wechsel auf einen anderen Datensatz ausgelöst wird. Wir legen dazu zunächst eine Ereignisprozedur für die Schaltfläche btnKundeLoeschen <\/b>des Ribbons an, welche den aktuell markierten Datensatz im Formular frmKundenuebersicht <\/b>löschen soll. Diese soll im ersten Ansatz wie in Listing 2 aussehen. Nachdem die Schaltfläche Kunde löschen <\/b>wie im Artikel btnKundeLoeschen<\/b> beschrieben wie folgt angelegt wurde, können Sie ihre Ereignisprozeduren implementieren:<\/p>\n Listing 2: Löschen eines Kunden per Ribbon-Schaltfläche<\/span><\/b><\/p>\n Dazu wählen Sie im Codefenster des Klassenmoduls des Formulars frmKundenuebersicht <\/b>erst im linken Kombinationsfeld den Eintrag btnKundeLoeschen <\/b>aus und dann im rechten den Eintrag OnAction<\/b> (s. Bild 4). Dies erstellt eine neue, leere Ereignisprozedur namens btnKundeLoeschen_OnAction<\/b>, die Sie dann entsprechend füllen.<\/p>\n Bild 4: Anlegen einer Ereignisprozedur für eine Ribbon-Schaltfläche<\/span><\/b><\/p>\n Die Prozedur fragt den Benutzer, ob er den Datensatz wirklich löschen will und führt dann gegebenenfalls eine entsprechende SQL-Anweisung aus. Anschließend sorgt sie durch den Aufruf der Methode Requery <\/b>des Formulars selbst (Me<\/b>) für die Aktualisierung der angezeigten Datensätze. Und nun kommt das Problem: Wir legen zuvor die Ereignisprozedur an, die durch das Ereignis Beim Anzeigen <\/b>ausgelöst wird, und fügen zwei Anweisungen hinzu, welche die beiden Schaltflächen btnKundeBearbeiten <\/b>und btnKundeLoeschen <\/b>des Ribbons aktivieren, wenn im Formular ein Datensatz markiert ist und deaktivieren, wenn kein Datensatz markiert ist:<\/p>\n Allerdings wird die Prozedur Form_Current <\/b>genau nur dann ausgelöst, wenn der Datensatzzeiger auch auf einen Datensatz springt – aber nicht, wenn kein Datensatz mehr vorhanden ist! Wenn Sie den letzten Datensatz gelöscht haben, feuert dieses Ereignis also nicht und die Schaltflächen btnKundeBearbeiten <\/b>und btnKundeLoeschen <\/b>werden nicht deaktiviert.<\/p>\n Warum nochmal verwenden wir eigentlich eine SQL-Anweisung, um einen Datensatz per Ribbon-Schaltfläche zu löschen, und rufen nicht einfach die Methode RunCommand acCmdDeleteRecord <\/b>auf Weil diese Methode deaktiviert ist, wenn wir die Eigenschaft Löschen zulassen <\/b>des Formulars auf Nein <\/b>eingestellt haben – und wir wollten ja erreichen, dass der Benutzer Bearbeitungen der Datensätze nur über die drei Ribbon-Schaltflächen initialisieren kann und nicht über die üblichen Elemente der Datenblattansicht.<\/p>\n Also gibt es nur eine einfache Möglichkeit: Wir fügen die beiden Anweisungen noch zur Prozedur btnKundeLoeschen_OnAction <\/b>hinzu, und zwar verbunden mit der Bedingung, dass die mit der Eigenschaft RecordCount <\/b>ermittelte Anzahl der Datenstze des Recordsets des Formulars den Wert 0 <\/b>enthält. Diesmal stellen wir die Werte der Eigenschaft Enabled <\/b>allerdings nicht auf einen noch zu ermittelnden Wert ein, sondern direkt auf False <\/b>– wir haben ja soeben schon geprüft, dass kein Datensatz mehr vorhanden ist (s. Listing 3). Auf diese Weise stellen wir die Enabled<\/b>-Eigenschaften auch jeweils nicht mehr als einmal ein.<\/p>\n Listing 3: Löschen eines Kunden per Ribbon-Schaltfläche und Deaktivieren von Schaltflächen, falls kein Datensatz mehr vorhanden ist.<\/span><\/b><\/p>\n Das Ergebnis nach dem Löschen des letzten vorhandenen Datensatzes in der Tabelle tblKunden <\/b>sieht dann wie in Bild 5 aus. Die beiden Schaltflächen Kunde bearbeiten <\/b>und Kunde löschen <\/b>werden wie gewünscht deaktiviert.<\/p>\n Bild 5: Deaktivieren der beiden Schaltflächen Kunde bearbeiten und Kunde löschen, wenn kein Datensatz angezeigt wird<\/span><\/b><\/p>\n Die Schaltfläche Neuer Kunde <\/b>soll ein weiteres Formular namens frmKundendetails <\/b>in der Formularansicht öffnen. Die durch diese Schaltfläche ausgelöste Ereignisprozedur btnNeuerKunde_OnAction<\/b>, die Sie wie die Prozedur btnKundeLoeschen_OnAction <\/b>weiter oben über die beiden Kombinationsfelder des Codefensters anlegen, finden Sie in Listing 4. Sie führt zwei Anweisungen aus. Die erste öffnet das Formular frmKundendetails <\/b>und verwendet dabei die beiden Parameter DataMode <\/b>und WindowMode<\/b>. WindowMode <\/b>mit dem Wert acDialog <\/b>sorgt dafür, dass das Formular frmKundendetails <\/b>als modaler Dialog geöffnet wird und der aufrufende Code erst weiterläuft, wenn der Benutzer das Fenster wieder schließt. Erst dann wird auch die zweite Anweisung der Prozedur ausgeführt, die dafür sorgt, dass die Datenherkunft des Formulars aktualisiert und somit auch ein eventuell neu hinzugefügter Datensatz im Formular frmKundenuebersicht <\/b>angezeigt wird. Der Wert acFormAdd <\/b>für den Parameter DataMode <\/b>sorgt dafür, dass das geöffnete Formular direkt einen neuen, leeren Datensatz anzeigt.<\/p>\n Listing 4: öffnen des Formulars frmKundendetails zum Anlegen eines neuen Datensatzes<\/span><\/b><\/p>\n Das Formular frmKundendetails<\/b> verwenden wir für zwei Anwendungszwecke: Erstens für das Anlegen neuer Kundendatensätze und zweitens zum Bearbeiten eines Kundendatensatzes. Um dieses Formular zu erstellen, legen Sie ein neues Formular an und speichern Sie es unter dem Namen frmKundendetails<\/b>.<\/p>\n Stellen Sie über die Eigenschaft Datenherkunft <\/b>die Tabelle tblKunden <\/b>als Datenquelle für das Formular ein. Wenn Sie nun die Feldliste aktivieren, können Sie auf einen Rutsch alle benötigten Felder in den Detailbereich des Formulars ziehen (s. Bild 6).<\/p>\n Bild 6: Hinzufügen der gewünschten Felder zum Formular frmKundendetails<\/span><\/b><\/p>\n Danach können Sie diese noch nach Ihren eigenen Wünschen anordnen. Wir haben es bei einer rudimentären Sortierung belassen und auch die Bezeichnungsfelder nicht angepasst, sondern uns gleich an die technischen Feinheiten begeben. Ein paar Einstellungen haben wir zuvor noch geändert, da das Formular ja nur jeweils die Details eines einzigen Datensatzes anzeigen soll und somit keine Navigationssteuerelemente nötig sind. Die Eigenschaften Navigationsschaltflächen<\/b>, Datensatzmarkierer<\/b>, Bildlaufleisten <\/b>und Trennlinien <\/b>haben wir dazu jeweils auf den Wert Nein <\/b>und die Eigenschaft Automatisch zentrieren <\/b>auf den Wert Ja <\/b>eingestellt.<\/p>\n Das heißt, dass wir zunächst zwei Schaltflächen namens cmdOK <\/b>und cmdAbbrechen <\/b>hinzugefügt und entsprechende Ereignisprozeduren hinterlegt haben.<\/p>\n Die OK<\/b>-Schaltfläche soll die folgende Ereignisprozedur auslösen:<\/p>\n Die einzige Anweisung der Prozedur schließt das Formular und gibt somit den Fokus zurück an die aufrufende Routine.<\/p>\n Die zweite Prozedur wird durch die Schaltfläche cmdAbbrechen <\/b>ausgelöst und löst die folgende Prozedur aus:<\/p>\n Diese schließt ebenfalls das Formular, setzt aber zuvor noch eventuell bereits durchgeführte änderungen am Datensatz zurück.<\/p>\n Wenn Sie das Formular frmKundendetails<\/b> zum Anlegen eines neuen Datensatzes über die Schaltfläche btnNeuerKunde <\/b>öffnen, sieht dies wie in Bild 7 aus.<\/p>\n Bild 7: Hinzufügen eines neuen Datensatzes<\/span><\/b><\/p>\n Ein Klick auf die Schaltfläche btnKundeBearbeiten <\/b>soll genau wie die Schaltfläche btnNeuerKunde <\/b>das Formular frmKundendetails <\/b>öffnen. Dies soll dann etwa wie in Bild 8 aussehen. Dort erkennen Sie, dass das Formular frmKundendetails <\/b>genau den Datensatz anzeigt, den der Benutzer vor dem Betätigen der Schaltfläche Kunde bearbeiten <\/b>im Ribbon ausgewählt hat.<\/p>\n Bild 8: Bearbeiten eines vorhandenen Datensatzes<\/span><\/b><\/p>\n Die dazu verwendete Prozedur nutzt allerdings geringfügig abgewandelte Parameter dazu. Hier kommt nämlich nicht der Parameter DataMode <\/b>zum Einsatz, sondern der Parameter WhereCondition<\/b>. Dieser übergibt die Bedingung für den anzuzeigenden und zu bearbeitenden Datensatz an das Formular. Dieser wird aus der Zeichenkette KundeID = <\/b>und dem mit Me!KundeID <\/b>ermittelten Primärschlüsselwert des aktuell markierten Datensatzes ermittelt. Die Prozedur finden Sie in Listing 5.<\/p>\n Listing 5: öffnen des Formulars frmKundendetails zum Bearbeiten eines Datensatzes<\/span><\/b><\/p>\n Auch hier soll nach dem Schließen des modal geöffneten Formulars ein Requery <\/b>der im Formular frmKundenuebersicht <\/b>angezeigten Daten erfolgen, damit der geänderte Datensatz direkt in der neuen Version angezeigt wird.<\/p>\n Am Formular frmKundendetails <\/b>sind noch ein paar Feinarbeiten nötig. Zum Beispiel ist es aktuell noch möglich, beim Aufruf zum Anlegen eines neuen Datensatzes gleich noch weitere Datensätze anzulegen. Das Anlegen neuer Datensätze ist auch nach dem Aufrufen des Formulars über die Ribbon-Schaltfläche Kunde bearbeiten <\/b>möglich. Zwar weist das Formular keine Navigationsschaltflächen mehr auf, über welche der Benutzer einen neuen, leeren Datensatz ansteuern kann, aber wenn er beispielsweise mit der Tab<\/b>-Taste alle Steuer-elemente durchläuft, landet er früher oder später bei einem neuen Datensatz. Dies beheben wir, indem wir die Eigenschaft Zyklus <\/b>von Alle Datensätze <\/b>auf Aktueller Datensatz <\/b>einstellen. Danach ist kein Wechseln zu einem neuen, leeren Datensatz mehr möglich.<\/p>\n Eine weitere kleine unschöne Sache ist, dass beim öffnen des Formulars frmKundenuebersicht <\/b>immer noch der Ribbon-Tab Datenblatt <\/b>angezeigt wird und aktiviert werden kann (s. Bild 9).<\/p>\n Bild 9: Das Datenblatt-Tab wird in Verbindung mit dem Datenblatt angezeigt.<\/span><\/b><\/p>\n Um dies zu beeinflussen, kommen wir mit den bisher im Rahmen der Ribbon-Klassen vorgestellten Elementen nicht weiter. Es handelt sich nämlich nicht um eine einfache Tab<\/b>-Definition, wenn wir auf das Element Datenblatt <\/b>zugreifen wollen. Sie können nicht mit der idMso <\/b>auf dieses Tab-Element zugreifen, wie es bei den übrigen Tab-Elementen wie TabHomeAccess <\/b>et cetera der Fall ist. Bei dem Element, das wir ausblenden wollen, handelt es sich nämlich um ein sogenanntes kontextbezogenes Tab<\/b>-Element. Diese finden wir in der Ribbon-Definition in einem eigenen Bereich, der in der Regel vor den eigentlichen Tabs <\/b>definiert wird. Das einschließende Element eines oder mehrerer dieser kontextsensitiven Tabs heißt contextualTabs<\/b>. Darin enthalten ist dann ein tabSet<\/b>-Element. In unserem Fall hat dieses die idMso <\/b>mit dem Wert TabSetFormDatasheet<\/b> und wird in der Ribbon-Definition wie in Listing 6 angelegt. Es kann auch noch sein, dass sich unterhalb des tabSet<\/b>-Elements weitere Elemente befinden. Im Gegensatz zum tabSet<\/b>-Element, dass alle enthaltenen Tabs zusammenfasst, finden Sie dort dann einzelne contextualTab<\/b>-Elemente. Dies wird interessant, wenn Sie ein einzelnes contextualTab<\/b>-Element innerhalb eines tabSet<\/b>-Elements ausblenden wollen. <\/p>\n Listing 6: Definition eines Ribbons, dessen eingebautes Tab-Element TabSetFormDatasheet ausgeblendet werden soll<\/span><\/b><\/p>\n Wir brauchen uns aber nicht um die XML-Definition zu kümmern, denn mit der Version der Ribbon-Klassen, die mit der Beispieldatenbank zu diesem Beitrag kommt, finden Sie auch die Möglichkeit vor, die einzelnen TabSet<\/b>-Gruppen anzusprechen und auszublenden. In diesem Fall wollen wir die änderung in der Methode CreateRibbon <\/b>vornehmen, die im Klassenmodul des Formulars frmKundenuebersicht <\/b>vorliegt und wie in Listing 7 ergänzt wird. Hier sehen Sie, dass wir ein neues Objekt des Typs clsTabSet <\/b>definieren und dieses an die ContextualTabs<\/b>-Auflistung des objRibbon<\/b>-Elements anhängen. Dazu übergeben wir die Konstante TabSetFormDatasheet <\/b>und stellen anschließend die Eigenschaft Visible <\/b>für dieses Element auf False <\/b>ein.<\/p>\nPublic Function <\/span>RibbonLaden()\r\n Dim <\/span>bolAdministrator As Boolean<\/span>\r\n bolAdministrator = MsgBox<\/span>(\"Sind Sie ein Administrator (Ja) oder ein normaler Benutzer (Nein)\", _\r\n vbYesNo) = vbYes\r\n TempVars.Add \"IstAdministrator\", bolAdministrator\r\n Startribbon.CreateRibbon\r\nEnd Function<\/span><\/pre>\nPrivate Sub <\/span>Form_Load()\r\n CreateRibbon\r\n If <\/span>TempVars(\"IstAdministrator\") = True<\/span> Then<\/span>\r\n btnKundeLoeschen.Enabled = True<\/span>\r\n Else<\/span>\r\n btnKundeLoeschen.Enabled = False<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Load()\r\n CreateRibbon\r\n btnKundeLoeschen.Enabled = TempVars(\"IstAdministrator\")\r\nEnd Sub<\/span><\/pre>\n![\"Deaktivierte](\"..\/fileadmin\/_temp_\/2017_05\/pic_1104_001.png\")
<\/p>\nWith<\/span> btnKundeLoeschen\r\n .Label = \"Kunde löschen\"\r\n .Size = msoRibbonControlSizelarge\r\n .Image = \"user_delete\"\r\nEnd With<\/span><\/pre>\n<button label=\"Kunde löschen\" id=\"ribKundenuebersicht_btnKundeLoeschen\" size=\"large\" image=\"user_delete\" \r\n onAction=\"OnAction\" enabled=\"true\" visible=\"true\" \/><\/pre>\n
With<\/span> btnKundeLoeschen\r\n .Label = \"Kunde löschen\"\r\n .Size = msoRibbonControlSizelarge\r\nEnd With<\/span><\/pre>\n<button label=\"Kunde löschen\" id=\"ribKundenuebersicht_btnKundeLoeschen\" size=\"large\" getImage=\"GetImage\" \r\n onAction=\"OnAction\" getEnabled=\"GetEnabled\" getVisible=\"GetVisible\" \/><\/pre>\n
Schaltflächen mit Leben füllen<\/h2>\n
\n
![\"Aktuell](\"..\/fileadmin\/_temp_\/2017_05\/pic_1104_002.png\")
<\/p>\n![\"Löschen,](\"..\/fileadmin\/_temp_\/2017_05\/pic_1104_003.png\")
<\/p>\nSchaltflächen abhängig von Datensätzen aktivieren und deaktivieren<\/h2>\n
Private Sub <\/span>btnKundeLoeschen_OnAction(control As <\/span>Office.IRibbonControl)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n If <\/span>MsgBox<\/span>(\"Kunde wirklich löschen\", vbYesNo) = vbYes Then<\/span>\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblKunden WHERE KundeID = \" & Me!KundeID, dbFailOnError\r\n Me.Requery\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nDim <\/span>WithEvents btnKundeLoeschen As <\/span>clsButton<\/pre>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2017_05\/pic_1104_004.png\")
<\/p>\nPrivate Sub <\/span>Form_Current()\r\n btnKundeLoeschen.Enabled = Not<\/span> IsNull(Me!KundeID)\r\n btnKundeBearbeiten.Enabled = Not<\/span> IsNull(Me!KundeID)\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>btnKundeLoeschen_OnAction(control As <\/span>Office.IRibbonControl)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n If <\/span>MsgBox<\/span>(\"Kunde wirklich löschen\", vbYesNo) = vbYes Then<\/span>\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblKunden WHERE KundeID = \" & Me!KundeID, dbFailOnError\r\n Me.Requery\r\n If <\/span>Me.Recordset.RecordCount = 0 Then<\/span>\r\n btnKundeLoeschen.Enabled = False<\/span>\r\n btnKundeBearbeiten.Enabled = False<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Deaktivieren](\"..\/fileadmin\/_temp_\/2017_05\/pic_1104_005.png\")
<\/p>\nNeuen Kunden anlegen<\/h2>\n
Private Sub <\/span>btnNeuerKunde_OnAction(control As <\/span>Office.IRibbonControl)\r\n DoCmd.OpenForm \"frmKundendetails\", DataMode:=acFormAdd, WindowMode:=acDialog\r\n Me.Requery\r\nEnd Sub<\/span><\/pre>\nFormular frmKundendetails anlegen<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2017_05\/pic_1104_006.png\")
<\/p>\nPrivate Sub <\/span>cmdOK_Click()\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdAbbrechen_Click()\r\n Me.Undo\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2017_05\/pic_1104_007.png\")
<\/p>\nBearbeiten von Datensätzen<\/h2>\n
![\"Bearbeiten](\"..\/fileadmin\/_temp_\/2017_05\/pic_1104_008.png\")
<\/p>\nPrivate Sub <\/span>btnKundeBearbeiten_OnAction(control As <\/span>Office.IRibbonControl)\r\n DoCmd.OpenForm \"frmKundendetails\", WhereCondition:=\"KundeID = \" & Me!KundeID, WindowMode:=acDialog\r\n Me.Requery\r\nEnd Sub<\/span><\/pre>\nFeinarbeiten<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2017_05\/pic_1104_009.png\")
<\/p>\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\" \r\n onLoad=\"onLoad\" loadImage=\"loadImage\">\r\n <ribbon startFromScratch=\"true\">\r\n <contextualTabs>\r\n <tabSet<\/span> idMso=\"TabSetFormDatasheet\" visible=\"false\">\r\n <\/tabSet>\r\n <\/contextualTabs>\r\n <tabs>\r\n <tab id=\"tabKundenuebersicht\" label=\"Kundenübersicht\">\r\n ...\r\n <\/tab>\r\n <\/tabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\nPrivate Sub <\/span>CreateRibbon()\r\n Dim <\/span>objRibbon As <\/span>clsRibbon\r\n Dim <\/span>objTab As <\/span>clsTab\r\n Dim <\/span>objTabSet As <\/span>clsTabSet<\/span>\r\n Dim <\/span>objGroup As <\/span>clsGroup\r\n Set<\/span> objRibbon = Ribbons.Add(\"ribKundenuebersicht\")\r\n With<\/span> objRibbon\r\n .StartFromScratch = True<\/span>\r\n Set<\/span> objTabSet<\/span> = .ContextualTabs.Add(TabSetFormDatasheet)\r\n objTabSet.Visible = False<\/span>\r\n Set<\/span> objTab = .Tabs.Add(\"tabKundenuebersicht\")\r\n ...\r\n End With<\/span>\r\n Me.RibbonName = Ribbons.GetRibbon(\"ribKundenuebersicht\")\r\nEnd Sub<\/span><\/pre>\n