<\/p>\n
Kombinationsfelder dienen in der Regel der Auswahl eines Eintrags aus einer Lookup-Tabelle. In manchen Fällen programmiert man noch Funktionen hinzu, mit denen ein noch nicht vorhandener Eintrag in der zugrunde liegenden Tabelle gespeichert werden kann. Wir gehen noch einen Schritt weiter und erlauben dem Benutzer, Einträge zu löschen oder zu bearbeiten. Das Ganze natürlich unter Berücksichtigung dessen, dass bereits verwendete Einträge nicht gelöscht werden können.<\/b><\/p>\n
Kombinationsfelder sind sehr flexible Steuerelemente, sind sie doch grundsätzlich bereits dazu ausgelegt, Daten per Auswahl oder per Eingabe anzunehmen – oder auch beides in Kombination.<\/p>\n
Wenn Sie ein Kombinationfeld dazu verwenden, die Daten einer Lookup-Tabelle anzuzeigen, also einer Tabelle, die lediglich die normalerweise in ein Textfeld einer anderen Tabelle einzutragenden Werte aufnimmt und zum Zwecke der Vermeidung von Redundanzen und Inkonsistenzen speichert, können Sie noch mehr aus diesem Steuerelement herausholen. Dazu wollen wir drei Funktionen zum TreeView hinzufügen:<\/p>\n
Dazu wollen wir nicht viel mehr nutzen als das Kombinationsfeld und drei zusätzliche Schaltflächen beziehungsweise Kontextmenü-Einträge (s. Bild 1). Die drei Schaltflächen heißen cmdNeu<\/b>, cmdAendern <\/b>und cmdLoeschen<\/b>. Die erste soll eine Inputbox <\/b>anzeigen, die den Wert für den neuen Datensatz entgegennimmt. Wenn der Benutzer einen Wert eingetragen hat, soll dieser in der zugrunde liegenden Tabelle gespeichert und im Kombinationsfeld ausgewählt werden. Die gleiche Funktion soll der Benutzer noch über zwei weitere Wege aufrufen können: erstens über den Kontextmenü-Eintrag namens Neuer Eintrag <\/b>und zweitens, indem er den neuen Wert direkt in das Kombinationsfeld einträgt.<\/p>\n
![\"So](\"..\/fileadmin\/_temp_\/2014_01\/pic_917_002.png\")
<\/p>\n
Bild 1: So soll das Formular später aussehen.<\/span><\/b><\/p>\n Dieses soll dann nach Rückfrage ebenfalls in der Tabelle gespeichert und gleich im Kombinationsfeld ausgewählt werden.<\/p>\n Die zweite Aktion, das Bearbeiten des aktuellen Datensatzes, wird über die Schaltfläche cmdBearbeiten <\/b>oder über den Kontextmenü-Eintrag Eintrag bearbeiten <\/b>aufgerufen. Dies kann nicht durch direktes Bearbeiten des aktuellen Eintrags im Kombinationsfeld erfolgen, da so ja schon neue Datensätze angelegt werden sollen.<\/p>\n Die dritte Aktion ist das Löschen des aktuell angezeigten Eintrags. Diese Aktion ist mit großer Vorsicht zu behandeln: Schließlich kann es ja sein, dass bereits Datensätze des Formulars mit dem aktuellen Eintrag im Kombinationsfeld verknüpft sind. In diesem Fall geschieht nichts (wenn keine Löschweitergabe definiert ist) oder der Datensatz im Formular wird gleich mit dem Eintrag des Kombinationsfeldes mit gelöscht – mehr dazu weiter unten.<\/p>\n Wir müssen also auf irgendeine Weise dafür sorgen, dass ein bereits verknüpfter Eintrag der Lookup-Tabelle nicht gelöscht werden kann – entweder durch Deaktivieren des entsprechenden Kontextmenü-Eintrags beziehungsweise der Schaltfläche oder durch Ausgabe einer passenden Meldung, wenn der Benutzer es versucht. Der erste Ansatz ist hier vorzuziehen, weil er ergonomischer ist – der Benutzer weiß so direkt, dass er den aktuellen Eintrag nicht löschen kann.<\/p>\n Datenmodell-Voraussetzungen<\/b><\/p>\n Für die betroffenen Tabellen der hier vorgestellten Technik gibt es die eine oder andere Voraussetzung. Zum Ersten benötigen Sie natürlich eine Tabelle mit den im Formular angezeigten Werten sowie eine weitere Tabelle mit Lookupdaten.<\/p>\n Die erste Tabelle enthält ein Fremdschlüsselfeld, mit dem ein Datensatz der Lookup-Tabelle ausgewählt werden kann. In unserem Beispiel sind dies die Tabellen tblEinzelteile <\/b>und tblEinzelteilkategorien <\/b>(siehe auch den Beitrag Stücklisten<\/b>, www.access-im-unternehmen.de\/923<\/b>). Bild 2 zeigt die beiden Tabellen im Beziehungen-Fenster.<\/p>\n Bild 2: Tabellen für das Beispiel zu diesem Beitrag<\/span><\/b><\/p>\n Damit das Löschen eines Eintrags der Tabelle tblEinzelteilkategorien <\/b>im Kombinationsfeld, was ja sonst nicht so einfach möglich ist, nicht zum Löschen eines Datensatzes in der verknüpften Tabelle tblEinzelteile <\/b>führt, dürfen Sie in diesem Fall auf keinen Fall die Löschweitergabe an verwandte Datensätze <\/b>aktivieren (s. Bild 3).<\/p>\n Bild 3: Eigenschaften der Beziehung<\/span><\/b><\/p>\n Desweiteren müssen Sie aber auf jeden Fall die referenzielle Integrität aktivieren. Anderenfalls könnte man problemlos auch Datensätze aus der Lookup-Tabelle tblEinzelteilkategorien <\/b>löschen, die bereits einem oder mehreren Datensätzen der Tabelle tblEinzelteile <\/b>zugewiesen sind.<\/p>\n Schließlich sollten Sie für das Feld Einzelteilkategorie <\/b>der Tabelle tblEinzelteilkategorien <\/b>einen eindeutigen Index anlegen, damit jede Kategorie nur einmal in der Tabelle gespeichert werden kann.<\/p>\n Beispielformular erstellen<\/b><\/p>\n Das Beispielformular frmEinzelteile <\/b>enthält die Tabelle tblEinzelteile <\/b>als Datenherkunft und zeigt all ihre Felder an (s. Bild 4). Das Feld EinzelteilkategorieID <\/b>haben wir als Kombinationsfeld ausgeführt und diesem den Namen cboEinzelteilkategorieID <\/b>gegeben.<\/p>\n Bild 4: Entwurf des Formulars<\/span><\/b><\/p>\n Das Feld verwendet die folgende SQL-Abfrage als Datensatzherkunft:<\/p>\n Die beiden Eigenschaften Spaltenanzahl <\/b>und Spaltenbreiten <\/b>sind auf die Werte 2 <\/b>und 0cm <\/b>eingestellt, damit nur die Werte der zweiten Spalte angezeigt werden.<\/p>\n Nebem dem Kombinationsfeld platzieren Sie drei Schaltflächen namens cmdLoeschen<\/b>, cmdBearbeiten <\/b>und cmdNeu<\/b>. Diese versehen Sie, wenn vorhanden, am besten mit entsprechenden Icons – mit diesen sparen Sie eine Menge Platz gegenüber Schaltlfächen mit Beschriftungen.<\/p>\n Eintrag löschen per Schaltfläche<\/b><\/p>\n Die Schaltfläche cmdLoeschen <\/b>soll eine Prozedur auslösen, die den aktuellen Eintrag im Kombinationsfeld löscht.<\/p>\n Moment mal: Soll man denn nicht nur solche Einträge der Tabelle tblEinzelteilkategorien <\/b>löschen können, die mit keinem Datensatz der Tabelle tblEinzelteile <\/b>verknüpft sind Und sollte nicht der aktuelle Eintrag des Kombinationfeldes cboEinzelteilkategorieID <\/b>auch dem aktuellen Datensatz im Hauptformular zugeordnet sein Das ist zu einigen Gelegenheiten der Fall – zum Beispiel beim öffnen des Formulars, beim Wechseln des Datensatzes oder auch nach dem Auswählen eines Eintrags im Kombinationsfeld und dem anschließenden Speichern des Datensatzes.<\/p>\n In dem Moment aber, in dem Sie gerade einen neuen Eintrag aus dem Kombinationsfeld ausgewählt, den Datensatz aber noch nicht gespeichert haben, ist dieser nicht dem aktuellen Datensatz zugeordnet. Sie können also einen Eintrag auswählen und diesen löschen, sofern er auch keinem anderem Datensatz der Datenherkunft des Formulars zugeordnet ist.<\/p>\n Kommen wir nun zu der Funktion, die durch die Schaltfläche cmdLoeschen<\/b> ausgelöst wird. Diese sieht wie in Listing 1 aus und und ruft lediglich eine weitere Funktion namens EintragLoeschen<\/b> auf. Dabei übergibt sie zwei Werte als Parameter:<\/p>\n Listing 1: Aufruf der Prozedur zum Löschen des Datensatzes zum aktuellen Eintrag des Kombinationsfeldes cboEinzelteilkategorieI<\/span><\/b><\/p>\n Die Prozedur EintragLoeschen<\/b> finden Sie in Listing 2. Sie verarbeitet zunächst den zweiten übergebenen Parameter, der in einem Meldungsfenster angezeigt wird, das den Benutzer fragt, ob der Eintrag wirklich gelöscht werden soll. Ist dies der Fall, führt die Prozedur mit der Execute<\/b>-Methode eine DELETE<\/b>-Abfrage aus, die den entsprechenden Datensatz löscht. Als Vergleichswert des Kriteriums verwendet sie dabei den mit dem ersten Parameter übergebenen Wert. Nach dem Löschen aktualisiert die Prozedur die Daten des Kombinationsfeldes mit der Requery<\/b>-Methode. Das Kombinationsfeld ist nach diesem Aufruf leer, da der zuletzt gespeicherte Wert gelöscht wurde. Man könnte hier auch einen anderen Wert eintragen – zum Beispiel eine Aufforderung wie Listing 2: Prozedur zum Löschen des aktuellen Kombinationsfeld-Eintrags<\/span><\/b><\/p>\n Also passen wir die Datensatzherkunft wie folgt an:-<\/p>\n Für das Feld EinzelteilkategorieID<\/b> der Tabelle tblEinzelteile <\/b>stellen wir außerdem als Standardwert <\/b>den Wert 0 <\/b>ein. Auf diese Weise zeigt das Formular bei einem neuen Datensatz gleich den Eintrag Bild 5: Standardeintrag für das Kombinationsfeld anzeigen<\/span><\/b><\/p>\n Damit dieser Eintrag nach dem Löschen eines vorhandenen Eintrags angezeigt wird, ergänzen Sie die Routine um die folgende Zeile, die Sie als letzte Anweisung innerhalb der If…Then<\/b>-Bedingung einfügen:<\/p>\n Bearbeiten eines Eintrags<\/b><\/p>\n Das Kombinationsfeld lädt praktisch dazu ein, einen Eintrag direkt im Kombinationsfeld zu bearbeiten. Dies ließe sich auch realisieren, allerdings führt das ändern eines vorhandenen Eintrags in einen Eintrag, der noch nicht vorhanden ist, zum Auslösen des Ereignisses Bei nicht in Liste <\/b>– und damit legt das Formular einen neuen Datensatz in der Tabelle tblEinzelteileKategorien <\/b>an (siehe weiter unten unter Neuen Eintrag anlegen<\/b>).<\/p>\n <\/p>\n Also bieten wir rechts neben dem Kombinationsfeld die Schaltfläche cmdBearbeiten<\/b> an. Diese soll eine Inputbox öffnen, die den vorhandenen Eintrag anzeigt und dem Benutzer die Möglichkeit gibt, diesen zu ändern.<\/p>\n Dabei ist zumindest ein Punkt zu beachten: Wir müssen eine Spezialbehandlung für den Fall vorsehen, dass der Benutzer den Eintrag in einen bereits vorhandenen Eintrag ändert. Dafür gibt es zwei Möglichkeiten:<\/p>\n Um Letzteres zu verstehen, brauchen wir vielleicht ein Beispiel: Angenommen, es gibt in der Tabelle tblEinzelteilkategorien <\/b>einen Eintrag Kategorie 1 <\/b>und einen Eintrag Kategorie 2<\/b>. Beide sind bereits mit Datensätzen der Tabelle tblEinzelteile <\/b>verknüpft. Nun möchte der Benutzer den Namen der Kategorie Kategorie 1 <\/b>in Kategorie 2 <\/b>ändern. Wenn wir dies per UPDATE<\/b>-Anweisung versuchen, löst dies den Fehler 3022 <\/b>aus, weil Kategorie 2 <\/b>ja schon vorhanden ist. An dieser Stelle können wir dem Benutzer eine Meldung anzeigen, dass die änderung nicht möglich ist. Wir können aber auch fragen, ob er vielleicht alle Einzelteile, die der Kategorie 1 <\/b>zugeordnet waren, der Kategorie 2 <\/b>zuordnen möchte. Wenn man es sich recht überlegt, kann man darauf aber auch verzichten: Davon ausgehend, dass der Benutzer die Kategorie 1 <\/b>durch die Kategorie 2 <\/b>ersetzen möchte, löschen wir einfach Kategorie 1 <\/b>und weisen allen Datensätzen der Tabelle tblEinzelteile<\/b>, die der Kategorie 1 <\/b>zugeordnet waren, der Kategorie 2 <\/b>zu. Gut: Wer mag, kann natürlich auch hier noch eine Rückfrage einbauen, um auf Nummer sicher zu gehen. Wir erledigen dies allerdings ohne eine Rückfrage.<\/p>\n Die Schaltfläche cmdBearbeiten <\/b>löst beim Anklicken schließlich die Prozedur aus Listing 3 aus. Dabei übergibt sie als Parameter den Wert der gebundenen Spalte des Kombinationsfeldes sowie auch den angezeigten Wert, den sie über die Eigenschaft Column(1) <\/b>ermittelt.<\/p>\n Listing 3: Aufruf der Routine zum ändern eines Eintrags<\/span><\/b><\/p>\n Die Prozedur EintragBearbeiten <\/b>finden Sie in Listing 4. Sie erwartet die beiden bereits genannten Parameter und speichert diese in den Variablen lngID <\/b>und strEintrag<\/b>. Sie fragt zunächst per InputBox <\/b>den geänderten Wert für den Eintrag ab. Dabei soll die InputBox <\/b>den bisher verwendeten Wert als Vorschlag anzeigen (s. Bild 6).<\/p>\n Bild 6: Anbieten des vorhandenen Werts als Vorgabe<\/span><\/b><\/p>\n Gibt der Benutzer einen Wert ein, dessen Länge größer als 0 <\/b>ist, und klickt dann auf die OK<\/b>-Schaltfläche, führt die Prozedur die folgenden Anweisungen aus. Das Anklicken der Schaltfläche Abbrechen <\/b>liefert hingegen eine leere Zeichenkette, die Prozedur wird daraufhin ohne weitere Aktionen beendet.<\/p>\n Bei Vorliegen eines Wertes für strEintrag <\/b>versucht die Prozedur zunächst, einen neuen Datensatz mit der angegebenen Einzelteilkategorie <\/b>in der Tabelle tblEinzelteilkategorien <\/b>anzulegen. Dabei deaktiviert sie zuvor die Fehlerbehandlung. Einen beim Aufruf der DELETE<\/b>-Anweisung auftretenden Fehler registriert die Prozedur, indem sie die Fehlernummer in die Variable lngError <\/b>schreibt. So können wir direkt im Anschluss die Fehlerbehandlung mit On Error Goto 0 <\/b>wieder aktivieren und den Fehler in Ruhe auswerten.<\/p>\n Die folgende If…Then<\/b>-Bedingung prüft, ob ein Fehler mit der Nummer 3022 <\/b>aufgetreten ist. Ist das der Fall, ist der Eintrag bereits in der Tabelle tblEinzelteilkategorien <\/b>vorhanden. Also soll die Prozedur den zuvor ausgewählten Eintrag des Kombinationsfeldes löschen und alle damit verknüpften Datensätze der Tabelle tblEinzelteile <\/b>mit der bereits vorhandenen Kategorie gleichen Namens verknüpfen.<\/p>\n Dazu fragt die Prozedur zunächst per DLookup<\/b>-Funktion den Primärschlüsselwert des Datensatzes der Tabelle tblEinzelteilkategorien <\/b>ab, dessen Feld Einzelteilkategorie <\/b>den bereits vorhandenen Wert enthält, und speichert diesen in der Variablen lngIDNeu<\/b>.<\/p>\n Dann aktualisiert sie alle Datensätze der Tabelle tblEinzelteile<\/b>, deren Feld EinzelteilkategorieID <\/b>die ID des zu ändernden Eintrags der Tabelle tblEinzelteilkategorien <\/b>referenziert, in den Wert aus lngIDNeu <\/b>ab.<\/p>\n Somit dürfte es nun keinen Datensatz mehr geben, der mit der zu übertragenden Kategorie verknüpft ist. Also kann die Prozedur den Datensatz der Tabelle tblEinzelteilkategorien <\/b>mit dem Wert lngID <\/b>im Feld EinzelteilkategorieID <\/b>per DELETE<\/b>-Aktionsabfrage löschen.<\/p>\n Für den Fall, dass die zuerst ausgeführte UPDATE<\/b>-Abfrage keinen Fehler ausgelöst hat, führt die Prozedur den zweiten Teil der If…Then<\/b>-Bedingung aus. Hier tragen wir einfach nur den Wert von lngID <\/b>in lngIDNeu <\/b>ein.<\/p>\n Damit kann die Prozedur im Anschluss an die If…Then<\/b>-Bedingung weiterarbeiten – und zwar, indem sie das Kombinationsfeld cboEinzelteilkategorien <\/b>aktualisiert und dieser für den aktuell angezeigten Datensatz im Hauptformular den Wert aus lngIDNeu <\/b>zuweist, der zuvor ermittelt wurde.<\/p>\n Neuen Eintrag anlegen<\/b><\/p>\n Zum Anlegen eines neuen Eintrags wollen wir nicht nur die Schaltfläche und den Kontextmenü-Eintrag, sondern auch noch die direkte Eingabe eines neuen Eintrags im Kombinationsfeld anbieten.<\/p>\n Diese schauen wir uns zuerst an. Das Hinzufügen eines noch nicht vorhandenen Eintrags in ein Kombinationsfeld löst das Ereignis Bei nicht in Liste <\/b>aus, auf das wir mit der Prozedur aus Listing 5 reagieren wollen.<\/p>\n Listing 5: Routine zum Hinzufügen eines Eintrags<\/span><\/b><\/p>\n Die Prozedur erhält den neuen Eintrag mit dem Parameter NewData<\/b>, Sie müssen diesen also nicht erst noch aus dem Kombinationsfeld auslesen. Sie fragt den Benutzer per Meldungsfenster, ob dieser einen neuen Eintrag für die neue Kategorie anlegen möchte.<\/p>\n Falls ja, legt die Prozeduren diesen per INSERT INTO<\/b>-Anweisung an und gibt mit dem Parameter Response den Wert acDataErrAdded <\/b>zurück. Dies sorgt dafür, dass das Kombinationsfeld direkt auf den richtigen Wert eingestellt wird.<\/p>\n Wenn wir dies per Schaltfläche erreichen wollen, ist der Weg etwas anders. Die Schaltfläche cmdNeu <\/b>ruft zunächst die folgende Prozedur auf:<\/p>\n Die Funktion EintragHinzufuegen<\/b> sieht wie in Listing 6 aus. Die Funktion erwartet in diesem Fall keine Parameter, da sie den Wert des hinzuzufügenden Eintrags noch selbst abfragt. Dies erledigt sie wiederum per InputBox <\/b>und speichert das Ergebnis in der Variablen strEintrag<\/b>.<\/p>\n Listing 6: Routine zum Hinzufügen eines Eintrags per Schaltfläche oder Kontextmenü<\/span><\/b><\/p>\n Hat der Benutzer einen Wert eingegeben (ist die Länge von strEintrag <\/b>also größer 0<\/b>), versucht die Funktion, einen neuen Datensatz mit dem Wert aus strEintrag <\/b>im Feld Einzelteilkategorie <\/b>mit einer INSERT INTO<\/b>-Anweisung zur Tabelle tblEinzelteilkategorien <\/b>hinzuzufügen. Die Fehlerbehandlung deaktivieren wir für diesen Zeitraum erneut und speichern den Wert aus Err.Number <\/b>in der Variablen lngError<\/b>, bevor wir die Fehlerbehandlung wieder aktivieren.<\/p>\n Dann untersucht die Funktion innerhalb einer Select Case<\/b>-Anweisung, welchen Wert lngError <\/b>hat, und reagiert entsprechend darauf. Im Falle des Wertes 0 <\/b>(kein Fehler aufgetreten) liest die Funktion mit SELECT @@IDENTITY <\/b>den Wert des zuletzt innerhalb der aktuellen Sitzung hinzugefügten Autowert-Feldes aus und speichert diesen in lngID<\/b>. Sie aktualisiert den Inhalt des Kombinationsfeldes cboEinzelteilkategorieID <\/b>und stellt dieses auf den neu hinzugefügten Eintrag ein.<\/p>\n Im Falle der Fehlernummer 3022 <\/b>ist der Eintrag schon vorhanden. Im Gegensatz zur Ereignisprozedur, die durch das Ereignis Bei nicht in Liste <\/b>ausgelöst wird, kann dies hier natürlich passieren.<\/p>\n Der Benutzer erhält dann eine entsprechende Meldung. Damit der Benutzer dennoch etwas von der vergeblichen Eingabe des neuen Eintrags hat, soll die Funktion zumindest den bestehenden Eintrag gleichen Namens im Kombinationsfeld auswählen.<\/p>\n Dazu muss die Funktion jedoch zunächst den Primärschlüsselwert dieses Eintrags in der Tabelle tblEinzelteilkategorien <\/b>ausfindig machen.<\/p>\n Dies erledigt sie mit einer entsprechenden DLookup<\/b>-Abfrage und weist den gefundenen Wert dem Kombinationsfeld zu.<\/p>\n Tritt ein anderer Fehlerwert als 0 <\/b>oder 3022 <\/b>auf, gibt die Funktion eine Fehlermeldung mit der Fehlernummer und der Fehlerbeschreibung aus.<\/p>\n Funktionen per Kontextmenü aufrufen<\/b><\/p>\n Nachdem wir uns die drei Routinen angesehen haben, mit denen Sie per Schaltfläche oder durch direkte Eingabe Einträge zur Tabelle tblEinzelteilkategorien <\/b>hinzufügen oder vorhandene Einträge löschen oder bearbeiten können, wollen wir nun noch ein Kontextmenü hinzufügen, um diese drei Vorgänge auf andere Art und Weise aufzurufen.<\/p>\n Wenn Sie bereits Schaltflächen verwenden, benötigen Sie natürlich nicht zwingend ein Kontextmenü. Wenn das betroffene Formular jedoch nur wenig Platz bietet, ist der Einsatz eines Kontextmenüs durchaus sinnvoll. Schauen wir uns also an, wie Sie ein solches Kontextmenü beim Rechtsklick auf das Kombinationfeld hervorzaubern und wie die gewünschten Aktionen ausgeführt werden. Die Anzeige des Kontextmenüs soll erfolgen, wenn der Benutzer mit der rechten Maustaste auf das Kontextmenü klickt. Dies löst das Ereignis Bei Maustaste ab <\/b>des Kontextmenüs aus, was wir durch Implementierung der Ereignisprozedur cboEinzelteilkategorieID_MouseDown <\/b>ausnutzen (s. Listing 7).<\/p>\n Listing 7: Diese Ereignisprozedur zeigt das Kontextmenü zum Hinzufügen, Löschen oder Editieren eines Kombinationsfeldeintrags an.<\/span><\/b><\/p>\n Die Prozedur wird beim Drücken beliebiger Maustasten ausgelöst, also prüft diese zunächst, welche Maustaste der Benutzer verwendet hat. Im Falle der rechten Maustaste liefert der Parameter Button dafür die Konstante acRightButton<\/b>, was wir mittels If…Then<\/b>-Bedingung prüfen. Dann deaktiviert die Prozedur die Fehlerbehandlung, um ohne Fehlermeldung ein eventuell bereits vorhandenes Kontextmenü gleichen Namens zu entfernen. Anschließend erstellt sie das Kontextmenü erneut und vergibt dabei den Namen Kombifeldmenue<\/b>. Das neue CommandBar<\/b>-Objekt wird mit msoBarPopup <\/b>als Kontextmenü gekennzeichnet und soll nur temporär erzeugt werden, also mit dem Schließen von Access wieder verschwinden.<\/p>\n Für das mit cbr <\/b>referenzierte CommandBar<\/b>-Objekt erstellt die Funktion alsdann die erste Schaltfläche (festgelegt durch den Typ msoControlButton<\/b>) und stellt die Beschriftung auf Eintrag bearbeiten <\/b>sowie die beim Auswählen auszuführende Funktion auf =EintragBearbeiten(…) <\/b>ein. Für diesen Funktionsaufruf legt die Prozedur noch zwei Parameter fest. Der erste ist der Wert der gebundenen Spalte des Kombinationfeldes, der zweite der angezeigte Wert. Zusammen ergibt sich also etwa ein Aufruf wie der folgende:<\/p>\n Auf ähnliche Art fügt die Prozedur den zweiten Eintrag hinzu. Diesmal soll dieser Eintrag hinzufügen <\/b>heißen. Der Aufbau der Funktion ist diesmal einfacher: Er besteht schlicht und einfach aus dem Gleichheitszeichen, dem Funktionsnamen und einem Klammernpaar:<\/p>\n Der Eintrag zum Löschen eines Eintrags erwartet wiederum die gleichen Parameter wie der zum ändern eines Eintrags, zum Beispiel:<\/p>\n Damit nach dem Auswählen eines Eintrags des Kontextmenüs nicht noch das eingebaute Kontextmenü angezeigt wird, deaktivieren wir dies formularweit durch Einstellen der Eigenschaft ShortcutMenu <\/b>auf den Wert False<\/b>. Schließlich sorgt die Methode ShopPopup <\/b>des CommandBar<\/b>-Objekts für die Anzeige des Kontextmenüs.<\/p>\n Funktionen des Kontextmenüs<\/b><\/p>\n Dadurch, dass wir für die durch die Schaltflächen ausgelösten Ereignisse angelegten Prozeduren bereits so angelegt haben, dass diese die benötigen Informationen ermitteln und dann weitere Funktionen mit übergabe entsprechender Parameter aufrufen, liegen die für die für die Kontextmenü-Einträge definierten Funktionen bereits vor: EintragLoeschen<\/b>, EintragHinzufuegen <\/b>und EintragBearbeiten<\/b>.<\/p>\n Löschen-Schaltfläche aktivieren\/deaktivieren<\/b><\/p>\n Fehlt noch ein Aspekt, den wir bisher nicht berücksichtigt haben: Je nachdem, ob der aktuell angezeigte Eintrag im Kombinationsfeld bereits mit einem der Einträge der Haupttabelle tblEinzelteile <\/b>verknüpft ist, soll die Schaltfläche cmdLoeschen <\/b>deaktiviert werden. Auch der Kontextmenü-Eintrag Eintrag löschen <\/b>soll nicht verwendet werden können.<\/p>\n Zu welchen Gelegenheiten müssen wir prüfen, ob die Löschen-Schaltfläche zu aktivieren oder deaktivieren ist<\/p>\n Zunächst einmal beim Wechseln des Datensatzes des Formulars. Dies erledigen wir durch eine Ereignisprozedur, die durch das Ereignis Beim Anzeigen <\/b>des Formulars ausgelöst wird:<\/p>\n Den Rest der Arbeit, nämlich die Erstellung der Funktion LoeschenAktivieren<\/b>, erledigen wie gleich im Anschluss. Wir wollen aber noch eine weitere Prozedur erstellen, nämlich eine Ereignisprozedur, die nach dem Auswählen des Kontextmenü-Eintrags ausgelöst wird. Diese sieht so aus:<\/p>\n![\"Tabellen](\"..\/fileadmin\/_temp_\/2014_01\/pic_917_001.png\")
<\/p>\n![\"Eigenschaften](\"..\/fileadmin\/_temp_\/2014_01\/pic_917_003.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2014_01\/pic_917_004.png\")
<\/p>\nSELECT -EinzelteilkategorieID, -Einzelteilkategorie -FROM -tblEinzelteilkategorien \r\n-ORDER BY Einzelteilkategorie;<\/pre>\n
Private Sub <\/span>cmdLoeschen_Click()\r\n EintragLoeschen Me!cboEinzelteilkategorieID, Me!cboEinzelteilkategorieID.Column(1)\r\nEnd Sub<\/span><\/pre>\n\n
Public Function <\/span>EintragLoeschen(lngID As Long<\/span>, strEintrag As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n If MsgBox<\/span>(\"Möchten Sie den Eintrag ''\" & strEintrag & \"'' wirklich löschen\", _\r\n vbYesNo + vbExclamation, \"Eintrag löschen\") _\r\n = vbYes Then\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblEinzelteilkategorien WHERE EinzelteilkategorieID = \" & lngID\r\n Me!cboEinzelteilkategorieID.Requery\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nSELECT 0 AS -EinzelteilkategorieID, -\"<Kategorie -auswählen>\" -AS -Einzelteilkategorie \r\nFROM -tblEinzelteilkategorien\r\nUNION\r\nSELECT EinzelteilkategorieID, -Einzelteilkategorie\r\nFROM tblEinzelteilkategorien\r\nORDER BY Einzelteilkategorie;<\/pre>\n
![\"Standardeintrag](\"..\/fileadmin\/_temp_\/2014_01\/pic_917_005.png\")
<\/p>\nMe!cboEinzelteilkategorieID = 0<\/pre>\n
\n
Private Sub <\/span>cmdEdit_Click()\r\n EintragBearbeiten Me!cboEinzelteilkategorieID, Me!cboEinzelteilkategorieID.Column(1)\r\nEnd Sub<\/span><\/pre>\n![\"Anbieten](\"..\/fileadmin\/_temp_\/2014_01\/pic_917_006.png\")
<\/p>\nPrivate Sub <\/span>cboEinzelteilkategorieID_NotInList(NewData As String<\/span>, Response As Integer<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n If <\/span>MsgBox<\/span>(\"Kategorie ''\" & NewData & \"'' anlegen\", vbYesNo) = vbYes Then<\/span>\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"INSERT INTO tblEinzelteilkategorien(Einzelteilkategorie) VALUES(''\" _\r\n & NewData & \"'')\", dbFailOnError\r\n Response = acDataErrAdded\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdNeu_Click()\r\n EintragHinzufuegen\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>EintragHinzufuegen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>lngID As Long<\/span>\r\n Dim <\/span>strEintrag As String<\/span>\r\n Dim <\/span>lngError As Long<\/span>\r\n strEintrag = InputBox(\"Geben Sie den Wert des neuen Eintrag an.\", \"Neuer Eintrag\", _\r\n \"[Neuer Eintrag]\")\r\n If <\/span>Len<\/span>(strEintrag) > 0 Then<\/span>\r\n Set<\/span> db = CurrentDb\r\n On Error Resume Next<\/span>\r\n db.Execute \"INSERT INTO tblEinzelteilkategorien(Einzelteilkategorie) VALUES(''\" _\r\n & strEintrag & \"'')\", dbFailOnError\r\n lngError = Err.Number\r\n On Error GoTo<\/span> 0\r\n Select Case lngError\r\n Case <\/span>0\r\n lngID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n Me!cboEinzelteilkategorieID.Requery\r\n Me!cboEinzelteilkategorieID = lngID\r\n Case <\/span>3022\r\n MsgBox<\/span> \"Der Eintrag ist bereits vorhanden und wird nun für dieses Einzelteil festgelegt.\"\r\n lngID = DLookup(\"EinzelteilkategorieID\", \"tblEinzelteilkategorien\", _\r\n \"Einzelteilkategorie = ''\" & strEintrag & \"''\")\r\n Me!cboEinzelteilkategorieID = lngID\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Fehler \" & lngError & \" \" & AccessError(lngError)\r\n End Select<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nPrivate Sub <\/span>cboEinzelteilkategorieID_MouseDown(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Dim <\/span>cbc As <\/span>CommandBarButton\r\n If <\/span>Button = acRightButton Then<\/span>\r\n On Error Resume Next<\/span>\r\n CommandBars(\"Kombifeldmenue\").Delete\r\n On Error GoTo<\/span> 0\r\n Set<\/span> cbr = CommandBars.Add(\"Kombifeldmenue\", msoBarPopup, False, True<\/span>)\r\n Set<\/span> cbc = cbr.Controls.Add(msoControlButton)\r\n With<\/span> cbc\r\n .Caption = \"Eintrag bearbeiten\"\r\n .OnAction = \"=EintragBearbeiten(\" & Me!cboEinzelteilkategorieID & \", ''\" _\r\n & Me!cboEinzelteilkategorieID.Column(1) & \"'')\"\r\n End With<\/span>\r\n Set<\/span> cbc = cbr.Controls.Add(msoControlButton)\r\n With<\/span> cbc\r\n .Caption = \"Eintrag hinzufügen\"\r\n .OnAction = \"EintragHinzufuegen()\"\r\n End With<\/span>\r\n Set<\/span> cbc = cbr.Controls.Add(msoControlButton)\r\n With<\/span> cbc\r\n .Caption = \"Eintrag löschen\"\r\n .OnAction = \"=EintragLoeschen(\" & Me!cboEinzelteilkategorieID & \", ''\" _\r\n & Me!cboEinzelteilkategorieID.Column(1) & \"'')\"\r\n End With<\/span>\r\n Me.ShortcutMenu = False<\/span>\r\n cbr.ShowPopup\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n=EintragBearbeiten(1, ''Kategorie 1'')<\/pre>\n
=EintragHinzufuegen()<\/pre>\n
=EintragLoeschen(1, ''Kapitel 1'')<\/pre>\n
Private Sub <\/span>Form_Current()\r\n LoeschenAktivieren\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cboEinzelteilkategorieID_ AfterUpdate()\r\n LoeschenAktivieren\r\nEnd Sub<\/span> <\/pre>\n