<\/p>\n
In der Datenblattansicht lassen sich ja bereits eine Menge Dinge erledigen – Daten einfügen, löschen, bearbeiten, kopieren, ausschneiden … Sie können sogar komplette Bereiche kopieren und in andere Bereiche einfügen, sofern diese Bereiche zueinander kompatibel sind, und Access ist hier recht tolerant. Was aber fehlt, ist die Markierung eines Zielbereichs, dessen Felder dann alle mit dem gleichen Wert gefüllt werden. Wenn Sie also etwa für alle Datensätze ein Ja\/Nein-Feld anhaken möchten, müssen Sie dies immer noch manuell erledigen. Dieser Beitrag zeigt eine passende Lösung für Datenblätter in Formularen und Unterformularen.<\/b><\/p>\n
Wenn Sie einen Bereich eines Formulars oder Unterformulars in der Datenblattansicht mit den gleichen Werten füllen wollten, waren Sie bislang auf zwei Möglichkeiten angewiesen:<\/p>\n
Letzteres geschieht für eine bessere Effizienz am besten so, dass man eine gewisse Menge Felder mit dem Wert füllt (sagen wir zehn untereinander liegende Felder), dann diesen Bereich kopiert und in eine Markierung unter den gefüllten Feldern mit einer Spalte Breite und zehn Zeilen Höhe wieder einfügt. Wenn man viele Felder füllen muss, kann man nochmal größere Bereiche markieren und kopieren und dann in entsprechend größere Bereiche einfügen.<\/p>\n
Der Nachteil: Man müsste immer ungefähr die gewünschte Menge Felder ermitteln, damit alle kopierten Werte dort hineinpassen. Der Vorteil: Access ist beim Einfügen nicht pingelig, die Größe von Quell- und Zielfeldern muss nicht unbedingt übereinstimmen. Das heißt, wenn Sie beispielsweise zehn Felder in einen Bereich von weniger als zehn Feldern einfügen, dann werden nur die markierten Felder gefüllt.<\/p>\n
Wenn der Zielbereich größer ist als der Quellbereich, dann werden ebenfalls nur die entsprechend dem kopierten Bereich gefüllt.<\/p>\n
Befriedigend ist das alles nicht: Fehler können so leicht auftreten, sei es durch das Auslassen eines zu füllenden Feldes oder durch überschreiben von Bereichen, die gar nicht geändert werden sollen. Es wäre also am einfach-sten, wenn man etwa die in Bild 1 markierten Felder mit einem Klick etwa aktivieren oder deaktivieren oder mit einem Wert füllen könnte.<\/p>\n
![\"Das](\"..\/fileadmin\/_temp_\/2016_01\/pic_1022_001.png\")
<\/p>\n
Bild 1: Das wäre schön: Die markierten Felder alle mit einem Schlag beispielsweise aus- oder abwählen<\/span><\/b><\/p>\n Ein viel besserer Ansatz wäre etwa ein Kontextmenü-Eintrag, den man für eine Markierung in der Datenblattansicht auswählen kann und der dann eine InputBox <\/b>öffnet, der man den einzufügenden Wert übergibt. Nach Betätigen der OK<\/b>-Schaltfläche soll dieser Wert in alle markierten Zellen eingefügt werden. Dabei soll es keine Rolle spielen, wie groß die Markierung ist – es sollen also sowohl mehrere Spalten als auch mehrere Zeilen markierbar sein, auch in Kombination miteinander. Noch schöner wäre es, wenn ein in der Zwischenablage befindlicher Wert gleich als Standardwert in der InputBox <\/b>angezeigt würde.<\/p>\n Dies gilt es nun zu realisieren – machen wir uns ans Werk!<\/p>\n Die fertige Lösung wird in Form einer Klasse kommen, die alle notwendigen Funktionen liefert. Die Klasse heißt clsDatasheetInsert <\/b>und sollte in dem Hauptformular, welches das in der Datenblattansicht erscheinende Unterformular enthält, mit der Objektvariablen objDatasheetInsert<\/b> deklariert werden:<\/p>\n In die Prozedur, die durch das Ereignis Beim Laden <\/b>des Hauptformulars ausgelöst wird, fügen wir die folgenden Anweisungen ein:<\/p>\n Die erste Anweisung instanziert das neue Objekt und speichert einen Verweis darauf in der Variablen objData-sheetInsert<\/b>. Die Anweisung innerhalb des With<\/b>-Konstrukts weist der Eigenschaft Form <\/b>des Objekts einen Verweis auf das Unterformular in der Datenblattansicht zu, das mit den Funktionen zum Füllen mehrerer Felder gleichzeitig versehen werden soll.<\/p>\n Danach können Sie dann wie in Bild 2 die Zielfelder markieren, mit der rechten Maustaste das Kontextmenü aufrufen und dann den Eintrag Wert einfügen <\/b>auswählen, um die gewünschten Daten in die markierten Felder einzufügen.<\/p>\n Bild 2: Einfügen von Werten per Kontextmenü<\/span><\/b><\/p>\n Für diese Funktion benötigen wir zunächst einmal einen Kontextmenü-Eintrag – und zwar nicht in irgendeinem Kontextmenü, sondern genau in dem, das beim Rechtsklick auf eines der Felder oder auf mehrere markierte Felder erscheint.<\/p>\n Für einen groben überblick, um welches Kontextmenü es sich handeln könnte, schauen wir uns die Liste aller Commandbar<\/b>-Objekte an, die den Typ msoBarTypePopup <\/b>aufweisen. Das erledigt die folgende Prozedur, welche die Namen der Kontextmenüs im Direktbereich ausgibt (für diese und weitere Prozeduren benötigen Sie einen Verweis auf die Bibliothek Microsoft Office x.0 Object Library <\/b>– s. Bild 3):<\/p>\n Bild 3: Verweis auf die Office-Bibliothek<\/span><\/b><\/p>\n Hier erscheinen gleich zu Beginn die folgenden beiden Einträge:<\/p>\n Nun müssen wir nur noch herausfinden, welches der beiden Kontextmenüs beim Anklicken eines Feldes im Datenblatt erscheint. Dazu legen wir einfach in allen betroffenen Kontextmenüs einen neuen Eintrag an, der den Namen des Kontextmenüs trägt:<\/p>\n Die Set cbr …<\/b>-Anweisung referenziert jeweils eines der betroffenen Kontextmenüs, die Set cbb …<\/b>-Anweisung fügt ein neues Steuerelement des Typs msoControlButton <\/b>hinzu. über die Caption<\/b>-Eigenschaft legt die Prozedur die Beschriftung des jeweiligen Eintrags fest.<\/p>\n Danach klicken wir einfach mit der rechten Maustaste auf das gewünschte Element im Datenblatt und erhalten ganz unten die Antwort auf unsere Frage: Das Kontextmenü Form Datasheet Cell<\/b> ist unser gesuchtes Objekt (s. Bild 4).<\/p>\n Bild 4: Ermitteln des Kontextmenüs für das Datenblatt<\/span><\/b><\/p>\n Weiter oben haben wir ja bereits erläutert, dass wir die Funktionalität zum Einfügen von Daten in mehrere Felder gleichzeitig in einer Klasse kapseln möchten. Das hat den Vorteil, dass Sie den Code ganz einfach in mehreren Formularen wiederverwenden können.<\/p>\n Diese Klasse heißt clsDatasheetFill <\/b>und enthält eine Property Set<\/b>-Prozedur, die einen Verweis auf das zu unterstützende Formular erwartet. Diesen Verweis speichert die Klasse in der wie folgt im Klassenmodul deklarierten Variablen:<\/p>\n Die Prozedur selbst finden Sie in Listing 1. Sie trägt zuerst den Verweis auf das per Parameter übergebene Formular-Objekt in die Variable m_Form <\/b>ein. Dann sorgt sie noch für die Erweiterung des Kontextmenüs um einen Eintrag mit dem Text Wert einfügen<\/b>. Dazu füllt sie die Variable cbr <\/b>mit einem Verweis auf das Element Form Datasheet Cell <\/b>der CommandBars<\/b>-Auflistung.<\/p>\n Listing 1: Einrichten des Kontextmenüs<\/span><\/b><\/p>\n Anschließend durchläuft sie alle Einträge dieses Kontextmenüs und prüft diese auf die Beschriftung Wert einfügen<\/b>. Sind bereits Einträge mit dieser Beschriftung vorhanden, entfernt die Prozedur diese mit der Delete<\/b>-Methode des jeweiligen Elements. Danach legt sie diesen Eintrag neu an und speichert einen Verweis darauf in der Variablen cbbInsert<\/b>. Die folgende Anweisung stellt nur noch die Beschriftung auf Wert einfügen <\/b>ein.<\/p>\n Die Variable cbbInsert <\/b>wurde noch nicht deklariert. Da wir für den neu hinzugefügten Eintrag zum Kontextmenü auch eine Ereignisprozedur hinterlegen möchten, die beim Anklicken des Eintrags ausgelöst wird, benötigen wir noch eine entsprechende, mit dem Schlüsselwort WithEvents <\/b>ausgestattete Variable.<\/p>\n Auch diese landet wieder im Kopf des Klassenmoduls:<\/p>\n Wie legen Sie nun die benötigte Ereignisprozedur an Dazu wählen Sie einfach im Klassenmodul im linken Kombinationsfeld den Eintrag cbbInsert<\/b> aus, der dort nur deshalb erscheint, weil Sie die Objektvariable mit With-Events <\/b>deklariert haben. Nun erscheint im rechten Kombinationsfeld das Standardereignis Click <\/b>(im übrigen auch das einzige Ereignis dieses Objekts) und der VBA-Editor legt die passende Ereignisprozedur an (s. Bild 5).<\/p>\n Bild 5: Anlegen einer Ereignisprozedur, die beim Anklicken eines Kontextmenü-Eintrags ausgelöst wird<\/span><\/b><\/p>\n Diese Prozedur ergänzen Sie nun wie in Listing 2. Die Prozedur fragt per Inputbox den einzufügenden Inhalt ab. Dabei verwendet sie als Standardwert einen Wert, den die Funktion AusZwischenablage <\/b>liefert.<\/p>\n Listing 2: Die Ereignisprozedur, die beim Auswählen des Kontextmenü-Eintrags ausgelöst wird<\/span><\/b><\/p>\n Diese finden Sie im Modul mdlTools<\/b>. Die Funktion gibt den aktuellen Inhalt der Zwischenablage zurück. Auf diese Weise könnte der Benutzer wie gewohnt den einzufügenden Text per Strg + C <\/b>oder mit dem Kontextmenü-Befehl Kopieren <\/b>ermitteln.<\/p>\n <\/p>\n Enthält die Variable strInhalt <\/b>nach dem Eintragen des Ergebnisses der InputBox<\/b>-Funktion keine leere Zeichenfolge, stellt die Prozedur die Variable bolFill <\/b>auf den Wert True <\/b>ein. Falls nicht, soll die Prozedur prüfen, ob der Benutzer vielleicht einfach nur die Abbrechen<\/b>-Schaltfläche betätigt hat (was ebenfalls eine leere Zeichenkette zurückliefert) oder ob er tatsächlich eine leere Zeichenkette eingegeben hat, um die markierten Felder der Datenblattansicht zu leeren beziehungsweise mit einer leeren Zeichenkette zu füllen. Wählt der Benutzer hier die Antwort Ja <\/b>(vbYes<\/b>), wird bolFill <\/b>ebenfalls auf True <\/b>eingestellt. Hat bolFill<\/b> im Anschluss den Wert True<\/b>, ruft die Prozedur die Routine Fill <\/b>mit dem einzusetzenden Wert aus der Variablen strInhalt <\/b>als Parameter auf.<\/p>\n Nun folgt der interessante Teil der Lösung. Hier benötigen wir zunächst einen Ansatz, um die markierten Felder zu füllen.<\/p>\n Um die entsprechenden Inhalte zu ändern, gibt es zwei Wege:<\/p>\n Für die erste Variante müssten wir jeweils den Namen des Feldes ermitteln sowie den Primärschlüsselwert des Datensatzes mit dem zu ändernden Feld.<\/p>\n Beides ist mit erhöhtem Aufwand verbunden, da wir zum Beispiel den Namen des Primärschlüsselfeldes ermitteln müssten, um dann mit dem Primärschlüsselwert auf den zu ändernden Datensatz zuzugreifen.<\/p>\n Die zweite Variante erscheint etwas intuitiver, da sie keinen direkten Zugriff auf die zugrunde liegenden Daten erfordert, sondern über die Benutzeroberfläche auf die zu ändernden Felder zugreift.<\/p>\n In beiden Fällen müssen wir die aktuelle Markierung zum Zeitpunkt der Betätigung des Kontextmenü-Eintrags ermitteln. Dies scheint relativ einfach zu sein – wozu gibt es schließlich die Eigenschaften SelTop<\/b>, SelLeft<\/b>, SelHeight <\/b>und SelWidth <\/b>des Form<\/b>-Objekts<\/p>\n Leider liefern diese Eigenschaften etwas merkwürdige Werte, wie folgende Beispiele zeigen:<\/p>\n Der Index von links aus gesehen scheint mit dem Wert 2 <\/b>zu beginnen statt mit 1<\/b>, die Breite und Höhe der Markierung wird jeweils mit dem Wert 0 <\/b>angegeben. Der Rest ist reproduzierbar.<\/p>\n Interessant wird es bei Markierungen mit mehreren Feldern: Hier stimmen die Werte für SelLeft <\/b>und SelTop <\/b>mit denen aus den vorherigen Experimenten überein, allerdings liefert eine Markierung, die etwa zwei Spalten und eine Zeile umfasst, für SelWidth <\/b>den Wert 2<\/b>. Dies passt nicht exakt zu dem Wert für eine Markierung über eine Spalte, wo SelWidth <\/b>den Wert 0 <\/b>annimmt.<\/p>\n Nach einigen weiteren Experimenten wurde klar, woran dies liegt: Wenn Sie beim Markieren eines einzelnen Feldes nur die Einfügemarke im Feld platzieren, haben SelWidth <\/b>und SelHeight <\/b>den Wert 0<\/b>. Erst, wenn Sie das komplette Feld markiert haben, bekommen SelWidth <\/b>und SelHeight <\/b>den Wert 1<\/b>.<\/p>\n Dies ist unter den Standardeinstellungen per Mausklick aber nur zu erreichen, wenn der Mauszeiger beim Anklicken das Plus-Symbol anzeigt – daher erhielten wir beim Testen immer den Wert 0<\/b> (und manchmal zufällig und zu unserer Verwirrung den Wert 1 <\/b>…).<\/p>\n Die bereits erwähnte Prozedur Fill <\/b>finden Sie in Listing 3. Die Prozedur erwartet den einzutragenden Wert als Parameter. Sie ermittelt zunächst die Originalwerte der Eigenschaften SelLeft<\/b>, SelWidth<\/b>, SelTop <\/b>und SelHeight <\/b>der aktuellen Markierung und speichert diese in den Variablen intSelLeftOriginal<\/b>, intSelWidthOriginal<\/b>, intSelTopOriginal <\/b>und intSelHeightOriginal<\/b>. Diese benötigen wir, um die aktuelle Markierung später wieder herzustellen.<\/p>\n Listing 3: Ermitteln, Durchlaufen und Wiederherstellen der Markierung<\/span><\/b><\/p>\n Danach tragen wir die tatsächlichen Abmessungen in die Variablen intSelLeft<\/b>, intSelWidth<\/b>, intSelTop <\/b>und intSelHeight <\/b>ein. Diese weichen dabei unter Umständen von den eigentlichen Werten aus den Eigenschaften SelLeft<\/b>, SelWidth<\/b>, SelTop <\/b>und SelHeight <\/b>ab.<\/p>\n So prüft die Prozedur, ob sich nur die Einfügemarke in einem Feld befindet (SelWidth = 0 <\/b>und SelHeight = 0<\/b>) oder ob ein oder mehrere Felder tatsächlich markiert sind (SelWidth <\/b>und SelHeight <\/b>ungleich 0<\/b>). Enthalten SelWidth<\/b> und SelHeight <\/b>den Wert 0, trägt die Prozedur für intSelWidth <\/b>und intSelHeight <\/b>jeweils den Wert 1 <\/b>ein. Anderenfalls übernimmt sie die vorhandenen Werte der Eigenschaften SelWidth <\/b>und SelHeight<\/b>.<\/p>\n Vom Wert der Eigenschaft SelLeft<\/b>, die ja aus unerfindlichen Gründen immer um eins größer ist als der tatsächliche Spaltenindex, subtrahieren wir den Wert 1 <\/b>und tragen das Ergebnis in intSelLeft <\/b>ein. SelTop <\/b>ist die einzige Eigenschaft, deren Wert wir unverändert in die Variable intSelTop <\/b>übernehmen können.<\/p>\n Damit starten wir in zwei verschachtelte For…Next<\/b>-Schleifen. Die erste durchläuft die Werte von intSelLeft <\/b>(Index der ersten Spalte) bis intSelLeft + intSelWidth -1<\/b> (Index der letzten Spalte) und speichert diese jeweils in der Laufvariablen intColumn<\/b>. Die zweite durchläuft alle markierten Zeilen, also die Werte von intSelTop <\/b>bis intSelTop + intSelHeight -1<\/b>, in der Variablen intRow<\/b>.<\/p>\n Die beiden Schleifen sollen nacheinander die Felder aller Zeilen und Spalten durchlaufen und dabei den Wert aus dem Parameter varWert <\/b>in das jeweils aktuelle Feld eintragen.<\/p>\n In der ersten Schleife stellen wir zunächst die Eigenschaften SelHeight <\/b>und SelWidth <\/b>auf 0 <\/b>ein. Dies hat den Hintergrund, dass man die Werte dieser Eigenschaften nicht auf einen Wert größer als 0 <\/b>verändern kann, solange sie einen Wert größer als 0 <\/b>aufweisen – wir müssen also quasi die Markierung erst auflösen, bevor wir diese neu setzen können. Dann stellt die Prozedur die Eigenschaft SelLeft<\/b> auf den aktuellen Wert von intColumn <\/b>ein und die Breite mit der Eigenschaft SelWidth <\/b>auf 1<\/b> (wir können ja nur ein Feld auf einmal verändern).<\/p>\n Dann in der inneren For…Next<\/b>-Schleife mit der Laufvariablen intRow <\/b>stellt die Prozedur den Wert der Eigenschaft SelTop <\/b>auf den Wert aus intRow <\/b>und den Wert der Eigenschaft SelHeight <\/b>auf 1 <\/b>ein.<\/p>\n Außerdem ruft sie dort die Routine FillValue <\/b>auf und übergibt den einzutragenden Wert. Warum hier noch eine eigene Routine Weil es sonst etwas unübersichtlich wird, denn wir müssen hier noch die verschiedenen Feldtypen behandeln und gegebenenfalls auf Fehler durch bestehende Restriktionen reagieren.<\/p>\n Schließlich soll die Prozedur noch die beim Aufrufen vorhandene Markierung im Datenblatt wiederherstellen. Dazu stellt sie die Eigenschaften SelTop<\/b>, SelLeft<\/b>, SelWidth <\/b>und SelHeight <\/b>wieder auf die in den Variablen intSelTopOriginal<\/b>, intSelLeftOriginal<\/b>, intSelWidth <\/b>und intSelHeight <\/b>ein.<\/p>\n Das Füllen der verschiedenen Steuerelementtypen (Textfeld, Kombinationsfeld und Kontrollkästchen) erledigt die Prozedur FillValues<\/b>, die als Parameter den zu verwendenden Wert erwartet (s. Listing 4).<\/p>\n Listing 4: Füllen des Wertes in die einzelnen Steuerelemente<\/span><\/b><\/p>\n Das zu füllende Steuerelement wurde ja durch die Prozedur Fill <\/b>bereits markiert. Es wird nun über die Funktion Screen.ActiveControl <\/b>ermittelt und mit der Variablen ctl <\/b>referenziert. Je nach dem Steuerelementtyp steuert die Prozedur nun einen der drei Zweige einer Select Case<\/b>-Bedingung an – je einen für die Werte Die Lösung<\/h2>\n
Einsatz der fertigen Lösung<\/h2>\n
Dim <\/span>objDatasheetInsert As <\/span>clsDatasheetInsert<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objDatasheetInsert = New<\/span> clsDatasheetInsert\r\n With<\/span> objDatasheetInsert\r\n Set<\/span> .Form = Me!sfmArtikel.Form\r\n End With<\/span>\r\nEnd Sub<\/span> <\/pre>\n![\"Einfügen](\"..\/fileadmin\/_temp_\/2016_01\/pic_1022_002.png\")
<\/p>\nKontextmenü-Eintrag hinzufügen<\/h2>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2016_01\/pic_1022_004.png\")
<\/p>\nPublic Sub <\/span>CommandbarsAusgeben()\r\n Dim <\/span>cbr As <\/span>Office.CommandBar\r\n For Each cbr In CommandBars\r\n If <\/span>cbr.Type = msoBarTypePopup Then<\/span>\r\n Debug.Print<\/span> cbr.Name\r\n End If<\/span>\r\n Next<\/span> cbr\r\nEnd Sub<\/span><\/pre>\n\n
Public Sub <\/span>CommandbarsTesten()\r\n Dim <\/span>cbr As <\/span>Office.CommandBar\r\n Dim <\/span>cbb As <\/span>Office.CommandBarButton\r\n Set<\/span> cbr = CommandBars.Item(\"Form Datasheet Cell\")\r\n Set<\/span> cbb = cbr.Controls.Add(msoControlButton, , , , True<\/span>)\r\n cbb.Caption = \"Form Datasheet Cell\"\r\n Set<\/span> cbr = CommandBars.Item(\"Form Datasheet\")\r\n Set<\/span> cbb = cbr.Controls.Add(msoControlButton, , , , True<\/span>)\r\n cbb.Caption = \"Form Datasheet\"\r\nEnd Sub<\/span><\/pre>\n![\"Ermitteln](\"..\/fileadmin\/_temp_\/2016_01\/pic_1022_003.png\")
<\/p>\nWerte einfügen per Klasse<\/h2>\n
Dim <\/span>m_Form As <\/span>Form<\/pre>\nPublic Property Set<\/span> <\/span>Form(frm As <\/span>Form)\r\n Dim <\/span>cbr As <\/span>Office.CommandBar\r\n Dim <\/span>i As Integer<\/span>\r\n Set<\/span> m_Form = frm\r\n Set<\/span> cbr = CommandBars.Item(\"Form Datasheet Cell\")\r\n For i = cbr.Controls.Count To 1 Step -1\r\n If <\/span>cbr.Controls.Item(i).Caption = \"Wert einfügen\" Then<\/span>\r\n cbr.Controls.Item(i).Delete\r\n End If<\/span>\r\n Next<\/span> i\r\n Set<\/span> cbbInsert = cbr.Controls.Add(msoControlButton, , , , True<\/span>)\r\n cbbInsert.Caption = \"Wert einfügen\"\r\nEnd Property<\/span><\/pre>\nDim <\/span>WithEvents cbbInsert As <\/span>CommandBarButton<\/pre>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2016_01\/pic_1022_005.png\")
<\/p>\nPrivate Sub <\/span>cbbInsert_Click(ByVal Ctrl As <\/span>Office.CommandBarButton, CancelDefault As Boolean<\/span>)\r\n Dim <\/span>strInhalt As String<\/span>\r\n Dim <\/span>bolFill As Boolean<\/span>\r\n strInhalt = InputBox(\"Geben Sie den einzufügenden Wert an:\", \"Zellen füllen\", AusZwischenablage)\r\n If <\/span>Len<\/span>(strInhalt) > 0 Then<\/span>\r\n bolFill = True<\/span>\r\n Else<\/span>\r\n If <\/span>MsgBox<\/span>(\"Felder leeren\", vbYesNo) = vbYes Then<\/span>\r\n bolFill = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n If <\/span>bolFill Then<\/span>\r\n Fill strInhalt\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nFüllen der markierten Felder<\/h2>\n
\n
\n
Markierungen ermitteln und durchlaufen<\/h2>\n
Public Sub <\/span>Fill(varWert As Variant<\/span>)\r\n Dim <\/span>intSelLeft As Integer<\/span>\r\n Dim <\/span>intSelTop As Integer<\/span>\r\n Dim <\/span>intSelWidth As Integer<\/span>\r\n Dim <\/span>intSelHeight As Integer<\/span>\r\n Dim <\/span>intRow As Integer<\/span>\r\n Dim <\/span>intColumn As Integer<\/span>\r\n Dim <\/span>intSelLeftOriginal As Integer<\/span>\r\n Dim <\/span>intSelTopOriginal As Integer<\/span>\r\n Dim <\/span>intSelWidthOriginal As Integer<\/span>\r\n Dim <\/span>intSelHeightOriginal As Integer<\/span>\r\n With<\/span> m_Form\r\n intSelLeftOriginal = .SelLeft\r\n intSelWidthOriginal = .SelWidth\r\n intSelTopOriginal = .SelTop\r\n intSelHeightOriginal = .SelHeight\r\n If <\/span>.SelWidth = 0 Then<\/span>\r\n intSelWidth = 1\r\n Else<\/span>\r\n intSelWidth = .SelWidth\r\n End If<\/span>\r\n intSelLeft<\/span> = .SelLeft<\/span> - 1\r\n If <\/span>.SelHeight = 0 Then<\/span>\r\n intSelHeight = 1\r\n Else<\/span>\r\n intSelHeight = .SelHeight\r\n End If<\/span>\r\n intSelTop = .SelTop\r\n For intColumn = intSelLeft<\/span> To intSelLeft<\/span> + intSelWidth - 1\r\n .SelHeight = 0\r\n .SelWidth = 0\r\n .SelLeft<\/span> = intColumn\r\n .SelWidth = 1\r\n For intRow = intSelTop To intSelTop + intSelHeight - 1\r\n .SelTop = intRow\r\n .SelHeight = 1\r\n FillValue varWert\r\n Next<\/span> intRow\r\n Next<\/span> intColumn\r\n .SelTop = intSelTopOriginal\r\n .SelLeft<\/span> = intSelLeftOriginal\r\n .SelWidth = intSelWidth\r\n .SelHeight = intSelHeight\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nSteuerelemente füllen<\/h2>\n
Public Function <\/span>FillValue(varValue As Variant<\/span>) As Boolean<\/span>\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>txt As <\/span>TextBox\r\n Dim <\/span>chk As <\/span>CheckBox\r\n Dim <\/span>cbo As <\/span>ComboBox\r\n Dim <\/span>lngError As Long<\/span>\r\n Dim <\/span>strFehlermeldung As String<\/span>\r\n Set<\/span> ctl = Screen.ActiveControl\r\n Select Case ctl.ControlType\r\n Case <\/span>acTextBox\r\n Set<\/span> txt = ctl\r\n On Error Resume Next<\/span>\r\n txt.Value = varValue\r\n lngError = Err.Number\r\n On Error GoTo<\/span> 0\r\n Case <\/span>acComboBox\r\n Set<\/span> cbo = ctl\r\n lngError = ComboBoxFuellen(varValue, cbo)\r\n Case <\/span>acCheckBox\r\n Set<\/span> chk = ctl\r\n On Error Resume Next<\/span>\r\n chk.Value = varValue\r\n lngError = Err.Number\r\n On Error GoTo<\/span> 0\r\n Case Else<\/span>\r\n Debug.Print<\/span> ctl.ControlType\r\n End Select<\/span>\r\n If <\/span>lngError = 0 Then<\/span>\r\n FillValue = True<\/span>\r\n Else<\/span>\r\n If <\/span>Not<\/span> lngError = -1 Then<\/span>\r\n strFehlermeldung = AccessError(lngError)\r\n Else<\/span>\r\n strFehlermeldung = \"Kein passender Wert im Kombifeld vorhanden.\"\r\n End If<\/span>\r\n MsgBox<\/span> \"Der Wert ''\" & varValue & \"'' konnte nicht in das Feld ''\" & ctl.Name & \"'' eingetragen werden.\" _\r\n & vbCrLf<\/span> & \"Fehlermeldung: \" & vbCrLf<\/span> & vbCrLf<\/span> & \"''\" & strFehlermeldung & \"''\" & vbCrLf<\/span> & vbCrLf<\/span> _\r\n & \"Die Verarbeitung wurde abgebrochen.\"\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\n