{"id":55000420,"date":"2018-10-01T00:00:00","date_gmt":"2020-01-24T16:00:13","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=420"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Formulare_per_VBA_referenzieren","status":"publish","type":"post","link":"https:\/\/access-basics.de\/index.php\/Formulare_per_VBA_referenzieren.html","title":{"rendered":"Formulare 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 von verschiedenen Orten aus auf die Formulare zugreifen können. In weiteren Artikeln betrachten wir dann etwa den Zugriff auf die darin enthaltenen Steuer-elemente.<\/p>\n

Beispieldatenbank<\/h2>\n

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

Innerhalb des Formulars <\/h2>\n

Wenn Sie ein Formular erstellen und diesem ein Klassenmodul zuweisen, das sogenannte Code behind-Modul, dann können Sie von diesem aus auf andere Weise auf die Elemente des Formulars zugreifen als dies etwa von einem anderen Formular oder auch von einem Standardmodul aus möglich ist.<\/p>\n

Hier steht nämlich das Me<\/b>-Schlüsselwort für den Zugriff auf die Objektvariable des aktuellen Formulars zur Verfügung. Zur Verdeutlichung legen Sie einfach einmal ein neues Formular in einer leeren Datenbank an und speichern dieses unter dem Namen frmBeispiel<\/b>.<\/p>\n

Diesem fügen wir nun eine Schaltfläche hinzu, die wir mit der Beschriftung Name anzeigen <\/b>und dem Namen cmdNameAnzeigen<\/b> versehen und für die wir eine neue Ereignisprozedur für das Ereignis Beim Klicken <\/b>anlegen (siehe Bild 1).<\/p>\n

\"Hinzufügen<\/a><\/p>\n

Bild 1: Hinzufügen einer Ereignisprozedur für eine Schaltfläche<\/p>\n

Der Ereignisprozedur fügen wir nun eine Anweisung hinzu, die den Namen des Formulars in einem Meldungsfenster ausgeben soll:<\/p>\n

Private Sub <\/span>cmdNameAnzeigen_Click()\r\n    MsgBox<\/span> Me.Name\r\nEnd Sub<\/span><\/pre>\n
Das hier wie selbstverständlich verwendete Schlüsselwort Me <\/b>ist eine sehr praktische Vereinfachung für den Zugriff auf die Elemente des Formulars, auf das sich das Klassenmodul bezieht.<\/p>\n
Mit diesem Schlüsselwort können Sie auf alle Eigenschaften und Methoden des Formulars zugreifen und auch auf die darin angelegten Steuer-elemente – darauf gehen wir später ein.<\/p>\n
Von außen<\/h2>\n
Wie aber greifen wir denn eigentlich von außen auf dieses Formular zu Dazu müssen wir erst einmal wissen, ob das Formular geöffnet ist. Greifen wir auf ein Formular zu, das nicht geöffnet ist, erhalten wir einen Laufzeitfehler.<\/p>\n
Um dies auszuprobieren, fügen Sie der Beispieldatenbank ein Standardmodul namens mdlFormularzugriff <\/b>hinzu. Hier legen Sie die folgende Prozedur an:<\/p>\n
Public Sub <\/span>NameAnzeigen()\r\n    MsgBox<\/span> Forms!frmBeispiel.Name\r\nEnd Sub<\/span><\/pre>\n
Die Prozedur erledigt nichts anders als die im Formular für die Schaltfläche cmdNameAnzeigen <\/b>– Sie gibt ein Meldungsfenster mit dem Namen des Formulars aus.<\/p>\n
Allerdings wissen wir, wenn wir auf die Schaltfläche des Formulars klicken, dass dieses logischerweise gerade geöffnet ist und brauchen dies nicht zu prüfen. Beim Zugriff von außen müssen wir dies jedoch vorher absichern. Rufen Sie die obige Prozedur auf, nachdem Sie das Formular geschlossen haben, löst dies den Fehler aus Bild 2 aus.<\/p>\n
Bild 2: Fehler beim Zugriff auf ein nicht geöffnetes Formular<\/p>\n
Prüfen, ob ein Formular geöffnet ist<\/h2>\n
Für die Prüfung, ob ein Formular geöffnet ist, hat sich die folgende Funktion etabliert. Sie erwartet den Namen des zu untersuchenden Formulars als Parameter. Sie nutzt die SysCmd<\/b>-Funktion, der sie die Konstante acSysCmdGetObjectState<\/b>, den Objekttyp undd den Namen des Formulars übergibt. Wenn das Ergebnis größer als 0 <\/b>ist, ist das Formular geöffnet:<\/p>\n
Public Function <\/span>IstFormularGeoeffnet(strFormular As <\/span>                                      String) As Boolean<\/span>\r\n    IstFormularGeoeffnet = SysCmd(        acSysCmdGetObjectState, acForm, strFormular) > 0\r\nEnd Function<\/span><\/pre>\n
Mit dieser Funktion können wir bei Zugriff von außen leicht prüfen, ob das Formular geöffnet ist. Die obige Prozedur erweitern wir dabei wie folgt:<\/p>\n
Public Sub <\/span>NameAnzeigen()\r\n    If <\/span>IstFormularGeoeffnet(\"frmBeispiel\") Then<\/span>\r\n        MsgBox<\/span> Forms!frmBeispiel.Name\r\n    Else<\/span>\r\n        MsgBox<\/span> \"Das Formular ist nicht geöffnet.\"\r\n    End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Wenn das Formular nicht geöffnet ist, weist die Prozedur per Meldungsfenster auf diesen Zustand hin.<\/p>\n
Auf das aktuelle Formular zugreifen<\/h2>\n
In manchen Fällen möchten Sie auch einfach auf das aktuell geöffnete Formular zugreifen, um beispielsweise dessen Namen zu ermitteln. Hierfür stellt Microsoft eine Klasse mit verschiedenen Eigenschaften bereit. Diese heißt Screen <\/b>und liefert beispielsweise über die Eigenschaft ActiveForm <\/b>Zugriff auf das aktuell aktive Formular. Die folgende Prozedur gibt beispielsweise den Namen des aktuellen Formulars aus:<\/p>\n
Public Sub <\/span>AktuellesFormular()\r\n    MsgBox<\/span> Screen.ActiveForm.Name\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
\"Fehler<\/a><\/p>\n