<\/p>\n
Datenblätter sind sehr flexibel, wenn es um die Anzeige tabellarischer Daten geht. Sie können die Daten damit sortieren und filtern und die Breite und Sortierung der Spalten anpassen. Gelegentlich platziert man jedoch um ein Unterformular mit einem Datenblatt herum noch weitere Elemente wie etwa Schaltflächen oder individuelle Steuerelemente etwa zur Eingabe von Suchbegriffen. Diese sollen sich, wenn der Benutzer die Spalten ändert, natürlich anpassen. Wie dies gelingt, zeigt der vorliegende Beitrag.<\/b><\/p>\n
Ein Anwendungsfall für das Anpassen von Steuerelementen an die Spalten eines Datenblatts ist das Formular aus dem Beitrag Textdateien vergleichen <\/b>(www.access-im-unternehmen.de\/922<\/b>). Dieses zeigt in jeweils drei Spalten im Datenblatt des Unterformulars die Zeilennummer, ein Kontrollkästchen und den Zeileninhalt der Zeilen einer Datei an (s. Bild 1). Der Benutzer wird hier gelegentlich die Breite der beiden Spalten Datei 1<\/b> und Datei 2 <\/b>verändern, um den kompletten Inhalt einer Zeile lesen zu können.<\/p>\n
![\"Beispiel](\"..\/fileadmin\/_temp_\/2014_01\/pic_918_001.png\")
<\/p>\n
Bild 1: Beispiel für Steuerelemente, die sich auf die Spalten eines Datenblatts im Unterformular beziehen<\/span><\/b><\/p>\n Wir können der Abbildung schon die Vorgaben entnehmen, die wir programmieren müssen: Die Textfelder zur Eingabe des Dateinamens sollen linksbündig mit den Spalten zur Anzeige der Zeilenzahl abschließen. Die Schaltflächen sollen rechtsbündig mit der Spalte zur Anzeige der Zeileninhalte abschließen. Die Schaltflächen haben eine feste Breite. Die Breite der Textfelder zur Eingabe der Dateinamen orientiert sich an der Gesamtbreite der drei Spalten minus der Breite der Schaltfläche zur Auswahl der Textdatei.<\/p>\n Bild 2 zeigt, wie das Formular nach dem Vergrößern etwa der Spalten zur Anzeige der Spalteninhalte aussieht. Wie man sieht, ist eine dynamische Anpassung der darüber angeordneten Steuerelemente aus optischen Gründen dringend erforderlich. Was ist zu tun Wir müssen erstens ein Ereignis identifizieren, das durch das ändern der Spaltenbreiten ausgelöst wird. Zweitens müssen wir die Breiten ermitteln und definieren, wie die Breite der Steuerelemente im Hauptformular in Abhängigkeit davon eingestellt wird. Drittens – und das ist sehr wichtig – müssen wir in diesem Fall verhindern, dass der Benutzer die Reihenfolge der Spalten ändert. Das würde unsere Regeln für die Einstellung der Breite der Steuerelemente im Hauptformular empfindlich stören. In anderen Anwendungsfällen, wo etwa jeweils ein Steuerelemente im Hauptformular einer Spalte im Unterformular zugeordnet ist, sieht das anders aus – hier erhält einfach jedes Steuerelement die Position und die Breite der jeweils zugeordneten Spalte im Datenblatt des Unterformulars.<\/p>\n Bild 2: Nach dem ändern der Spaltenbreiten befinden sich die Steuerelemente im Hauptformular nicht mehr exakt über den Spalten.<\/span><\/b><\/p>\n Ereignis identifizieren<\/b><\/p>\n Als Erstes wollen wir herausfinden, über welches Ereignis wir überhaupt auf änderungen der Position oder Breite der Spalten reagieren können. Dazu betrachten wir zunächst die Liste der Ereigniseigenschaften des Unterformulars. Wie ändert der Benutzer überhaupt die Breite oder Position von Spalten im Datenblatt Dies ist nur mit der Maus möglich: Zum ändern der Reihenfolge der Spalten klickt der Benutzer zunächst den Spaltenkopf der zu verschiebenden Spalte an und zieht diesen dann bei gedrückter Maustaste an die gewünschte Position. ähnlich sieht es beim Anpassen der Spaltenbreiten aus: Hier drückt der Benutzer die Maustaste herunter, wenn sich der Mauszeiger über einem der Zwischenräume zwischen zwei Spaltenköpfen befindet und zieht den Zwischenraum an die gewünschte Position. Eine weitere Möglichkeit ist ein Doppelklick auf den Zwischenraum zwischen zwei Spaltenköpfen, um die optimale Breite der Spalte entsprechend den Inhalten einzustellen.<\/p>\n Die Mausbewegungen und Mausklicks lösen grundsätzlich die Ereignisse Bei Mausbewegung<\/b>, Bei Maustaste ab <\/b>und Bei Maustaste auf <\/b>aus. Aber es gibt einige dieser Ereignisse in einem Formular: für das Formular selbst, für die einzelnen Bereiche und auch für jedes einzelne Steuerelement.<\/p>\n Um herauszufinden, ob die Ereignisse eines dieser Bereiche für uns hilfreich sind, müssen wir experimentieren. Dazu legen wir einfach entsprechende Ereignisprozeduren an und schauen, welches Ereignis wann ausgelöst wird.<\/p>\n Welche Kandidaten wollen wir untersuchen Wir nehmen uns die drei Ereignisse des Formulars selbst, des Detailbereichs (da keine anderen Bereiche für das Unterformular definiert wurden) und, als Beispiel für eines der Steuerelemente, das Textfeld Datei1<\/b>.<\/p>\n Die Programmierung der Ereignisprozeduren finden Sie in Listing 1.<\/p>\n Listing 1: Prozeduren zum Ermitteln des Ereignisses zum Abfangen von Spaltenänderungen<\/span><\/b><\/p>\n Nun prüfen wir, welches Mausbewegung welches Ereignis auslöst. Dazu positionieren Sie das Access-Fenster mit dem zu untersuchenden Formular und das VBA-Fenster nebeneinander. Wenn Sie dann mit der Maus über die Spaltenköpfe des Unterformulars fahren, sollte sich etwas im Direktbereich des VBA-Editors tun. Wenn Sie nun noch beispielsweise die Breite einer Spalte durch Anklicken und Ziehen des Zwischenraums zwischen den Spaltenköpfen ändern, sollte das Ergebnis im Direktfenster etwa wie in Bild 3 aussehen. Bingo – wir benötigen die Ereignisse Bei Maustaste ab<\/b>, Bei Mausbewegung <\/b>und Bei Maustaste auf<\/b>, um das ändern der Spaltenbreiten zu ermitteln.<\/p>\n <\/p>\n Bild 3: Ereignisse im Direktbereich des VBA-Editors<\/span><\/b><\/p>\n Wann sollen die Steuerelemente angepasst werden<\/b><\/p>\n Nachdem wir die passenden Ereignisse identifiziert haben, schauen wir uns an, zu welchen Zeitpunkten die Steuerelemente im Hauptformular an die Spalten im Unterformular angepasst werden sollen. Dies ist immer dann der Fall, wenn der Benutzer die Maustaste auf den Spaltenköpfen gedrückt hat und den Mauszeiger bewegt. Wenn er ihn wieder loslässt, soll nichts mehr geschehen.<\/p>\n Bei einer naiven Herangehensweise verwenden wir nur das Ereignis Bei Mausbewegung<\/b>: Immerhin bietet das mit dem Parameter button <\/b>die Möglichkeit zu ermitteln, ob und welche Maustaste der Benutzer beim Bewegen der Maus gedrückt hält. Leider liefert und dies allerdings keine Information darüber, wann der Benutzer die Maustaste heruntergedrückt hat. Um zu prüfen, ob der Mauszeiger auf einem der Spaltenköpfe heruntergedrückt und dann bewegt wurde, bedienen wir uns einer Boolean<\/b>-Variablen namens bolMausGedrueckt<\/b>, die beim Eintreten des Ereignisses Bei Maustaste ab <\/b>des Formulars auf den Wert True <\/b>eingestellt wird. In der Prozedur, die durch das Ereignis Bei Mausbewegung <\/b>ausgelöst wird, prüfen wir nun, ob bolMausGedrueckt <\/b>den Wert True <\/b>hat. In diesem Fall wurde der Mauszeiger auf einem der Spaltenköpfe niedergedrückt und bewegt.<\/p>\n Wenn der Benutzer die Maustaste wieder loslässt, soll die Variable bolMausGedrueckt <\/b>wieder auf den Wert False <\/b>eingestellt werden. Unsere aktuelle Konfiguration sieht also nun wie in Listing 2 aus.<\/p>\n Listing 2: Das Ereignis Form_MouseMove soll nur reagieren, wenn die Maustaste gedrückt wurde.<\/span><\/b><\/p>\n Wenn wir dies nun testen, kommt es darauf an, alle möglichen Verhaltensweisen zu erfassen – denken Sie daran: Der Benutzer deckt alle Schwachstellen auf! Also bemühen wir uns lieber gleich selbst, dies zu erledigen. Experimentieren Sie: Klicken Sie doppelt auf die Spaltenköpfe, ziehen Sie bei gedrückter Maustaste, bewegen Sie die Maus ohne gedrückte Maustaste – es funktioniert! Ups, doch nicht: Da bin ich doch aus Versehen bei gedrückter Maustaste von der Zeile der Spaltenköpfe abgekommen und habe erst dort die Maustaste losgelassen. Das heißt, dass die Variable bolMausGedrueckt <\/b>nicht wieder auf den Wert False <\/b>eingestellt wird. Das ist ungünstig, weil die Prozedur Form_MouseMove <\/b>so beim nächsten überfahren gleich davon ausgeht, dass wir die Maustaste bereits gedrückt haben.<\/p>\n Wir benötigen also doch noch die Maus-Ereignisse anderer Elemente des Formulars, um die Variable bolMausGedrueckt<\/b> auf False zu setzen, wenn sich der Mauszeiger auf einem anderen Element als einem der Spaltenköpfe befindet und die Maustaste bereits wieder losgelassen wurde. Dazu müssen wir zunächst herausfinden, welche Elemente des Formulars davon betroffen sein könnten. Wir fügen also dem Detailbereich und dem Textfeld Datei1 <\/b>(stellvertretend für die übrigen Steuerelemente des Datenblatts) wieder Ereignisprozeduren hinzu, die durch die drei Maus-Ereignisse ausgelöst werden. Diese enthalten nun Anweisungen wie die folgenden:<\/p>\n Wir wollen also immer, wenn der Benutzer außerhalb der Spaltenköpfe die Maustaste loslässt, eine entsprechende Ausgabe im Direktbereich bewirken.<\/p>\n Das Ergebnis ist, dass wir allen Steuerelementen des Datenblatts eine Ereignisprozedur mitgeben müssen, welche die Variable bolMausGedrueckt <\/b>auf False<\/b> einstellt, wenn der Benutzer die Maustaste über einem der Steuerelemente loslässt.<\/p>\n In unserem Beispiel ist die Anzahl der Steuerelemente im Unterformular überschaubar – es sind nur sechs Stück. Für diese können wir die notwendigen Ereignisprozeduren, jeweils ausgelöst durch das Ereignis Bei Maustaste auf<\/b>, von Hand anlegen. Eines davon sieht etwa wie in Listing 3 aus.<\/p>\n Listing 3: Einstellen der Variablen bolMausGedrueckt auf den Wert False.<\/span><\/b><\/p>\n Fehlt noch der Fall, dass der Benutzer die Maustaste auf einem der Spaltenköpfe niederdrückt und dann den Mauszeiger außerhalb des Unterformulars mit der Datenblattansicht positioniert, bevor er die Maustaste loslässt. Für diesen Fall hat Microsoft ein für uns günstiges Verhalten definiert: Dies löst dann einfach das Ereignis Form_MouseUp <\/b>des Unterformulars aus, wo als ob der Mauszeiger dieses nie verlassen hätte.<\/p>\n Ständiges Anpassen<\/b><\/p>\n Nun stellt sich die Frage, ob wir wirklich bei jedem Feuern des Ereignisses Form_MouseMove <\/b>die Steuerelemente anpassen müssen, wenn bolMausGedrueckt <\/b>den Wert True <\/b>hat. Flackert das nicht zu sehr Hier zeigt sich mal wieder, wie wenig man (in diesem Fall zumindest ich) auf Details achtet: Die Breite eines Spaltenkopfes ändert sich nämlich gar nicht während des Ziehens mit der Maus, sondern erst, wenn der Benutzer diese loslässt! Wir brauchen also nur das Ereignis Bei Maustaste auf <\/b>zu untersuchen!<\/p>\n Steuerelemente anpassen<\/b><\/p>\n In diesem Ereignis bringen wir nun den Aufruf der Prozedur unter, die sich um das Anpassen der Steuerelemente kümmert. Dies sieht dann wie in Listing 4 aus.<\/p>\n Listing 4: Die Steuerelemente werden nur beim Loslassen der Maustaste angepasst.<\/span><\/b><\/p>\n Das Ereignis Form_MouseMove <\/b>kann komplett entfallen!<\/p>\n Die Prozedur SteuerelementeAnpassen <\/b>deklariert zwei Variablen für die Breite der ersten und der zweiten drei Spalten sowie eine Variable zum Referenzieren des übergeordneten Hauptformulars (s. Listing 5). Diese füllt die Prozedur mit einem Verweis auf das Hauptformular (Me.Parent<\/b>). Danach ermittelt die Prozedur die Breite der ersten drei Spalten des Unterformulars. Zum Ermitteln der Breite einer einzelnen Spalte verwendet sie dabei die Eigenschaft ColumnWidth <\/b>des jeweiligen Steuerelements. Dies liefert, im Gegensatz zur Eigenschaft Width<\/b>, nicht die Breite des Steuerelements, wie Sie es in der Entwurfsansicht angelegt haben, sondern die aktuelle Breite der Spalte in der Datenblattansicht des Unterformulars. Auf diese Weise addiert die Prozedur die Breite der ersten drei Steuerelemente und speichert diese in der Variablen lngWidth1<\/b>. Der gleiche Vorgang wird analog für die zweiten drei Steuerelemente durchgeführt, das Ergebnis landet in lngWidth2<\/b>.<\/p>\n Listing 5: Anpassen der Steuerelemente<\/span><\/b><\/p>\n Danach stellt die Prozedur die Breite des Textfeldes txtDatei1 <\/b>ein. Dazu füllt sie die Eigenschaft Width <\/b>mit einem Wert, welcher der Breite der ersten drei Spalten des Unterformulars minus der Breite der rechts vom Textfeld zu platzierenden Schaltfläche entspricht.<\/p>\n Außerdem ziehen wir weitere 50 Twips ab, damit wir erstens einen Abstand zwischen Textfeld und Schaltfläche erhalten und zweitens mit der folgenden Anweisung einen Abstand zwischen der Schaltfläche und dem folgenden Textfeld einrichten können.<\/p>\n Die Position der Schaltfläche cmdDatei1 <\/b>berechnen wir, indem wir von der Breite der linken drei Spalten des Datenblatts die Breite der Schaltfläche abziehen, den Abstand vom Textfeld vom linken Formularrand hinzuaddieren und 25 Twips abziehen, damit wir noch einen kleinen Abstand zum folgenden Textfeld erhalten.<\/p>\n Für die linken beiden Steuerelemente fehlt noch die Breite des Textfeldes txtDatei1<\/b>. Diese richtet sich nach der Breite der drei zu überdeckenden Spalten minus der Breite der Schaltfläche minus 50 Twips.<\/p>\n Nun ermittelt die Prozedur die Position und die Breite der Steuerelemente txtDatei2 <\/b>und cmdDatei2<\/b>. txtDatei hat einen Abstand zum linken Formularrand, der sich aus dem Abstand der Schaltfläche cmdDatei1 <\/b>vom linken Rand plus der Breite der Schaltfläche plus 50 Twips ergibt.<\/p>\n Die Breite berechnen wir über die Breite der linken drei Spalten des Datenblatts minus der Breite der Schaltfläche minus 50 Twips, den Abstand der Schaltfläche cmdDatei2 <\/b>vom linken Rand analog zu cmdDatei1<\/b>.<\/p>\n Das Ergebnis sehen Sie in Bild 4 – die Steuerelemente werden nun korrekt ausgerichtet.<\/p>\n Bild 4: Formular mit Steuerelementen, die an die Spaltenbreiten angepasst sind<\/span><\/b><\/p>\n Drunter und drüber<\/b><\/p>\n Nachdem wir nun für die Spaltenköpfe eine Prozedur implementiert haben, die nur auf das Loslassen der Maus auf dem Formular (Form_MouseUp<\/b>) reagiert, müssen wir dies noch für die Steuerelemente des Datenblatts umsetzen.<\/p>\n Es kann immer noch geschehen, dass der Benutzer zwar ein Ziehen mit der Maus auf einem der Spaltenköpfe beginnt, dann aber nach unten fährt und erst dort loslässt.<\/p>\n Auch in diesem Fall müssen die Steuerelemente beim Eintreten des MouseUp<\/b>-Ereignisses angepasst werden.<\/p>\n Deshalb lagern wir die notwendigen Anweisungen von der Ereignisprozedur Form_MouseUp <\/b>zunächst in eine eigene Prozedur aus:<\/p>\n Dann fügen wir diesen Aufruf in alle relevanten Ereisnisprozeduren ein, also:<\/p>\n Reihenfolge blockieren<\/b><\/p>\n Für das vorliegende Datenblatt ist es sinnvoll, die Reihenfolge der Spalten beizubehalten. Deshalb fügen wir noch eine Funktion hinzu, die verhindert, dass der Benutzer die Reihenfolge der Spalten ändert. Die Prozedur funktioniert ganz simpel: Sie stellt ganz einfach die Eigenschaft ColumnOrder <\/b>der sechs Spalten auf die der Reihenfolge entsprechenden Zahlenwerte ein:<\/p>\n![\"Nach](\"..\/fileadmin\/_temp_\/2014_01\/pic_918_002.png\")
<\/p>\nPrivate Sub <\/span>Datei1_MouseDown(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Debug.Print<\/span> \"Datei1_MouseDown\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Datei1_MouseMove(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Debug.Print<\/span> \"Datei1_MouseMove\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Datei1_MouseUp(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Debug.Print<\/span> \"Datei1_MouseUp\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Detailbereich_MouseDown(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Debug.Print<\/span> \"Detailbereich_MouseDown\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Detailbereich_MouseMove(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Debug.Print<\/span> \"Detailbereich_MouseMove\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Detailbereich_MouseUp(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Debug.Print<\/span> \"Detailbereich_MouseUp\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_MouseDown(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Debug.Print<\/span> \"Form_MouseDown\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_MouseMove(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Debug.Print<\/span> \"Form_MouseMove\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_MouseUp(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Debug.Print<\/span> \"Form_MouseUp\"\r\nEnd Sub<\/span><\/pre>\n![\"Ereignisse](\"..\/fileadmin\/_temp_\/2014_01\/pic_918_003.png\")
<\/p>\nPrivate Sub <\/span>Form_MouseDown(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n bolMausGedrueckt = True<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_MouseMove(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n If <\/span>bolMausGedrueckt Then<\/span>\r\n Debug.Print<\/span> \"Ziehen der Spalten\", Button, Shift, X, Y\r\n End If<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_MouseUp(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n bolMausGedrueckt = False<\/span>\r\nEnd Sub<\/span><\/pre>\nIf <\/span>bolMausGedrueckt Then<\/span>\r\n Debug.Print<\/span> \"Datei1_MouseDown\"\r\nEnd If<\/span><\/pre>\nPrivate Sub <\/span>Datei1_MouseUp(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n If <\/span>bolMausGedrueckt Then<\/span>\r\n bolMausGedrueckt = False<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_MouseUp(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n If <\/span>bolMausGedrueckt Then<\/span>\r\n SteuerelementeAnpassen\r\n End If<\/span>\r\n bolMausGedrueckt = False<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>SteuerelementeAnpassen()\r\n Dim <\/span>lngWidth1 As Long<\/span>\r\n Dim <\/span>lngWidth2 As Long<\/span>\r\n Dim <\/span>frm As <\/span>Form\r\n Set<\/span> frm = Me.Parent\r\n lngWidth1 = Me.Controls(\"ZeileDatei1\").ColumnWidth + Me.Controls(\"Datei1\").ColumnWidth _\r\n + Me.Controls(\"Uebernehmen1\").ColumnWidth\r\n lngWidth2 = Me.Controls(\"ZeileDatei2\").ColumnWidth + Me.Controls(\"Datei2\").ColumnWidth _\r\n + Me.Controls(\"Uebernehmen2\").ColumnWidth\r\n frm!cmdDatei1.Left<\/span> = lngWidth1 - frm!cmdDatei1.Width + frm!txtDatei1.Left<\/span> - 25\r\n frm!txtDatei1.Width = lngWidth1 - frm!cmdDatei1.Width - 50\r\n frm!txtDatei2.Left<\/span> = frm!cmdDatei1.Left<\/span> + frm!cmdDatei1.Width + 50\r\n frm!txtDatei2.Width = lngWidth2 - frm!cmdDatei2.Width - 50\r\n frm!cmdDatei2.Left<\/span> = lngWidth2 - frm!cmdDatei2.Width + frm!txtDatei2.Left<\/span> - 25\r\nEnd Sub<\/span><\/pre>\n![\"Formular](\"..\/fileadmin\/_temp_\/2014_01\/pic_918_004.png\")
<\/p>\nPrivate Sub <\/span>MouseUp()\r\n If <\/span>bolMausGedrueckt Then<\/span>\r\n SteuerelementeAnpassen\r\n ReihenfolgeWiederherstellen\r\n End If<\/span>\r\n bolMausGedrueckt = False<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Datei1_MouseUp(...)\r\n MouseUp\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Datei2_MouseUp(...)\r\n MouseUp\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Uebernehmen1_MouseUp(...)\r\n MouseUp\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Uebernehmen2_MouseUp(...)\r\n MouseUp\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>ZeileDatei1_MouseUp(...)\r\n MouseUp\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>ZeileDatei2_MouseUp(...)\r\n MouseUp\r\nEnd Sub<\/span> <\/pre>\nPublic Sub <\/span>ReihenfolgeWiederherstellen()\r\n Me!ZeileDatei1.ColumnOrder = 1\r\n Me!Uebernehmen1.ColumnOrder = 2\r\n Me!Datei1.ColumnOrder = 3\r\n Me!ZeileDatei2.ColumnOrder = 4\r\n Me!Uebernehmen2.ColumnOrder = 5\r\n Me!Datei2.ColumnOrder = 6\r\nEnd Sub<\/span><\/pre>\n