<\/p>\n
Die meisten Kombinationsfelder beziehen Ihre Daten aus einer Tabelle oder Abfrage. Manchmal liegen die anzuzeigenden Daten aber nicht in Tabellenform vor – weil es sich nicht lohnt, dafür eine Tabelle anzulegen, oder weil diese aus anderen Quellen stammen, wie etwa Benutzer oder Benutzergruppen. Am Beispiel von Datumsangaben zeigt dieser Beitrag, wie Sie Kombinationsfelder zur Laufzeit mit Daten füllen, die nicht aus einer oder mehreren Tabellen stammen.<\/b><\/p>\n<\/p><\/div>\n Die Eigenschaft Herkunftsart <\/b>eines Kombinationsfeldes entscheidet darüber, woher dieses seine Daten beziehen soll. üblicherweise heißt der Wert dieser Eigenschaft Tabelle\/Abfrage <\/b>und die Eigenschaft Datensatzherkunft <\/b>liefert die passende Datenquelle. Der zweite Wert namens Wertliste ermöglicht die Angabe einer durch Semikola getrennten Liste von Elementen für die Eigenschaft Datensatzherkunft<\/b>, die je nach Spaltenanzahl unterschiedlich ausgegeben werden. Die dritte Variante namens Feldliste <\/b>ist eher für Spezialanwendungen gedacht und liefert die Felder der in Datensatzherkunft<\/b> angegebenen Tabelle als Elemente des Kombinationsfeldes.<\/p>\n Bei den beiden zuerst genannten Einstellungen Tabelle\/Abfrage <\/b>und Wertliste <\/b>können Sie den Wert für Datensatzherkunft <\/b>natürlich nachträglich per VBA anpassen und damit eine gewisse Dynamik erreichen. Das Gleiche gilt für die vierte Möglichkeit, die nicht auf den ersten Blick ersichtlich ist: Dabei weisen Sie der Eigenschaft Herkunftsart <\/b>den Namen einer VBA-Funktion mit spezieller Syntax zu, mit der Sie die einzufügenden Daten definieren.<\/p>\n Und es gibt auch noch eine fünfte Variante, in deren Genuss allerdings nur Benutzer von Access XP und höher kommen: Dabei können Sie der Eigenschaft Recordset <\/b>eines Steuerelements direkt ein DAO- oder ADO-Recordset zuweisen.<\/p>\n Bis auf die erste und dritte können Sie alle Varianten einsetzen, um Daten, die nicht aus Tabellen stammen, in Kombinationsfeldern zur Auswahl bereitzustellen. Natürlich können Sie auch eine Tabelle temporär füllen und als Datensatzherkunft des Kombinationsfeldes angeben, aber dieser Ansatz soll hier nicht weiter besprochen werden.<\/p>\n Beispielanwendung<\/b><\/p>\n Als Beispiel für die verschiedenen Varianten zum dynamischen Füllen eines Kombinationsfeldes dient die Auswahl eines Jahres. Das Beispielformular enthält drei Textfelder, in die Sie das erste, das letzte und das aktuell anzuzeigende Jahr eingeben können. Mit einem Klick auf eine Schaltfläche füllen Sie dann die Kombinationsfelder mit den drei verschiedenen Varianten.<\/p>\n Kombinationsfeld füllen per Wertliste<\/b><\/p>\n Für kleinere Datenmengen bietet sich eine Wertliste an. Die Wertliste enthält die einzelnen Einträge mit Semikola als Trennzeichen. Für die Anzeige von Jahren sieht dies ausschnittsweise so aus:<\/p>\n Natürlich geben Sie diese Liste nicht von Hand ein, sondern lassen den Rechner für sich arbeiten. Wie das funktioniert, zeigt Listing 1. Die Laufvariable i <\/b>(die Sie auch intAktuellesJahr <\/b>nennen könnten) enthält jeweils das aktuelle der in einer Schleife durchgelaufenen Jahre. Innerhalb der Schleife fügt eine Anweisung das jeweils aktuelle Jahr plus ein Semikolon an die in der Variablen strJahre <\/b>gespeicherte Zeichenkette an.<\/p>\n Listing 1: Füllen eines Kombinationsfeldes mit einer dynamisch zusammengestellten Wertliste<\/p>\n Anschließend werden die Eigenschaften Herkunftstyp <\/b>auf Wertliste <\/b>und Datensatzherkunft <\/b>auf den soeben zusammengesetzten Ausdruck eingestellt. Damit das Kombinationsfeld das im Textfeld txtAktuellesJahr <\/b>enthaltene Jahr anzeigt, stellen Sie seine Eigenschaft DefaultValue <\/b>direkt auf den im Textfeld enthaltenen Wert ein.<\/p>\n Dies funktioniert auch für die Anzeige von Daten in mehr als einer Spalte. Access fügt die in dem Wertlistenausdruck enthaltenen Elemente dann von links nach rechts und dann von oben nach unten in das Kombinationsfeld ein.<\/p>\n Kombinationsfeld füllen per Recordset<\/b><\/p>\n Seit Access XP (2002) können Sie Formularen und Steuerelementen wie dem Kombinationsfeld und dem Listenfeld per VBA Recordsets zuweisen. Das eröffnet verschiedene Möglichkeiten.<\/p>\n Die naheliegendste ist das Erzeugen eines Recordsets auf Basis einer Tabelle oder Abfrage und das anschließende Zuweisen zur Eigenschaft Recordset <\/b>des Kombinationsfelds. Dies ließe sich ausnutzen, um die enthaltenen Daten per Code zu sortieren, zu filtern oder anderweitig zu manipulieren.<\/p>\n Die zweite in Kombination mit ADO-Recordsets interessante Möglichkeit ist der Einsatz ungebundener Recordsets. Dabei handelt es sich um ein ganz normales Recordset, das allerdings nicht auf einer Tabelle basiert, sondern komplett per VBA-Code erzeugt wird – was nicht nur das Füllen mit den gewünschten Daten, sondern auch das Definieren der enthaltenen Felder betrifft.<\/p>\n <\/p>\n Sie können so eine Reihe von Daten, beispielsweise Namen, in einem Recordset speichern und die Methoden und Eigenschaften des Recordset<\/b>-Objekts ausnutzen, um die darin enthaltenen Daten zu sortieren. <\/p>\n Im Beispiel aus Listing 2 erzeugen Sie zunächst ein leeres Recordset<\/b>-Objekt und weisen diesem mit der Append<\/b>-Methode ein Integer<\/b>-Feld namens Jahr <\/b>hinzu. Nach dem Einstellen einiger Recordset-Eigenschaften wie CursorLocation<\/b>, LockType <\/b>und CursorType <\/b>(ohne dies funktioniert es nicht!) öffnet die Open<\/b>-Methode das Recordset. Wie im Wertlisten-Beispiel erfolgt das Zusammenstellen der Datenquelle innerhalb einer For Next<\/b>-Schleife, die diesmal allerdings keine Zeichenkette zusammensetzt, sondern pro Jahr einen neuen Datensatz mit der Jahreszahl im ungebundenen Recordset anlegt.<\/p>\n Listing 2: Füllen eines Kombinationsfeldes mit den Daten eines ungebundenen Recordsets<\/p>\n Schließlich weist die Routine der Recordset<\/b>-Eigenschaft des Kombinationsfeldes das frisch zusammengestellte Recordset<\/b>-Objekt zu. Wichtig ist hier der Einsatz der Set<\/b>-Anweisung, da es sich um die Zuweisung einer Objektvariablen handelt. Wie im Wertlisten-Beispiel sorgt die DefaultValue<\/b>-Eigenschaft für das Einstellen des Standardwerts.<\/p>\n Kombinationsfeld füllen per Funktion<\/b><\/p>\n Die dritte und letzte Variante erwartet die Angabe des Namens einer speziell formatierten Funktion für die Eigenschaft Herkunftstyp <\/b>(VBA: RowSourceType<\/b>). Dies geschieht mit der folgenden Anweisung:<\/p>\n Zum Füllen des Kombinationsfeldes mit Hilfe dieser Funktion ist das Aufrufen der Requery<\/b>-Methode erforderlich:<\/p>\n Die Funktion selbst sieht wie in Listing 3 aus. Im Fachjargon heißt diese Funktion „Callback“-Funktion. Sie wird je nach den enthaltenen Informationen unterschiedlich oft und mit verschiedenen Parametern aufgerufen.<\/p>\n Listing 3: Funktion zum Füllen eines Kombinationfeldes<\/p>\n Wie das im Detail aussieht, schaut man sich am besten durch das Setzen einiger Haltepunkte oder das Einfügen passender Debug.Print<\/b>-Anweisungen an. Ohne zu sehr ins Detail zu gehen: Die wichtigen Aufrufe der Funktion Jahre<\/b> aus Listing 3 sind die mit den Werten acLBInitialize<\/b>, acLBGetRowCount <\/b>und acLBGetValue<\/b> für den Parameter code<\/b>. Der Teil des Select Case<\/b>-Konstrukts, der für den Parameter acLBInitialize <\/b>ausgelöst wird, gibt den Wert True <\/b>zurück, damit Access die restlichen Callback-Aufrufe überhaupt ausführt. Die zweite Anweisung weist dem Objekt fld<\/b>, das dem Kombinationsfeld entspricht, das in txtAktuellesJahr<\/b> angegebene Jahr als Standardwert zu.<\/p>\n Im acLBGetRowCount<\/b>-Teil müssen Sie die Anzahl der Zeilen angeben, die das Kombinationsfeld erhalten soll. Das ist besonders deshalb wichtig, weil der Teil, der für das eigentliche Füllen des Kombinationsfeldes zuständig ist, keine Möglichkeit mehr bietet, mehr oder weniger als die hier angegebenen Elemente auszugeben. Der acLBGetValue<\/b>-Teil schließlich wird entsprechend der im acLBGetRowCount<\/b>-Teil angegebenen Anzahl aufgerufen. Damit die Routine weiß, welchen Wert sie aktuell zurückgeben soll, übernimmt der Parameter row <\/b>die Funktion einer Laufvariablen. Der erste Wert ist übrigens 0<\/b>.<\/p>\n üblicherweise trägt man den Namen einer solchen Funktion direkt für die Eigenschaft Herkunftstyp<\/b> ein. Dann erfolgt ein Teil der Aufrufe im Anschluss an das Beim Anzeigen<\/b>-Ereignis des Formulars. Die anzuzeigenden Daten werden noch nicht eingelesen: Dies geschieht erst, wenn der Benutzer das Kombinationsfeld öffnet.<\/p>\n Die Anzeige von zwei oder mehr Spalten ist ebenfalls möglich. In der Beispieldatenbank finden Sie ein weiteres Beispiel für ein Kombinationsfeld, das zwar nur eine Spalte anzeigt, aber zwei weitere Spalten mit Daten besitzt: Die erste Spalte enthält dabei den Monat, die zweite das Jahr und die dritte – für die Anzeige – die Kombination aus beiden. Die Callback-Funktion sieht wie in Listing 4 aus. Die Hauptarbeit verrichtet hier der Teil der Select Case<\/b>-Anweisung, der beim Initialisieren aufgerufen wird. Der Grund liegt ganz einfach in der bequemeren Handhabung: Die Routine stellt dort die Daten in Form eines zweidimensionalen Arrays zusammen, die sie später im GetValue<\/b>-Teil nur noch über die beiden dort verfügbaren Parameter row <\/b>und col <\/b>abrufen muss. Die Einstellungen bezüglich der Spaltenanzahl (3<\/b>) und der Spaltenbreiten (0cm;0cm<\/b>) nehmen Sie im Entwurf des Steuerelements vor. Stellen Sie außerdem die Eigenschaft Gebundene Spalte <\/b>auf 3 <\/b>ein, da nur die Kombination aus Monaten und Jahren eindeutige Werte liefert. Außerdem können Sie so leicht einen Standardwert für das Kombinationsfeld festlegen. In der Callback-Funktion stellen Sie unter acLBGetRowCount <\/b>die Spaltenanzahl auf 3 <\/b>ein.<\/p>\n Listing 4: Funktion zum Füllen eines Kombinationfeldes mit mehreren Spalten<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Wertlisten helfen weiter, wenn es um das schnelle Füllen eines Kombinationsfeldes mit wenigen, bekannten Daten geht. Der Platz ist allerdings begrenzt: Die RowSource<\/b>-Eigenschaft fasst „nur“ 32.750 Zeichen (per Zuweisung in VBA) unter Access XP und 2003 und nur 2.048 unter Access 2000. Für einige Anwendungsfälle dürfte dies nicht ausreichend sein.<\/p>\n Callback-Funktionen als Herkunftstyp sind eine Lösung, wenn die Datenmenge das Fassungsvermögen einer Wertliste überschreitet und kein Access XP oder höher vorhanden ist. Davon abgesehen füllen Callback-Funktionen Kombinationsfelder nicht besonders schnell. Alternative: eine temporäre Tabelle.<\/p>\n Für Access XP und höher sind die ungebundenen Recordsets eine sehr gute Lösung: Neben dem schnellen Anzeigen der Daten – soweit einmal zugewiesen – können Sie die Daten im Recordset auch noch komfortabel sortieren, filtern oder bearbeiten.<\/p>\n Enthaltene Beispieldateien:<\/p>\n KombinationsfelderFuellen00.mdb<\/p>\n KombinationsfelderFuellen.accdb<\/p>\n KombinationsfelderFuellenXP.mdb<\/p>\n\n2000;2001;2002;2003;2004...<\/pre>\n
\nDim i As Integer<\/pre>\n
Dim strJahre As String<\/pre>\n
For i = Me!txtErstesJahr To Me!txtLetztesJahr<\/pre>\n
strJahre = strJahre & i & \";\"<\/pre>\n
Next i<\/pre>\n
Me!cboJahreAusWertliste.RowSourceType = \"Wertliste\"<\/pre>\n
Me!cboJahreAusWertliste.RowSource = strJahre<\/pre>\n
Me!cboJahreAusWertliste.DefaultValue = Me!txtAktuellesJahr<\/pre>\n<\/p><\/div>\n
\nDim i As Integer<\/pre>\n
Dim rst As ADODB.Recordset
<\/pre>\nSet rst = New ADODB.Recordset<\/pre>\n
rst.Fields.Append \"Jahr\", adInteger<\/pre>\n
rst.CursorLocation = adUseClient<\/pre>\n
rst.LockType = adLockOptimistic<\/pre>\n
rst.CursorType = adOpenKeyset<\/pre>\n
rst.Open<\/pre>\n
For i = Me!txtErstesJahr To Me!txtLetztesJahr<\/pre>\n
rst.AddNew<\/pre>\n
rst!Jahr = i<\/pre>\n
rst.Update<\/pre>\n
Next i<\/pre>\n
Set Me!cboJahreAusRecordset.Recordset = rst<\/pre>\n
Me!cboJahreAusRecordset.DefaultValue = Me!txtAktuellesJahr<\/pre>\n
rst.Close<\/pre>\n
Set rst = Nothing<\/pre>\n<\/p><\/div>\n
Me!cboJahreAusFunktion.RowSourceType = \"Jahre\"<\/pre>\n
Me!cboJahreAusFunktion.Requery<\/pre>\n
\nFunction Jahre(fld As Control, ID As Variant, row As Variant, _
col As Variant, code As Variant) As Variant<\/pre>\n Select Case code<\/pre>\n
Case acLBInitialize<\/pre>\n
Jahre = True<\/pre>\n
fld.DefaultValue = Me!txtAktuellesJahr<\/pre>\n
Case acLBOpen<\/pre>\n
Jahre = Timer<\/pre>\n
Case acLBGetRowCount<\/pre>\n
Jahre = 1 - Me!txtErstesJahr + Me!txtLetztesJahr<\/pre>\n
Case acLBGetColumnCount<\/pre>\n
Jahre = 1<\/pre>\n
Case acLBGetColumnWidth<\/pre>\n
Jahre = -1<\/pre>\n
Case acLBGetValue<\/pre>\n
Jahre = Me!txtErstesJahr + row<\/pre>\n
End Select<\/pre>\n
End Function<\/pre>\n<\/p><\/div>\n
\nFunction MonateUndJahre(fld As Control, ID As Variant, row As Variant, _
col As Variant, code As Variant) As Variant<\/pre>\n Dim intMonat As Integer<\/pre>\n
Dim intJahr As Integer<\/pre>\n
Dim i As Integer<\/pre>\n
Static varArray() As Variant<\/pre>\n
Select Case code<\/pre>\n
Case acLBInitialize<\/pre>\n
MonateUndJahre = True<\/pre>\n
ReDim varArray((Me!txtLetztesJahr - Me!txtErstesJahr + 1) * 12, _
3)
<\/pre>\n For intJahr = Me!txtErstesJahr To Me!txtLetztesJahr
<\/pre>\n For intMonat = 1 To 12
<\/pre>\n varArray(i, 0) = intMonat<\/pre>\n
varArray(i, 1) = intJahr<\/pre>\n
varArray(i, 2) = intMonat & \"\/\" & intJahr<\/pre>\n
i = i + 1
<\/pre>\n Next intMonat
<\/pre>\n Next intJahr
<\/pre>\n fld.DefaultValue = Chr(34) & Month(Date) & \"\/\" _
& Me!txtAktuellesJahr & Chr(34)
<\/pre>\n Case acLBOpen<\/pre>\n
MonateUndJahre = Timer
<\/pre>\n Case acLBGetRowCount<\/pre>\n
MonateUndJahre = (Me!txtLetztesJahr - Me!txtErstesJahr + 1) * 12
<\/pre>\n Case acLBGetColumnCount<\/pre>\n
MonateUndJahre = 3
<\/pre>\n Case acLBGetColumnWidth<\/pre>\n
MonateUndJahre = -1
<\/pre>\n Case acLBGetValue<\/pre>\n
MonateUndJahre = varArray(row, col)<\/pre>\n
End Select<\/pre>\n
End Function<\/pre>\n<\/p><\/div>\n
Downloads zu diesem Beitrag<\/h3>\n