<\/p>\n
Ereignisse kann man nicht nur innerhalb des jeweiligen Klassenmoduls eines Objekts wie in Formularen oder Berichten abfangen. Sie können auch Code in Klassenmodulen, Formular- und Berichtsmodulen unterbringen, der die Ereignisse anderer Klassenmodule abfängt und sich dort einklinkt. Dieser Beitrag zeigt, wie nützlich dies sein kann und wie es überhaupt funktioniert.<\/b><\/p>\n
Im Beitrag Ereignisprozeduren<\/b> (Shortlink 684) haben wir einige Grundlagen zur Programmierung der Ereignisprozeduren von Formularen und Berichten sowie darin enthaltener Steuerelementen beschrieben. Was wir dort nur angerissen haben, ist die Tatsache, dass Sie sich auch von außerhalb des betroffenen Objekts und zur Laufzeit in die Ereigniskette einschleichen können.<\/p>\n
Was um Himmels willen soll man denn damit anfangen Bevor wir Beispiele liefern, zunächst einmal die grundsätzliche Vorgehensweise. Normalerweise schreiben Sie Ereignisprozeduren in das Klassenmodul des jeweiligen Formulars oder Berichts und stellen die Ereigniseigenschaften auf den Wert [Ereignisprozedur] <\/b>oder [Event Procedure] <\/b>ein, damit das Formular oder der Bericht weiß, dass für ein Ereignis eine entsprechende Prozedur vorhanden ist.<\/p>\n
Solche Ereignisse kann man aber auch außerhalb des eigentlichen Klassenmoduls nutzen, indem man eine Objektvariable mit einer Referenz auf das Formular oder den Bericht deklariert und instanziert – und das unter Zuhilfenahme eines speziellen Schlüsselworts namens WithEvents<\/b>.<\/p>\n
Der Beispielaufbau besteht aus zwei ungebundenen Formularen namens frmEreignisAbfangen<\/b> und frmFormularMitEreignis<\/b>. Ersteres enthält lediglich eine Schaltfläche namens cmdSetReference <\/b>und sieht wie in Bild 1 aus.<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2009_05\/EreignisseAbfangenUndAuswerten-web-images\/pic001_opt.jpeg\")
<\/p>\n
Bild 1: Dieses Formular wird gleich die Ereignisse eines anderen Formulars abfangen.<\/span><\/b><\/p>\n Das Formular frmFormularMitEreignis <\/b>ist ein komplett leeres Formular, das lediglich Ereignisprozeduren für die Ereignisse Beim Öffnen <\/b>und Beim Schließen <\/b>enthält:<\/p>\n Der Schaltfläche cmdSetReference <\/b>weisen Sie nun die folgende Ereignisprozedur zu – nicht ohne eine Objektvariable namens objForm <\/b>mit dem Schlüsselwort WithEvents <\/b>im Kopf des Klassenmoduls des Formulars zu referenzieren:<\/p>\n Bei einem Mausklick auf die Schaltfläche geschieht nichts Unerwartetes: Die Routine öffnet das Formular frmFormularMitEreignis<\/b>, welches wiederum mit der oben definierten Meldung anzeigt, dass es geöffnet wurde. Gleiches geschieht, wenn Sie es wieder schließen.<\/p>\n Ereignis einschleusen<\/b><\/p>\n Dank der Deklaration von objForm <\/b>mit dem Schlüsselwort WithEvents <\/b>können wir im Klassenmodul des Formulars frmEreignisAbfangen <\/b>Ereignisprozeduren für das mit objForm <\/b>referenzierte Formular festlegen.<\/p>\n Das geht am einfachsten, indem Sie aus dem linken Kombinationsfeld des Codefensters mit dem Modul Form_frmEreignisAbfangen <\/b>den Eintrag objForm <\/b>und aus dem rechten Fenster zum Beispiel den Eintrag Open <\/b>auswählen. Probieren wir dies am Beispiel des Close<\/b>-Ereignisses des Objekts objForm <\/b>aus:<\/p>\n Wenn Sie die Schaltfläche nun betätigen und das Formular frmFormularMitEreignis <\/b>anschließend wieder schließen, erscheinen zwei Meldungsfenster – das erste mit dem Text Implantiert: Formular wurde geschlossen <\/b>und schließlich die Meldung aus dem Formular frmFormularMitEreignis <\/b>selbst.<\/p>\n Das Fazit lautet: Sie können Ereignisse für ein Formular auch von außen festlegen, wenn Sie nur eine Objektvariable mit WithEvents <\/b>deklarieren und damit auf das Zielformular verweisen. Hierbei gibt es noch einige weitere Möglichkeiten und auch Punkte, die Sie beachten müssen – fürs Erste soll dies jedoch ausreichen, sodass wir uns nun wichtigeren Dingen zuwenden: Wofür brauchen wir das Ganze überhaupt<\/p>\n Beispiele für die vorgestellte Technik<\/b><\/p>\n In den folgenden Abschnitten zeigen wir Ihnen an zwei Beispielen, wie Sie durch das Implantieren einer Ereignisprozedur von einem Formular in ein anderes Vorteile erzielen und den Entwurf Ihrer Anwendung verbessern können.<\/p>\n Beispiel Detailformular<\/b><\/p>\n Das erste Beispiel, bei dem das Implantieren einer Ereignisprozedur eine Verbesserung hervorruft, ist die typische Vorgehensweise beim Öffnen eines Detailformulars von einer Übersichtsliste aus zum Anlegen eines neuen Datensatzes (Objekte in der Beispieldatenbank: frmArtikeluebersicht_I<\/b>, sfmArtikeluebersicht_I<\/b>, frmArtikeldetails_I<\/b>). Bild 2 zeigt das Übersichtsformular mit einer Anzeigen<\/b>-Schaltfläche, die den Detaildialog aus Bild 3 öffnen soll. Normalerweise ist dafür etwa folgender Code verantwortlich, den Sie für die Ereigniseigenschaft Beim Klicken <\/b>hinterlegen:<\/p>\n Bild 2: Mit der Anzeigen-Schaltfläche dieses Formulars öffnen Sie …<\/span><\/b><\/p>\n Bild 3: … dieses Detailformular.<\/span><\/b><\/p>\n Diese Routine öffnet das Detailformular als modalen Dialog, das heißt, dass der aufrufende Code erst weiterläuft, wenn das Formular wieder geschlossen ist. Genau dann führt die Routine noch eine Anweisung aus, die den Inhalt des Unterformulars mit der Übersicht der Datensätze aktualisiert, damit dieses den über das Detailformular hinzugefügten Datensatz direkt anzeigt.<\/p>\n Nachteil Detailformular, Version I<\/b><\/p>\n Der Nachteil hierbei ist in manchen Fällen, dass der Benutzer nicht auf die Daten im aufrufenden Formular zugreifen kann, solange das Detailformular geöffnet ist (manchmal ist dies auch gewollt – in diesen Fällen reicht die obige Technik natürlich aus).<\/p>\n Verbesserung Detailformular<\/b><\/p>\n Wenn Sie auf das Übersichtsformular zugreifen möchten, während das Detailformular geöffnet ist, rufen Sie dieses mit folgender Anweisung auf – also wie oben, nur ohne den Parameter WindowMode <\/b>auf acDialog <\/b>einzustellen:<\/p>\n Das Detailformular verschwindet nun allerdings hinter dem Übersichtsformular, was Sie durch Einstellen der Eigenschaft Popup <\/b>des Detailformulars auf den Wert Ja <\/b>ändern. Sie können dann auf das Übersichtsformular zugreifen, während das Detailformular geöffnet ist (siehe Bild 4).<\/p>\n Bild 4: Arbeiten im Übersichtsformular, während das Detailformular geöffnet ist<\/span><\/b><\/p>\n Wenn Sie allerdings wollen, dass der neue Datensatz gleich nach dem Schließen des Detailformulars im Übersichtsformular angezeigt wird, können Sie mit einem Requery <\/b>in der aufrufenden Routine direkt hinter dem DoCmd.OpenForm <\/b>nichts erreichen: Da das Detailformular nicht als modaler Dialog geöffnet wird, hält Access auch die Ausführung des Codes nicht an und ruft die Requery<\/b>-Anweisung unmittelbar nach dem Öffnen des Detailformulars auf, was hier nicht hilfreich ist.<\/p>\n Wie aber bekommen wir nun mit, wann der Benutzer das Detailformular schließt und wir das Hauptformular aktualisieren müssen Hier setzen wir mit einem Ereignisprozedur-Implantat an. Deklarieren Sie im Kopf des Klassenmoduls des Formulars frmArtikelUebersicht_I <\/b>eine Objektvariable, die eine Referenz auf das geöffnete Formular enthält:<\/p>\n Diese Variable füllen Sie in der Ereignisprozedur, die das Detailformular öffnet:<\/p>\n Nun brauchen Sie nur noch ein Ereignis für das Detailformular im Klassenmodul des Übersichtsformulars anzulegen, das beim Schließen des Detailformulars ausgelöst wird und das Unterformular mit der Datenübersicht aktualisiert:<\/p>\n <\/p>\n Wenn Sie dies nun ausprobieren, schlägt der Plan allerdings fehl: Der Grund ist, dass wir zwar eine Ereignisprozedur für das Ereignis Beim Schließen <\/b>des Detailformulars festgelegt haben, dieses aber nicht in die entsprechende Ereigniseigenschaft eingetragen wurde.<\/p>\n Weiter oben in der Beschreibung der grundlegenden Techniken hat dies noch funktioniert, weil das Ereignis bereits im Formular vorhanden und dementsprechend auch die Ereigniseigenschaft gefüllt war. An dieser Stelle gibt es zwei Möglichkeiten:<\/p>\n Für Letzteres ist nur eine Zeile nötig, die Sie in die Beim Klicken<\/b>-Prozedur des Übersichtsformulars gleich hinter der Anweisung zum Füllen der Objektvariablen objFrmArtikelDetails_I <\/b>einfügen:<\/p>\n Somit wird nun beim Schließen des Detailformulars frmArtikelDetails <\/b>die im Klassenmodul des Übersichtsformulars frmArtikelUebersicht <\/b>angelegte Ereignisprozedur ausgelöst, die das zeitnahe Aktualisieren des Unterformulars ermöglicht, ohne dass das Detailformular als modaler Dialog geöffnet werden muss.<\/p>\n Ereignisimplantat für Haupt- und Unterformulare<\/b><\/p>\n Wenn Sie in einem Formular ein Unterformular verwenden, sollten Sie ebenfalls auf die Abhängigkeiten der beiden Elemente achten. Sinnvoll wäre es, wenn die Steuerung beziehungsweise die Logik komplett im Hauptformular läge.<\/p>\n Als Beispiel schauen wir uns die Artikelübersicht vom Anfang dieses Beitrags an. Sie enthält einige Schaltflächen, die normalerweise nur verwendet werden können, wenn ein Datensatz im Unterformular markiert ist. Um die Wirkung der folgenden Technik ein wenig zu unterstreichen, soll beispielsweise die Löschen<\/b>-Schaltfläche nur aktiviert sein, wenn der im Unterformular angezeigte Artikel einen Lagerbestand <\/b>von 0 <\/b>aufweist.<\/p>\n Normalerweise würden Sie nun im Unterformular eine Ereignisprozedur für die Ereigniseigenschaft Beim Anzeigen <\/b>anlegen, welche den aktuellen Datensatz prüft und die Schaltfläche cmdLoeschen <\/b>im Hauptformular in Abhängigkeit vom ausgewählten Datensatz aktiviert oder deaktiviert.<\/p>\n Diese Abhängigkeit geht in die falsche Richtung: Das Unterformular sollte normalerweise völlig unabhängig vom Hauptformular sein, sich also ohne Probleme auch in andere Hauptformulare einfügen lassen – beispielsweise eines, das nur für solche Mitarbeiter gedacht ist, die nur Artikeldaten lesen, diese aber nicht bearbeiten und schon gar nicht löschen dürfen.<\/p>\n Das Formular frmArtikeluebersicht_II <\/b>sieht wie in Bild 5 aus und enthält als Unterformular das Formular sfmArtikeluebersicht_II<\/b>. Für die Objektreferenz auf das Unterformular brauchen wir wieder eine entsprechende Variable, die wir im Kopf des Klassenmoduls von frmArtikeluebersicht_II <\/b>platzieren:<\/p>\n Bild 5: Dieses Formular implantiert dem Unterformular ein Beim Anzeigen-Ereignis.<\/span><\/b><\/p>\n Die Löschen<\/b>-Schaltfläche soll diese Funktion auslösen:<\/p>\n Wie Sie sehen, enthält die Prozedur keinerlei Prüfung, ob der Datensatzzeiger des Unterformulars überhaupt auf einem löschbaren Datensatz und nicht etwa auf einem neuen, leeren Datensatz wie in Bild 5 steht, was zu einem Fehler führen würde.<\/p>\n Also sorgen wir dafür, dass die Löschen<\/b>-Schaltfläche nur dann aktiviert ist, wenn das Unterformular einen löschbaren Datensatz anzeigt.<\/p>\n Dazu füllen wir im Beim Laden<\/b>-Ereignis des Hauptformulars zunächst die Objektvariable für das Unterformular und stellen dann die Eigenschaft Beim Anzeigen <\/b>auf [Event Procedure] <\/b>ein:<\/p>\n Fehlt noch die Ereignisprozedur, die wie folgt aussieht und beim Wechseln des Datensatzes im Unterformular ausgelöst wird: <\/p>\n Die Routine prüft einfach nur, ob das Unterformular gerade einen leeren, neuen Datensatz anzeigt oder einen mit einem Lagerbestand <\/b>von 0<\/b>, und aktiviert oder deaktiviert die Löschen<\/b>-Schaltfläche entsprechend.<\/p>\n Falls dies nicht funktioniert, besitzt das Unterformular möglicherweise noch kein Klassenmodul. Dies legen Sie ganz einfach an, indem Sie Enthält Modul <\/b>auf den Wert Ja <\/b>einstellen.<\/p>\n Selbstimplantierung<\/b><\/p>\n Nicht immer muss das ausführende Formular selbst für das Implantieren der Ereignisprozeduren zuständig sein. Schauen wir uns folgendes Beispiel an: Eine Anwendung verwendet ein Formular, das immer eingeblendet ist und beispielsweise die wichtigsten Unternehmensdaten anzeigt.<\/p>\n Nun kann der Benutzer zu den dortigen Informationen Datensätze hinzufügen und dies auf zwei Arten initiieren:<\/p>\n Erkennen Sie das Problem, das bei der zweiten Variante auftritt<\/p>\n Richtig: Das Hauptformular ruft das Detailformular nicht selbst auf und kann diesem deshalb auch keine Ereignisprozeduren implantieren, die ihm dabei helfen, das Hinzufügen neuer Daten zu erkennen.<\/p>\n Zur Vereinfachung nehmen wir statt eines Menü- oder Ribbon-Eintrags einfach eine kleine VBA-Routine, die das Detailformular zum Anlegen eines neuen Artikels öffnet:<\/p>\n Das Beim Laden<\/b>-Ereignis des Detailformulars frmArtikeldetails_III <\/b>statten wir mit dieser Ereignisprozedur aus:<\/p>\n Die Routine prüft zunächst mit einer Hilfsfunktion, ob das Hauptformular dieses Beispiels, frmArtikeluebersicht_III<\/b>, überhaupt geöffnet ist, und ruft dann dessen Methode ImplantCloseEvent <\/b>auf.<\/p>\n Diese wiederum sieht so aus:<\/p>\n Diese enthält wiederum nur zwei Anweisungen, die einfach nur aus der Ereignisprozedur Form_Load <\/b>des ersten Beispiels dieses Beitrags entnommen sind.<\/p>\n Sie fügen der Objektvariablen objFrmArtikelDetails_III <\/b>einen Verweis auf das soeben geöffnete Formular frmArtikeldetails_III <\/b>und stellen die Eigenschaft Beim Schließen <\/b>auf den Wert [Event Procedure] <\/b>ein.<\/p>\n Was passiert hier nun Ganz einfach: frmArtikelUebersicht_III<\/b>, das Hauptformular mit der Artikelübersicht, ist bereits geöffnet.<\/p>\n Die Routine SampleImplantEvent <\/b>öffnet das Formular frmArtikelDetails_III<\/b>, das wiederum beim Laden prüft, ob das Formular frmArtikelUebersicht_III <\/b>geöffnet ist, und ruft dessen Methode ImplantCloseEvent <\/b>auf.<\/p>\n Diese wiederum sorgt dafür, dass das Formular frmArtikelUebersicht_III <\/b>es mitbekommt, wenn der Benutzer das Formular frmArtikelDetails_III <\/b>schließt und somit die in frmArtikelUebersicht_III <\/b>angezeigten Daten aktualisiert werden können.<\/p>\n Ups – haben Sie es auch gemerkt Wir haben da gerade eine Abhängigkeit vom aufgerufenen Formular frmArtikelDetails_III <\/b>zum eigentlichen Hauptformular frmArtikelUebersicht_III <\/b>hergestellt, und das wollten wir ja gerade vermeiden.<\/p>\n Kein Problem: Wir können die Anweisungen, welche die Methode ImplantCloseEvent <\/b>des Formulars frmArtikelUebersicht_III <\/b>aufrufen, ja auch nach außen verlagern, etwa in die Routine, die für das Öffnen des Formulars frmArtikelDetails_III <\/b>verantwortlich ist:<\/p>\n Das Formular frmArtikelDetails_III <\/b>ist nun, wie gewünscht, nach wie vor völlig unabhängig von den aufrufenden Instanzen. Und jede Instanz, die es mitbekommen möchte, wenn das Formular geschlossen und möglicherweise ein neuer Datensatz angelegt wurde, erfährt auch davon – und kann dann etwa seine Artikelübersicht aktualisieren.<\/p>\n Erst lesen, dann schließen<\/b><\/p>\n Noch eine Stufe weiter geht die Variante, bei der das aufrufende Formular Informationen vom aufgerufenen Formular auslesen muss, bevor dieses geschlossen wird.<\/p>\n Die Beispielformulare für diesen Fall heißen frmForm <\/b>und frmPopup<\/b>. frmForm <\/b>und frmPopup <\/b>besitzen beide ein Textfeld. frmForm <\/b>kann frmPopup <\/b>per Klick auf eine Schaltfläche aufrufen. Der Inhalt des Textfelds von frmPopup <\/b>soll dann nach dem Schließen von frmPopup <\/b>in das Textfeld von frmForm <\/b>geschrieben werden (siehe Bild 6).<\/p>\n Bild 6: Vom aufrufenden Formular zum Popup-Formular und zurück<\/span><\/b><\/p>\n Normalerweise geschieht dies, indem Sie frmPopup <\/b>als modalen Dialog öffnen und dort zwei Schaltflächen unterbringen: Die erste heißt cmdOK <\/b>und macht das Formular frmPopup <\/b>unsichtbar, das zweite namens cmdAbbrechen <\/b>schließt das Formular gleich komplett.<\/p>\n Der aufrufende Code läuft dann nach dem Fokusverlust des modalen Dialogs weiter und prüft, ob das Formular frmPopup <\/b>noch geöffnet ist: Falls ja, steht fest, dass der Benutzer die Schaltfläche cmdOK <\/b>angeklickt hat (die Variante über die eingebaute Schließen-Schaltfläche lassen wir außen vor). In diesem Fall liest die Routine den Inhalt des Textfelds im zwar nun unsichtbaren, aber noch geöffneten Formular frmPopup <\/b>aus, schreibt diesen in das eigene Textfeld und schließt dieses dann endgültig. Falls der Benutzer frmPopup <\/b>über die Abbrechen<\/b>-Schaltfläche verlassen hat, findet die aufrufende Prozedur das Formular nicht mehr und geht davon aus, dass der Inhalt des Textfelds nicht geändert werden soll.<\/p>\n Sehen Sie das Problem Das Formular frmPopup <\/b>wird auf unsichtbar geschaltet, damit das aufrufende Formular noch darauf zugreifen kann.<\/p>\n frmPopup <\/b>ist somit abhängig vom aufrufenden Formular, weil es sonst nicht geschlossen wird und beim nächsten Aufruf per DoCmd.OpenForm <\/b>die übergebenen Parameter nicht ausgewertet werden, weil das Formular schon geöffnet ist.<\/p>\n Beim Versuch, diese Konstellation mit den oben vorgestellten Techniken abzubilden, stoßen wir an deren Grenzen. Wir wollen erreichen, dass das aufrufende Formular beim Schließen des Popup-Formulars ermitteln kann, ob dieses über die OK<\/b>– oder die Abbrechen<\/b>-Schaltfläche geschlossen wurde, und somit entscheiden, ob der Inhalt des dortigen Textfelds in das Textfeld des aufrufenden Formulars übernommen werden soll.<\/p>\n Der erste Versuch läuft über das Implantieren des Beim Schließen<\/b>-Ereignisses. Die Information über die gedrückte Schaltfläche soll uns die Eigenschaft Screen.ActiveControl <\/b>liefern, aber leider hat das Popup-Formular zum Zeitpunkt des Schließens nicht mehr den Fokus und Screen.ActiveControl <\/b>führt zu einem Fehler.<\/p>\n Als Nächstes versuchen wir, eine Ereignisprozedur für das Ereignis Beim Klicken <\/b>der OK<\/b>-Schaltfläche zu implantieren. Wird dieses Ereignis ausgelöst, steht fest, dass der Benutzer diese Schaltfläche zum Schließen des Formulars verwendet hat und somit auch den Text aus dem Textfeld übernehmen möchte.<\/p>\n Leider gibt es auch hier ein Problem: Es liegen nämlich nun zwei Beim Klicken<\/b>-Ereignisprozeduren vor. Die erste im Klassenmodul des Popup-Formulars sieht so aus:<\/p>\n Die implantierte Variante, die sich im Klassenmodul des aufrufenden Formulars befindet, besitzt diesen Code:<\/p>\n Zunächst einmal müssen Sie Zugriff auf die Ereignisse der Schaltfläche cmdOK <\/b>des Popup-Formular erhalten, was nicht viel aufwendiger als beim Formular selbst ist. Die folgende Routine öffnet zunächst frmPopup<\/b>, holt sich dann die Referenz auf das Formular, legt dessen Ereigniseigenschaft Beim Schließen <\/b>fest und bezieht dann eine zweite Referenz, diesmal auf die Schaltfläche cmdOK <\/b>im bereits referenzierten Formular. Auch die damit gefüllte Objektvariable erhält noch einen entsprechenden Wert für die Ereigniseigenschaft Beim Klicken<\/b>:<\/p>\n Nun stellt sich die Frage, ob überhaupt beide Ereignisprozeduren ausgelöst werden, und wenn ja, welche zuerst<\/p>\n Die Antwort ist ungünstig: Die im Popup-Formular befindliche wird zuerst ausgelöst und sorgt somit dafür, dass das Formular bereits geschlossen ist, wenn die implantierte Beim Schließen<\/b>-Prozedur startet und versucht, den Inhalt des Textfelds auszulesen. Somit gibt es auch hier keine Möglichkeit, beim Schließen auf den Text zuzugreifen.<\/p>\n Um es vorwegzunehmen: Es gibt noch die Möglichkeit, das KeyDown<\/b>-Ereignis zu nutzen. Dieses wird durch das Herunterdrücken der Maustaste und vor allem vor dem Ereignis OnClick <\/b>ausgelöst und würde die Möglichkeit bieten, den Inhalt des Textfelds aus dem Popup-Formular in das aufrufende Formular zu übertragen.<\/p>\n Das Problem ist aber: Sie müssen dann sicherstellen, dass der Benutzer auch wirklich die Maustaste verwendet, um das Formular zu schließen.<\/p>\n Dies ist ja auch über das vorherige Aktivieren der Schaltfläche per Tab- oder Cursor-Taste und anschließendes Betätigen der Leertaste oder der Eingabetaste möglich – und wenn dann noch das Ereignis Bei Taste ab <\/b>ins Spiel kommt, übersteigt der Aufwand doch allmählich den Nutzen.<\/p>\n Es gibt allerdings eine Möglichkeit, dies recht einfach zu lösen – allerdings nicht durch das Implantieren eines eingebauten, sondern eines benutzerdefinierten Ereignisses. Huh! Das wäre nun wirklich etwas viel neuer Stoff für einen einzigen Beitrag, weshalb wir darauf detaillierter im Beitrag Ereignisse im Eigenbau <\/b>(Shortlink 685) eingehen.<\/p>\n An dieser Stelle nur so viel zu dieser Methode: Sie werden dabei das kleine Manko der Reihenfolge beim Auslösen von originalen und implantierten Ereignissen beheben und dafür sorgen, dass das externe Element in Aktion treten kann und somit vor dem Schließen des Formulars zum Zuge kommt, und gleichzeitig keine zusätzlichen Abhängigkeiten schaffen – mehr erfahren Sie im oben genannten Beitrag.<\/p>\n Enthaltene Beispieldateien:<\/p>\n Ereignisse.mdb<\/p>\nPrivate Sub Form_Close()\r\n MsgBox \"Formular wird geschlossen.\"\r\n End Sub\r\nPrivate Sub Form_Open(Cancel As Integer)\r\n MsgBox \"Formular wird geöffnet.\"\r\n End Sub<\/pre>\n
Dim WithEvents objForm As Form\r\nPrivate Sub cmdSetReference_Click()\r\n DoCmd.OpenForm \"frmFormularMitEreignis\"\r\n Set objForm = Forms!frmFormularMitEreignis\r\n End Sub<\/pre>\n
Private Sub objForm_Close()\r\n MsgBox \"Implantiert: Formular wurde\r\n geschlossen.\"\r\n End Sub<\/pre>\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2009_05\/EreignisseAbfangenUndAuswerten-web-images\/pic002_opt.jpeg\")
<\/p>\n![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2009_05\/EreignisseAbfangenUndAuswerten-web-images\/pic003_opt.jpeg\")
<\/p>\nPrivate Sub cmdNeu_Click()\r\n DoCmd.OpenForm \"frmArtikeldetails_I\", _\r\n DataMode:=acFormAdd, WindowMode:=acDialog\r\n Me!sfmArtikeluebersicht.Form.Requery\r\n End Sub<\/pre>\n
DoCmd.OpenForm \"frmArtikeldetails_I\",\r\nDataMode:=acFormAdd<\/pre>\n
![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2009_05\/EreignisseAbfangenUndAuswerten-web-images\/pic004_opt.jpeg\")
<\/p>\nDim WithEvents objFrmArtikelDetails_I As Form<\/pre>\n
Set objFrmArtikelDetails_I =\r\nForms!frmArtikeldetails_I<\/pre>\n
Private Sub objFrmArtikelDetails_I_Close()\r\n Me!sfmArtikeluebersicht.Requery\r\n End Sub<\/pre>\n
\n
objFrmArtikelDetails_I.OnClose =\r\n\"[Event Procedure]\"<\/pre>\n
![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2009_05\/EreignisseAbfangenUndAuswerten-web-images\/pic005_opt.jpeg\")
<\/p>\nDim WithEvents objSfmArtikeluebersicht_II As Form<\/pre>\n
Private Sub cmdLoeschen_Click()\r\n With Me.sfmArtikeluebersicht.Form\r\n .RecordsetClone.Bookmark = .Bookmark\r\n .RecordsetClone.Delete\r\n .Requery\r\n End With\r\n End Sub<\/pre>\n
Private Sub Form_Load()\r\n Set objSfmArtikeluebersicht_II =\r\n Me!sfmArtikeluebersicht.Form\r\n With objSfmArtikeluebersicht_II\r\n .OnCurrent = \"[Event Procedure]\"\r\n End With\r\n End Sub<\/pre>\n
Private Sub objSfmArtikeluebersicht_II_Current()\r\n If objSfmArtikeluebersicht_II.NewRecord _\r\n Or objSfmArtikeluebersicht_II. _\r\n Lagerbestand = 0 Then\r\n Me!cmdLoeschen.Enabled = False\r\nElse\r\n Me!cmdLoeschen.Enabled = True\r\nEnd If\r\nEnd Sub<\/pre>\n
\n
Public Sub SampleImplantEvent()\r\nDoCmd.OpenForm \"frmArtikeldetails_III\", _\r\nDataMode:=acFormAdd\r\nEnd Sub<\/pre>\n
Private Sub Form_Load()\r\nIf IstFormularGeoeffnet(\"frmArtikel\r\nuebersicht_III\") Then\r\nForms!frmArtikeluebersicht_III.\r\nImplantCloseEvent\r\nEnd If\r\nEnd Sub<\/pre>\n
Public Sub ImplantCloseEvent()\r\nSet objFrmArtikelDetails_III =\r\nForms!frmArtikeldetails_III\r\nobjFrmArtikelDetails_III.OnClose =\r\n\"[Event Procedure]\"\r\nEnd Sub<\/pre>\n
Public Sub SampleImplantEvent()\r\nDoCmd.OpenForm \"frmArtikeldetails_III\",\r\nDataMode:=acFormAdd\r\nIf IstFormularGeoeffnet(\"frmArtikel\r\nuebersicht_III\") Then\r\nForms!frmArtikeluebersicht_III.\r\nImplantCloseEvent\r\nEnd If\r\nEnd Sub<\/pre>\n
![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2009_05\/EreignisseAbfangenUndAuswerten-web-images\/pic006_opt.jpeg\")
<\/p>\nPrivate Sub cmdOK_Click()\r\nDoCmd.Close acForm, Me.Name\r\nEnd Sub<\/pre>\n
Private Sub objCmdOK_Click()\r\nMe!txtVonPopup = objFrmPopup!txtPopup\r\nEnd Sub<\/pre>\n
Private Sub cmdPopupOeffnen_Click()\r\nDoCmd.OpenForm \"frmPopup\"\r\nSet objFrmPopup = New Form_frmPopup\r\nobjFrmPopup.OnClose = \"[Event Procedure]\"\r\nSet objCmdOK = objFrmPopup!cmdOK\r\nobjCmdOK.OnClick = \"[Event Procedure]\"\r\nEnd Sub<\/pre>\n
Downloads zu diesem Beitrag<\/h3>\n