<\/p>\n
Wir haben bereits in mehreren Beiträgen beschrieben, wie Sie die individuelle Reihenfolge von Elementen einer Tabelle über den Inhalt eines Feldes etwa namens „ReihenfolgeID“ einstellen können – zum Beispiel in Listenfeldern oder Unterformularen in der Datenblattansicht. Dort haben wir die Reihenfolge dann durch Markieren der Einträge und anschließendes Betätigen etwa von Schaltflächen mit Beschriftungen wie „Ganz nach oben“, „Nach oben“, „Nach unten“ oder „Ganz nach unten“ geändert. Im vorliegenden Beitrag schauen wir uns nun an, wie wir im Unterformular in der Datenblattansicht die Reihenfolge für mehrere Einträge gleichzeitig ändern können.<\/b><\/p>\nMehrfach-Reihenfolge im Datenblatt<\/h2>\n
Im Beitrag Listenfeld: Reihenfolge mehrerer Einträge ändern <\/b>(www.access-im-unternehmen.de\/1197<\/b>) zeigen wir, wie das Ändern der Reihenfolge mehrerer markierter Einträge gleichzeitig im Listenfeld funktioniert. Aber oft sollen Daten auch in einem Unterformular in der Datenblattansicht dargestellt werden, was Vorteile gegenüber einem Listenfeld bietet – zum Beispiel das schnelle Sortieren, Filtern oder das Ändern der Spaltenanordnung oder -breite.<\/p>\n
Außerdem kann der Benutzer in einem Unterformular in der Datenblattansicht auch direkt Daten ändern, was im Listenfeld nicht möglich ist. Also zeigen wir auch für das Unterformular in der Datenblattansicht, wie Sie die Reihenfolge der markierten Datensätze ändern können.<\/p>\n
Die Beispielkonstellation sieht wie in Bild 1 aus. Hier haben wir ein Unterformular namens sfmMehrfachreihenfolgeDatenblatt <\/b>erstellt, dass an die Tabelle tblKategorien <\/b>gebunden ist – und zwar über die folgende SQL-Abfrage:<\/p>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2019_04\/pic_1198_001.png\")
<\/p>\n
Bild 1: Entwurf des Formulars frmMehrreihenfolgeDatenblatt<\/span><\/b><\/p>\n Dadurch werden die Datensätze aufsteigend nach der Sortierung des Feldes ReihenfolgeID <\/b>angezeigt.<\/p>\n Das Unterformular soll die Daten der drei Felder KategorieID<\/b>, Kategoriename <\/b>und ReihenfolgeID <\/b>anzeigen. Für die Eigenschaft Standardansicht <\/b>haben wir den Wert Datenblatt <\/b>eingestellt.<\/p>\n Danach haben wir das Unterformular aus dem Navigationsbereich von Access in den Entwurf des Hauptformulars frmMehrfachreihenfolgeDatenblatt <\/b>gezogen. Das Unterformularsteuerelement, in dem das Unterformular angezeigt wird, haben wir aus Gründen der Übersicht in sfm <\/b>umbenannt.<\/p>\n Rechts neben dem Unterformular befinden sich die vier Schaltflächen cmdTop<\/b>, cmdUp<\/b>, cmdDown <\/b>und cmdBottom<\/b>. Die Eigenschaften Navigationsschaltflächen<\/b>, Datensatzmarkierer<\/b>, Trennlinien <\/b>und Bildlaufleisten <\/b>des Hauptformulars haben wir auf Nein <\/b>eingestellt, die Eigenschaft Automatisch zentrieren <\/b>auf Ja<\/b>.<\/p>\n Im Gegensatz zum Listenfeld können wir mit der Datenblattansicht nur zusammenhängende Datensätze markieren. Dafür gibt es beim Datenblatt ganz andere Möglichkeiten, um die jeweils markierten Datensätze zu identifizieren. Diese werden Sie in den folgenden Abschnitten kennenlernen.<\/p>\n Im ersten Schritt wollen wir sicherstellen, dass jeweils nur die aktuell notwendigen Schaltflächen aktiviert sind. Das heißt, dass die beiden Schaltflächen cmdTop <\/b>und cmdUp <\/b>deaktiviert werden sollen, wenn der Benutzer den obersten Datensatz im Datenblatt markiert hat, denn dann können die markierten Elemente nicht mehr weiter nach oben verschoben werden. Das gleiche gilt für die Schaltflächen cmdDown <\/b>und cmdBottom<\/b>, wenn der letzte Datensatz im Datenblatt markiert ist. Wenn der Benutzer alle Datensätze markiert, sollen dementsprechend alle vier Schaltflächen deaktiviert sein.<\/p>\n Eine besondere Herausforderung besteht darin, dass beim Wechseln der Markierung im Unterformular Steuer-elemente im Hauptformular geändert sollen. Es ist zwar einfach möglich, dies über eine entsprechende Ereignisprozedur im Unterformular zu realisieren. Diese würde dann etwa über Me.Parent.cmdUp <\/b>auf die Schaltfläche cmdUp <\/b>zugreifen. Schöner und wartungsfreundlicher ist es allerdings, wenn der Code im Hauptformular versammelt ist. Das heißt, dass wir im Hauptformular eine Objektvariable zum Referenzieren des Unterformulars deklarieren und für diese Objektvariable die Ereignisse implementieren, die normalerweise im Klassenmodul des Unterformulars gelandet wären.<\/p>\n Die Schaltflächen sollen in Abhängigkeit von den aktuell markierten Einträgen des Unterformulars aktiviert und deaktiviert werden. Das Problem dabei ist, dass wir erst noch ein Ereignis finden müssen, dass beim Setzen der Markierung im Unterformular ausgelöst wird. Das Ereignis Bei Markierungsänderung <\/b>hört sich spannend an, aber es kann nur in der veralteten PivotChart<\/b>– oder PivotTable<\/b>-Ansicht eingesetzt werden.<\/p>\n Also nutzen wir die Bei Maustaste auf<\/b>-Ereigniseigenschaft eines der Bereiche des Unterformulars. Wir finden schnell heraus, dass dieses Ereignis für das Formular selbst ausgelöst wird, wenn wir auf einen der Datensatzmarkierer klicken, also auf den in Bild 2 markierten Bereich. Im Unterformular selbst sieht die Ereignisprozedur wie folgt aus:<\/p>\n Bild 2: Bereich, der das Ereignis OnMouseDown auslöst<\/span><\/b><\/p>\n Wir wollen diese allerdings im Klassenmodul des Hauptformulars implementieren. Dazu deklarieren wir die Variable sfm <\/b>wie folgt:<\/p>\n Bei dieser Gelegenheit deklarieren wir direkt drei Konstanten, die später oft verwendete Bezeichnungen enthalten – für die Tabelle, das Primärschlüsselfeld der Tabelle und das Feld, nach dem die Sortierung erfolgt, in diesem Fall ReihenfolgeID<\/b>:<\/p>\n Auf diese Weise können Sie, wenn Sie den Code dieser Lösung in anderen Formularen einsetzen wollen, schnell die Bezeichnungen der von Ihnen verwendeten Tabelle und Felder angeben.<\/p>\n Danach füllen wir diese Variable in der Prozedur, die durch das Ereignis Beim Laden <\/b>des Hauptformulars ausgelöst wird, wie folgt:<\/p>\n Die zweite Anweisung stellt per Code die Eigenschaft Bei Maustaste auf <\/b>des Unterformulars auf den Wert [Ereignisprozedur] <\/b>ein – diesen Schritt würden Sie normalerweise über das Eigenschaftenblatt erledigen.<\/p>\n Die Prozedur FillOrderID <\/b>füllt das in m_Orderfield <\/b>angegebene Feld der Tabelle aus m_Table <\/b>mit durchlaufenden Werten von 1 <\/b>bis zur Anzahl der enthaltenen Datensätze.<\/p>\n Diese Prozedur beschreiben wir ausführlich im Beitrag Listenfeld: Reihenfolge mehrerer Einträge ändern <\/b>(www.access-im-unternehmen.de\/1197<\/b>).<\/p>\n Nun hinterlegen wir eine Ereignisprozedur für das Ereignis Bei Maustaste ab <\/b>des Unterformulars.<\/p>\n Dazu wählen Sie im Codefenster des Moduls Form_frmMehrfachreihenfolgeDatenblatt <\/b>aus dem linken Kombinationsfeld den Wert m_SubForm <\/b>und aus dem rechten Kombinationsfeld den Wert MouseUp<\/b> aus (siehe Bild 3).<\/p>\n Bild 3: Anlegen des Ereignisses für das Unterformular<\/span><\/b><\/p>\n Damit das Ereignis auch ausgelöst wird, müssen Sie für das Unterformular noch ein Klassenmodul anlegen. Dazu können Sie einfach die Eigenschaft Enthält Modul <\/b>des als Unterformular verwendeten Formulars auf Ja <\/b>einstellen.<\/p>\n Die so entstandene Prozedur, die wie folgt aussieht, müssen wir nun noch mit dem Code füllen, der die Markierung prüft und die Schaltflächen aktiviert oder deaktiviert. Diesen Code lagern wir in eine neue Prozedur namens ActivateControls <\/b>aus:<\/p>\n Hier geben wir testweise erst einmal die Werte der Eigenschaften SelTop <\/b>und SelHeight <\/b>im Direktbereich aus, um zu prüfen, ob diese die entsprechenden Werte zur durchgeführten Markierung liefern:<\/p>\n Das gelingt auch recht gut. Die Eigenschaft SelTop <\/b>liefert immer den 1-basierten Index des ersten markierten Eintrags, die Eigenschaft SelHeight <\/b>die Anzahl der markierten Einträge. Wenn Sie etwa erst auf den Datensatzmarkierer des zweiten Eintrags klicken und dann bei gedrückter Umschalt<\/b>-Taste auf den fünften Eintrag, werden vier Einträge vom zweiten bis zum fünften Eintrag markiert (siehe Bild 4).<\/p>\n Bild 4: Markieren mehrerer Einträge<\/span><\/b><\/p>\n Die Eigenschaft SelTop <\/b>liefert dann den Wert 2<\/b>, die Eigenschaft SelHeight <\/b>den Wert 4<\/b>. Sie können auch mehrere Datensätze markieren, indem Sie auf den Datensatzmarkierer des ersten zu markierenden Datensatzes klicken und dann bei gedrückter linker Maustaste den Mauszeiger bis zum Datensatzmarkierer des letzten gewünschten Datensatzes herunterziehen.<\/p>\n Hier gibt es noch ein paar Besonderheiten:<\/p>\n Bild 5: Markieren des letzten Eintrags<\/span><\/b><\/p>\n Bild 6: Anklicken des Bereichs zwischen zwei Datensätzen<\/span><\/b><\/p>\n Um den neuen, leeren Datensatz zu berücksichtigen, müssen wir zunächst einmal herausfinden, ob dieser überhaupt eingeblendet wird. Dies gelingt mit der Eigenschaft AllowEditions<\/b>.<\/p>\n Diese fragen wir als Eigenschaft des Unterformulars ab, also etwa mit Me!sfm.Form.AllowAdditions<\/b> und in unserem Fall mit m_SubForm.AllowAdditions<\/b>. Wenn der Benutzer das Hinzufügen von Datensätzen erlaubt, liefert die Eigenschaft den Wert True<\/b>, sonst False<\/b>.<\/p>\n Damit ergeben sich zwei Fälle:<\/p>\n Im zweiten Fall können wir als einfach die von SelLength <\/b>gelieferte Anzahl verwenden. Im ersten Fall müssen wir jedoch prüfen, ob der Index eines der markierten Einträge der Index des neuen, leeren Datensatzes ist. Und dazu benötigen Sie die Anzahl der Datensätze des Unterformulars.<\/p>\n Die Anzahl der Datensätze ermitteln wir ganz einfach mit der Eigenschaft RecordCount <\/b>des Recordset-Objekts des Unterformulars:<\/p>\n Mit diesen Erkenntnissen können wir uns nun um die Prozedur ActivateControls <\/b>kümmern (siehe Listing 1). In dieser aktivieren wir nun zuerst alle Schaltflächen durch Einstellen der Eigenschaft Enabled <\/b>auf den Wert True<\/b>.<\/p>\n Listing 1: Prozedur zum Aktivieren und Deaktivieren der Schaltflächen<\/span><\/b><\/p>\n Dann ermitteln wir die Anzahl der enthaltenen Datensätze und speichern sie in der Variablen lngAnzahl<\/b>. Die beiden Variablen bolErster <\/b>und bolLetzter<\/b> verwenden wir, um einzustellen, dass der Benutzer den ersten und\/oder letzten Datensatz markiert hat.<\/p>\n Anschließend prüfen wir, ob die Eigenschaft SelTop<\/b> den Wert 1 <\/b>aufweist, was schon einmal bedeutet, dass der erste Datensatz markiert ist. Also stellen wir die Variable bolErster <\/b>auf den Wert True <\/b>ein.<\/p>\n Dann unterscheiden wir nach dem Wert der Eigenschaft AllowEditions<\/b>, wie es weitergeht. Hat sie den Wert True<\/b>, prüfen wir, ob der Ausdruck m_SubForm.SelTop + m_SubForm.SelHeight – 1 >= lngAnzahl <\/b>wahr ist.<\/p>\n Wir ermitteln im ersten Teil also den Index des letzten markierten Eintrags und prüfen, ob dieser größer oder gleich der Anzahl der Recordsets im Unterformular ist. Ist das der Fall, erhält bolLetzter <\/b>den Wert True<\/b>. Im Else<\/b>-Teil prüfen wir mit einer ähnlichen Bedingung, die sich nur im Vergleichsoperator von der ersten unterscheidet, ob der Index des letzten markierten Eintrags der Anzahl der Recordsets entspricht und legen dann den Wert von bolLetzter <\/b>auf True <\/b>fest.<\/p>\n <\/p>\n Wenn kein Eintrag markiert ist, SelHeight <\/b>also den Wert 0 <\/b>liefert, rufen wir direkt die beiden Prozeduren DisableUp <\/b>und DisableDown <\/b>auf, damit die Schaltflächen deaktiviert werden. Anderenfalls rufen wir DisableUp <\/b>nur auf, wenn bolErster <\/b>den Wert True <\/b>hat und DisableDown <\/b>nur dann, wenn bolLetzter <\/b>den Wert True <\/b>hat.<\/p>\n Die beiden Prozeduren DisableUp <\/b>und DisableDown <\/b>deaktivieren nur jeweils die entsprechenden Schaltflächen:<\/p>\n Damit haben wir die Aktivierung und Deaktivierung der Schaltlfächen erledigt. Diese reagieren jetzt wie gewünscht – siehe Bild 7:<\/p>\n Bild 7: Aktivieren und Deaktivieren der Schaltflächen abhängig von den markierten Datensätzen<\/span><\/b><\/p>\n Allein beim Öffnen des Formulars werden die Schaltflächen noch nicht richtig eingestellt. Das ändern wir, indem wir der Ereignisprozedur Beim Laden <\/b>noch den Aufruf von ActivateControls <\/b>hinzufügen:<\/p>\n Wenn der Benutzer die Tastenkombination Strg + A <\/b>verwendet, um alle Datensätze des Datenblatts zu markieren, werden die Schaltflächen nicht automatisch deaktiviert. Dazu müssen wir eine weitere Ereignisprozedur hinzufügen, die durch ein Tastenereignis ausgelöst wird. Welches aber verwenden wir hier Wenn wir uns ansehen, wann beim Betätigen von Strg + A <\/b>die Datensätze markiert werden, stellen wir fest, dass dies bereits beim Herunterdrücken der Tastenkombination geschieht. Also können wir das Aktivieren und Deaktivieren der Schaltflächen für das Ereignis Bei Taste auf <\/b>auslösen, denn dann liegt ja schon die zu untersuchende Markierung vor.<\/p>\n Die nächste Frage ist, für welche Elemente wir die Ereignisprozedur einrichten müssen. Dazu legen wir Ereignisprozeduren für alle in Frage kommenden Elemente fest und lassen uns den Namen des Elements im Direktbereich ausgeben:<\/p>\n Das Ergebnis ist: Das Ereignis wird immer für das zuletzt aktivierte Steuer-element im Unterformular ausgelöst. Wenn nach dem Öffnen des Formulars noch kein Steuer-element aktiviert wurde, weil der Benutzer etwa auf die Navigationsschaltflächen geklickt hat, wird automatisch das erste gebundene Steuerelement verwendet, in diesem Fall das Textfeld zur Anzeige des Feldes KategorieID<\/b>. Das heißt, wir müssen für alle Steuer-elemente des Unterformulars Ereignisprozeduren definieren, welche die Prozedur ActivateControls <\/b>aufrufen. Das ist mehr Aufwand als erwartet, vor allem, wenn wir den Programmcode auch für das Unterformular und seine Steuer-elemente komplett im Klassenformular des Hauptformulars unterbringen wollen. Wir müssten dann für jedes Steuer-element eine entsprechende Objektvariable unterbringen, für die wir dann die Ereignisprozedur Bei Taste Ab <\/b>implementieren.<\/p>\n Aber wir benötigen noch ein weiteres Ereignis, nämlich Bei Maustaste ab<\/b>: Denn auch, wenn der Benutzer mit der Maus in eines der Felder klickt, kann es sein, dass dadurch die Markierung verändert wird.<\/p>\n Für unseren Fall lagern wir den Code in ein Klassenmodul aus, das die gewünschte Funktionalität bereitstellt, und legen von dieser Klasse für jedes Steuer-element im Unterformular eine Instanz an. Diese sammeln wir dann in einer Collection, damit sie nach dem Erstellen nicht verloren gehen. Die Klasse sieht wie in Listing 2 aus.<\/p>\n Listing 2: Inhalt des Klassenmoduls clsControlWrapper<\/span><\/b><\/p>\n Dort deklarieren wir im Kopf einige Variablen. Die erste nimmt einen Verweis auf das gebundene Steuer-element auf, das wir mit Ereignisprozeduren versehen wollen, die zweite einen Verweis auf das Hauptformular. Diesen benötigen wir, weil sich die Prozedur, die wir über die Ereignisprozedur aufrufen wollen, im Klassenmodul des Formulars befindet. m_Form <\/b>werden wir mit einem Verweis auf dieses füllen, damit wir auf die Prozedur Activate-Controls <\/b>zugreifen können.<\/p>\n Die drei weiteren Variablen sollen je nach Steuerelementtyp einen Verweis auf das Steuer-element aufnehmen. Das erledigen wir in der öffentlichen Property Set<\/b>-Eigenschaft Control. Diese nimmt über den Parameter ctl <\/b>einen Verweis auf das gebundene Steuer-element entgegen. Dann prüft sie in einer Select Case<\/b>-Bedingung, ob es sich um ein TextBox<\/b>-, ein ComboBox<\/b>– oder ein CheckBox<\/b>-Steuerelement handelt. Je nach Steuerelementtyp wird entweder die Variable txt<\/b>, cbo <\/b>oder chk <\/b>mit der Variablen aus ctl <\/b>gefüllt.<\/p>\n Außerdem legt die Prozedur für die entsprechende, mit dem Schlüsselwort WithEvents <\/b>deklarierte Variable die Eigenschaften OnKeyUp <\/b>und OnMouseUp <\/b>auf den Wert [Event Procedure] <\/b>fest. <\/p>\n Die Property Set<\/b>-Prozedur Form <\/b>nimmt mit dem Parameter frm <\/b>einen Verweis auf das Hauptformular fest.<\/p>\n Von den drei Ereignisprozeduren cbo_KeyUp<\/b>, chk_KeyUp <\/b>und txt_KeyUp <\/b>verwendet jede Instanz der Klasse nur eine, denn es wird ja nur einer der drei Steuerelementtypen zugewiesen. Die Prozeduren enthalten aber den gleichen Code. Die erste Anweisung prüft, ob der Benutzer gerade die Taste A <\/b>(Parameter KeyCode <\/b>gleich 65<\/b>) bei gedrückter Umschalttaste (Parameter Shift <\/b>gleich acCtrlMask<\/b>) betätigt hat. Nur in diesem Fall wird in dem mit frm <\/b>referenzierten Hauptformular die Prozedur ActivateControls <\/b>aufgerufen. Damit die Prozedur ActivateControls <\/b>im Klassenmodul des Hauptformulars überhaupt von der Klasse aus aufgerufen werden kann, müssen wir noch das Schlüsselwort Private <\/b>durch Public <\/b>ersetzen:<\/p>\n Danach brauchen wir nur noch ein paar zusätzliche Anweisungen in der Form_Load<\/b>-Ereignisprozedur des Hauptformulars sowie eine Variable für die Collection. Diese deklarieren wir im Klassenmodul Form_MehrfachreihenfolgeDatenblatt <\/b>wie folgt:<\/p>\n Die Prozedur Form_Load <\/b>erweitern wir wie folgt, damit für jedes der gebundenen Steuer-elemente im Unterformular eine Instanz der Klasse clsControlWrapper <\/b>erzeugt wird. Als Erstes benötigen wir drei neue Variablen namens strControlSource<\/b>, objControlWrapper<\/b> und ctl<\/b>. Erstere dient der Prüfung, ob es sich bei einem Steuer-element um ein gebundenes Steuer-element handelt. Zweiteres nimmt die neue Instanz der Klasse clsControlWrapper <\/b>auf.<\/p>\n Die letzte Variable ctl <\/b>dient zum Durchlaufen der Steuer-elemente des Unterformulars:<\/p>\n In der Prozedur erstellen wir eine neue Collection zum Speichern der Instanzen von clsControlWrapper<\/b>:<\/p>\n Dann durchlaufen wir alle Steuer-elemente des Unterformulars und stellen die Variable strControlSource <\/b>zunächst auf eine leere Zeichenkette ein. Bei deaktivierter Fehlerbehandlung versuchen wir dann, diese mit dem Inhalt der Eigenschaft ControlSource <\/b>des jeweiligen Steuerelements zu füllen.<\/p>\n Ist das Steuer-element nicht gebunden, löst dies einen Fehler aus, daher die ausgeschaltete Fehlerbehandlung. Anschließend prüfen wir, ob strControlSource <\/b>mit einem Wert gefüllt wurde – in diesem Fall handelt es sich um ein gebundenes Steuer-element. Wir erstellen dann eine neue Instanz der Klasse clsControlWrapper <\/b>und speichern diese in der Variablen objControlWrapper<\/b>.<\/p>\n Danach weisen wir die Referenzen auf das Steuer-element und das Hauptformular zu und fügen die neue Instanz aus der Objektvariablen zur Collection colControlWrappers <\/b>hinzu:<\/p>\nSELECT tblKategorien.KategorieID, tblKategorien.Kategoriename, tblKategorien.ReihenfolgeID FROM tblKategorien ORDER BY tblKategorien.ReihenfolgeID;<\/pre>\n
Beschreibung der Aufgabe<\/h2>\n
Aktivieren und Deaktivieren der Schaltflächen<\/h2>\n
![\"Bereich,](\"..\/fileadmin\/_temp_\/2019_04\/pic_1198_002.png\")
<\/p>\nPrivate Sub <\/span>Form_MouseUp(Button As Integer<\/span>, _\r\n Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\nEnd Sub<\/span><\/pre>\nDim <\/span>WithEvents m_SubForm As <\/span>Form<\/pre>\nConst m_Table As String<\/span> = \"tblKategorien\"\r\nConst m_PKField As String<\/span> = \"KategorieID\"\r\nConst m_Orderfield As String<\/span> = \"ReihenfolgeID\"<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> m_SubForm = Me!sfm.Form\r\n m_SubForm.OnMouseUp = \"[Event Procedure]\"\r\n FillOrderID\r\nEnd Sub<\/span><\/pre>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2019_04\/pic_1198_003.png\")
<\/p>\nMarkierte Datensätze erkennen<\/h2>\n
Private Sub <\/span>m_SubForm_MouseDown(Button As Integer<\/span>, _\r\n Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n ActivateControls\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>ActivateControls()\r\n Debug.Print<\/span> m_SubForm.SelTop, m_SubForm.SelHeight\r\nEnd Sub<\/span><\/pre>\n![\"Markieren](\"..\/fileadmin\/_temp_\/2019_04\/pic_1198_005.png\")
<\/p>\n\n
![\"Markieren](\"..\/fileadmin\/_temp_\/2019_04\/pic_1198_004.png\")
<\/p>\n![\"Anklicken](\"..\/fileadmin\/_temp_\/2019_04\/pic_1198_006.png\")
<\/p>\nNeuen Datensatz berücksichtigen<\/h2>\n
\n
Anzahl der Datensätze im Unterformular ermitteln<\/h2>\n
m_SubForm.Recordset.RecordCount<\/pre>\n
Schaltflächen aktivieren und deaktivieren<\/h2>\n
Private Sub <\/span>ActivateControls()\r\n Dim <\/span>bolErster As Boolean<\/span>, bolLetzter As Boolean<\/span>\r\n Dim <\/span>lngAnzahl As Long<\/span>\r\n Me!cmdBottom.Enabled = True<\/span>\r\n Me!cmdDown.Enabled = True<\/span>\r\n Me!cmdTop.Enabled = True<\/span>\r\n Me!cmdUp.Enabled = True<\/span>\r\n lngAnzahl = m_SubForm.Recordset.RecordCount\r\n If <\/span>m_SubForm.SelTop = 1 Then<\/span>\r\n bolErster = True<\/span>\r\n End If<\/span>\r\n If <\/span>m_SubForm.AllowAdditions = True<\/span> Then<\/span>\r\n If <\/span>m_SubForm.SelTop + m_SubForm.SelHeight - 1 >= lngAnzahl Then<\/span>\r\n bolLetzter = True<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n If <\/span>m_SubForm.SelTop + m_SubForm.SelHeight - 1 = lngAnzahl Then<\/span>\r\n bolLetzter = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n If <\/span>m_SubForm.SelHeight = 0 Then<\/span>\r\n DisableUp\r\n DisableDown\r\n Else<\/span>\r\n If <\/span>bolErster Then<\/span>\r\n DisableUp\r\n End If<\/span>\r\n If <\/span>bolLetzter Then<\/span>\r\n DisableDown\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>DisableUp()\r\n Me!cmdUp.Enabled = False<\/span>\r\n Me!cmdTop.Enabled = False<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>DisableDown()\r\n Me!cmdDown.Enabled = False<\/span>\r\n Me!cmdBottom.Enabled = False<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Aktivieren](\"..\/fileadmin\/_temp_\/2019_04\/pic_1198_007.png\")
<\/p>\n\n
Private Sub <\/span>Form_Load()\r\n Set<\/span> m_SubForm = Me!sfm.Form\r\n m_SubForm.OnMouseUp = \"[Event Procedure]\"\r\n FillOrderID\r\n ActivateControls\r\nEnd Sub<\/span><\/pre>\nSchaltflächen Deaktivieren bei Strg + A<\/h2>\n
Private Sub <\/span>Form_KeyDown(...)\r\n Debug.Print<\/span> \"Form\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>KategorieID_KeyDown(...)\r\n Debug.Print<\/span> \"KategorieID\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Kategoriename_KeyDown(...)\r\n Debug.Print<\/span> \"Kategoriename\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>ReihenfolgeID_KeyDown(...)\r\n Debug.Print<\/span> \"ReihenfolgeID\"\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>m_Control As <\/span>Control\r\nPrivate <\/span>m_Form As <\/span>Form\r\nPrivate <\/span>WithEvents txt As <\/span>TextBox\r\nPrivate <\/span>WithEvents cbo As <\/span>ComboBox\r\nPrivate <\/span>WithEvents chk As <\/span>CheckBox\r\nPublic Property Set<\/span> <\/span>Control(ctl As <\/span>Control)\r\n Set<\/span> m_Control = ctl\r\n Select Case m_Control.ControlType\r\n Case <\/span>acTextBox\r\n Set<\/span> txt = ctl\r\n With<\/span> txt\r\n .OnKeyUp = \"[Event Procedure]\"\r\n .OnMouseUp = \"[Event Procedure]\"\r\n End With<\/span>\r\n Case <\/span>acComboBox\r\n Set<\/span> cbo = ctl\r\n With<\/span> cbo\r\n .OnKeyUp = \"[Event Procedure]\"\r\n .OnMouseUp = \"[Event Procedure]\"\r\n End With<\/span>\r\n Case <\/span>acCheckBox\r\n Set<\/span> chk = ctl\r\n With<\/span> chk\r\n .OnKeyUp = \"[Event Procedure]\"\r\n .OnMouseUp = \"[Event Procedure]\"\r\n End With<\/span>\r\n End Select<\/span>\r\nEnd Property<\/span>\r\nPublic Property Set<\/span> <\/span>Form(frm As <\/span>Form)\r\n Set<\/span> m_Form = frm\r\nEnd Property<\/span>\r\nPrivate Sub <\/span>cbo_KeyUp(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n If <\/span>KeyCode = 65 And Shift = acCtrlMask Then<\/span>\r\n m_Form.ActivateControls\r\n End If<\/span>\r\nEnd Sub<\/span>\r\n... gleiche Prozedur für chk_KeyUp und txt_KeyUp ...\r\nPrivate Sub <\/span>cbo_MouseUp(Button As Integer<\/span>, Shift As <\/span>_\r\n Integer, X As Single<\/span>, Y As Single<\/span>)\r\n m_Form.ActivateControls\r\nEnd Sub<\/span>\r\n... gleiche Prozedur für cbo_MouseUp und txt_MouseUp ...<\/pre>\nPublic Sub <\/span>ActivateControls()\r\n ...\r\nEnd Sub<\/span><\/pre>\nDim <\/span>colControlWrappers As <\/span>Collection<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Dim <\/span>strControlSource As String<\/span>\r\n Dim <\/span>objControlWrapper As <\/span>clsControlWrapper\r\n Dim <\/span>ctl As <\/span>Control\r\n Set<\/span> m_SubForm = Me!sfm.Form\r\n m_SubForm.OnMouseUp = \"[Event Procedure]\"\r\n FillOrderID\r\n ActivateControls<\/pre>\n Set<\/span> colControlWrappers = New<\/span> Collection<\/pre>\n For Each ctl In Me!sfm.Form.Controls\r\n strControlSource = \"\"\r\n On Error Resume Next<\/span>\r\n strControlSource = ctl.ControlSource\r\n On Error GoTo<\/span> 0\r\n If <\/span>Not<\/span> Len<\/span>(strControlSource) = 0 Then<\/span>\r\n Set<\/span> objControlWrapper = New<\/span> clsControlWrapper\r\n With<\/span> objControlWrapper\r\n