<\/p>\n
Modale Dialoge, also Formulare, die mit dem Befehl DoCmd.OpenForm mit dem Parameter WindowMode:=acDialog geöffnet wurden, sind in vielen Fällen hilfreich: Wir können den aufrufenden Code anhalten, bis das Formular geschlossen oder ausgeblendet wird und so gegebenenfalls auszulesende Werte ermitteln. Oder wir sorgen so dafür, dass der Benutzer nicht an anderen Formularen arbeiten kann, bevor er nicht die Eingabe in dieses Formular abgeschlossen hat. Einen Nachteil haben modale Dialog allerdings: Wir können ihre Rahmenart nicht so einstellen, wie wir es von normal geöffneten Formularen gewohnt sind. Wollen wir also einen modalen Dialog einmal ohne Titelleiste anzeigen, weil er zum Beispiel einfach als Erweiterung neben einem anderen Steuerelement geöffnet werden soll, können wir das so nicht machen. Es gibt allerdings einen Workaround, den wir hier vorstellen.<\/b><\/p>\nModaler Dialog, der „normale“ Weg<\/h2>\n
Der übliche Weg, ein Formular als modalen Dialog zu öffnen, ist dieser:<\/p>\n
Private Sub <\/span>cmdOpenForm_Click()\n DoCmd.OpenForm \"frmPopup\", WindowMode:=acDialog\n If <\/span>IstFormularGeoeffnet(\"frmPopup\") Then<\/span>\n MsgBox<\/span> \"Eingebener Wert: \" _\n & Forms!frmpopup!txtWert\n DoCmd.Close acForm, \"frmPopup\"\n Else<\/span>\n MsgBox<\/span> \"Eingabe abgebrochen\"\n End If<\/span>\nEnd Sub<\/span><\/pre>\nIm aufgerufenen Formular fügen wir eine OK<\/b>– und eine Abbrechen<\/b>-Schaltfläche hinzu. OK <\/b>blendet das Formular aus, was das Fortsetzen des aufrufenden Codes erlaubt, der dann den Wert der Steuerelemente des Popups auslesen kann, bevor er dieses schließt:<\/p>\nPrivate Sub <\/span>cmdOK_Click()\n Me.Visible = False<\/span>\nEnd Sub<\/span><\/pre>\nAbbrechen <\/b>schließt das Formular, was wir in der aufrufenden Prozedur als Abbruch der Eingabe interpretieren können:<\/p>\nPrivate Sub <\/span>cmdAbbrechen_Click()\n DoCmd.Close acForm, Me.Name\nEnd Sub<\/span><\/pre>\nDie aufrufende Prozedur prüft mit der Funktion IstFormularGeoeffnet<\/b>, ob der Benutzer OK <\/b>oder Abbrechen <\/b>angeklickt hat. Das aufrufende Formular und das modale Formular sehen wie in Bild 1 aus.<\/p>\n
![\"Beispiel](\"..\/fileadmin\/_temp_\/2024_01\/pic_1467_001.png\")
<\/p>\n
Bild 1: Beispiel für einen modalen Dialog<\/span><\/b><\/p>\nNachteil dieser Variante<\/h2>\n
Der große Nachteil ist: Wir können bestimmte Dinge nicht beeinflussen, weil durch den Aufruf mit WindowMode:=acDialog <\/b>einige Eigenschaften automatisch eingestellt werden – zum Beispiel die Rahmenart. Diese können wir zwar im Entwurf einstellen, aber letztlich wird das Formular immer mit der Rahmenart Dialog <\/b>angezeigt – auch wenn wir den tatsächlich für diese Eigenschaft eingestellten Wert erhalten, wenn wir uns diesen beispielsweise per Meldungsfenster ausgeben lassen. Außerdem ist die Eigenschaft Modal <\/b>für Formulare, die mit WindowMode:=acDialog <\/b>geöffnet wurden, immer auf Ja <\/b>eingestellt. Dies sorgt dafür, dass der Rahmen abgerundet dargestellt wird. Den Unterschied sehen wir in Bild 2.<\/p>\n
![\"Unterschied](\"..\/fileadmin\/_temp_\/2024_01\/pic_1467_002.png\")
<\/p>\n
Bild 2: Unterschied zwischen Rahmenart gleich Dialog und einem tatsächlich als Dialog geöffnetem Formular<\/span><\/b><\/p>\nModale Formulare mit einstellbarer Rahmenart<\/h2>\n
Wenn wir zum Beispiel ein Formular mit der Einstellung Keine <\/b>für die Eigenschaft Rahmenart <\/b>als modalen Dialog anzeigen wollen, müssen wir einen ganz anderen Ansatz wählen. Dabei rufen wir das gewünschte Formular als neue Objektinstanz auf statt mit DoCmd.OpenForm<\/b>.<\/p>\n
Damit das Formular auch noch als modaler Dialog angezeigt wird, also die übrigen Formulare solange deaktiviert werden, bis das aufgerufene Formular wieder geschlossen ist, stellen wir nach dem Instanziieren des Formulars noch die Eigenschaft Modal <\/b>auf den Wert True<\/b> ein und machen es dann mit Me.Visible = True <\/b>sichtbar:<\/p>\nPrivate Sub <\/span>cmdNew_Click()\n Set<\/span> frm = New<\/span> Form_frmPopupNew<\/span>\n With<\/span> frm\n .Modal = True<\/span>\n .Visible = True<\/span>\n End With<\/span>\nEnd Sub<\/span><\/pre>\nDie hier verwendete Objektvariable frm <\/b>müssen wir unbedingt außerhalb der Prozedur deklarieren. Wenn wir sie in der Prozedur deklarieren, verliert sie bereits beim Beenden der Prozedur ihre Gültigkeit und auch das darin referenzierte Formular wird gelöscht. Deshalb deklarieren wir die Variable im Kopf des Formulars:<\/p>\nDim <\/span>frm As <\/span>Form<\/pre>\nProbieren wir dies aus, erleben wir einen Unterschied zum Öffnen von modalen Formularen mit DoCmd.OpenForm<\/b>: Der Navigationsbereich wird eingeklappt. Dadurch wird auch das aufrufende Formular nach links verschoben. Wenn wir das Popup-Formular beispielsweise direkt neben einem anderen Steuerelement öffnen wollen, gelingt das nun nicht mehr so einfach, da wir die Koordinaten neu berechnen müssen. Und auch wenn wir eine professionelle Anwendung ohnehin ohne Anzeige des Navigationsbereichs ausliefern, wollen wir dieses Verhalten abschalten.<\/p>\n
Das erledigen wir durch Einstellen der Eigenschaft Popup. Diese ist zwar auch unter VBA verfügbar, aber sie kann zur Laufzeit nur gelesen und nicht geschrieben werden. Also müssen wir sie über das Eigenschaftenblatt auf den Wert Ja <\/b>einstellen (siehe Bild 3).<\/p>\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2024_01\/pic_1467_003.png\")
<\/p>\n
Bild 3: Einstellen der Eigenschaft Popup auf den Wert Ja<\/span><\/b><\/p>\nDamit erhalten wir zumindest optisch schon einmal das gleiche Ergebnis wie bei einem per WindowMode:=acDialog <\/b>geöffneten Formular (siehe Bild 4).<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2024_01\/pic_1467_004.png\")
<\/p>\n
Bild 4: Die neue Instanz des Formulars sieht wie ein herkömmliches Popup-Formular aus.<\/span><\/b><\/p>\nVerhalten der Formular-Instanz nach dem Aufrufen nachbilden<\/h2>\n
Allerdings ist das Verhalten noch nicht identisch. Dadurch, dass wir das Formular nun nicht mehr mit DoCmd.OpenForm <\/b>und dem Parameter WindowMode:=acDialog <\/b>öffnen, läuft der aufrufende Code einfach weiter. Wir können also nicht auf die gleiche Art das Schließen oder Ausblenden des Formulars abwarten und dieses dann auswerten. Also müssen wir einen anderen Weg finden, zu erkennen, wann der Benutzer das Formular schließt.<\/p>\n
Der erste Schritt dazu ist, dass wir im Hauptformular auf die Ereignisse im Popup-Formular reagieren können wollen. Dazu ändern wir die Deklaration der Variablen frm<\/b>, indem wir das Schlüsselwort WithEvents <\/b>hinzufügen:<\/p>\nDim <\/span>WithEvents frm As <\/span>Form<\/pre>\nIn der Prozedur, welche die Formularinstanz erzeugt, fügen wir die Eigenschaft OnUnload <\/b>mit dem Wert [Event Procedure] <\/b>hinzu:<\/p>\nPrivate Sub <\/span>cmdNew_Click()\n Set<\/span> frm = New<\/span> Form_frmPopupNew<\/span>\n With<\/span> frm\n .Modal = True<\/span>\n .Visible = True<\/span>\n .OnUnload = \"[Event Procedure]\"\n End With<\/span>\nEnd Sub<\/span><\/pre>\nAußerdem legen wir eine Ereignisprozedur für das Ereignis Beim Entladen <\/b>des Popup-Formulars an. Dazu wählen wir im Codefenster im linken Kombinationsfeld den Eintrag frm <\/b>aus und im rechten Kombinationsfeld den Eintrag Unload<\/b> (siehe Bild 5).<\/p>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2024_01\/pic_1467_005.png\")
<\/p>\n
Bild 5: Anlegen des Unload-Ereignisses für das Popup-Formular<\/span><\/b><\/p>\nAuf diese Weise können wir alle Formular des Popup-Formulars, das wir mit der Variablen frm <\/b>referenzieren, implementieren. Allerdings müssen wir für jedes Ereignis auch die entsprechende Eigenschaft wie OnUnload <\/b>auf den Wert [Event Procedure] <\/b>einstellen.<\/p>\n
![\"Popup-Formular](\"..\/fileadmin\/_temp_\/2024_01\/pic_1467_006.png\")
<\/p>\n