{"id":55000419,"date":"2018-10-01T00:00:00","date_gmt":"2020-01-24T16:00:13","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=419"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Steuerelemente_per_VBA_referenzieren","status":"publish","type":"post","link":"https:\/\/access-basics.de\/index.php\/Steuerelemente_per_VBA_referenzieren.html","title":{"rendered":"Steuerelemente per VBA referenzieren"},"content":{"rendered":"

Wenn Sie Formulare und Steuerelemente programmieren wollen, müssen Sie wissen, wie Sie diese referenzieren. Nicht immer geschieht dies vom Klassenmodul des Formulars selbst aus – manchmal wollen Sie vielleicht auch von anderen Formularen auf die Steuer-elemente eines anderen Formulars zugreifen oder auch von einer VBA-Prozedur in eine Standardmodul. Dieser Artikel zeigt, wie Sie die Unterformulare und Steuer-elemente eines Formulars referenzieren und auf diese zugreifen.<\/p>\n

Beispieldatenbank<\/h2>\n

Die Beispiele dieses Artikels finden Sie in der Datenbank 1805_FormsControlsVBARead.accdb<\/b>.<\/p>\n

Innerhalb des Formulars <\/h2>\n

Im Artikel Formulare per VBA referenzieren <\/b>haben Sie bereits erfahren, dass ein Formular ein Klassenmodul erhält, sobald Sie Ereignisprozeduren für das Formular oder die enthaltenen Steuer-elemente anlegen. In diesem Klassenmodul können Sie mit dem Schlüsselwort Me <\/b>auf das Formular und seine Eigenschaften zugreifen, während Sie von außen auf andere Art auf das Formular zugreifen müssen. Für den Zugriff auf die in einem Formular enthaltenen Elemente wie Unterformulare oder andere Steuer-elemente gelten daher auch verschiedene Regeln, auch wenn Sie letztendlich auf das gleiche Element zugreifen wollen. Allerdings können wir das entschärfen, indem wir die Regeln dafür nochmal zusammenfassen. Wenn Sie also auf Steuer-elemente in einem Formular zugreifen wollen, verwenden Sie abhängig vom Ausgangspunkt die folgenden Referenzen für das Formular:<\/p>\n

Im eigenen Klassenformular:<\/p>\n

Me...<\/pre>\n
Von außen: <\/p>\n
Forms!...\r\nForms(\"\")...<\/pre>\n
Etwas komplizierter wird es noch, wenn sich die zu referenzierenden Steuer-elemente in einem Unterformular befinden – dazu jedoch später mehr.<\/p>\n
über den Namen auf ein Steuer-element zugreifen<\/h2>\n
Die einfachste Methode, auf ein Steuer-element zuzugreifen, ist die über den Namen des Steuerelements. Dazu fügen wir dem Beispielformular frmBeispiel <\/b>zwei Schaltflächen hinzu, von denen die zweite den Namen der ersten Schaltfläche ausgeben soll (siehe Bild 1). In der Ereignisprozedur, die durch die zweite Schaltfläche ausgelöst wird, referenzieren wir die erste Schaltfläche dann über die Syntax mit dem Ausrufezeichen und geben den Namen per MsgBox <\/b>aus:<\/p>\n
\"Schaltfläche<\/a><\/p>\n
Bild 1: Schaltfläche zum Ermitteln des Namens einer anderen Schaltfläche<\/p>\n
Private Sub <\/span>cmdNameEinesSteuerelements_Click()\r\n    MsgBox<\/span> Me!cmdNameAnzeigen.Name\r\nEnd Sub<\/span><\/pre>\n
Die zweite Möglichkeit ist die Angabe des Steuerelementnamens als Parameter des Me<\/b>-Schlüsselworts:<\/p>\n
MsgBox<\/span> Me(\"cmdNameAnzeigen\").Name<\/pre>\n
Dies ist allerdings auch nur möglich, weil die Auflistung Controls <\/b>die Standardeigenschaft des mit dem Schlüsselwort Me <\/b>referenzierten Objekts, in diesem Fall des Formulars, ist. Die ausgeschriebene Form dieser Schreibweise bezieht die Controls<\/b>-Auflistung dann explizit mit ein:<\/p>\n
MsgBox<\/span> Me.Controls(\"cmdNameAnzeigen\").Name<\/pre>\n
Dabei fällt mir ein, dass man mal prüfen könnte, welchen Typ das Schlüsselwort Me <\/b>eigentlich hat. Ist es Form<\/b> Nein: Es handelt sich um die Code behind-Klasse des Formulars selbst:<\/p>\n
Debug.Print<\/span> TypeName(Me)\r\n  Form_frmBeispiel<\/pre>\n
Für weitere Experimente fügen wir dem Formular noch ein Textfeld namens txtBeispiel<\/b> hinzu sowie eine weitere Schaltfläche namens cmdTextfeldAusgeben <\/b>(siehe Bild 2). Den Inhalt des Textfeldes legen wir in einer Ereignisprozedur fest, die beim Laden des Formulars ausgelöst wird:<\/p>\n
\"Neues<\/a><\/p>\n
Bild 2: Neues Textfeld zum Experimentieren<\/p>\n
Private Sub <\/span>Form_Load()\r\n    Me!txtBeispiel = \"Beispieltext\"\r\nEnd Sub<\/span><\/pre>\n
Warum Ausrufezeichen und kein Punkt<\/h2>\n
Theoretisch kommen Sie in den meisten Fällen auch ohne Fehler aus, wenn Sie zwischen Formularbezeichner (also etwa Me <\/b>oder Forms!<\/b>) und Steuerelementname den Punkt als Trennzeichen angeben. Warum aber verwenden wir hier so beharrlich das Ausrufezeichen Dieses sollten Sie immer dann nutzen, wenn Sie Elemente von Auflistungen referenzieren, die Sie selbst angelegt haben beziehungsweise anlegen können – also etwa Formulare (Forms!<\/b>) oder Steuer-elemente in Formularen (Forms!!<\/b>).<\/p>\n
Zugriff auf Textfelder von verschiedenen Stellen<\/h2>\n
Wenn wir vom Formular selbst – in diesem Fall über die Schaltfläche cmdTextfeldAusgeben <\/b>– auf den Inhalt dieses Textfeldes zugreifen wollen, verwenden wir, wie oben gelernt, das Schlüsselwort Me <\/b>sowie das Ausrufezeichen und den Namen des Textfeldes<\/b>:<\/p>\n
Private Sub <\/span>cmdTextfeldAusgeben_Click()\r\n    MsgBox<\/span> Me!txtBeispiel\r\nEnd Sub<\/span><\/pre>\n
Tatsächlich ist dies wiederum eine Kurzform. Wir geben ja nicht das Textfeld txtBeispiel <\/b>aus, sondern den Inhalt dieses Textfeldes. Die Kurzform funktioniert deshalb, weil die Eigenschaft Value <\/b>des Textfeldes die Standardeigenschaft der Textfeld-Klasse ist. Ohne diese Kurzform müssten Sie also mit dem folgenden Asudruck arbeiten:<\/p>\n
MsgBox<\/span> Me!txtBeispiel.Value<\/pre>\n
Woher wissen wir so etwas Dies erfahren wir beispielsweise im Objektkatalog, den Sie über den Menüeintrag Ansicht|Objektkatalog<\/b> öffnen (siehe Bild 3). In der Liste der Eigenschaften finden Sie zum Beispiel für das Textfeld (TextBox<\/b>) ein spezielles Icon für die Eigenschaft Value<\/b>. Unten finden Sie dann den Text Standardelement von Access.TextBox <\/b>– das ist eindeutig.<\/p>\n
\"Standardeigenschaft<\/a><\/p>\n
Bild 3: Standardeigenschaft einer Klasse im Objektkatalog<\/p>\n
Das waren nun zwei Kurzform. Genau wie beim Referenzieren von Formularen können Sie aber auch noch über die Schreibweise mit Klammern auf die Steuer-elemente eines Formulars zugreifen. Die erste Variante nimmt den Namen des Formulars entgegen:<\/p>\n
Debug.Print<\/span> Me(\"txtBeispiel\").Value<\/pre>\n
Das war wiederum die Kurzform für die Variante mit der Controls<\/b>-Auflistung:<\/p>\n
Debug.Print<\/span> Me.Controls(\"txtBeispiel\").Value<\/pre>\n
Und wenn Sie den Index-Wert des Steuerelements kennen, können Sie auch noch einen numerischen Wert angeben:<\/p>\n
Debug.Print<\/span> Me.Controls(2).Value<\/pre>\n
Zugriff auf das aktive Steuerelement<\/h2>\n
Im Artikel zum Thema Formulare haben Sie die Eigenschaft ActiveForm <\/b>des Screen<\/b>-Objekts kennengelernt, mit der Sie das aktive Formular referenzieren konnten. Ein Pendand zu dieser Eigenschaft gibt es auch für Steuer-elemente. Wenn Sie also das aktuell aktive Steuer-element ermitteln wollen, nutzen Sie die Eigenschaft ActiveControl <\/b>des Screen<\/b>-Objekts:<\/p>\n
Debug.Print<\/span> Screen.ActiveControl.Name<\/pre>\n
Dies liefert beispielsweise den Namen des aktiven Steuerelements. Was geschieht hier beispielsweise, wenn derzeit kein Formular, sondern etwa eine Tabelle den Fokus hat Dann liefert Screen.ActiveControl <\/b>den Namen des Feldes der Tabelle, das gerade markiert ist! Im Falle der Tabelle tblBeispiel <\/b>unserer Beispieldatenbank sieht der Aufruf im Direktbereich etwa wie folgt aus:<\/p>\n
Debug.Print<\/span> Screen.ActiveControl.Name\r\nID<\/pre>\n
Können wir darüber auch auf den Namen der Tabelle zugreifen Ja, auch das gelingt:<\/p>\n
Debug.Print<\/span> Screen.ActiveControl.Parent.Name\r\ntblBeispiel<\/pre>\n
Dadurch angespornt lassen wir auch gleich noch den mit TypeName <\/b>ermittelten Typ dieses Tabellenobjekts ausgeben:<\/p>\n
Debug.Print<\/span> TypeName(Screen.ActiveControl.Parent)\r\nT_tblBeispiel<\/pre>\n
Dies ist dann also das Pendant zu dem Typ Form_…<\/b>, der für ein Formular zurückgeliefert wird.<\/p>\n
Wenn Sie also etwa per Code über Screen.Active-Control <\/b>auf ein Steuer-element eines Formulars zugreifen wollen, sollten Sie zuvor mit Screen.ActiveForm <\/b>sicherstellen, dass auch gerade ein Formular den Fokus hat.<\/p>\n
Steuer-elemente durchlaufen<\/h2>\n
Sie haben nun schon gesehen, dass es eine Auflistung namens Controls <\/b>gibt, mit der Sie Steuer-elemente referenzieren können. Für Auflistungen können Sie auch die Anzahl der enthaltenen Elemente bestimmen und Sie können die Elemente in verschiedenen Schleifentypen durchlaufen.<\/p>\n
Wir fügen dem Formular zwei weitere Schaltflächen hinzu. Die erste heißt cmdSteuerelementeDurchlaufenForNext <\/b>und löst die folgende Ereignisprozedur aus:<\/p>\n
Private Sub <\/span>cmdSteuerelementeDurchlaufenForNext_Click()\r\n    Dim <\/span>intCount As Integer<\/span>\r\n    Dim <\/span>i As Integer<\/span>\r\n    intCount = Me.Controls.Count\r\n    For i = 0 To intCount - 1\r\n        Debug.Print<\/span> Me.Controls(i).Name\r\n    Next<\/span> i\r\nEnd Sub<\/span><\/pre>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Access [basics]<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 400 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t