<\/p>\n
Wenn im Formular oder in den enthaltenen Steuerelementen zur Laufzeit merkwürdige Werte angezeigt werden oder die Elemente nicht wie gewünscht reagieren, kann das verschiedene Ursachen haben. Viele davon lassen sich am einfachsten aufdecken, wenn Sie die Werte und Eigenschaften auslesen, während das Formular in der Formularansicht geöffnet ist. Doch das ist nicht ganz einfach, denn es erfordert eine Menge Tipparbeit – und oft die genaue Kenntnis der Formular-, Unterformular- oder Steuerelementnamen. Wir zeigen eine Methode, die das Abfragen der Eigenschaftswerte erheblich vereinfacht.<\/b><\/p>\nDie Standardmethode<\/h2>\n
Sind wir mal ehrlich: Wenn Sie den Wert der Eigenschaft eines Steuerelements eines geöffneten Formulars ermitteln wollen, geht man üblicherweise über das Direktfenster und ermittelt den gesuchten Wert mit der Debug.Print<\/b>-Anweisung.<\/p>\n
Schauen Sie sich beispielsweise das Formular aus Bild 1 an. Es enthält einige Kombinationsfelder, die natürlich – wie es in einer professionel gestalteten Anwendung der Fall sein sollte – nicht die Primärschlüsselwerte der gebundenen Datenherkunft, sondern die für den Benutzer wichtigen Werte wie den Kundennamen, den Namen des Sachbearbeiters oder auch im Unterformular den Namen des Artikels anzeigen. Nun kommt es vor, dass Sie sich fragen, welches Formular Sie dort gerade überhaupt geöffnet haben. Wenn es das einzige Formular ist, können Sie dies mit dem ersten Eintrag der Forms<\/b>-Auflistung herausfinden:<\/p>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2016_06\/pic_1066_001.png\")
<\/p>\n
Bild 1: Formular und Unterformular zur Verwaltung von Bestellungen<\/span><\/b><\/p>\n Sind mehrere Formular geöffnet, hilft dies nicht weiter, denn Sie kennen ja den Index des zu untersuchenden Formulars nicht. In diesem Fall greifen Sie einfach über die Eigenschaft ActiveForm <\/b>des Screen<\/b>-Objekts auf das Formular zu und lassen sich dessen Namen ausgeben:<\/p>\n Auf diese Weise haben Sie schon einmal den Namen des Formulars herausgefunden. Damit können Sie nun gezielt auf dieses Formular und seine Eigenschaften, wie zum Beispiel Name<\/b>, zugreifen (was zugegebenermaßen wenig Sinn macht, da wir den Namen ja schon kennen – aber es ist ja nur ein Beispiel!):<\/p>\n Sie können damit natürlich auch etwa die Datenherkunft des Formulars ausgeben lassen:<\/p>\n Auf die gleiche Weise greifen Sie auch auf die übrigen Eigenschaften des Formulars zu.<\/p>\n Nun gehen wir einen Schritt weiter und kümmern uns um die Steuerelemente. Wenn Sie nicht wissen, wie ein Steuerelement heißt, können Sie sich in einer Schleife die Steuerelementnamen ausgeben lassen:<\/p>\n Dies gibt die Namen aller Steuerelemente im Direktfenster aus. Wenn Sie das gewünschte Steuerelement gefunden haben, können Sie wie folgt darauf zugreifen – in diesem Beispiel auf das Steuerelement BestellungID<\/b>:<\/p>\n Das entspricht der folgenden Syntax mit dem Ausrufezeichen:<\/p>\n Bei den Steuerelementen, die aktivierbar sind, also denen Sie den Fokus etwa per Mausklick zuweisen können, gibt es noch eine einfachere Methode, beispielsweise den Namen zu ermitteln. Dazu verwenden Sie eine weitere Eigenschaft des Screen<\/b>-Objekts, nämlich ActiveControl<\/b>. Wenn Sie einmal das Steuerelement zur Anzeige des Feldes BestellungID <\/b>per Mausklick aktivieren und dann im Direktfenster die folgende Anweisung absetzen, erhalten Sie ebenfalls den Namen dieses Steuerelements:<\/p>\n Auf den enthaltenen Wert oder andere Eigenschaften greifen Sie auf diesem Wege zu:<\/p>\n Aber warum sollte man überhaupt auf den Wert eines Steuerelements zugreifen, wenn man diesen sowieso im Formular selbst ablesen kann Nun: Es gibt ja auch Steuerelemente, die ihren eigentlichen Inhalt nicht offenbaren – zum Beispiel die Kombinationsfelder dieses Beispielformulars, die allesamt nicht den Wert der gebundenen Spalte anzeigen (also den Feldwert des Feldes der Datenherkunft des Formulars, an das sie gebunden sind), sondern den Wert einer anderen Spalte der Datensatzherkunft des Kombinationsfeldes. Um die KundeID <\/b>des Kunden aus dem Kombinationsfeld KundeID <\/b>zu ermitteln, geben Sie folglich ein:<\/p>\n Diese Information können Sie dem Kombinationsfeld sonst nicht entlocken. Sie können natürlich auch auf den Inhalt der übrigen Spalten der Datensatzherkunft des Kombinationsfeldes zugreifen:<\/p>\n Noch sinnvoller ist dies natürlich, wenn die Datensatzherkunft des Kombinationsfeldes noch weitere Felder enthält, die nicht eingeblendet sind. Mit der Eigenschaft Column <\/b>stehe ich übrigens auf Kriegsfuß – ich gebe immer Columns ein, da ich denke, dass diese Eigenschaft, der man ja einen Index übergibt, eine Auflistung sein und dementsprechend im Plural angegeben werden müsste. Deshalb wäre es praktisch, wenn man hier mit IntelliSense arbeiten könnte – aber der VBA-Editor erkennt an dieser Stelle nicht den Typ des Objekts KundeID <\/b>und blendet somit auch nicht dessen Eigenschaften und Methoden ein. Später schauen wir uns allerdings eine Möglichkeit an, auch über das Direktfenster auf solche Informationen per IntelliSense zuzugreifen.<\/p>\n Nun stürzen wir uns allerdings erstmal auf das Unterformular. Hier entsteht oft das Missverständnis, dass das Unterformular-Steuerelement, das ja quasi nur ein Rahmen für das eigentliche, als Unterformular angegebene Formular ist, als Formular angesprochen wird.<\/p>\n Das Unterformular-Steuerelement hat jedoch ganz andere Eigenschaften als das darin enthaltene Formular, und Sie können auch nicht direkt über das Unterformular-Steuerelement auf die enthaltenen Steuerelemente des Unterformulars zugreifen. Zur Verdeutlichung haben wir das Unterformular-Steuerelement, das beim Hineinziehen des Unterformulars in den Entwurf des Hauptformulars unpraktischerweise den gleichen Namen erhält wie das Unterformular selbst (hier sfmBestellungen<\/b>), umbenannt, und zwar in sfmBestellungen_UFD <\/b>(für Unterformular-Control, s. Bild 2). <\/p>\n Bild 2: Umbenennen des Unterformulare-Steuerelements<\/span><\/b><\/p>\n Nun können wir zunächst wie folgt auf das Unterformular-Steuerelement zugreifen und uns zum Beispiel die beiden Felder ausgeben lassen, über welche die Synchronisation zwischen den Datensätzen aus Haupt- und Unterformular hergestellt wird:<\/p>\n Den Namen dieser beiden Eigenschaften müsste man zu diesem Zweck auch erst mal kennen beziehungsweise ermitteln. Das Unterformular-Steuerelement ist übrigens eines der Steuerelemente, dem Sie nicht den Fokus zuweisen können. Sie können also auch nicht mit Screen.ActiveControl <\/b>darauf zugreifen.<\/p>\n Wenn Sie dann auf das im Unterformular-Steuerelement selbst enthaltene Unterformular zugreifen wollen, müssen Sie noch die Eigenschaft Form <\/b>hinzufügen – hier ermitteln wir den Namen des Unterformulars:<\/p>\n Um auf die im Unterformular enthaltenen Steuerelemente zuzugreifen, können Sie einfach wieder den Steuerelementnamen entweder über die Controls<\/b>-Auflistung referenzieren oder direkt per Ausrufezeichen-Syntax:<\/p>\n In diesem Fall greifen wir auf ein Feld der Datenherkunft zu, das selbst gar nicht als Steuerelement abgebildet ist. Woran erkennen Sie, dass Sie ein Feld der Datenherkunft referenzieren und dass es kein Steuerelement ist Sie können versuchen, etwa die Eigenschaft Name <\/b>oder DefaultValue <\/b>abzufragen. Das führt zu der Fehlermeldung aus Bild 3. Greifen wir lieber auf ein echtes Steuerelement zu, beispielsweise um die ArtikelID <\/b>des Artikels der ersten Bestellposition im Unterformular zu erhalten. Erstmal geben wir den Namen aus, um zu prüfen, ob wir auch auf das Steuerelement zugreifen:<\/p>\n Bild 3: Fehler beim Zugriff auf die Eigenschaft DefaultValue eines Feldes<\/span><\/b><\/p>\n Danach holen wir uns die ArtikelID<\/b>:<\/p>\n übrigens können Sie so auch nur auf die Werte des jeweils aktivierten Datensatzes im Unterformular zugreifen. Wenn beispielsweise der erste Datensatz markiert ist und Sie wollen die ArtikelID <\/b>für den zweiten Datensatz einer Bestellung erhalten, müssen Sie diesen Datensatz zunächst im Unterformular markieren.<\/p>\n Wenn Sie diesen Datensatz im Unterformular markieren, können Sie aber auch gleich auf das Kombinationsfeld zur Auswahl der Artikel klicken, um die folgende, viel einfachere Anweisung zu nutzen:<\/p>\n Dennoch: Es stört schon etwas, dass man immer noch die Eigenschaften selbst eintippen muss und dass kein IntelliSense zur Verfügung steht. Wie Sie dies hinzufügen können, schauen wir uns im Folgenden an.<\/p>\n Um unser Ziel zu erreichen, bedarf es der Programmierung einer kleinen Klasse mit speziellen Eigenschaften.<\/p>\n Diese Klasse fügen Sie über den Menübefehl Einfügen|Klassenmodul <\/b>des VBA-Editors hinzu und nennen sie Debugger<\/b>. Dann exportieren Sie die Klasse über den Kontextmenü-Befehl des neuen Eintrags im Projekt-Explorer in eine Textdatei (s. Bild 4). Entfernen Sie die soeben erstellte Klasse dann mit dem Kontextmenü-Eintrag Entfernen von Debugger … <\/b>und antworten Sie auf die nun erscheinende Meldung mit Nein<\/b>.<\/p>\n Bild 4: Exportieren des Klassenmoduls<\/span><\/b><\/p>\n Nun ändern Sie in einem Texteditor Ihrer Wahl die gespeicherte Textdatei mit der Klasse wie in Bild 5. Dabei stellen Sie die Werte für die beiden Eigenschaften VB_Creatable <\/b>und VB_PredeclaredID <\/b>auf True <\/b>ein:<\/p>\n <\/p>\n Bild 5: Geänderte Version des Klassenmoduls<\/span><\/b><\/p>\n Nun importieren Sie die Datei wieder in das VBA-Projekt – am einfachsten, indem Sie es einfach aus dem Windows Explorer in den Projekt-Explorer ziehen. Aber was bewirkt diese änderung nun Das lässt sich schnell erklären, wenn Sie eine kleine Beispielmethode wie die folgende zu der Klasse hinzufügen:<\/p>\n Sie können nun im Direktfenster einfach den folgenden Ausdruck eingeben, um die Klasse zu instanzieren und die Methode Test <\/b>zu nutzen:<\/p>\n Dies zeigt dann das erwartete Meldungsfenster an. Nun wollen wir unsere Debugger-Klasse zunächst mit den Funktionen ausstatten, die auch die Screen-Klasse bietet – zum Beispiel mit dem Zugriff auf das aktive Formular über die Eigenschaft Screen.ActiveForm<\/b>. Dazu fügen wir der Klasse die folgende Property Get<\/b>-Methode hinzu:<\/p>\n Damit können Sie nun wie in Bild 6 mit IntelliSense-Unterstützung auf die Methode ActiveForm<\/b> unserer neuen Klasse zugreifen. Diese leitet dann das Ergebnis der Methode Screen.ActiveForm <\/b>weiter. Der komplette Aufruf sieht etwa wie folgt aus:<\/p>\n Bild 6: Neue Methoden per IntelliSense<\/span><\/b><\/p>\n Das Gleiche erledigen wir noch für die Eigenschaft ActiveControl<\/b>. Aber was haben wir damit nun erreicht – abgesehen davon, dass wir nun eine eigene Klasse haben, auf die wir direkt zugreifen können und die uns eine Teilmenge der Funktionen der Screen-Klasse liefert Noch nicht viel, aber: Unsere Klasse können wir im Vergleich zur Screen<\/b>-Klasse erweitern! Und hier beginnt der Spaß: Wir können nun beispielsweise Eigenschaften hinzufügen, mit denen wir nicht nur allgemein auf das aktuelle Steuerelement zugreifen, was nicht viel bringt, da wir nicht per IntelliSense auf seine Eigenschaften zugreifen können.<\/p>\n Da wäre zum Beispiel die Property Get<\/b>-Eigenschaft namens ActiveTextbox <\/b>aus Listing 1, die – falls das aktive Steuerelement ein Textfeld ist – einen Verweis auf dieses Textfeld zurückliefern soll. Die Eigenschaft hat den Datentyp Textbox<\/b>, was bedeuetet, dass Sie per IntelliSense auf alle Eigenschaften dieses Steuerelements zugreifen können. Dazu müssen wir es allerdings erst einmal referenzieren. Die Eigenschaftsmethode stellt dazu zunächst die Control<\/b>-Variable ctl <\/b>auf das mit Screen.ActiveControl <\/b>ermittelte aktive Steuerelement ein. Handelt es sich dabei um ein Steuerelement des Typs Textbox<\/b>, was wir durch den Abgleich der Eigenschaft ControlType <\/b>mit der Konstanten acTextBox <\/b>prüfen, stellt die Prozedur den Rückgabewert der Methode auf Screen.ActiveControl <\/b>ein. Das ist im Grunde nichts anderes als das, was Screen.ActiveControl <\/b>selbst liefert – nur, dass wir über die Eigenschaft den Datentyp des gelieferten Elements auf Textbox <\/b>einstellen.<\/p>\n Listing 1: Definition einer Eigenschaft für den Zugriff auf das aktive Textfeld<\/span><\/b><\/p>\n Sollte der Benutzer die Eigenschaft Debugger.ActiveText-box <\/b>aufrufen, wenn das aktive Steuerelement nicht den Typ Textbox <\/b>aufweist, ermitteln wir mit der Hilfsfunktion GetControlType <\/b>eine Zeichenkette mit dem Namen des Steuerelementtyps und geben eine Meldung aus, damit der Benutzer über den Grund der nachfolgenden Fehlermeldung informiert wird.<\/p>\n Die Abfolge der Meldungen in diesem Fall finden Sie, ausgehend vom Absetzen der Debugger.ActiveTextbox<\/b>-Anweisung im Direktfenster, in Bild 7.<\/p>\n Bild 7: Fehlermeldungen beim Zugriff auf das aktive Steuerelement, wenn es kein Textfeld ist<\/span><\/b><\/p>\n Die Hilfsfunktion GetControlType<\/b> sieht wie in Listing 2 aus. Die Funktion erwartet einen Verweis auf das zu untersuchende Steuerelement als Parameter und prüft dann in einer Select Case<\/b>-Bedingung den Wert der Eigenschaft ControlType <\/b>des Steuerelements. Wir haben hier nur die vier Steuerelementtypen Textbox<\/b>, ComboBox<\/b>, ListBox <\/b>und CommandButton <\/b>berücksichtigt – weitere können Sie nach Bedarf ergänzen.<\/p>\n Listing 2: Hilfsfunktion zum Ermitteln eines Strings mit dem Steuerelementtyp<\/span><\/b><\/p>\n Wenn Sie nun im Direktfenster wie in Bild 8 die Zeichenfolge Debugger.ActiveTextbox <\/b>gefolgt von einem Punkt eingeben, erhalten Sie direkt eine Liste der verfügbaren Eigenschaften, Methoden und Ereignisse – im Gegensatz zum Aufruf von Screen.ActiveControl<\/b>, wo Sie logischerweise keine IntelliSense-Unterstützung erwarten dürfen – Access kann einfach zur Laufzeit nicht ermitteln, welchen Typ das aktuelle Steuerelement aufweist.<\/p>\n Bild 8: Zugriff auf die spezifischen Eigenschaften eines Steuerelements des Typs Textbox<\/span><\/b><\/p>\n Sie sehen, dass wir hiermit schon einen großen Fortschritt im Vergleich zu den vorhandenen Möglichkeiten gemacht haben. Das wollen wir noch erweitern, indem wir ähnliche Methoden für weitere Steuerelementtypen zur Klasse Debugger<\/b> hinzufügen. In der Beispieldatenbank zu diesem Beitrag finden Sie die Unterstützung für das ComboBox<\/b>-, das ListBox<\/b>– und das CommandButton<\/b>-Steuerelement.<\/p>\n Die dazu verwendeten Eigenschaftsmethoden heißen ActiveComboBox<\/b>, ActiveListBox <\/b>und ActiveCommandButton<\/b>. Den Code dieser Elemente finden Sie in Listing 3.<\/p>\n Listing 3: Eigenschaftsmethoden, welche den Zugriff auf das weitere Steuerelement erlauben<\/span><\/b><\/p>\n Wie weiter oben erläutert, können Sie nicht per Screen.ActiveControl <\/b>auf das aktuelle Unterformular-Steuerelement zugreifen – und auch nicht mit Screen.ActiveForm <\/b>auf das darin enthaltene Formular.<\/p>\n Der Grund ist ganz einfach: Beide lassen sich nicht mit dem Fokus versehen. Dieser landet immer auf dem Steuerelement im Unterformular (im Falle von Screen.ActiveControl<\/b>) oder auf dem Hauptformular (bei Screen.ActiveForm<\/b>).<\/p>\n Aber es wäre doch gelacht, wenn wir dies nicht mit einer eigenen Eigenschaftsmethode in unserer Klasse Debugger <\/b>hinbekommen würden. Dazu müssen wir uns zunächst überlegen, wie wir überhaupt an das Unterformular-Steuerelement beziehungsweise an das darin enthaltene Formular herankommen.<\/p>\n Von oben aus ist das einfach: Forms!frmBestellungen!sfmBestellungen_UFC <\/b>liefert einen Verweis auf das Unterformular-Steuerelement, Form!frmBestellungen!sfmBestellungen_UFC.Form <\/b>einen Verweis auf das als Unterformular verwendete Formular. Wir wollen nun auf diese Elemente zugreifen, während ein Steuerelement im Unterformular selbst den Fokus hat. Es ist am einfachsten, wenn wir dieses Steuerelement auch als Ausgangsposition verwenden. Aber wie kommen wir von dort aus an das Unterformular heran, in dem sich dieses befindet – und wie an das Unterformular-Steuerelement <\/p>\n Für das Unterformular-Steuerelement erledigen wir das mit der Ereignismethode ActiveSubformControl <\/b>aus Listing 4. Die Vo-raussetzung dafür, dass wir über ein Steuerelement, das wir mit Screen.ActiveControl <\/b>ermitteln und in der Variablen ctl <\/b>speichern, zwei übergeordnete Parent<\/b>-Elemente finden können. Das erste Parent<\/b>-Element ist das Unterformular, in dem sich das Element befindet, das zweite ist das Formular, in dem sich das Unterformular befindet (also nicht etwa das Unterformular-Steuerelement – dies wird von der Parent<\/b>-Eigenschaft nicht berücksichtigt). Sind keine zwei Parent<\/b>-Elemente vorhanden, handelt es sich auch nicht um ein Unterformular.<\/p>\n Listing 4: Ermitteln des aktuellen Unterformular-Steuerelements<\/span><\/b><\/p>\n Forms(0).Name\r\nfrmBestellungen<\/pre>\n
Screen.ActiveForm.Name\r\nfrmBestellungen<\/pre>\n
Forms!frmBestellungen.Name\r\nfrmBestellungen<\/pre>\n
Forms!frmBestellungen.Recordsource\r\ntblBestellungen<\/pre>\n
Steuerelemente ansprechen<\/h2>\n
Public Sub <\/span>Steuerelementnamen()\r\n Dim <\/span>ctl As <\/span>Control\r\n For Each ctl In Forms!frmBestellungen.Controls\r\n Debug.Print<\/span> ctl.Name\r\n Next<\/span> ctl\r\nEnd Sub<\/span><\/pre>\n Forms!frmBestellungen.Controls(\"BestellungID\").Value\r\n 10248 <\/pre>\n
Forms!frmBestellungen!BestellungID\r\n10248<\/pre>\n
Aktivierbare Steuerelemente ansprechen<\/h2>\n
Screen.ActiveControl.Name\r\nBestellungID<\/pre>\n
Screen.ActiveControl.Value\r\n 10248 <\/pre>\n
Nicht sichtbare Werte ermitteln<\/h2>\n
Forms!frmBestellungen!KundeID\r\n 90 <\/pre>\n
Forms!frmBestellungen!KundeID.Column(1)\r\nWilman Kala<\/pre>\n
Unterformular-Steuerelement referenzieren<\/h2>\n
![\"Umbenennen](\"..\/fileadmin\/_temp_\/2016_06\/pic_1066_002.png\")
<\/p>\n Forms!frmBestellungen!sfmBestellungen_UFC.LinkChildFields\r\nBestellungID\r\n Forms!frmBestellungen!sfmBestellungen_UFC.LinkMasterFields\r\nBestellungID<\/pre>\n
Unterformular referenzieren<\/h2>\n
Forms!frmBestellungen!sfmBestellungen_UFC.Form.Name\r\nsfmBestellungen<\/pre>\n
Forms!frmBestellungen!sfmBestellungen_UFC.Form.BestellungID\r\n 10248 <\/pre>\n
![\"Fehler](\"..\/fileadmin\/_temp_\/2016_06\/pic_1066_003.png\")
<\/p>\n Forms!frmBestellungen!sfmBestellungen_UFC.Form.ArtikelID.Name\r\nArtikelID<\/pre>\n
Forms!frmBestellungen!sfmBestellungen_UFC.Form. ArtikelID.Value\r\n 11 <\/pre>\n
Screen.ActiveControl.Value\r\n 42 <\/pre>\n
Eigene Debugging-Klasse<\/h2>\n
![\"Exportieren](\"..\/fileadmin\/_temp_\/2016_06\/pic_1066_004.png\")
<\/p>\n![\"Geänderte](\"..\/fileadmin\/_temp_\/2016_06\/pic_1066_005.png\")
<\/p>\nAttribute VB_Creatable = True<\/span>\r\nAttribute VB_PredeclaredId = True<\/span><\/pre>\nPublic Sub <\/span>Test()\r\n MsgBox<\/span> \"Test erfolgreich\"\r\nEnd Sub<\/span><\/pre>\nDebugger.Test<\/pre>\n
Public Property Get <\/span>ActiveForm()\r\n Set<\/span> ActiveForm = _\r\n Screen.ActiveForm\r\nEnd Property<\/span><\/pre>\n![\"Neue](\"..\/fileadmin\/_temp_\/2016_06\/pic_1066_006.png\")
<\/p>\n Debugger.ActiveForm.Name\r\nfrmBestellungen<\/pre>\n
Aktives Textfeld ansprechen<\/h2>\n
Public Property Get <\/span>ActiveTextbox() As <\/span>Textbox\r\n Dim <\/span>txt As <\/span>Textbox\r\n Dim <\/span>strTyp As String<\/span>\r\n Dim <\/span>ctl As <\/span>Control\r\n Set<\/span> ctl = Screen.ActiveControl\r\n If <\/span>ctl.ControlType = acTextBox Then<\/span>\r\n Set<\/span> txt = Screen.ActiveControl\r\n Else<\/span>\r\n strTyp = GetControlType(ctl)\r\n MsgBox<\/span> \"Aktives Steuerelement hat den Typ ''''\" & strTyp & \"''''.\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n Set<\/span> ActiveTextbox = txt\r\nEnd Property<\/span><\/pre>\n![\"Fehlermeldungen](\"..\/fileadmin\/_temp_\/2016_06\/pic_1066_007.png\")
<\/p>\nHilfsfunktion zum Ermitteln des Steuerelementtyps<\/h2>\n
Private Function <\/span>GetControlType(ctl As <\/span>Control) As String<\/span>\r\n Select Case ctl.ControlType\r\n Case <\/span>acTextBox\r\n GetControlType = \"Textbox\"\r\n Case <\/span>acComboBox\r\n GetControlType = \"ComboBox\"\r\n Case <\/span>acListBox\r\n GetControlType = \"Listbox\"\r\n Case <\/span>acCommandButton\r\n GetControlType = \"CommandButton\"\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\n![\"Zugriff](\"..\/fileadmin\/_temp_\/2016_06\/pic_1066_008.png\")
<\/p>\nUnterstützung für weitere Steuerelemente<\/h2>\n
Public Property Get <\/span>ActiveComboBox() As <\/span>ComboBox\r\n Dim <\/span>cbo As <\/span>ComboBox\r\n Dim <\/span>strTyp As String<\/span>\r\n Dim <\/span>ctl As <\/span>Control\r\n Set<\/span> ctl = Screen.ActiveControl\r\n If <\/span>ctl.ControlType = acComboBox Then<\/span>\r\n Set<\/span> cbo = Screen.ActiveControl\r\n Else<\/span>\r\n strTyp = GetControlType(ctl)\r\n MsgBox<\/span> \"Aktives Steuerelement hat den Typ ''''\" & strTyp & \"''''.\"\r\n End If<\/span>\r\n Set<\/span> ActiveComboBox = cbo\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>ActiveCommandButton() As <\/span>CommandButton\r\n Dim <\/span>cmd As <\/span>CommandButton\r\n Dim <\/span>strTyp As String<\/span>\r\n Dim <\/span>ctl As <\/span>Control\r\n Set<\/span> ctl = Screen.ActiveControl\r\n If <\/span>ctl.ControlType = acCommandButton Then<\/span>\r\n Set<\/span> cmd = Screen.ActiveControl\r\n Else<\/span>\r\n strTyp = GetControlType(ctl)\r\n MsgBox<\/span> \"Aktives Steuerelement hat den Typ ''''\" & strTyp & \"''''.\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n Set<\/span> ActiveCommandButton = cmd\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>ActiveListBox() As <\/span>ListBox\r\n Dim <\/span>lst As <\/span>ListBox\r\n Dim <\/span>strTyp As String<\/span>\r\n Dim <\/span>ctl As <\/span>Control\r\n Set<\/span> ctl = Screen.ActiveControl\r\n If <\/span>ctl.ControlType = acListBox Then<\/span>\r\n Set<\/span> lst = Screen.ActiveControl\r\n Else<\/span>\r\n strTyp = GetControlType(ctl)\r\n MsgBox<\/span> \"Aktives Steuerelement hat den Typ ''''\" & strTyp & \"''''.\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n Set<\/span> ActiveListBox = lst\r\nEnd Property<\/span><\/pre>\nUnterformular-Steuerelement<\/h2>\n
Public Property Get <\/span>ActiveSubformControl() As <\/span>SubForm\r\n Dim <\/span>sfmControl As <\/span>SubForm\r\n Dim <\/span>strTyp As String<\/span>\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>ctlParent As Object<\/span>\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>ctlForm As <\/span>Control\r\n Set<\/span> ctl = Screen.ActiveControl\r\n On Error Resume Next<\/span>\r\n Set<\/span> ctlParent = ctl.Parent.Parent\r\n On Error GoTo<\/span> 0\r\n If <\/span>Not<\/span> ctlParent Is Nothing Then<\/span>\r\n If <\/span>TypeName(ctl.Parent.Parent) = \"Form_\" & Screen.ActiveForm.Name Then<\/span>\r\n Set<\/span> frm = Screen.ActiveForm\r\n For Each ctlForm In frm.Controls\r\n If <\/span>ctlForm.ControlType = acSubform Then<\/span>\r\n If <\/span>TypeName(ctlForm.Form) = \"Form_\" & ctl.Parent.Name Then<\/span>\r\n Set<\/span> sfmControl = ctlForm\r\n Exit For<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> ctlForm\r\n End If<\/span>\r\n Set<\/span> ActiveSubformControl = sfmControl\r\n Else<\/span>\r\n MsgBox<\/span> \"Aktives Steuerelement befindet sich nicht in einem Unterformular.\"\r\n Exit Property<\/span>\r\n End If<\/span>\r\nEnd Property<\/span><\/pre>\n