<\/p>\n
Kombinationsfelder spielen eine wichtige Rolle bei der Dateneingabe in Formularen. Auch wenn sie mit zahlreichen Eigenschaften und Programmiermöglichkeiten ausgestattet sind, gibt es immer wieder Fälle, in denen man sich eine ausgefeiltere Bedienung oder eine andere Optik wünscht. Einige änderungsmöglichkeiten finden Sie in diesem Beitrag.<\/b><\/p>\n<\/div>\n Neben Textfeldern sind Kombinationsfelder wohl das zweitwichtigste Steuerelement in Formularen. Dennoch hapert es manchmal – der eine möchte gern Einträge mit den Pfeiltasten auswählen (siehe auch Beitrag Eingabe in Text- und Kombinationsfelder vereinfachen<\/b>, Shortlink 516), der andere ist mit dem Erscheinungsbild nicht ganz zufrieden. Außer der Möglichkeit, mehrere Spalten in der Liste einzublenden, beschränken sich Formatierungen auf die Schrift. Funktionell bieten Kombinationsfelder zwar eine automatische Wortergänzung, eine Filterung der Liste ist aber nicht oder nur umständlich möglich. Dieser Beitrag soll zeigen, wie Sie mehr erreichen können: Basteln Sie sich Kombinationsfelder einfach selbst!<\/p>\n Wo ist das Problem<\/b><\/p>\n Was soll Kombinationsfeldern, wie Access sie mitbringt, denn fehlen, könnten Sie fragen. Nichts, würde ich Ihnen antworten, solange sie nur einfache Listen mit einer mäßigen Zahl an Einträgen beherbergen. Sobald jedoch unter Hunderten oder Tausenden von Einträgen ausgewählt werden soll, kann dies zu einer Tipp- und Scroll-Arie ausarten. Wenn außerdem zu den einzelnen Einträgen genauere Informationen benötigt werden, helfen zusätzliche Spalten nur bedingt weiter. Ein anderer Punkt ist der Ressourcenbedarf von Kombinationsfeldern. Jedes Kombinationsfeld hat ein eigenes Recordset als Basis, das unter Umständen mehrmals abgefragt oder aufgebaut wird. Jedes Recordset stellt im Prinzip jeweils eine komplette Tabelle dar. Für ein Formular mit zahlreichen Kombinationsfeldern, die vielleicht noch auf mehrere Registerkarten verteilt sind, steigt die Rechenleistung beim Füllen meist deutlich und auch Speicher und Netzwerktraffic sind betroffen. Ein gebundenes Kombinationsfeld ist im Grunde vergleichbar mit einem Unterformular. Dieser Umstand führt dazu, dass Access Formulare mit Kombinationsfeldern langsam lädt und die Belastung auf das Backend erhöht wird. Wie baue ich ein Kombinationsfeld<\/b><\/p>\n Technisch gesehen ist ein Kombinationsfeld unter Windows die Ableitung eines Textfeldes. Dem Textfeld wird zusätzlich ein Knöpfchen spendiert. Ein Klick auf den Button erzeugt dann ein Listbox-Fenster. Auf die gleiche Weise könnte man bei dem geplanten Nachbau eines Kombinationsfeldes verfahren und drei Elemente kombinieren: Dazu müssen Sie ein Textfeld, eine Schaltfläche mit Bild und ein Listensteuerelement im Formular platzieren und diese programmtechnisch verbinden. Ein solches Pseudokombinationsfeld hätte dann allerdings die gleichen Nachteile wie das eingebaute von Access, denn das Listenfeld ist in seinen Möglichkeiten ebenfalls ziemlich beschränkt. Besser ist es daher, statt des Listenfeldes ein randloses Formular in Datenblatt- oder Endlosansicht einzusetzen. Damit sind der Gestaltung der Liste dann keine Grenzen mehr gesetzt. Für das Formular selbst sind zwei Varianten implementierbar: Entweder ein Unterformular oder ein Popup-Formular. Das muss ein Kombinationsfeld können<\/b><\/p>\n Grundsätzlich lässt sich ein Kombinationsfeld vollständig sowohl mit der Maus als auch mit der Tastatur bedienen. Mit der Maus hat man diese Abfolge: Ein Klick auf den Pfeil-Button öffnet die Liste, die Bildlaufleiste dient zum Navigieren und ein Klick auf einen Eintrag wählt diesen aus. Die Liste selbst hat eine Datenherkunft, die auf einer Tabelle, einer Wertliste oder, ab Access 2002, direkt auf einem Recordset basiert. Die veraltete Möglichkeit, es mit einer benutzerdefinierten Funktion zu füllen, bleibt hier außen vor. Das Steuerelement lässt sich direkt an ein Datenfeld des Formulars oder eines Berichts binden – die Auswahl eines anderen Eintrags ändert also den Wert des zu Grunde liegenden Feldes.<\/p>\n Wollte man all diese Eigenschaften per Eigenbau akribisch nachbilden, würde dies eine ganze Menge Arbeit bedeuten. In den folgenden Beispielen ist das nur teilweise umgesetzt. Schließlich sollen die neuen Kombinationsfelder ja neue Möglichkeiten aufweisen, die dann unter Umständen auch eine andere Bedienung erfordern. Wichtig ist vor allem, dass die Liste sich mit den erwähnten Tastenkombinationen öffnen und schließen lässt, eine Verwendung auch allein mit der Maus möglich ist und das Ergebnis schließlich im zugewiesenen Datenfeld des Formulars landet.<\/p>\n Eigenbau, Version mit Unterformular<\/b><\/p>\n In Bild 1 sehen Sie, wie sich die einzelnen Komponenten des nachgebildeten Kombinationsfeldes zusammenfügen. Ausgangspunkt ist ein Textfeld mit Beschriftung („Label“), an dessen rechter Seite eine Schaltfläche mit Bild angeflanscht wird. Das Textfeld ist im Formular ungebunden.<\/p>\n Bild 1: Nachgebildetes Kombinationsfeld<\/span><\/b><\/p>\n<\/div>\n Unterhalb des Textfeldes ist ein Unterformular angebracht, das rechtsbündig mit der Schaltfläche abschließt. Seine Eigenschaft Sichtbar <\/b>wurde in der Entwurfsansicht auf Nein <\/b>eingestellt. Vielleicht wundern Sie sich darüber, warum das Unterformular so klein ist, obwohl es nachher doch die ganze ausgeklappte Liste anzeigen soll. Der Grund ist ganz einfach der, dass das Unterformular über anderen weiteren Steuerelementen des Formulars liegen muss, sie also in der Entwurfsansicht überdecken würde. Das machte die Arbeit am Formularentwurf etwas schwierig, falls Sie nachträglich die überdeckten Steuerelemente bearbeiten wollten. Stattdessen wird das Unterformular zur Laufzeit beim Laden des Formulars per VBA auf die gewünschte Größe gebracht.<\/p>\n Ein Wort zur Schaltfläche: Hier muss man sich leider entscheiden, welches Bildchen man für das Pfeilsymbol anheften möchte. Je nach Access-Version, nach Betriebssystem und nach Einstellung der Option Mit einem Design versehene Steuerelemente verwenden<\/b> sieht ein Kombinationsfeld-Pfeil unterschiedlich aus. In Bild 1 wurde ein Symbol mit XP-Style unter Access 2003 verwendet. Man könnte zwar zur Laufzeit die Einstellungen ermitteln und in Abhängigkeit davon individuelle Bildchen in den Button laden, der Aufwand hierfür scheint aber etwas übertrieben.<\/p>\n Es macht ja nichts, wenn der User bemerkt, dass es sich nicht um ein Windows-konformes Kombinationsfeld handelt. Im Verzeichnis der Beispieldatenbank comboboxfakes.mdb <\/b>finden Sie zwei unterschiedliche Bilddateien, die sich für den Button eignen.<\/p>\n Wie nun die einzelnen Elemente zusammenarbeiten, lässt sich am besten anhand der Beipieldatenbank demonstrieren. Als Datenbasis wurde die von der Nordwind-Datenbank abgeleitete Version Südsturm verwendet. Das Formular frmBestellungen <\/b>(siehe Bild 2) zeigt die Bestellungen einzelner Kunden und die zugehörigen Bestelldetails in einem Unterformular. Zwei gefakte Kombinationsfelder sind eingebaut: Ganz oben eines zur Auswahl des Kunden und im Unterformular eines zur Auswahl von Artikeln für eine Bestellung.<\/p>\n Bild 2: Das Formular Das Kundenkombinationsfeld ist in der Unterformularversion ausgeführt. Im Unterformular für die Artikel ist das nicht möglich, weil dieses selbst in Endlosansicht vorliegt und – abgesehen vom fehlenden Platz pro Zeile – damit nicht erlaubt, Unterformulare einzufügen. Dort kommt die Version mit einem Popup-Formular zur Anwendung, die später besprochen wird. Bild 3: Geöffnetes Kombinationsfeld im Eigenbau<\/span><\/b><\/p>\n<\/div>\n <\/p>\n Die Kunden sind in der Liste mit detaillierten Angaben aufgeführt. Sie bietet die Gelegenheit, nach verschiedenen Feldern wie Code, Kontaktperson, Firmenname oder Adresse zu filtern und das auch kombiniert. In die Felder der Filterzeile können Anfangsbuchstaben oder Wortteile eingegeben werden, die in einem SQL-String per LIKE zu einem Filterausdruck zusammengesetzt werden. Einträge können durch Klick auf eine der grün markierten Schaltflächen mit der Beschriftung Auswählen<\/b> oder durch Betätigen der Eingabetaste selektiert werden. Die Liste schließt sich dann wieder und der Eintrag wird in die Kunden-Textbox übernommen.<\/p>\n Sie mögen einwenden, dass man statt eines solchen nachgebauten Kombinationsfelds auch gleich ein Popup-Fformular verwenden könnte. Dazu müsste man jedoch eine Möglichkeit zum öffnen dieses Formulars wie etwa eine zusätzliche Schaltfläche bereitstellen, die für die meisten Benutzer jedoch zunächst ungewohnt sein dürfte. Hat der Benutzer hingegen ein Kombinationsfeld vor sich, dann sind die Funktionen der Pfeil-Schaltfläche und die Tastenkombinationen selbstverständlich.<\/p>\n Die Funktion im Detail<\/b><\/p>\n Das öffnen der Liste geschieht, indem das Unterformular sichtbar gemacht wird. So, wie es im Entwurf eingerichtet wurde, sähe das dann zunächst eigenartig aus – wurde es doch verkleinert angelegt.<\/p>\n Deshalb ist in der Ereignisprozedur Beim Anzeigen <\/b>des Hauptformulars der Code zum Einstellen der gewünschten Größe des Unterformulars untergebracht:<\/p>\n Stören Sie sich nicht daran, dass dem Unterformularnamen das Präfix cbo <\/b>statt des „korrekten“ sfrm <\/b>spendiert wurde. Es wurde zur leichteren Unterscheidung von „richtigen“ Unterformularen gewählt. Die Beim Klicken<\/b>-Ereignisprozedur der Pfeil-Schaltfläche macht das Unterformular sichtbar:<\/p>\n Hier wird Visible <\/b>nicht einfach auf True<\/b> gesetzt, sondern ausgewertet, ob das Unterformular eventuell bereits geöffnet wurde. Dann nämlich wird es wieder auf Unsichtbar <\/b>gestellt, was dem Verhalten des Pfeil-Buttons eines herkömmlichen Kombinationsfeldes entspricht. Die gleiche Aktion soll erfolgen, wenn die Tasten F4 <\/b>oder Alt + Cursor nach unten <\/b>betätigt werden. Das ist mit dem Key_Down<\/b>-Ereignis (Bei Taste Ab<\/b>) des Kunden-Textfeldes zu lösen. In dieser Prozedur werden die passenden Keycodes abgefangen:<\/p>\n Statt hier den gleichen Code wie für die Schaltfläche zu wiederholen, wird einfach die Prozedur cmdDropDown_Click <\/b>selbst aufgerufen.<\/p>\n Fehlt noch der Inhalt des Textfeldes selbst. Da es nicht an ein Feld der Datenherkunft des Formulars gebunden ist, muss per Code im Current<\/b>-Ereignis für das Befüllen Sorge getragen werden (in einer Zeile):<\/p>\n Das Textfeld selbst ist übrigens für die Eingabe gesperrt. Das Verhalten unserer Fake-Combobox entspricht damit quasi der Einstellung Nur Listeneinträge anzeigen<\/b> einer Access-Combobox.<\/p>\n Mehr Code ist im Hauptformular für die Lösung nicht notwendig. Der Fokus hat sich ja nun auf das Unterformular verlagert, welches sich in der Beispieldatenbank frm_cbKunden <\/b>nennt. Man hätte darauf auch gut verzichten und es gleich selbst als Endlosformular ausführen können. Die Lösung mit zusätzlichem Unterformular lässt jedoch erweiterten Gestaltungsspielraum offen.<\/p>\n Da die Kombinationsfeldliste, also das Unterformular cboKunden<\/b>, auch mit den gleichen Tasten geschlossen werden soll, mit denen es geöffnet wurde, müssen in diesem wieder Keycodes abgefangen werden. Da hier aber mehr als nur ein Steuerelement im Formular enthalten ist, soll dieses Abfangen formularweit erfolgen.<\/p>\n Dazu ist die Eigenschaft Tastenvorschau <\/b>des Formulars auf Ja <\/b>zu stellen, was dazu führt, dass jeglicher Tastenanschlag zuerst an die Prozedur Form_KeyDown <\/b>geleitet wird, bevor er seinen vorgesehenen Zielort erreicht. In der Prozedur können die Tastenanschläge dann ausgewertet und gegebenenfalls gefiltert und mit Aktionen belegt werden:<\/p>\n Das Formular enthält noch einige weitere Prozeduren, die für das Filtern der Liste verantwortlich sind oder die Bedienung per Tastatur genauer regeln – auf diese wird hier nicht weiter eingegangen. Für das Filtern sind die Prozeduren FilterMe<\/b> und ConcatenateFilter<\/b> zuständig, die immer aufgerufen werden, sobald ein Wert in den Filtereingabefeldern geändert wird. Das Elternformular wiederum enthält die öffentliche Prozedur KundeSelectedID<\/b>:<\/p>\n Hier werden mehrere Aufgaben erledigt. Zunächst wird der Filter für die Datenherkunft des Hauptformulars auf die ID des ausgewählten Kunden gesetzt. Dadurch wechselt der Datensatz im Hauptformular, was die beabsichtigte Navigationsfunktion des Kombinationsfeldes ist. Dann wird noch das Textfeld des zusammengesetzten Kombinationsfelds mit dem im Unterformular ermittelten Kunden-String, übergeben im Parameter KID<\/b>, gefüllt. Das wäre an sich allerdings nicht notwendig, weil bereits das Current<\/b>-Ereignis des Hauptformulars, das nach dem Filtern eintritt, Gleiches tut. Es demonstriert hier aber den Zugriff vom Unterformular auf ein Steuerelement des Hauptformulars.<\/p>\n Damit sind die Grundfunktionen der ersten Version des Kombinationsfeld-Eigenbaus besprochen. Man könnte noch mehr Features einbauen: So fehlt etwa der Umstand, dass nach dem öffnen der Liste gleich der im Textfeld bereits angezeigte Datensatz markiert wird, wie das bei Kombinationsfeldern üblich ist. Dieses Feature macht in diesem Beispiel jedoch wenig Sinn, weil die Hauptfunktion das Filtern von Einträgen ist, weshalb der Fokus nach dem öffnen eher auf einem Filtereingabefeld stehen sollte als auf einem Listeneintrag.<\/p>\n Eigenbau, Version mit Popup-Formular<\/b><\/p>\n Die vorige Lösung hat entscheidende Nachteile: Erstens lässt sie sich nicht in Endlos-Unterformularen einsetzen und zweitens benötigt die Liste als Unterformular Platz, der leider nicht zur Verfügung steht, wenn die Combobox etwa am unteren Rand des Formulars sitzt – ein Unterformular kann nun mal nicht über den Rand das Hauptformulars hinausragen. Das lässt sich daher nur mit einem externen Formular lösen. Bild 4: Kombinationsfeld-Eigenbau mit einem Popup-Formular<\/span><\/b><\/p>\n<\/div>\n Dieses Kombinationsfeld ist deutlich einfacher gehalten als das im ersten Beispiel. Neben der Liste von auswählbaren Artikeln zeigt es links neben jedem Eintrag den Lagerbestand des Artikels an. Je nach Bestand wird dieser Wert zusätzlich farblich unterlegt. Ein Bestand von weniger als sechs Artikeln etwa markiert das Feld rot, ein Bestand von mehr als 20 Artikeln zeigt sich grün. Ein besonderes Feature des Kombinationsfelds ist aber die Tatsache, dass die Liste dynamisch ist: Für eine Bestellung kann ein Artikel nur einmal angegeben werden. Würde Queso Cabrales<\/b> in eine weitere Zeile eingegeben, dann würde sich Access mit einem Fehler wegen Verletzung der Indexregeln für Bestelldetails melden – ein Artikel soll ja nicht mehrmals angegeben, sondern in der Bestellmenge verändert werden. Das Kombinationsfeld berücksichtigt dies, indem es in der Liste alle Artikel ausfiltert, die bereits vergeben sind. Das erledigt dieser Code:<\/p>\n Ausgangspunkt ist das Unterformular sfrm_Bestelldetails<\/b>, eingebettet in das Hauptformular frmBestellungen<\/b>. Es enthält eine Liste der Artikel zu einer Bestellung, gespeichert in Form der ArtikelIDs<\/b>. Der Code durchläuft nun in einer Schleife alle Datensätze der aktuellen Bestellung und setzt dabei in der Variablen strIDs <\/b>einen String zusammen, der alle vergebenen ArtikelIDs <\/b>enthält. Dieser String wird dann als WHERE-Bedingung beim öffnen des Popup-Formulars per Docmd.OpenForm <\/b>übergeben. Das geöffnete Popup-Formular hat damit eine Datenherkunft wie diese:<\/p>\n Doch das war nur ein Vorgriff. Sehen Sie zunächst, wie das öffnen der alternativen Combobox vonstatten geht. Aus dem Hauptformular wird es durch die gleichen Aktionen geöffnet, wie im ersten Beispiel: entweder Klick auf den Combobox-Button oder eine der Tastenkombinationen. Der Code, der hierbei abläuft, ist allerdings ein wenig komplizierter, da wir es nun mit einem eigenständigen Popup-Formular zu tun haben, dessen Position auf dem Bildschirm erst anzupassen ist.<\/p>\n Der Reihe nach: Während im ersten Beispiel das Kombinationsfeld durch Setzen der Visible<\/b>-Eigenschaft eingeblendet wurde, muss es hier per Docmd.OpenForm <\/b>geöffnet werden. Und da wird es etwas umständlich: Würde man es im Modus Dialog <\/b>öffnen, dann hätte es erstens eine Titelleiste und zweitens würde der Code beim Aufruf anhalten, was es unmöglich machen würde, es vom aufrufenden Formular per Code zu positionieren. Also bleibt nur die Möglichkeit, es mit dem Wert Ja <\/b>für die Eigenschaft Gebunden<\/b> zu versehen, damit nicht gleichzeitig das Pseudo-Kombinationsfeld geöffnet ist und dennoch weitere Funktionen in Access ausgeführt werden können. Ein Formular im gebundenen Modus verhindert aber nicht, dass der Code nach Aufruf von DoCmd.OpenForm <\/b>fortgeführt wird. Das kann man sich zu Nutze machen, um die Positionierung des Popup-Formulars genau an die richtige Stelle zu vollziehen, damit es überhaupt erst wie die Liste eines Kombinationsfeldes aussieht:<\/p>\n Positioniert wird es mit der Methode Move <\/b>des Formulars, der als Parameter die X- und Y-Koordinaten relativ zum Access-Hauptfenster übergeben werden. Achtung: Leider wird die Methode Move <\/b>nur von Access XP und höher unterstützt. Für Access 2000 käme nur die Positionierung über API-Code infrage – machbar, aber kompliziert. Um den Wert zu erhalten, der in der Combobox ausgewählt wurde, kommt hier eine Methode zum Einsatz, die manch einer als unschön empfindet: Die Verwendung einer globalen Variablen. Vor dem Aufruf des Popup-Formulars wird die Variable globvTemp <\/b>auf Null gesetzt und nach dem Schließen wieder ausgelesen. Dazwischen wird in einer Schleife auf das Schließen gewartet:<\/p>\n Wurde kein Wert ausgewählt, dann ist die Variable globvTemp <\/b>noch immer Null; anderenfalls wird im aktuellen Bestelldetaildatensatz die entsprechende ArtikelID <\/b>gespeichert. Diese Methode über eine globale Variable ist hier aus zwei Gründen unproblematisch: Erstens kann in der Datenbank parallel praktisch nichts passieren, weil das Popup-Formular im gebundenen Modus betrieben wird. Zum anderen enthält dessen Code eine Fehlerbehandlung, sodass globvTemp <\/b>nicht zufällig durch einen Fehler auf Null gesetzt werden kann. über die Variable ist zudem eine stärkere Entkopplung zum aufrufenden Formular gegeben.<\/p>\n Feinschliff<\/b><\/p>\n Nachdem diese Version der Combobox im Aussehen einer üblichen recht nahekommt, sollte sie auch ein ähnliches Verhalten an den Tag legen. Dazu gehört etwa, dass man sich mit dem Cursor nicht innerhalb eines Eintrags bewegen kann, wie das die hier verwendeten Textboxen nun mal vorsehen, oder dass ein Eintrag vollständig markiert ist. Sehen Sie sich den Entwurf des Popup-Formulars in Bild 5 an.<\/p>\n Bild 5: Popup-Formular für die Kombinationsfeldliste im Entwurf<\/span><\/b><\/p>\n<\/div>\n\n
Einige Beispiele dafür, was Kombinationsfelder unter Access nicht können:<\/p>\n\n
Wenn Sie nicht auf Kombinationsfelder verzichten können oder wollen, etwa, weil dem Kunden eine kompakte Oberfläche vorschwebt, dann sollten Sie eine ungebundene Version im Eigenbau in Betracht ziehen, um die Belastung des Systems zu verringern.<\/p>\n
Bevor wir ins Detail gehen, schauen wir uns einmal an, wie sich ein herkömmliches Kombinationsfeld eigentlich verhält.<\/p>\n
Die Tastatur bietet weitere Möglichkeiten: Innerhalb des Textbereichs verhält sich das Kombinationsfeld nämlich genau so wie ein Textfeld. Mit der Taste F4 <\/b>oder der Tastenkombination Alt + Cursor nach unten<\/b> klappen Sie das Kombinationsfeld auf. Die gleichen Tastaturanweisungen oder die Tasten Escape <\/b>und Tab <\/b>schließen die Liste wieder. Das Scrollen durch die Liste geschieht durch die Cursor nach unten<\/b>– und Cursor nach oben<\/b>-Tasten oder, für größere Sprünge, mit Bild auf <\/b>und Bild ab<\/b>. Die Eingabe von Zeichen in das Textfeld navigiert zu entsprechenden Einträgen, falls die automatische Ergänzung eingeschaltet ist. Die Eingabetaste schließlich wählt den markierten Eintrag aus.<\/p>\n\n ![\"missing](\"..\/fileadmin\/_temp_\/2007_05\/Combos_Extended-web-images\/Bild258_opt.jpeg\")
\n<\/div>\n\n\n ![\"missing](\"..\/fileadmin\/_temp_\/2007_05\/Combos_Extended-web-images\/Bild265_opt.jpeg\")
\n<\/div>\n\n
Kundenbestellungen der Beispieldatenbank<\/span><\/b><\/p>\n<\/div>\n
Das öffnen des Kundenkombinationsfeldes mit F4<\/b>, Alt + Cursor nach unten<\/b> oder Klick auf die Pfeil-Schaltfläche führt zur in Bild 3 dargestellten Erscheinung.<\/p>\n\n ![\"missing](\"..\/fileadmin\/_temp_\/2007_05\/Combos_Extended-web-images\/Bild271_opt.jpeg\")
\n<\/div>\n\nMe!cboKunden.Left = 980
Me!cboKunden.Width = 10900
Me!cboKunden.Height = 6630<\/pre>\nPrivate Sub cmdDropdown_Click()
Me!cboKunden.Visible = _
Not Me!cboKunden.Visible
...\r\nEnd Sub<\/pre>\nPrivate Sub txtKunde_KeyDown(KeyCode As _
Integer, Shift As Integer)
If (KeyCode = vbKeyDown And Shift = _
ALT_MASK) Or (KeyCode = vbKeyF4 And _
Shift = 0) Then
cmdDropdown_Click
End If
End Sub<\/pre>\nMe!txtKunde.Value = DFirst("Firma", "tblKunden", "KundeID=" & Me!KundeID)<\/pre>\n
Es enthält selbst wieder ein Unterformular sfrm_cbKunden <\/b>in Endlosausführung.<\/p>\nPrivate Sub Form_KeyDown(KeyCode As Integer, _
Shift As Integer)
'Bei ESC, ALT+NACH-UNTEN und F4 Liste wieder
'ausblenden
If KeyCode = vbKeyEscape Or (KeyCode = _
vbKeyDown And Shift = ALT_MASK) Or _
(KeyCode = vbKeyF4 And Shift = 0) Then
Me.Parent!txtKunde.SetFocus
Me.Visible = False
End If
End Sub<\/pre>\n
Wichtig ist dagegen die Prozedur zum Auswählen eines Eintrags der Liste. Da die Schaltfläche Auswählen<\/b> sich im Unterformular sfrm_cbKunden <\/b>des Unterformulars befindet, leitet es eine Aktion an das Elternfenster weiter:<\/p>\nPrivate Sub cmdSelect_Click()
Me.Parent.KundeSelectedID Nz(Me!Firma) & _
" \/ " & Nz(Me!KundenCode) & " \/ " _
& Nz(Me!Person)
End Sub<\/pre>\nPublic Sub KundeSelectedID(KID As Variant)
Me.Parent.Filter = "KundeID=" _
& Me!sfrmKunden!KundeID
Me.Parent.FilterOn = True
With Me.Parent!txtKunde
.SetFocus
.Value = KID
End With
Me.Visible = False
End Sub<\/pre>\n
In der Beispieldatenbank sieht der andere Eigenbau so wie in Bild 4 aus.<\/p>\n\n ![\"missing](\"..\/fileadmin\/_temp_\/2007_05\/Combos_Extended-web-images\/Bild277_opt.jpeg\")
\n<\/div>\n\nDim strIDs As String
Dim rsClone As DAO.Recordset
Set rsClone = Me.RecordsetClone
rsClone.MoveFirst
Do While Not rsClone.EOF
strIDs = strIDs & rsClone!ArtikelID & ","
rsClone.MoveNext
Loop
Set rsClone = Nothing
If Len(strIDs) > 0 Then strIDs = _
Left(strIDs, Len(strIDs) - 1)
DoCmd.OpenForm "sfrm_Artikel", , , _
"ArtikelID NOT IN (" & strIDs & ")"<\/pre>\nSELECT * FROM tblArtikel WHERE ArtikelID NOT IN(12,14,22,26,33)<\/pre>\n
Dim lPosLeft As Long, lPosTop As Long
lPosLeft = Me.WindowLeft + _
Me.CurrentSectionLeft + _
Me!cmdDropdown.Left + _
Me!cmdDropdown.Width - _
Forms!sfrm_Artikel.WindowWidth - 30
lPosTop = Me.WindowTop + _
Me.CurrentSectionTop + _
Me.Section(acDetail).Height - 30
Forms!sfrm_Artikel.Move lPosLeft, lPosTop<\/pre>\n
Die Koordinaten werden aus der Position des aufrufenden Fensters ermittelt (WindowLeft<\/b>, WindowTop <\/b>– ebenfalls nicht unter Access 2000 verfügbar), der Position des Pfeil-Buttons und der Position der Zeile mit den Eigenschaften CurrentLeft<\/b>, CurrentTop<\/b> sowie Detailbereich.Height<\/b>.<\/p>\nglobvTemp = Null
Docmd.OpenForm "sfrm_Artikel", ...
Do
DoEvents
Loop Until SysCmd(acSysCmdGetObjectState, _
acForm, "sfrm_Artikel") = 0
If Not IsNull(globvTemp) Then _
Me!ArtikelID = globvTemp<\/pre>\n
Das Setzen der Variablen im Popup-Formular übernimmt eine Zeile:<\/p>\nPrivate Sub txtArtikelname_Click()
globvTemp = Me!ArtikelID
DoCmd.Close acForm, Me.Name
End Sub<\/pre>\n\n ![\"missing](\"..\/fileadmin\/_temp_\/2007_05\/Combos_Extended-web-images\/Bild283_opt.jpeg\")
\n<\/div>\n\n