<\/p>\n
Access bietet verschiedene Möglichkeiten, um Steuerelemente auszurichten. Diese stellen wir im Beitrag Steuerelemente ausrichten (www.access-im-unternehmen.de\/1431) vor. All diese Methoden haben jedoch Vor- und Nachteile. Der größte Nachteil ist, dass sie Zeit kosten – Zeit, die man in viel schönere Arbeiten investieren könnte. Deshalb schauen wir uns in diesem Beitrag an, wie wir in der Entwurfsansicht selektierte Steuerelemente einfach per VBA ausrichten können. Dabei ist nicht die Technik die entscheidende Frage, sondern die Vorgabe, nach welchen Regeln die Ausrichtung genau erfolgen soll. In diesem Beitrag beschreiben wir, wie man per VBA solche Steuerelemente wie Textfeld, Kombinationsfeld, Listenfeld und Kontrollkästchen und ihre Bezeichnungsfelder, die untereinander angeordnet sind, ausrichten kann.<\/b><\/p>\nAusgangssituation im Formular<\/h2>\n
Wir gehen davon aus, dass Sie als Entwickler auch mit dem Zusammenstellen von Formularen und dem Layout der enthaltenen Steuerelemente zu tun haben.<\/p>\n
In vielen Fällen kann man sich die Aufgabe, Steuerelemente sauber ausgerichtet anzulegen, erleichtern – zum Beispiel durch das Ziehen der gebundenen Felder aus der Feldliste in das Formular.<\/p>\n
Aber sobald man der Datensatzquelle des Formulars ein weiteres Feld hinzugefügt hat, das nun auch im Formularentwurf landen soll, muss man seine Position an die der anderen anpassen.<\/p>\n
Da ist man mit den im oben genannten Beitrag vorgestellten Methoden durchaus ein paar Sekunden beschäftigt – und dabei handelt es sich um eine Tätigkeit, die man während eines Access-Entwicklerlebens sehr oft wiederholt.<\/p>\n
Wir wollen die Ausgangssituation noch ein wenig chaotischer darstellen und gehen während der Entwicklung von Steuerelementen aus, die wie in Bild 1 angeordnet sind.<\/p>\n
![\"Ausgangssituation](\"..\/fileadmin\/_temp_\/2023_02\/pic_1429_001.png\")
<\/p>\n
Bild 1: Ausgangssituation im Formular<\/span><\/b><\/p>\n Wenn man diese nun manuell anordnen würde, wäre das Markieren aller Beschriftungsfelder durch Ausziehen eines geeigneten Rahmens wohl der erste Schritt. Dann würde man aus dem Kontextmenü den Befehl Ausrichten|Linksbündig <\/b>wählen. Als Nächstes wären dann die Textfelder an der Reihe, die man auf die gleiche Weise linksbündig anordnet.<\/p>\n Dann bringt man diese vielleicht noch auf eine Breite und verschiebt sie so nah an die Beschriftungsfelder heran, dass der Abstand zwischen dem breitesten Beschriftungsfeld und den Textfeldern etwa so groß ausfällt wie der vertikale Abstand zwischen den Textfeldern. Das Ergebnis sieht dann beispielsweise wie in Bild 2 aus.<\/p>\n Bild 2: Fertig ausgerichtete Steuerelemente<\/span><\/b><\/p>\n Nun wollen wir diese ganzen Schritte per VBA erledigen. Dazu können wir grundsätzlich ähnlich vorgehen. Aber welche Rahmenbedingungen dazu wollen wir festhalten? Als Erstes benötigen wir die Position unseres Blocks vom linken und vom oberen Rand aus betrachtet. Deshalb ermitteln wir die Y-Position des obersten Steuerelements und die X-Position des am weitesten links befindlichen Steuerelements. <\/p>\n Danach würden wir die Position aller Bezeichnungsfelder links an der soeben ermittelten Position ausrichten.<\/p>\n Danach wird es schon spannend – nämlich bei der Positionierung der Steuerelemente von oben nach unten. Die erste Idee war, einfach alle markierten Steuerelemente von oben nach unten zu durchlaufen und dabei dem obersten Steuerelement den soeben ermittelten Abstand vom oberen Rand zu vergeben. Die nachfolgenden Steuerelemente würden wir dann jeweils unter dem zuvor ausgerichteten Steuerelement positionieren – mit einem kleinen zusätzlichen Abstand.<\/p>\n Allerdings durchläuft Access die Steuerelemente über die Controls<\/b>-Auflistung in der Reihenfolge, die durch die Aktivierreihenfolge vorgegeben wurde. Hier stellt sich die Frage, ob wir die Steuerelemente nach der Aktivierreihenfolge ausrichten wollen oder nach der aktuellen vertikalen Anordnung. Intuitiver scheint es, die Steuerelemente nach der aktuellen Anordnung auszurichten.<\/p>\n Diese müssten wir dann erst einmal ermitteln – und das ist nicht gerade trivial. Unsere Lösung für diese Frage ist, den Steuerelementnamen und die Y-Position in einem zweidimensionalen Array zu speichern und die Daten in diesem Array nach der Y-Position zu sortieren, bevor wir sie in der so festgelegten Reihenfolge ausrichten.<\/p>\n Des Weiteren stellt sich die Frage, ob wir uns bei der Höhe für ein Bezeichnungsfeld-Steuerelement-Paar nach der Höhe des Bezeichnungsfeldes oder des Steuerelements richten. Es kann sowohl vorkommen, dass das Bezeichnungsfeld höher ist als das Steuerelement (bei einer längeren Bezeichnung), aber auch Textfelder kommen gelegentlich mit einer größeren Höhe, beispielsweise um mehrere Zeilen anzuzeigen.<\/p>\n Spätestens wenn Listenfelder ins Spiel kommen, sind diese meist höher als das jeweilige Bezeichnungsfeld.<\/p>\n Die einfachste Lösung für diesen Fall scheint zu sein, das jeweils höhere Element zu berücksichtigen.<\/p>\n Bei den Bezeichnungsfeldern stellt sich die Frage, ob diese bereits die richtige Breite aufweisen. Sicherheitshalber wollen wir die Breite auf den tatsächlich enthaltenen Bezeichnungstext anpassen. Damit ermitteln wir nun die maximale Breite der Bezeichnungsfelder und stellen alle Bezeichnungsfelder auf diese Breite ein. Dies ist eine Vorbereitung auf den Fall, dass der Benutzer seine Bezeichnungsfelder rechtsbündig ausrichten möchte.<\/p>\n Danach richten wir die eigentlichen Steuerelemente, in unserem Beispiel also die Textfelder, entsprechend aus. Dabei nutzen wir die X-Position der Bezeichnungsfelder plus ihre Breite plus wiederum einem kleinen Abstand, wie wir ihn auch bereits für die vertikale Anordnung genutzt haben.<\/p>\n Während die Höhe von Textfeldern in der Regel an die jeweiligen Bezeichnungsfelder angepasst ist, sind Kontrollkästchen etwas weniger hoch und ihr Abstand vom oberen Rand des Formulars stimmt nicht mit dem des dazugehörigen Bezeichnungsfelds überein. Hier müssen wir eine Spezialbehandlung vornehmen. Wir können das Kontrollkästchen nicht auf der gleichen Y-Position wie das Bezeichnungsfeld platzieren, da es sonst optisch etwas zu weit oben angezeigt wird.<\/p>\n Also bauen wir beim Ausrichten des Kontrollkästchens einen zusätzlichen Abstand von oben ein. Da es normalerweise auch noch weniger hoch als ein Textfeld oder Bezeichnungsfeld ist, müssen wir in diesem Fall die Höhe des Bezeichnungsfeldes als Maßstab für die Ausrichtung des darunter liegenden Steuerelements nutzen.<\/p>\n Neben den bereits erwähnten Vorgaben wollen wir dem Benutzer noch die Möglichkeit geben, weitere Einstellungen vorzunehmen. Dazu stellen wir der Hauptprozedur einige Parameter bereit. Damit wollen wir die folgenden Einstellungen vornehmen:<\/p>\n Zum Aufwärmen wollen wir die Prozedur schreiben, mit der wir den aktuell markierten Bezeichnungsfeldern einen Doppelpunkt hinzufügen, sofern dieser noch nicht vorhanden ist. Diese Prozedur heißt AddColonToLabels <\/b>und ist in Listing 1 abgebildet.<\/p>\n Listing 1: Hinzufügen von Doppelpunkten zu den Bezeichnungsfeldern<\/span><\/b><\/p>\n Die Prozedur können wir auch allein aufrufen. Sie deklariert eine Form<\/b>– und eine Control<\/b>-Variable. Mit der Form<\/b>-Variable frm <\/b>referenziert sie über die Eigenschaft Screen.ActiveForm <\/b>das aktuell markierte Formular. Die Variable ctl <\/b>kann alle Steuerelemente referenzieren. Damit durchlaufen wir in einer For Each<\/b>-Schleife alle Steuerelemente des referenzierten Formulars.<\/p>\n In der folgenden If…Then<\/b>-Bedingung prüfen wir mit der Eigenschaft InSelection<\/b>, ob das aktuelle mit ctl <\/b>über die Schleife referenzierte Steuerelement derzeit markiert ist. Ist das der Fall, untersuchen wir in einer Select Case<\/b>-Bedingung durch einen Vergleich der Eigenschaft ControlType <\/b>mit der Konstanten acLabel<\/b>, ob es sich um ein Bezeichnungsfeld handelt. Falls ja, prüfen wir schließlich noch, ob das letzte Zeichen ein Doppelpunkt ist. Ist das nicht der Fall, fügen wir der Eigenschaft Caption am Ende einen Doppelpunkt hinzu.<\/p>\n Diese Prozedur können Sie nun bereits ausprobieren. Dazu fügen Sie einem Formular in der Entwurfsansicht ein beliebiges Steuerelement mit einem Bezeichnungsfeld hinzu oder ein einzelnes Bezeichnungsfeld. Dieses markieren Sie nun. Anschließend rufen Sie die Prozedur AddColonToLabels <\/b>auf. Sollte das Bezeichnungsfeld zu diesem Zeitpunkt noch keinen abschließenden Doppelpunkt haben, wird dieser nun hinzugefügt.<\/p>\n Nach dem Aufwärmen schauen wir uns gleich die Hauptprozedur der Lösung aus diesem Beitrag an. Diese heißt AlignControls <\/b>und erwartet vier Parameter:<\/p>\n Die Prozedur finden Sie in Listing 2. Die von dieser Prozedur aufgerufenen weiteren Funktionen und Prozeduren bilden wir im Verlauf ab. Die Prozedur deklariert zunächst einige Variablen.<\/p>\n [<\/p>\n Listing 2: Hauptprozedur zum Ausrichten von Steuerelementen<\/span><\/b><\/p>\n Direkt die erste Anweisung ruft eine Hilfsfunktion namens GetFormInDesignView <\/b>auf, welche eine leere Rückgabevariable namens frm <\/b>als Parameter erhält. Die Funktion, die wir in Listing 3 abgebildet haben, hat die Aufgabe, das aktuelle Formular zu ermitteln und gleich noch zu prüfen, ob dieses in der Entwurfsansicht geöffnet ist. Anderenfalls können wir nämlich nicht auf die aktuell markierten Steuerelemente zugreifen.<\/p>\n Listing 3: Funktion zum Holen des aktuellen Formulars in der Entwurfsansicht<\/span><\/b><\/p>\n Die Funktion holt mit Screen.ActiveForm <\/b>das Formular, welches aktuell den Fokus hat. Das kann bereits schiefgehen, wenn gerade kein Formular den Fokus hat – in diesem Fall ist frm <\/b>danach leer und die Funktion wird mit dem Wert False <\/b>verlassen.<\/p>\n Enthält frm <\/b>danach jedoch ein Formular, prüfen wir seine Ansicht mit der CurrentView<\/b>-Eigenschaft. Hat diese den Wert 0<\/b>, ist das aktuelle Objekt ein Formular in der Entwurfsansicht und wir können den Wert True <\/b>als Funktionswert zurückliefern – die Rückgabevariable frm <\/b>ist ja ohnehin bereits mit einem Verweis auf das betroffene Formular gefüllt.<\/p>\n Liefert GetFormInDesignView <\/b>den Wert False <\/b>zurück, erscheint eine entsprechende Meldung und die Prozedur AlignControls <\/b>wird beendet.<\/p>\n Die Prozedur macht nur Sinn, wenn zumindest zwei Steuerelemente markiert sind – genau genommen ein Steuerelement plus seinem Bezeichnungsfeld.<\/p>\n Diese Information holen wir mit der Funktion GetSelectedControlCount<\/b>, der wir einen Verweis auf das zu untersuchende Formular übergeben und welche die Anzahl der markierten Steuerelemente zurückliefern soll.<\/p>\n Die Funktion finden wir in Listing 4. In dieser Funktion durchlaufen wir alle Steuerelemente des Formulars und untersuchen eine Eigenschaft, die wohl eher selten eingesetzt wird: Sie heißt InSelection <\/b>und gibt an, ob das Steuerelement, für das sie abgefragt wird, markiert ist.<\/p>\n Listing 4: Funktion zum Zählen der markierten Steuerelemente<\/span><\/b><\/p>\n Für jedes markierte Element addieren wir den Wert 1 <\/b>zur Variablen lngCount <\/b>hinzu. Den Wert dieser Variablen geben wir nach dem Durchlaufen aller Steuerelemente als Funktionsergebnis zurück.<\/p>\n Sind weniger als zwei Steuerelemente ausgewählt, wird die aufrufende Prozedur nach einer entsprechenden Meldung beendet.<\/p>\n Mit den nächsten Anweisungen werden wir schnell viele Steuerelemente manipulieren.<\/p>\n Dies führt gelegentlich zu Flackern und Artefakten von verschobenen Steuerelementen. Um dies zu verhindern, deaktivieren wir für diesen Zeitraum die Aktualisierung der Anzeige und aktivieren sie am Ende der Prozedur wieder:<\/p>\n Wenn der Benutzer mit dem Parameter bolColons <\/b>den Wert True <\/b>übergeben hat, ruft die Prozedur die Routine AddColonToLabels <\/b>auf, um den Bezeichnungsfeldern Doppelpunkte hinzuzufügen, wo noch keine vorhanden sind.<\/p>\n Die nächste Anweisung ruft die Prozedur OptimizeLabelSizes <\/b>auf und übergibt einen Verweis auf das zu bearbeitende Formular. Die Prozedur durchläuft wiederum alle Steuerelemente in einer Schleife, um die Bezeichnungsfelder der markierten Steuerelemente anzupassen (siehe Listing 5). In der Schleife prüft die Prozedur, ob es sich um ein markiertes Steuerelement handelt. Ist dieses kein Bezeichnungsfeld, holt es sich über Controls(0) <\/b>das zum Steuerelement gehörende Bezeichnungsfeld und stellt seine Größe mit der Methode SizeToFit <\/b>auf die Größe des enthaltenen Texts ein.<\/p>\n Listing 5: Prozedur zum Optimieren der Größe der Bezeichnungsfelder<\/span><\/b><\/p>\n Die nun aufgerufene Funktion GetMostLeftLabel <\/b>soll den Abstand des am meisten links liegenden Bezeichnungsfeldes vom linken Rand des Formulars ermitteln (siehe Listing 6).<\/p>\n Listing 6: Funktion zum Ermitteln des am weitesten links liegenden Bezeichnungsfeldes<\/span><\/b><\/p>\n Die Funktion durchläuft alle Steuerelemente und prüft, ob das aktuelle Element markiert ist. In einer Select Case<\/b>-Bedingung untersucht sie nur die Bezeichnungsfelder. Der Abstand des am weitesten links befindlichen Steuerelements vom linken Rand soll in der Variablen lngLeft <\/b>gespeichert werden. Der Wert ist zu Beginn auf 999.999 <\/b>eingestellt. Ist der Wert der Eigenschaft Left <\/b>des aktuell durchlaufenen Bezeichnungsfeldes kleiner als dieser Wert, wird dieser in lngLeft <\/b>gespeichert. Nach dem Untersuchen aller Bezeichnungsfelder landet so der entsprechende Wert in der Variablen lngLeft<\/b> und wird an die aufrufende Prozedur zurückgegeben.<\/p>\n Der folgende Funktionsaufruf ermittelt die Breite des breitesten Bezeichnungsfeldes unter den markierten Steuerelementen. Die Funktion heißt GetMaxLabelWidth <\/b>und erwartet das zu untersuchende Formular als Parameter (siehe Listing 7).<\/p>\n Listing 7: Funktion zum Ermitteln der größten Breite eines Bezeichnungsfeldes<\/span><\/b><\/p>\n Sie funktioniert so ähnlich wie die zuvor beschriebene Funktion, nur dass sie die Breite der markierten Bezeichnungsfelder untersucht und jeweils die Breite des aktuellen Bezeichnungsfeldes in der Variablen lngWidth <\/b>speichert, wenn diese größer als der bisher darin enthaltene Wert ist. Der zurückgegebene Wert landet in der Variablen lngLabelWidth<\/b>.<\/p>\n Damit können wir nun den gewünschten Abstand der Steuerelemente (nicht der Bezeichnungsfelder) vom linken Rand des Formulars ermitteln. Er entspricht der Breite der Bezeichnungsfelder plus dem Abstand zwischen Bezeichnungsfeld und Steuerelement plus dem Abstand der Bezeichnungsfelder vom linken Formularrand und wird in der Variablen lngControlLeft <\/b>gespeichert.<\/p>\n Hier ein wichtiger Hinweis: Die Prozedur soll die Steuerelemente in der Reihenfolge von oben nach unten anordnen, in der sich diese auch vor dem Aufruf der Prozedur befinden. Dazu sind ein paar zusätzliche Schritte erforderlich, denn wenn wir einfach alle Steuerelemente durchlaufen und diese von oben nach unten anordnen würden, würden wir diese in der Reihenfolge der Aktivierung durchlaufen.<\/p>\n Um diese nach der Position von oben aus gesehen zu durchlaufen (was die gleiche Reihenfolge sein kann), fügen wir die Steuerelemente samt der Höhe in ein Array ein und sortieren dessen Einträge anschließend nach der jeweiligen Höhe. Die erste Funktion, die wir benötigen, heißt GetControlArray <\/b>und fügt die markierten Steuerelemente (außer die Bezeichnungsfelder) in ein zweidimensionales Array ein (siehe Listing 8).<\/p>\nVorgaben zur Anordnung von Steuerelementen<\/h2>\n
![\"Fertig](\"..\/fileadmin\/_temp_\/2023_02\/pic_1429_002.png\")
<\/p>\nVorgang per VBA abbilden<\/h2>\n
Sonderfall Kontrollkästchen<\/h2>\n
Zusätzliche Einstellungen<\/h2>\n
\n
Doppelpunkte hinter Beschriftungen setzen<\/h2>\n
Public Sub <\/span>AddColonToLabels()\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>ctl As <\/span>Control\r\n Set<\/span> frm = Screen.ActiveForm\r\n For Each ctl In frm.Controls\r\n If <\/span>ctl.InSelection Then<\/span>\r\n Select Case ctl.ControlType\r\n Case <\/span>acLabel\r\n If <\/span>Not<\/span> Right<\/span>(ctl.Caption, 1) = \":\" Then<\/span>\r\n ctl.Caption = ctl.Caption & \":\"\r\n End If<\/span>\r\n End Select<\/span>\r\n End If<\/span>\r\n Next<\/span> ctl\r\nEnd Sub<\/span><\/pre>\nProzedur zum Ausrichten der Steuerelemente<\/h2>\n
\n
Public Sub <\/span>AlignControls(Optional<\/span> lngDistanceLabelControl As Long<\/span> = 100, Optional<\/span> lngVerticalDistance As Long<\/span> = 100, _\r\n Optional<\/span> varAlignment As Variant<\/span> = 0, Optional<\/span> bolColons As Boolean<\/span> = False<\/span>)\r\n Dim <\/span>frm As <\/span>Form, ctl As <\/span>Control\r\n Dim <\/span>lngLabelLeft As Long<\/span>, lngLabelWidth As Long<\/span>, lngControlLeft As Long<\/span>, lngTop As Long<\/span>, lngMaxHeight As Long<\/span>\r\n Dim <\/span>lblControl As <\/span>Label, varControls() As Variant<\/span>, i As Integer<\/span>\r\n If <\/span>Not<\/span> GetFormInDesignView(frm) Then<\/span>\r\n MsgBox<\/span> \"Es ist kein Formular in der Entwurfsansicht geöffnet.\", vbOKOnly + vbExclamation\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n If <\/span>GetSelectedControlCount(frm) < 2 Then<\/span>\r\n MsgBox<\/span> \"Es müssen mindestens zwei Steuerelemente ausgewählt sein.\", vbOKOnly + vbExclamation\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n DoCmd.Echo False<\/span>\r\n If <\/span>bolColons Then<\/span>\r\n AddColonToLabels\r\n End If<\/span>\r\n OptimizeLabelSizes frm\r\n lngLabelLeft<\/span> = GetMostLeftLabel(frm)\r\n lngLabelWidth = GetMaxLabelWidth(frm)\r\n lngControlLeft<\/span> = lngLabelWidth + lngDistanceLabelControl + lngLabelLeft\r\n varControls = GetControlArray(frm)\r\n SortArray varControls\r\n lngTop = varControls(0, 0)\r\n For i = 0 To UBound<\/span>(varControls, 2)\r\n Set<\/span> ctl = frm.Controls(varControls(1, i))\r\n ctl.Left<\/span> = lngControlLeft\r\n If <\/span>Not<\/span> lngTop = 0 Then<\/span>\r\n ctl.Top = lngTop\r\n If <\/span>ctl.ControlType = acCheckBox Then<\/span> ''Korrektur für Kontrollkästchen\r\n ctl.Top = ctl.Top + 30\r\n End If<\/span>\r\n Set<\/span> lblControl = ctl.Controls(0)\r\n lngMaxHeight = ctl.Height\r\n If <\/span>lblControl.Height > lngMaxHeight Then<\/span>\r\n lngMaxHeight = lblControl.Height\r\n End If<\/span>\r\n lblControl.Top = lngTop\r\n lblControl.Left<\/span> = lngLabelLeft\r\n lblControl.Width = lngLabelWidth\r\n If <\/span>Not<\/span> IsMissing(varAlignment) Then<\/span>\r\n lblControl.TextAlign = varAlignment\r\n End If<\/span>\r\n End If<\/span>\r\n lngTop = lngTop + lngMaxHeight + lngVerticalDistance\r\n Next<\/span> i\r\n DoCmd.Echo True<\/span>\r\nEnd Sub<\/span><\/pre>\nAktuelles Formular in der Entwurfsansicht holen<\/h2>\n
Public Function <\/span>GetFormInDesignView(frm As <\/span>Form) As Boolean<\/span>\r\n On Error Resume Next<\/span>\r\n Set<\/span> frm = Screen.ActiveForm\r\n If <\/span>Not<\/span> frm Is Nothing Then<\/span>\r\n If <\/span>frm.CurrentView = 0 Then<\/span>\r\n GetFormInDesignView = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\nEnd Function<\/span><\/pre>\nMarkierte Steuerelemente zählen<\/h2>\n
Public Function <\/span>GetSelectedControlCount(frm As <\/span>Form) As Long<\/span>\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>lngCount As Long<\/span>\r\n For Each ctl In frm.Controls\r\n If <\/span>ctl.InSelection Then<\/span>\r\n lngCount = lngCount + 1\r\n End If<\/span>\r\n Next<\/span> ctl\r\n GetSelectedControlCount = lngCount\r\nEnd Function<\/span><\/pre>\nFlackern und Effekte ausschalten<\/h2>\n
DoCmd.Echo False<\/span>\r\n...\r\nDoCmd.Echo True<\/span><\/pre>\nBezeichnungsfelder mit Doppelpunkten versehen<\/h2>\n
Größe der Bezeichnungsfelder optimieren<\/h2>\n
Public Sub <\/span>OptimizeLabelSizes(frm As <\/span>Form)\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>lbl As <\/span>Label\r\n For Each ctl In frm.Controls\r\n If <\/span>ctl.InSelection Then<\/span>\r\n Select Case ctl.ControlType\r\n Case <\/span>acLabel\r\n Case Else<\/span>\r\n Set<\/span> lbl = ctl.Controls(0)\r\n lbl.SizeToFit\r\n End Select<\/span>\r\n End If<\/span>\r\n Next<\/span> ctl\r\nEnd Sub<\/span><\/pre>\nBezeichnungsfeld ermitteln, das am weitesten links liegt<\/h2>\n
Public Function <\/span>GetMostLeftLabel(frm As <\/span>Form) As Long<\/span>\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>lngLeft As Long<\/span>\r\n Dim <\/span>lbl As <\/span>Label\r\n lngLeft<\/span> = 999999\r\n For Each ctl In frm.Controls\r\n Select Case ctl.ControlType\r\n Case <\/span>acLabel\r\n Set<\/span> lbl = ctl\r\n If <\/span>lbl.Left<\/span> < lngLeft Then<\/span>\r\n If <\/span>ctl.InSelection = True<\/span> Then<\/span>\r\n lngLeft<\/span> = lbl.Left\r\n End If<\/span>\r\n End If<\/span>\r\n End Select<\/span>\r\n Next<\/span> ctl\r\n GetMostLeftLabel = lngLeft\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>GetMaxLabelWidth(frm As <\/span>Form) As Long<\/span>\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>lngMaxLabelWidth As Long<\/span>\r\n Dim <\/span>lbl As <\/span>Label\r\n For Each ctl In frm.Controls\r\n Select Case ctl.ControlType\r\n Case <\/span>acLabel\r\n Set<\/span> lbl = ctl\r\n If <\/span>ctl.InSelection = True<\/span> Then<\/span>\r\n If <\/span>lbl.Width > lngMaxLabelWidth Then<\/span>\r\n lngMaxLabelWidth = lbl.Width\r\n End If<\/span>\r\n End If<\/span>\r\n End Select<\/span>\r\n Next<\/span> ctl\r\n GetMaxLabelWidth = lngMaxLabelWidth\r\nEnd Function<\/span><\/pre>\nSteuerelemente von oben nach unten sortieren<\/h2>\n
Public Function <\/span>GetControlArray(frm As <\/span>Form) As Variant<\/span>\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>varControls() As Variant<\/span>\r\n For Each ctl In frm.Controls\r\n If <\/span>ctl.InSelection