<\/p>\n
Listenfelder sind tolle Steuerelemente. Mit ihnen können Sie Daten schnell zur Auswahl bereitstellen. Allerdings haben sie einen Makel: Sie erlauben keine automatische änderung der Spaltenbreite zur Laufzeit – zumindest nicht mit Bordmitteln. Dieser Beitrag zeigt, wie Sie in Zusammenhang mit den Verankern-Eigenschaften von Formularen zumindest ein klein wenig Flexibilität aus den ansonsten recht statischen Listenfelder herausholen.<\/b><\/p>\nBeispiel Kundenliste<\/h2>\n
Als Beispiel für diesen Beitrag verwenden wir die Tabelle tblKunden <\/b>der Suedsturm-Datenbank. Die Daten dieser Tabelle sollen in einem Listenfeld namens lstKunden <\/b>angezeigt werden. Daher stellen wir die Datensatzherkunft dieses Steuerelements auf eine Abfrage ein, die wie in Bild 1 aussieht.<\/p>\n
![\"Datensatzherkunft](\"..\/fileadmin\/_temp_\/2016_06\/pic_1063_002.png\")
<\/p>\n
Bild 1: Datensatzherkunft des Listenfeldes lstKunden<\/span><\/b><\/p>\n Diese Abfrage liefert die Felder Kunde-ID<\/b>, KundenCode<\/b>, Firma<\/b>, Vorname <\/b>und Nachname <\/b>der Tabelle tblKunden <\/b>sortiert nach dem Inhalt des Feldes Firma<\/b>. Die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen<\/b>, Trennlinien <\/b>und Bildlaufleisten <\/b>dieses Formulars stellen wir auf Nein <\/b>ein. Das Formular sieht in der Entwurfsansicht wie in Bild 2 aus. Es enthält lediglich das Listenfeld lstKunden <\/b>als Steuerelement.<\/p>\n Bild 2: Das Formular frmKunden mit dem Listenfeld zur Anzeige der Kunden in der Entwurfsansicht<\/span><\/b><\/p>\n Das Listenfeld soll alle fünf Felder der als Datensatzherkunft verwendeten Abfrage nutzen, also legen wir für die Eigenschaft Spaltenanzahl <\/b>den Wert 5 <\/b>fest.<\/p>\n Die Eigenschaft Spaltenbreiten <\/b>stellen wir auf den Wert 0cm;2cm;5cm;2cm;4cm <\/b>ein. Damit legen wir fest, dass das erste Feld der Datensatzherkunft, also KundeID<\/b>, nicht im Listenfeld angezeigt wird. Die übrigen Felder erscheinen in der jeweils angegebenen Breite, wie Bild 3 zeigt.<\/p>\n Bild 3: Die Formularansicht entspricht noch nicht unseren Wünschen.<\/span><\/b><\/p>\n Dies ist allerdings noch längst nicht die Ansicht, die wir uns wünschen. In der Abbildung haben wir die Größe des Formulars bereits geändert, was sich aber aktuell noch nicht auf die Größe des Listenfeldes auswirkt. Dieses sollte sich eigentlich analog zum Rest des Formulars vergrößern. Damit dies im nächsten Anlauf gelingt, stellen wir die Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>auf den Wert Beide <\/b>ein. Außerdem korrigieren Sie den dabei automatisch geänderten Wert dieser beiden Eigenschaften für das Bezeichnungsfeld des Listenfeldes wieder auf Links <\/b>und Oben<\/b>.<\/p>\n Nun passt es: Das Listenfeld wird automatisch vergrößert, wenn man das Formular anpasst (s. Bild 4). Leider verändert sich innerhalb des Listenfeldes aber nur die Breite der letzten Spalte. Schön wäre es gewesen, wenn sich die Spalte mit der Firma automatisch entsprechend der Breite des Formulars angepasst hätte, damit ihre Inhalte komplett sichtbar sind.<\/p>\n Bild 4: Nun wird zumindest das Listenfeld mit dem Formular vergrößert.<\/span><\/b><\/p>\n Damit kommen wir zum ersten notwendigen Schritt, wenn Sie dafür sorgen wollen, dass genau eine Spalte immer mit dem Formular vergrößert oder verkleinert wird. In diesem stellen wir die Eigenschaft Spaltenbreiten<\/b> auf einen neuen Wert ein, der wie folgt lautet (s. Bild 5):<\/p>\n Bild 5: Einstellen der Spaltenbreiten für unseren Anwendungsfall<\/span><\/b><\/p>\n Was ist wichtig an dieser Stelle Dass Sie für die Spalte, deren Breite flexibel eingestellt werden soll, keinen numerischen Wert angeben, sondern den Platz zwischen den entsprechenden Semikola (;<\/b>) einfach freilassen.<\/p>\n Nun erhalten Sie die gewünschte Ansicht (s. Bild 6), aber nur unter einer Voraussetzung: Sie hatten das Formular zuvor geöffnet und bereits einmal auf eine gewisse Breite vergrößert und sind dann wieder zur Entwurfsansicht gewechselt.<\/p>\n Bild 6: Die Spalte mit der Firma wird auf die enthaltenen Daten optimiert.<\/span><\/b><\/p>\n Wenn Sie es dann erneut in der Formularansicht öffnen, wird die Spalte Firma <\/b>so breit angezeigt, dass es genau den Rest der Breite des Listenfeldes minus der Spaltenbreite der übrigen Felder einnimmt.<\/p>\n Wenn Sie das Formular nun komplett schließen und wieder öffnen, erhalten Sie nicht nur den alten Zustand – es ist noch übler: Das Feld Firma<\/b> erhält nun noch weniger Platz, nämlich wiederum die Gesamtbreite des Formulars minus der für die übrigen Spalten fix eingestellten Breiten (s. Bild 7).<\/p>\n Bild 7: Beim erneuten öffnen bekommt die Spalte Firma nun leider noch weniger Platz ab.<\/span><\/b><\/p>\n Nun kommt Schritt zwei der notwendigen änderungen für eine flexible Spaltenbreite im Listenfeld: Wir fügen dem Formular eine Ereignisprozedur für das Ereignis Bei Größenänderung <\/b>hinzu, welche die folgende Anweisung ausführt:<\/p>\n Das Ergebnis überzeugt: Von nun an ändert sich die Breite der Spalte Firma<\/b> immer, sobald wir am rechten Rand des Formulars ziehen und so die Breite des Listenfeldes ändern (s. Bild 8).<\/p>\n Bild 8: Mit einer kleinen Ereignisprozedur passt sich die Spaltenbreite des Feldes Firma immer der Listenfeldbreite minus den übrigen fixen Spaltenbreiten an.<\/span><\/b><\/p>\n Wir gehen noch einen Schritt weiter: Während bisher die flexible Spalte fest durch den Eintrag in die Eigenschaft Spaltenbreiten <\/b>vorgegeben war, wollen wir diesen nun durch den Benutzer anpassen lassen. Dazu soll dieser einfach die entsprechende Spalte anklicken können und dann die Breite dieser Spalte durch Anpassen der Formularbreite vergrößern oder verkleinern. Um zu überprüfen, welche Spalte aktuell die flexible Spaltenbreite aufweist, zeigen wir ihren Namen in einem Textfeld namens txtDynamischeSpalte <\/b>an (die neue Version des Formulars samt Textfeld finden Sie in Bild 9).<\/p>\n Bild 9: Neues Formular, neues Textfeld zur Anzeige der aktuell veränderbaren Spalte<\/span><\/b><\/p>\n Was nun folgt, ist das Ergebnis einiger Experimente und der Verwendung des Maustaste auf<\/b>-Ereignisses. Vorab die Idee, die hinter dieser Prozedur steckt: Aktuell ist genau eine Spalte durch änderung der Breite des Formulars anpassbar.<\/p>\n Dies geschieht erstens dadurch, dass Veränderungen der Formularbreite durch die Einstellung des Wertes Beide <\/b>für das Steuerelement lstKunden <\/b>die Listenfeldbreite verändert. Die oben vorgestellte Ereignisprozedur, die durch das Ereignis Bei Größenänderung <\/b>ausgelöst wird, sorgt dann dafür, dass die Eigenschaft Spaltenbreiten <\/b>des Listenfeldes bei jeder änderung der Formularbreite aktualisiert wird. So wird immer die Spalte, für die keine feste Breite festgelegt wurde, so angepasst, dass sie der Breite des Listenfeldes minus der Breite der übrigen Spalten entspricht.<\/p>\n Nun wollen wir dafür sorgen, dass der Benutzer durch einen einfachen Mausklick auf eine der Spalten die angeklickte Spalte zur flexibel einstellbaren Spalte machen kann. Das heißt: Zu Beginn ist beispielsweise die Spalte Firma <\/b>flexibel einstellbar. Dann klickt der Benutzer auf die Spalte Vorname <\/b>und ändert dann die Formularbreite. Nun ändert sich nicht mehr automatisch die Breite der Spalte Firma<\/b>, sondern die der Spalte Vorname<\/b>! Dazu sind einige Verrenkungen nötig, aber wenn man länger mit Access arbeitet, weiß man, dass man fast alles erreichen kann, wenn man nur ein wenig Zeit und Hirnschmalz investiert.<\/p>\n Der Plan sieht so aus: Der Benutzer klickt auf die Spalte, die er zur flexibeln Spalte machen möchte. Dadurch löst er das Ereignis Bei Maustaste auf <\/b>aus. Dieses Ereignis liefert mit seinen Parametern beispielsweise den Wert der X-Koordinate der Position, die der Benutzer angeklickt hat:<\/p>\n <\/p>\n Damit wollen wir nun alle Spalten durchlaufen und deren Start-X-Koordinate und End-X-Koordinate ermitteln. Wenn wir eine Spalte finden, für die der Wert des Parameters X <\/b>der angeklickten Position zwischen Start- und Endkoordinate der Spalte liegt, haben wir bereits die angeklickte Spalte entdeckt.<\/p>\n Nun müssen wir nur noch den Wert der Eigenschaft Spaltenbreiten <\/b>(unter VBA: ColumnWidths<\/b>) so ändern, dass nicht mehr die Spalte Firma <\/b>als flexible Spalte markiert ist (hier etwa mit 0cm;2cm;;2cm;2cm<\/b>), sondern nun die Spalte Vorname<\/b>, also etwa mit dem Wert 0cm;2cm;5cm;;2cm <\/b>für die Eigenschaft ColumnWidths<\/b>. Dabei müssen wir natürlich zuvor ermitteln, wie breit die bis dahin flexibel anpassbare Spalte Firma <\/b>gewesen ist. Diesen Wert tragen wir dann für ColumnWidths <\/b>dort ein, wo sich zuvor ein Loch zwischen zwei Semikola befand, und entfernen die fixe Spaltenbreite für die nun als flexibel festgelegte Spalte.<\/p>\n Dazu verwenden wir ein paar Hilfsfunktionen, denn ein paar der gesuchten Werte sind nicht allzu einfach zu ermitteln – zum Beispiel können Sie zwar immer mit der Width<\/b>-Eigenschaft die Breite des Listenfeld-Steuerelements ermitteln, aber dies liefert immer nur die beim öffnen des Formulars festgelegte und in den Eigenschaften definierte Breite. Die Width<\/b>-Eigenschaft ändert sich aber etwa während des Verbreiterns des Formulars und der damit verbundenen änderung der Breite des Listenfeldes nicht. Wir müssen also einen anderen Weg finden, um die Breite des Listenfeldes nach änderung der Breite des Formulars zu ermitteln.<\/p>\n Doch schauen wir uns zunächst einmal an, wie die Prozedur lstKunden_MouseUp <\/b>abläuft (s. Listing 1).<\/p>\n Listing 1: Prozedur, die beim Anklicken einer Listenfeldspalte ausgelöst wird<\/span><\/b><\/p>\n Die Prozedur deklariert drei Objekte der DAO-Bibliothek mit den Typen Database<\/b>, Recordset <\/b>und Field<\/b>. Außerdem benötigen wir zwei Variablen, mit denen wir die Start- und die Endkoordinate der aktuell untersuchten Spalte des Listenfeldes speichern können (lngPositionStart<\/b>, lngPositionEnd<\/b>). Die Variablen lngWidth <\/b>und varWidth <\/b>sowie lngListboxWidth <\/b>benötigen wir zur Ermittlung verschiedener Breiten. Fehlt noch die Laufvariable i<\/b>, eine String<\/b>-Variable namens strColumnWidthsNew <\/b>zum Speichern des zu aktualisierenden Wertes für die Eigenschaft ColumnWidths <\/b>nach Auswahl einer neuen Spalte als flexible Spalte sowie eine Variable namens lst<\/b>, mit der wir das betroffene Listenfeld referenzieren (es ist übersichtlicher, immer lst <\/b>zu schreiben als beispielsweise Me!lstKunden<\/b>). Die erste richtige Anweisung trägt dann auch gleich den Verweis auf das Listenfeld lstKunden <\/b>in die Variable lst <\/b>ein.<\/p>\n Danach füllt die Prozedur die Variable db <\/b>mit einem Verweis auf das aktuelle Database<\/b>-Objekt und erstellt ein neues Recordset auf Basis der Datensatzherkunft des Listenfeldes, die wir aus der Eigenschaft RowSource <\/b>des Steuerelements ermitteln. Dieses Recordset ist unsere Basis, um auf die den einzelnen Spalten zugrunde liegenden Felder zugreifen zu können.<\/p>\n Nun folgt die erste Hürde: Wir wollen die Listenfeldbreite ermitteln. Wozu benötigen wir diese Nun: Durch den Wert 0cm;2cm;;2cm;2cm <\/b>für die Eigenschaft ColumnWidths <\/b>beziehungsweise Spaltenbreiten <\/b>des Listenfeldes haben wir ja festgelegt, dass es eine Spalte gibt, welche den verbleibenden Platz nach Abzug der Spaltenbreiten für die übrigen Spalten einnimmt (der Leerraum zwischen den beiden aufeinanderfolgenden Semikola). Wenn wir nun nach der Auswahl einer anderen Spalte als flexible Spalte der vorherigen flexiblen Spalte eine Breite zuweisen wollen, müssen wir diese Breite zunächst ermitteln.<\/p>\n Das sollte eigentlich ganz leicht gehen: Wir nehmen die Listenfeldbreite und subtrahieren die in ColumnWidths<\/b> angegebenen Spaltenbreiten. Allerdings gibt es ein Problem: Wenn wir die Listenfeldbreite mit lst.Width <\/b>abfragen, erhalten wir immer den gleichen Wert – egal, wie breit wir das Formular und somit auch das Listenfeld aufgezogen haben. Klar: Der Wert wurde im Entwurf festgelegt und wird nur dynamisch in Abhängigkeit von der Formularbreite geändert. Also müssen wir einen kleinen Umweg gehen, um die Listenfeldbreite zum jeweils aktuellen Zeitpunkt zu ermitteln. Dazu ziehen wir die Breite des Formulars (Me.Width<\/b>) zur Entwurfszeit sowie die aktuelle Breite des Formulars hinzu, die wir mit Me.InsideWidth <\/b>ermitteln. Und InsideWidth <\/b>liefert immer die aktuelle Breite! Dies veranschaulicht Bild 10. Hier sehen Sie oben das Formular im Zustand gleich nach dem öffnen. Die Listenfeldbreite und die Formularbreite entsprechen den Werten, die Sie mit den jeweiligen Width<\/b>-Eigenschaften ermitteln können. Wenn Sie dann das Formular verbreitern, bleiben die Werte für frm.Width <\/b>und lst.Width <\/b>erhalten, da diese aus der Definition des Formulars ermittelt werden. frm.InsideWidth <\/b>liefert jedoch die aktuelle Breite des Formulars. Wie aber gelangen wir an die Listenbreite<\/p>\n Bild 10: Ermittlung der Listenfeldbreite zur Laufzeit<\/span><\/b><\/p>\n Zur Ermittlung der Breite des Listenfeldes verwenden wir die kleine Hilfsfunktion Listenfeldbreite<\/b>, der wir einen Verweis auf das Listenfeld und auf das aktuelle Formular übergeben:<\/p>\n Die Funktion ermittelt mit frm.Width – lst.Width <\/b>den Gesamtabstand des Listenfeldes zum linken und zum rechten Rand des Formulars, also die Differenz der Breite. Diesen Wert zieht sie dann von der aktuellen Breite des Formulars ab. Wer sich an die Mathematik-Grundlagen erinnert, weiß auch, dass man a – (b – c) in a – b + c umwandeln kann – und dies ergibt dann unseren Ausdruck frm.InsideWidth – frm.Width + lst.Width <\/b>als aktuelle Listenfeldbreite. Diesen Wert trägt die aufrufende Ereignisprozedur dann in die Variable lngListboxWidth <\/b>ein.<\/p>\n Manchmal kommt es vor, dass die hintere Spalte als flexible Spalte ausgewählt und dieser Zustand gespeichert wird – dann lautet der Wert für die Spaltenbreiten etwa 0;2;2;2;;<\/b>. Gespeichert wird aber 0;2;2;2;, <\/b>ohne das hintere Semikolon. Wir benötigen aber den Ausdruck mit allen Semikola, weshalb wir eventuell fehlende Elemente durch die Funktion aus Listing 2 ergänzen. Die Funktion erwartet den Wert der Eigenschaft ColumnWidths <\/b>sowie die Anzahl der Spalten aus der Eigenschaft ColumnCount<\/b>.<\/p>\n Listing 2: Ergänzen fehlender Semikola<\/span><\/b><\/p>\n Sie durchläuft so lange eine Do While<\/b>-Schleife und hängt darin jeweils ein Semikolon an strColumnWidths <\/b>an, bis die Anzahl der Elemente der Anzahl der Spalten entspricht. Das Ergebnis der Funktion landet wieder in der Eigenschaft ColumnWidths <\/b>des Listenfeldes aus lst<\/b>.<\/p>\n Dann startet die Prozedur eine For Each<\/b>-Schleife über alle Felder der Datensatzherkunft des Listenfeldes, welche von der Eigenschaft Fields <\/b>des Recordset<\/b>-Objekts rst <\/b>geliefert werden. Hier trägt die folgende Anweisung die Breite für die aktuelle Spalte aus der Eigenschaft ColumnWidths <\/b>in die Variable varWidth <\/b>ein. Dazu wandeln wir lst.ColumnWidths<\/b>, also etwa 0;2;;2;2 <\/b>mit der Split<\/b>-Funktion in ein Array um und ermitteln daraus das Element, dessen Index dem aktuellen Wert der Laufvariablen i <\/b>entspricht.<\/p>\n Beim ersten Durchlauf hat i <\/b>den Wert 0<\/b>, also wird varWidth <\/b>mit dem Wert 0 <\/b>gefüllt. Warum aber verwenden wir eine Variant<\/b>-Variable, wo die Spaltenbreite doch offensichtlich ein Zahlenwert ist Nun: In unserem Beispiel gelangen wir mit der dritten Spalte an eine leere Zeichenkette. Würden wir diese etwa an eine Long<\/b>-Variable übergeben, erhielten wir eine entsprechende Fehlermeldung. Nun speichern wir den Wert also zuerst in einer Variant<\/b>-Variablen, um den Inhalt anschließend zu untersuchen – und zwar in einer If…Then<\/b>-Bedingung, welche die Länge des Inhalts von varWidth <\/b>prüft. Ist diese nicht 0<\/b>, tragen wir den Wert von varWidth <\/b>in die Long<\/b>-Variable lngWidth <\/b>ein. Anderenfalls rufen wir die Funktion FlexibleSpalteBreite <\/b>auf, welche die aktuelle Breite der flexiblen Spalte berechnen soll.<\/p>\n Diese Funktion erwartet einen Verweis auf das Listenfeld sowie die aktuelle Listenfeldbreite als Parameter (s. Listing 3). Sie überträgt den Wert des Parameters lngListenfeldbreite <\/b>in die Variable lngWidthFlex<\/b>. Dann durchläuft sie eine For…Next<\/b>-Schleife über alle Werte von 0 <\/b>bis zur Anzahl der Listenfeldspalten minus 1<\/b>, wobei diese aus der Eigenschaft ColumnCount <\/b>ermittelt wird.<\/p>\n Listing 3: Ermitteln der Breite der flexiblen Spalte<\/span><\/b><\/p>\n Für jeden Durchlauf ermitteln wir wieder mit der Split<\/b>-Funktion das Array der einzelen Elemente der Eigenschaft ColumnWidths <\/b>(also etwa 0cm;2cm;;2cm;2cm<\/b> – was aber intern in einer anderen Einheit gespeichert wird) und prüfen dabei, ob die Länge des Elements nicht 0 <\/b>ist. Ist der Wert ungleich 0<\/b>, subtrahieren wir ihn zum aktuellen Wert der Variablen lngWidthFlex<\/b>.<\/p>\n Nachdem wir so alle Spaltenbreiten von der Gesamtbreite des Listenfeldes subtrahiert haben, sollte die Breite der flexiblen Spalte in der Variablen lngWidthFlex <\/b>übrig bleiben. Der Wert von lngWidthFlex <\/b>ist auch der Rückgabewert der Funktion und wird in der Variablen lngWidth <\/b>im zweiten Teil der If…Then<\/b>-Bedingung der aufrufenden Ereignisprozedur gespeichert.<\/p>\n Nun ermitteln wir die Start- und die Endkoordinaten der aktuellen Spalte auf der X-Achse. Der Startpunkt des ersten Elements wird mit lngPositionStart = lngPositionEnd <\/b>ermittelt, wobei lngPositionEnd <\/b>noch den Wert 0 <\/b>enthält und lngPositionStart <\/b>nun somit auch. Danach ermitteln wir die Endposition über den Ausdruck lngPositionStart + lngWidth<\/b>. Nach dem Erhöhen der Laufvariablen i <\/b>um den Wert 1 <\/b>prüfen wir, ob sich die Position, auf die der Benutzer geklickt hat, der aktuell in der For Each<\/b>-Schleife über alle Spalten\/Felder des Listenfeldes, innerhalb der mit lngPositionStart <\/b>und lngPositionEnd <\/b>markierten Grenzen befindet:<\/p>\n Falls ja, trägt die Prozedur zunächst den Namen der aktuellen flexiblen Spalte in das Textfeld txtDynamischeSpalte <\/b>ein. Außerdem wird der neue Ausdruck für die Eigenschaft Spaltenbreiten <\/b>beziehungsweise ColumnWidths <\/b>in der Variablen strColumnWidthsNew <\/b>um ein Semikolon erweitert. Hat der Benutzer nicht auf die aktuell durchlaufene Spalte geklickt, sondern in eine andere, fügt die Prozedur die Breite der aktuellen Spalte aus lngWidth <\/b>gefolgt von einem Semikolon zu strColumnWidthsNew <\/b>hinzu. Auf diese Weise stellt die Schleife den neuen Wert für die Eigenschaft ColumnWidths <\/b>zusammen.<\/p>\n Da mit jedem Durchlauf auch ein abschließendes Semikolon angefügt wird, dieses aber in den meisten Fällen überflüssig ist (außer, die letzte Spalte ist die flexible Spalte), wird dieses noch abgetrennt. Sollte die letzte Spalte doch die flexible Spalte sein, ergänzt der folgende Aufruf der bereits weiter oben beschriebenen Funktion SemikolonErgaenzen <\/b>wieder das abschließende Semikolon.<\/p>\n Schließlich trägt die Ereignisprozedur den Wert von strColumnWidthsNew <\/b>in die Eigenschaft ColumnWidths <\/b>des betroffenen Listenfeldes ein.<\/p>\n Dieser Beitrag hat gezeigt, dass man immer wieder noch ein wenig mehr aus den eingebauten Steuerelementen von Access herausholen kann. Das dynamische Anpassen der Spaltenbreiten eines Listenfeldes beim Anpassen der Formularbreite gibt dem Listenfeld etwa mehr Flexibilität als zuvor.<\/p>\n Wenn Sie die Lösung für eigene Formulare und Listenfelder nutzen wollen, können Sie die Anzeige der flexiblen Spalte im Textfeld auch weglassen. Grundsätzlich kann man natürlich schlecht erkennen, dass die aktuell angeklickte Spalte beim ändern der Formularbreite angepasst wird.<\/p>\n Daher beschränkt sich der Nutzen dieser Erweiterung des Listenfeldes wohl auf Anwendungen für den Eigengebrauch – aber vielleicht fällt Ihnen ja eine Möglichkeit ein, wie man dem Benutzer dies als intuitiv zu bedienendes Feature verkaufen kann <\/p>\n Enthaltene Beispieldateien:<\/p>\n DynamischeListenfeldspalte.accdb<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2016_06\/pic_1063_001.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2016_06\/pic_1063_003.png\")
<\/p>\n![\"Nun](\"..\/fileadmin\/_temp_\/2016_06\/pic_1063_004.png\")
<\/p>\nFlexible Spalte – aber nur einmal<\/h2>\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2016_06\/pic_1063_007.png\")
<\/p>\n0cm;2cm;;2cm;4cm<\/pre>\n
![\"Die](\"..\/fileadmin\/_temp_\/2016_06\/pic_1063_008.png\")
<\/p>\n![\"Beim](\"..\/fileadmin\/_temp_\/2016_06\/pic_1063_009.png\")
<\/p>\nDauerhafte flexible Spalte<\/h2>\n
Private Sub <\/span>Form_Resize()\r\n Me!lstKunden.ColumnWidths = Me!lstKunden.ColumnWidths\r\nEnd Sub<\/span><\/pre>\n![\"Mit](\"..\/fileadmin\/_temp_\/2016_06\/pic_1063_010.png\")
<\/p>\nFlexible Spalte selbst festlegen<\/h2>\n
![\"Neues](\"..\/fileadmin\/_temp_\/2016_06\/pic_1063_011.png\")
<\/p>\nPrivate Sub <\/span>lstKunden_MouseUp(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)<\/pre>\nPrivate Sub <\/span>lstKunden_MouseUp(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>lngPositionStart As Long<\/span>\r\n Dim <\/span>lngPositionEnd As Long<\/span>\r\n Dim <\/span>lngWidth As Long<\/span>\r\n Dim <\/span>varWidth As Variant<\/span>\r\n Dim <\/span>lngListboxWidth As Long<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>strColumnWidthsNew As String<\/span>\r\n Dim <\/span>lst As <\/span>ListBox\r\n Set<\/span> lst = Me!lstKunden\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(lst.RowSource)\r\n lngListboxWidth = Listenfeldbreite(lst, Me)\r\n lst.ColumnWidths = SemikolonErgaenzen(lst.ColumnWidths, lst.ColumnCount)\r\n For Each fld In rst.Fields\r\n varWidth = Split<\/span>(lst.ColumnWidths, \";\")(i)\r\n If <\/span>Not<\/span> Len<\/span>(varWidth) = 0 Then<\/span>\r\n lngWidth = varWidth\r\n Else<\/span>\r\n lngWidth = FlexibleSpalteBreite(lst, lngListboxWidth)\r\n End If<\/span>\r\n lngPositionStart = lngPositionEnd\r\n lngPositionEnd = lngPositionStart + lngWidth\r\n i = i + 1\r\n If <\/span>X >= lngPositionStart And X < lngPositionEnd Then<\/span>\r\n Me!txtDynamischeSpalte = fld.Name\r\n strColumnWidthsNew<\/span> = strColumnWidthsNew<\/span> & \";\"\r\n Else<\/span>\r\n strColumnWidthsNew<\/span> = strColumnWidthsNew<\/span> & lngWidth & \";\"\r\n End If<\/span>\r\n Next<\/span> fld\r\n strColumnWidthsNew<\/span> = Left<\/span>(strColumnWidthsNew, Len<\/span>(strColumnWidthsNew<\/span>) - 1)\r\n strColumnWidthsNew<\/span> = SemikolonErgaenzen(strColumnWidthsNew, lst.ColumnCount)\r\n lst.ColumnWidths = strColumnWidthsNew<\/span>\r\nEnd Sub<\/span><\/pre>\nListenfeldbreite ermitteln<\/h2>\n
![\"Ermittlung](\"..\/fileadmin\/_temp_\/2016_06\/pic_1063_012.png\")
<\/p>\nPrivate Function <\/span>Listenfeldbreite(lst As <\/span>ListBox, _\r\n frm As <\/span>Form) As Long<\/span>\r\n Listenfeldbreite = _\r\n frm.InsideWidth - frm.Width + lst.Width\r\nEnd Function<\/span><\/pre>\nPrivate Function <\/span>SemikolonErgaenzen(ByVal strColumnWidths As String<\/span>, ByVal lngColumnCount As Long<\/span>)\r\n Do While<\/span> Len<\/span>(strColumnWidths) - Len<\/span>(Replace<\/span>(strColumnWidths, \";\", \"\")) < lngColumnCount\r\n strColumnWidths = strColumnWidths & \";\"\r\n Loop<\/span>\r\n SemikolonErgaenzen = strColumnWidths\r\nEnd Function<\/span><\/pre>\nBreite der flexiblen Spalte ermitteln<\/h2>\n
Private Function <\/span>FlexibleSpalteBreite(lst As <\/span>ListBox, lngListenfeldbreite As Long<\/span>)\r\n Dim <\/span>j As Integer<\/span>\r\n Dim <\/span>lngWidthFlex As Long<\/span>\r\n lngWidthFlex = lngListenfeldbreite\r\n For j = 0 To lst.ColumnCount - 1\r\n If <\/span>Not<\/span> Len<\/span>(Split<\/span>(lst.ColumnWidths, \";\")(j)) = 0 Then<\/span>\r\n lngWidthFlex = lngWidthFlex - Split<\/span>(lst.ColumnWidths, \";\")(j)\r\n End If<\/span>\r\n Next<\/span> j\r\n FlexibleSpalteBreite = lngWidthFlex\r\nEnd Function<\/span><\/pre>\nIf <\/span>X >= lngPositionStart And X < lngPositionEnd Then<\/span>\r\n ...<\/pre>\nZusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h3>\n