<\/p>\n
Das Kombinationsfeld ist ein treuer Diener in fast allen Situationen. Manchmal allerdings kann man es nicht sinnvoll einsetzen – zum Beispiel in einem Formular in der Datenblattansicht oder Endlosansicht, wenn das Kombinationsfeld Daten anzeigen soll, die vom Wert eines anderen Kombinationsfeldes des gleichen Datensatzes abhängen. Aber es gibt eine Lösung – wenn auch nicht in Form eines Kombinationsfeldes. Wir zeigen die zur Auswahl stehenden Daten einfach per Kontextmenü an! Wie dies gelingt, zeigt der vorliegende Beitrag.<\/b><\/p>\n
Problem: Abhängige Kombinationsfelder<\/b><\/p>\n
Früher oder später stößt jeder Access-Entwickler auf das Problem, dass er abhängige Daten mit zwei Kombinationsfeldern darstellen soll – und zwar in der Endlos- oder Datenblattansicht eines Formulars.<\/p>\n
Die Verwendung zweier abhängiger Kombinationsfelder in der Formularansicht ist kein Problem und wird vielfach genutzt. Dabei geht es darum, in einem ersten Kombinationsfeld einen Wert auszuwählen (beispielsweise eine Automarke) und in einem zweiten Kombinationsfeld, dem abhängigen Kombinationsfeld, nur noch diejenigen Einträge anzuzeigen, die zu dem im ersten Kombinationsfeld ausgewählten Eintrag passen (also etwa ein Fahrzeugmodell). Dazu wird nach dem Auswählen des Datensatzes im ersten Kombinationsfeld die Datensatzquelle im zweiten Kombinationsfeld so gefiltert, dass dieses nur noch die relevanten Einträge liefert.<\/p>\n
In Endlos- oder Datenblattansichten taucht jedoch das Problem auf, dass die meisten Eigenschaften von Steuerelementen jeweils für alle angezeigten Datensätze gleich sind – und dazu gehört auch die Datensatzherkunft von Kombinationsfeldern. Welche Probleme das mit sich bringt, schauen wir uns gleich kurz an. Hier benötigen wir eine Alternative zur Auswahl der Daten für das abhängige Tabellenfeld.<\/p>\n
Beispieltabellen<\/b><\/p>\n
Zunächst schauen wir uns die Beispieltabellen an. Dazu greifen wir das bereits erwähnte Beispiel der Fahrzeuge auf (Tabellen siehe Bild 1). Die Fahrzeuge werden in der Tabelle tblFahrzeuge <\/b>gespeichert. Zu jedem Fahrzeug können Sie einen Hersteller auswählen sowie ein Modell. Für beide haben wir entsprechende Lookup-Tabellen erstellt (tblHersteller <\/b>und tblModell<\/b>). Allerdings gibt es natürlich nicht jedes Modell bei jedem Hersteller. Deshalb fügen wir der Tabelle tblModelle <\/b>noch ein Nachschlagefeld hinzu, welches die Auswahl des Herstellers ermöglicht, zu dem das Modell gehört.<\/p>\n
![\"Tabellen](\"..\/fileadmin\/_temp_\/2014_05\/pic_953_001.png\")
<\/p>\n
Bild 1: Tabellen mit abhängigen Datensätzen<\/span><\/b><\/p>\n In der Tabelle tblFahrzeuge <\/b>kann man nun natürlich dennoch Kombinationen aus Hersteller und Modell auswählen, die gar nicht in der Tabelle tblModelle <\/b>vorgesehen sind.<\/p>\n Abbildung in der Formularansicht<\/b><\/p>\n In der Formularansicht eines Formulars sieht das standardmäßig nicht anders aus. Hier wird das Kombinationsfeld zur Auswahl der Modelle nicht nach dem zuvor ausgewählten Hersteller gefiltert (s. Bild 2).<\/p>\n Bild 2: Auch das Kombinationsfeld zeigt ungefiltert alle Datensätze an.<\/span><\/b><\/p>\n In dieser Ansicht lässt sich aber leicht Abhilfe schaffen. Dazu müssen wir lediglich die Datensatzherkunft des abhängigen Kombinationsfeldes anpassen.<\/p>\n Dies erledigen wir in einer einfachen Version an zwei Stellen – nämlich beim Anzeigen eines jeden Datenatzes sowie nach der Auswahl eines Eintrags des Kombinationsfeldes cboHerstellerID<\/b>. Die durch diese beiden Ereignisse ausgelösten Prozeduren rufen jeweils eine weitere Prozedur namens cboModelleAktualisieren<\/b> auf.<\/p>\n Diese prüft, ob das Steuerelement cboHersteller <\/b>überhaupt einen Wert enthält. Falls ja, wird die Datensatzherkunft des zweiten Kombinationsfeldes cboModelle <\/b>so eingeschränkt, dass es nur solche Einträge enthält, die zum entsprechenden Hersteller gehören. Anderenfalls soll das Kombinationsfeld cboModelle<\/b> einfach alle Einträge anzeigen (s. Listing 1).<\/p>\n Listing 1: Prozeduren zum Aktualisieren abhängiger Kombinationsfelder<\/span><\/b><\/p>\n Dies funktioniert auch wie gewünscht, wie Bild 3 zeigt.<\/p>\n Bild 3: Anzeige abhängiger Datensätze in Kombinationsfeldern<\/span><\/b><\/p>\n Abhängige Kombinationsfelder im Datenblatt oder in der Endlosansicht<\/b><\/p>\n Nun schauen wir uns an, was nicht wie gewünscht funktioniert. Dabei geht es um die gleiche Konstellation, allerdings mit einer anderen Darstellung – nämlich der in Listenform.<\/p>\n Wir betrachten zuerst die Datenblattansicht, weil wir diese ganz schnell als Alternative zur aktuellen Formularansicht aufrufen können. Das Ergebnis gleich nach dem Anzeigen dieses Formulars in der Datenblattansicht sieht wie in Bild 4 aus. Merkwürdigerweise erscheint nur noch beim ersten Datensatz das zuvor festgelegte Modell. Was ist hier schiefgelaufen Wurden die Daten gelöscht Ein Blick in die zugrunde liegende Tabelle zeigt, dass dies nicht der Fall ist. (übrigens lohnt sich ein Blick in die Tabellen immer, wenn scheinbar Daten aus Kombinationsfeldern verschwunden sind – meist sind Probleme mit der Datensatzherkunft schuld daran!)<\/p>\n Bild 4: Anzeige abhängiger Datensätze in der Datenblattansicht<\/span><\/b><\/p>\n In der Tat liegt das Problem darin, dass beim Anzeigen die Ereignisprozedur Form_Current <\/b>ausgelöst wurde, die dann die Prozedur cboModelleAktualisieren <\/b>aufgerufen hat. Diese sorgt dann dafür, dass die Datensatzherkunft des Kombinationsfeldes cboModelle <\/b>mit dem folgenden Ausdruck gefüllt wird:<\/p>\n <\/p>\n Und wenn dieser Wert für die Eigenschaft RowSource <\/b>(Datensatzherkunft<\/b>) wie oben beschrieben für alle Datensätze übernommen wird, entsteht das vorliegende Problem. Für den zweiten Datensatz der Abbildung, der im Feld HerstellerID <\/b>den Wert 2 <\/b>(BMW<\/b>) verwendet, steht der Eintrag, den er im Kombinationsfeld cboModellID <\/b>anzeigen möchte, einfach nicht zur Verfügung. Für den Einsteiger noch schwerer zu identifizieren wird dieses Verhalten, wenn das Kombinationsfeld für einige Datensätze gefüllt ist, für andere wiederum nicht. Auf den Zusammenhang muss man erstmal kommen.<\/p>\n Endlosansicht<\/b><\/p>\n Nur zum Nachweis, dass es auch in der Endlosansicht nicht anders ist, reichen wir noch das Formular frmFahrzeuge_Endlosansicht <\/b>nach. Dort ist zu beobachten, dass beim öffnen logischerweise nur der erste Eintrag das passende Modell im Kombinationsfeld anzeigt. Interessant ist hier, dass dieser Wert bei der Auswahl etwa des Modells für den dritten Datensatz stehen bleibt (s. Bild 5). Dies ist aber wohl eher auf eine gewisse Trägheit von Access zurückzuführen.<\/p>\n Bild 5: Anzeige abhängiger Datensätze in der Endlosansicht<\/span><\/b><\/p>\n Lösungsansatz<\/b><\/p>\n Es gibt verschiedene Ansätze, dieses Problem zu beheben. Richtig zufriedenstellend sind diese alle nicht. Wir stellen eine neue Variante vor: Dabei soll das Kombinationsfeld durch ein herkömmliches Textfeld ersetzt werden. Wenn der Benutzer auf das Feld klickt, soll ein Kontextmenü erscheinen, welches die zur Verfügung stehenden Werte anbietet. Nach der Auswahl eines der Einträge soll der Wert eingetragen werden.<\/p>\n Menüs programmieren<\/b><\/p>\n Um Menüs zu programmieren, was ab Access 2007 ja nur noch für Kontextmenüs unterstützt wird, benötigen Sie einen Verweis auf die Bibliothek Microsoft Office x.0 Library<\/b>. Diesen fügen Sie über den Verweise<\/b>-Dialog (VBA-Editor, Menüeintrag Extras|Verweise<\/b>) wie in Bild 6 hinzu.<\/p>\n Bild 6: Hinzufügen eines Verweises auf die Office-Bibliothek<\/span><\/b><\/p>\n Kontextmenü anzeigen<\/b><\/p>\n Nun müssen wir uns überlegen, wann das Kontextmenü erscheinen soll. Im vorliegenden Fall soll der Benutzer damit ja ausschließlich Einträge auswählen und keine neuen Daten eingeben. Also reicht es wohl aus, wenn das Kontextmenü immer dann erscheint, wenn der Benutzer auf das Kombinationsfeld klickt. Dies fangen wir mit der Ereigniseigenschaft Bei Maustaste ab <\/b>ab. Dabei spielt es dann keine Rolle, ob der Benutzer auf den Inhalt des Kontextmenüs klickt oder auf die Schaltfläche rechts zum Aufklappen des Kontextmenüs (s. Bild 7).<\/p>\n Bild 7: Kontextmenü statt Kombinationsfeld<\/span><\/b><\/p>\n Für diese Ereigniseigenschaft hinterlegen wir die Ereignisprozedur aus Listing 2. Sie deklariert je eine Objektvariable zur Aufnahme von Verweisen auf das Kontextmenü selbst (cbr<\/b>, Datentyp CommandBar<\/b>) und je einer Kontextmenü-Schaltfläche (cbb<\/b>, Datentyp CommandBarButton<\/b>). Außerdem benötigen wir ein Database<\/b>-Objekt und ein Recordset<\/b>-Objekt, um auf die anzuzeigenden Datensätze zuzugreifen.<\/p>\n Listing 2: Anzeigen eines Kontextmenüs zur Auswahl von Kontextmenü-Einträgen<\/span><\/b><\/p>\n Da gegebenenfalls bereits zuvor ein Kontextmenü gleichen Namens erstellt wurde, löscht die Prozedur dieses zunächst mit der Delete<\/b>-Methode des entsprechenden Elements aus der CommandBars<\/b>-Auflistung. Dies geschieht bei deaktivierter Fehlerbehandlung, da dies einen Fehler auslöst, wenn das zu löschende CommandBar<\/b>-Objekt gar nicht vorhanden ist.<\/p>\n Danach erstellt die Prozedur ein neues CommandBars<\/b>-Objekt namens cbrWerte <\/b>und stellt dieses mit dem Wert msoBarPopup <\/b>für den zweiten Parameter als Kontextmenü ein.<\/p>\n Dann erstellt die Prozedur ein Recordset auf Basis der Tabelle tblModelle<\/b>, das die beiden Felder ModellID <\/b>und Modell <\/b>liefert – aber nur für die Datensätze, deren Fremdschlüsselfeld HerstellerID <\/b>dem Wert des entsprechenden Kombinationsfeldes <\/b>entspricht.<\/p>\n Mit diesem Recordset geht es in eine Do While<\/b>-Schleife, die alle enthaltenen Datensätze durchläuft. Dabei legt die Prozedur für jeden Datensatz ein neues CommandBarButton<\/b>-Element an und referenziert es mit der Variablen cbb<\/b>. Für die Eigenschaft Caption<\/b> übergibt die Prozedur den Wert des Feldes Modell<\/b>, also die Modellbezeichnung.<\/p>\n Die Eigenschaft onAction <\/b>hingegen, welche den Namen einer VBA-Funktion erhalten soll, die beim Betätigen des jeweiligen Eintrags ausgelöst wird, erhält einen Ausdruck wie den folgenden:<\/p>\n Nach dem Hinzufügen aller CommandBarButton<\/b>-Elemente ruft die Prozedur schließlich die Popup<\/b>-Methode des CommandBar<\/b>-Objekts auf, um das Kontextmenü anzuzeigen.<\/p>\n Die benötigte VBA-Funktion platzieren wir in einem Standardmodul. Sie sieht so aus:<\/p>\n Nun wird es Zeit, dies auszuprobieren. Und siehe da – es funktioniert fast einwandfrei! Einziger Wermutstropfen ist, dass nach dem Betätigen des jeweiligen Kontextmenü-Eintrags noch das eingebaute Kontextmenü von Access erscheint (s. Bild 8).<\/p>\n Bild 8: Unerwünscht: das abschließende Erscheinen des eingebauten Kontextmenüs des Formulars<\/span><\/b><\/p>\n Außerdem klappt, wenn der Benutzer auf die Schaltfläche zum Auswählen der Kombinationsfeldeinträge klickt, auch noch das Kombinationsfeld auf. Diese beiden Dinge wollen wir noch unterbinden.<\/p>\n Beim Kontextmenü ist dies schnell erledigt: Dazu brauchen Sie einfach nur die Eigenschaft Kontextmenü <\/b>des Formulars auf den Wert Nein <\/b>einzustellen. Damit werden dann aber auch sämtliche Kontextmenüs für das Formular deaktiviert (das merken Sie spätestens, wenn Sie etwa zur Entwurfsansicht wechseln wollen …).<\/p>\n Das Problem mit dem aufklappenden Kombinationsfeld ist allerdings etwas ernster. Kombinationsfelder lassen sich zwar per VBA-Code mit der Methode Dropdown explizit aufklappen, aber nicht wieder schließen. Dazu gäbe es die Möglichkeit, den Fokus kurzzeitig auf ein anderes Steuerelement zu verschieben und dann wieder zurück auf das Kombinationsfeld. Die Lösung gefällt uns aber nicht.<\/p>\n Ein weiteres Problem wäre, dass die Kombinationsfelder natürlich, wenn Sie das aktuelle Beispiel auf dem vorherigen aufbauen, immer noch nach dem aktuellen Datensatz im Kombinationsfeld cboHerstellerID <\/b>gefiltert werden. Die Codezeilen, die dies verursachen, müssen Sie natürlich noch entfernen – anderenfalls zeigen immer noch nur einige Kombinationsfelder den korrekten Inhalt an.<\/p>\n Textfeld mit Kontextmenü statt Kombinationsfeld<\/b><\/p>\n Da die Lösung wegen des Aufklappens des Kombinationsfeldes nach einem Klick auf den rechten Bereich des Kombinationsfeldes scheitert, schauen wir uns eine ganz andere Alternative an. Diese sieht vor, dass wir erst gar kein Kombinationsfeld für das Feld ModellID <\/b>verwenden, sondern dessen Inhalt gleich in einem Textfeld abbilden.<\/p>\n Dazu müssen wir zunächst die Datenherkunft des Formulars anpassen, da das Textfeld ja den Namen des über die Tabelle tblModelle <\/b>im Kombinationsfeld angezeigten Datensatzes liefern soll. Diese Tabelle und das Feld Modell <\/b>müssen wir also zur neuen Datenherkunft hinzufügen, die nun wie in Bild 9 aussieht.<\/p>\n Bild 9: Neue Datenherkunft des Formulars in der Datenblattansicht<\/span><\/b><\/p>\n Das Feld ModellID <\/b>soll aber weiterhin in der Datenherkunft enthalten bleiben – warum, erfahren Sie gleich.<\/p>\n Das Steuerelement cboModellID <\/b>wandeln wir in ein Textfeld um und benennen es txtModellID<\/b>. Als Steuerelementinhalt für dieses Textfeld legen Sie nun das Feld Modell <\/b>fest. Damit ist die Anzeige schon einmal kein Problem – der Modellname erscheint wie erwartet in der Datenblattansicht des Formulars (s. Bild 10).<\/p>\n Bild 10: Aktualisieren des Modells per Kontextmenü<\/span><\/b><\/p>\n Mit der wie in Listing 3 angepassten Variante der Prozedur zum Anzeigen des Kontextmenüs mit den möglichen Einträgen zeigen wir das Kontextmenü wie in der Abbildung an.<\/p>\n![\"Auch](\"..\/fileadmin\/_temp_\/2014_05\/pic_953_002.png\")
<\/p>\nPrivate Sub <\/span>cboHerstellerID_AfterUpdate()\r\n Call<\/span> cboModelleAktualisieren\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_Current()\r\n Call<\/span> cboModelleAktualisieren\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cboModelleAktualisieren()\r\n If <\/span>Not<\/span> IsNull(Me.cboHerstellerID) Then<\/span>\r\n Me!cboModellID.RowSource = \"SELECT * FROM tblModelle WHERE HerstellerID = \" _\r\n & Nz(Me!cboHerstellerID)\r\n Else<\/span>\r\n Me!cboModellID.RowSource = \"SELECT * FROM tblModelle\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2014_05\/pic_953_003.png\")
<\/p>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2014_05\/pic_953_004.png\")
<\/p>\nSELECT * FROM tblModelle -WHERE HerstellerID = 1<\/pre>\n
![\"Anzeige](\"..\/fileadmin\/_temp_\/2014_05\/pic_953_005.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2014_05\/pic_953_006.png\")
<\/p>\n![\"Kontextmenü](\"..\/fileadmin\/_temp_\/2014_05\/pic_953_007.png\")
<\/p>\nPrivate Sub <\/span>cboModellID_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>cbb As <\/span>CommandBarButton\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n On Error Resume Next<\/span>\r\n CommandBars(\"cbrWerte\").Delete\r\n On Error GoTo<\/span> 0\r\n Set<\/span> cbr = CommandBars.Add(\"cbrWerte\", msoBarPopup, False, True<\/span>)\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT ModellID, Modell FROM tblModelle " _\r\n "WHERE HerstellerID = \" & Me!HerstellerID, dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Set<\/span> cbb = cbr.Controls.Add(msoControlButton)\r\n With<\/span> cbb\r\n .Caption = rst!Modell\r\n .onAction = \"=WertEinfuegen(\"\"\" & rst!ModellID & \"\"\")\"\r\n End With<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n cbr.ShowPopup\r\nEnd Sub<\/span><\/pre>\n=WertEintragen(123)<\/pre>\n
Public Function <\/span>WertEinfuegen(varWert As Variant<\/span>)\r\n Screen.ActiveControl = varWert\r\nEnd Function<\/span><\/pre>\n![\"Unerwünscht:](\"..\/fileadmin\/_temp_\/2014_05\/pic_953_008.png\")
<\/p>\n![\"Neue](\"..\/fileadmin\/_temp_\/2014_05\/pic_953_009.png\")
<\/p>\n![\"Aktualisieren](\"..\/fileadmin\/_temp_\/2014_05\/pic_953_010.png\")
<\/p>\nPrivate Sub <\/span>cboModellID_MouseDown(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n ...\r\n .onAction = \"=WertEinfuegenMitID(\"\"\" & rst!ModellID & \"\"\")\"\r\nEnd Sub<\/span><\/pre>\n