<\/p>\n
Wie wir im Beitrag „Benutzerdefinierte Felder in Outlook“ gezeigt haben, können Sie beispielsweise einem Outlook-Termin weitere Seiten mit benutzerdefinierten Steuerelementen hinzufügen. Wie nicht anders zu erwarten, lassen sich diese Elemente auch programmieren. Ein Einsatzzweck ist, die benutzerdefinierten Steuer-elemente beziehungsweise die dahinter stehenden Felder vorab mit Standardwerten zu füllen – beispielsweise das Feld „Mitarbeiter“ mit dem Namen des aktuellen Mitarbeiters.<\/b><\/p>\n
Ereignisse von Terminen und Steuerelementen<\/b><\/p>\n
Uns als Access-Entwickler interessiert neben den Objekten und Eigenschaften auch, welche Ereignisse die Objekte auslösen, mit denen wir arbeiten. Und natürlich lösen auch Outlook-Termine Ereignisse aus und auch die durch den Entwickler hinzugefügten Steuer-elemente.<\/p>\n
Schauen wir in den Objektkatalog, finden wir allein für das AppointmentItem<\/b>-Objekt, um das es hier im Wesentlichen geht, einige Ereignisse (siehe Bild 1).<\/p>\n
![\"Ereignisse](\"..\/fileadmin\/_temp_\/2020_01\/pic_1223_001.png\")
<\/p>\n
Bild 1: Ereignisse des AppointmentItem-Elements im Objektkatalog<\/span><\/b><\/p>\n Um ein AppointmentItem<\/b>, in diesem Beitrag auch Termin genannt, so zu programmieren, dass wir die hier aufgeführten Ereignisse implementieren, benötigen wir eine andere Herangehensweise als beispielsweise bei der Programmierung eines Access-Formulars oder seiner Steuer-elemente.<\/p>\n Dort brauchen wir nur explizit die gewünschten Ereignisse in das jeweilige Klassenmodul zu schreiben und für die Ereigniseigenschaft den Wert [Ereignisprozedur] <\/b>zu hinterlegen. Unter Outlook sieht das etwas anders aus – wie genau, schauen wir uns nun im Detail an.<\/p>\n Ereignisse beim Bearbeiten<\/b><\/p>\n Als Erstes schauen wir uns an, wie wir Ereignisse abfangen können, die beim Bearbeiten eines Termins ausgelöst werden. Dazu brauchen wir eine Instanz des Termins. Wie kommen wir an diese heran Dazu gehen wir den Weg über das sogenannte Inspector<\/b>-Element. Inspector <\/b>ist das Fenster, in dem ein Outlook-Objekt – wie in diesem Fall ein Termin – angezeigt wird. Über das Inspector<\/b>-Objekt können wir schließlich auf den enthaltenen Termin zugreifen, wenn der Benutzer diesen geöffnet hat.<\/p>\n Neu geöffneten Inspector referenzieren<\/b><\/p>\n Um auf ein frisch geöffnetes Termin-Objekt zugreifen zu können, benötigen wir das Inspector<\/b>-Objekt. Dieses erhalten wir über die Inspectors<\/b>-Auflistung. Dazu deklarieren wir eine Objektvariable wie die folgende im Klassenmodul ThisOutlookSession <\/b>des VBA-Projekts von Outlook:<\/p>\n Wir verwenden das Schlüsselwort WithEvents<\/b>, um die Ereignisse dieses Objekts implementieren zu können. Die Inspectors<\/b>-Auflistung hat nur eine Ereigniseigenschaft, die wir implementieren können, indem wir im linken Kombinationsfeld im VBA-Fenster des Moduls ThisOutlookSession <\/b>den Eintrag objInspectors <\/b>auswählen. Im rechten Kombinationsfeld wird dann automatisch das einzige Ereignis ausgewählt und im VBA-Fenster die Ereignisprozedur objInspectors_NewInspector <\/b>angelegt (siehe Bild 2). Diese Prozedur sieht zunächst wie folgt aus:<\/p>\n Bild 2: Anlegen des Ereignisses für die Inspectors-Auflistung<\/span><\/b><\/p>\n Diese Ereignisprozedur wird im aktuellen Zustand des Moduls niemals ausgelöst, denn die Objektvariable objInspectors <\/b>wurde noch nicht gefüllt. Das holen wir nun nach, indem wir ihr in der Ereignisprozedur Application_Startup <\/b>die Auflistung zuweisen:<\/p>\n Die Prozedur Application_Startup <\/b>wird bei jedem Start von Outlook aufgerufen. Sie können nun Outlook neu starten, um diese Prozedur auszulösen, oder Sie rufen diese einfach durch Platzieren der Einfügemarke in der Prozedur und Betätigen der Taste F5 <\/b>auf. Setzen Sie außerdem einen Haltepunkt in die Prozedur objInspectors_New-Inspector<\/b>. Wenn Sie nun zum Anwendungsfenster von Outlook wechseln und durch einen Doppelklick in den Kalender einen neuen Termin öffnen, wird die Prozedur objInspectors_NewInspector <\/b>ausgelöst und stoppt am Haltepunkt.<\/p>\n Neues Inspector-Fenster referenzieren<\/b><\/p>\n Damit kommen wir zum nächsten Schritt: Der Parameter Inspector <\/b>der Prozedur objInspectors_NewInspector <\/b>liefert einen Verweis auf das neue Inspector<\/b>-Fenster. Dieses können wir nun wiederum mit einer Objektvariablen referenzieren, um seine Ereignisse implementieren zu können. Dazu fügen wir dem Modul ThisOutlookSession <\/b>die folgende Objektvariable hinzu, wiederum mit dem Schlüsselwort WithEvents <\/b>ausgestattet:<\/p>\n Wenn wir das neue Objekt im linken Kombinationsfeld des VBA-Fensters auswählen, finden wir im rechten Kombinationsfeld alle dafür zur Verfügung stehenden Ereignisse vor – zum Beispiel eines, das beim Wechseln der Seite ausgelöst wird (siehe Bild 3). Um dieses auszuprobieren, stellen wir in der Ereignisprozedur objInspectors_NewInspector <\/b>die Objektvariable objInspector <\/b>auf das mit dem Parameter Inspector <\/b>gelieferte Objekt ein:<\/p>\n Bild 3: Ereignisse eines Outlook-Inspectors<\/span><\/b><\/p>\n Dann implementieren wir das Ereignis PageChange <\/b>der neuen Objektvariablen und geben darin den Wert des Parameters ActivePageName <\/b>aus:<\/p>\n Damit können wir nun zwischen den Seiten Termin <\/b>und Terminplanung <\/b>hin- und herwechseln und erhalten jeweils den Titel der aktiven Seite im Direktbereich. Wenn Sie, wie im Beitrag Benutzerdefinierte Felder in Outlook <\/b>(www.access-im-unternehmen.de\/1221<\/b>) beschrieben, bereits eine weitere Seite namens Termindetails <\/b>angelegt haben, können Sie auch diese aufrufen und den jeweiligen Namen ausgeben.<\/p>\n Unterscheidung zwischen verschiedenen Inspector-Objekten<\/b><\/p>\n Wir haben nun bewusst immer Termin-Einträge im Inspector<\/b>-Objekt geöffnet. Aber auch beim Öffnen von E-Mails oder Kontakten wird das Ereignis objInspectors_NewInspector <\/b>ausgelöst. Wenn wir nun nicht mehr nur mit objInspector <\/b>das geöffnete Inspector<\/b>-Objekt referenzieren wollen, sondern auch mit einer weiteren Objektvariablen namens objAppointmentItem <\/b>den im Inspector enthaltenen Termin, kann es zu Problemen kommen – beispielsweise, wenn wir gar keinen Termin-Inspector geöffnet haben.<\/p>\n In diesem Fall müssen wir also zuvor prüfen, ob überhaupt ein Inspector mit einem Termin geöffnet wurde.<\/p>\n Dazu deklarieren wir wieder eine Objektvariable mit dem Schlüsselwort WithEvents<\/b> für das AppointmentItem<\/b>-Objekt im neu geöffneten Inspector:<\/p>\n Dann erweitern wir die Prozedur objInspectors_NewInspector <\/b>so, dass wir den Typ des enthaltenen Elements prüfen und nur im Falle eines Appointments einen Verweis auf das Element in die Variable objAppointmentItem <\/b>schreiben:<\/p>\n Interessant sind zum Beispiel die beiden Ereignisse PropertyChange <\/b>und CustomPropertyChange<\/b>, die jeweils beim Ändern von eingebauten und benutzerdefinierten Ereignissen ausgelöst werden. Das Ereignis PropertyChange <\/b>können Sie so implementieren:<\/p>\n Hier können wir leider nicht über die Properties<\/b>-Auflistung auf die Eigenschaft mit dem geänderten Wert zugreifen, denn diese Auflistung gibt es schlicht nicht. Sie könnten aber per Select Case <\/b>auf die Änderung bestimmter Eigenschaften reagieren, die für den Anwendungsfall interessant sind. Im Beispiel aus Listing 1 geben wir die Werte für die Eigenschaften Subject <\/b>und Start <\/b>aus, wenn diese geändert wurden.<\/p>\n Listing 1: Ereignisprozedur beim Ändern einer eingebauten Eigenschaft<\/span><\/b><\/p>\n <\/p>\n Objektvariablen erneut initialisieren<\/b><\/p>\n Wenn Sie mit den hier vorgestellten Ereignisprozeduren experimentieren, werden Sie gelegentlich feststellen, dass diese nicht mehr wie gewünscht funktionieren. Es kann sein, dass die Objektvariablen bei Codeänderungen zur Laufzeit oder durch Laufzeitfehler geleert werden. Damit werden dann natürlich auch nicht mehr die für diese Objektvariablen implementierten Ereignisse ausgelöst. Sie sollten also gelegentlich die Prozedur Application_Startup<\/b> erneut ausführen, um die Objektvariablen zu initialisieren.<\/p>\n Änderungen von benutzerdefinierten Eigenschaften<\/b><\/p>\n Im oben genannten Beitrag Benutzerdefinierte Felder in Outlook <\/b>haben wir einem Termin eine neue Seite mit einem Feld namens Mitarbeiter <\/b>hinzugefügt. Eine Änderungen an einem solchen Feld können wir nicht über die Ereignisprozedur PropertyChange <\/b>erfassen, sondern wir benötigen dazu die Ereignisprozedur CustomPropertyChange<\/b>. Diese liefert ebenfalls mit dem Name<\/b>-Parameter den Namen der geänderten Eigenschaft. Im Gegensatz zu den eingebauten Eigenschaften können wir hier allerdings über die Auflistung UserProperties <\/b>des AppointmentItem<\/b>-Elements auf die Eigenschaft und ihren Wert zugreifen. Das erledigen wir wie folgt:<\/p>\n Schließen von Termin-Objekten<\/b><\/p>\n Mit den oben vorgestellten Ereignissen können Sie bereits auf Änderungen an den eingebauten und benutzerdefinierten Eigenschaften von Outlook-Terminen zugreifen. Damit könnten Sie die geänderten Eigenschaften beispielsweise direkt mit einer Tabelle in einer Access-Datenbank synchronisieren. Allerdings wäre es ressourcenschonender, wenn wir dies erst beim Schließen des Termin-Elements erledigen.<\/p>\n Dazu können wir beispielsweise eines der Ereignisse Close <\/b>oder Unload <\/b>nutzen. Wir legen beide Ereignisprozeduren an und versehen diese mit Haltepunkten, um zu prüfen, zu welchem Zeitpunkt diese beiden Ereignisse ausgelöst werden und in welcher Reihenfolge. In unseren Tests haben wir festgestellt, dass nur Close <\/b>ausgelöst wird, Unload <\/b>jedoch nicht.<\/p>\n Für unsere Zwecke würde es jedoch reichen, wenn die Close<\/b>-Ereignisprozedur ausgelöst wird – in dieser können wir noch auf alle Eigenschaften des Termin-Elements zugreifen und wir können das Schließen gegebenenfalls auch noch abbrechen, wenn Informationen fehlen. Das gestalten wir dann beispielsweise so:<\/p>\n Das setzt natürlich voraus, dass Sie wie im Beitrag Benutzerdefinierte Felder in Outlook <\/b>beschrieben, ein benutzerdefiniertes Feld namens Mitarbeiter <\/b>angelegt und auch über die Benutzeroberfläche verfügbar gemacht haben. Praktisch wäre es, wenn wir den Bereich, in dem sich das Steuer-element zur Eingabe des benutzerdefinierten Feldes befindet, noch einblenden könnten. Dazu erweitern wir die Prozedur wie in Listing 2. Hier fragen wir den Benutzer noch, ob er den Mitarbeiter eintragen möchte. Falls ja, wechseln wir mit der Methode SetCurrentFormPage <\/b>des Inspector<\/b>-Objekts zum Formularbereich Termindetails<\/b>.<\/p>\n Listing 2: Abbrechen des Schließens, wenn noch kein Mitarbeiter eingetragen wurde<\/span><\/b><\/p>\n Damit landen wir dann auf der Seite, die in Bild 4 abgebildet ist. Nach der Eingabe eines Wertes in das Textfeld können Sie das Termin-Element allerdings noch nicht schließen – es erscheint die gleiche Meldung wie zuvor. Der Grund ist, dass der eingegebene Wert nun zwar im Textfeld vorliegt, aber noch nicht in der zugrundeliegenden benutzerdefinierten Eigenschaft. Aber wann landet der Wert im benutzerdefinierten Feld und wie können wir nicht nur auf das benutzerdefinierte Feld, sondern auch auf das Steuer-element und seinen Inhalt zugreifen Das schauen wir uns im nächsten Abschnitt an.<\/p>\n Bild 4: Wechseln zum benutzerdefinierten Formularbereich<\/span><\/b><\/p>\n Steuer-elemente im Formularbereich referenzieren<\/b><\/p>\n Um Steuer-elemente in einem Formularbereich zu referenzieren, benötigen wir zunächst einen Verweis auf den Formularbereich. Aber welchen Objekttyp hat der Formularbereich eigentlich Das finden wir im Zweifel mit der Typename<\/b>-Funktion heraus. Und wie kommen wir überhaupt an den Formularbereich heran Dazu haben wir im Objektkatalog die Eigenschaften der beteiligten Objekte durchgesehen. Für das Inspector<\/b>-Element haben wir schließlich die Eigenschaft ModifiedFormPages <\/b>gefunden, deren Inhalt wir wie nachfolgend der Variablen obj-Pages <\/b>vom Typ Pages <\/b>zuweisen. Die Count<\/b>-Eigenschaft liefert den Wert 1 <\/b>und die Funktion Typename <\/b>für diesen einen Eintrag liefert den Wert UserForm<\/b>:<\/p>\n Damit können wir nun im Kopf des Klassenmoduls die folgende Deklaration vornehmen:<\/p>\n Dabei fällt uns allerdings auf, dass die Klasse UserForm <\/b>gar nicht per IntelliSense angeboten wird. Kein Wunder: Die UserForm<\/b>-Klasse ist auch Teil der Bibliothek Microsoft Forms 2.0 Object Library<\/b>, die im VBA-Projekt von Outlook nicht standardmäßig referenziert wird. Und leider finden wir diese auch nicht im Verweise<\/b>-Dialog. Es gibt jedoch einen alternativen Weg, um diesen Verweis hinzuzufügen. Dazu legen Sie im VBA-Projekt eine UserForm über den Menüeintrag Einfügen|UserForm <\/b>an. Dies fügt automatisch den Eintrag Microsoft Forms 2.0 Object Library <\/b>zur Liste der Verweise hinzu (siehe Bild 5). Die hinzugefügte UserForm können Sie danach wieder entfernen.<\/p>\n Bild 5: Verweis auf die Bibliothek Microsoft Forms 2.0 Object Library<\/span><\/b><\/p>\n Danach können wir die obige Prozedur noch um eine Schleife erweitern, die alle Steuerelemente der UserForm im Direktbereich ausgibt:<\/p>\n Das liefert in unserem Fall:<\/p>\n Die Textbox können wir wiederum referenzieren. Auch sie stellt Ereignisprozeduren bereit, daher erfolgt die Deklaration wieder mit dem Schlüsselwort WithEvents<\/b>:<\/p>\n Die Prozedur objInspectors_NewInspector <\/b>erweitern wir um die folgende Anweisung:<\/p>\n Damit können wir über die beiden Kombinationsfelder im Codefenster auch für das Textfeld Ereignisprozeduren implementieren.<\/p>\n Ereignisprozeduren für alle Fälle<\/b><\/p>\n Damit haben wir nun die Möglichkeit, Ereignisprozeduren für die folgenden Klassen zu implementieren:<\/p>\n Alternativer Ort für Programmcode<\/b><\/p>\n Wenn Sie Outlook-Elemente beispielsweise um Formular-Regionen erweitern wollen, die Sie auch an andere Benutzer weitergeben möchten, ist das VBA-Projekt von Outlook nicht der richtige Ort. Denn dann müssten Sie jedem Benutzer auch noch das VBA-Projekt weitergeben beziehungsweise den darin enthaltenen Code zur Automatisierung von Vorgängen.<\/p>\n Der in diesem Fall praktischere Weg ist, den Code direkt mit dem Formularbereich anzulegen. Um das zu tun, aktivieren Sie die Anzeige der Entwicklertools im Ribbon von Outlook. Danach können Sie mit dem Befehl Entwickler-tools|Benutzerdefinierte Formulare|Ein Formular entwerfen <\/b>den Dialog Formular entwerfen <\/b>öffnen. Hier finden Sie in einem der mit dem oberen Kombinationsfeld auszuwählenden Ordner das benutzerdefinierte Formular, sofern Sie schon eines angelegt haben (siehe Bild 6).<\/p>\n Bild 6: Auswahl eines zu entwerfenden Formulars<\/span><\/b><\/p>\n Nach dem Öffnen erscheint das Formular, in diesem Fall ein Termin, in der Entwurfsansicht. Hier finden Sie den Ribbon-Befehl Code anzeigen <\/b>vor (siehe Bild 7).<\/p>\n Bild 7: Anzeigen des Codes<\/span><\/b><\/p>\n Danach erscheint ein Fenster, das einem sehr einfachen Code-Editor entspricht. Hier können Sie zwei weitere Fenster zur Unterstützung bei der Eingabe von Code aufrufen, denn IntelliSense gibt es hier nicht. Diese beiden finden Sie unter dem Menüpunkt Schrifttyp <\/b>unter den Namen Ereignishandler <\/b>und Objektkatalog<\/b>. Warum der Menüpunkt Schrifttyp <\/b>heißt, wollen wir an dieser Stelle nicht herausfinden.<\/p>\n Mit dem Dialog Ereignishandlerroutinen einfügen <\/b>können wir Ereignisprozeduren beziehungsweise -funktionen für das Item<\/b>-Objekt hinzufügen, im Screenshot zum Beispiel die Open<\/b>-Ereignisprozedur (siehe Bild 8).<\/p>\n Bild 8: Der Skript-Editor<\/span><\/b><\/p>\n Das Item<\/b>-Objekt entspricht dabei dem AppointmentItem<\/b>-Objekt, das wir weiter oben vorgestellt haben. Allerdings finden wir hier nicht alle Ereignisprozeduren, die für das AppointmentItem<\/b>-Objekt zur Verfügung stehen.<\/p>\n Praktische Anwendung<\/b><\/p>\n Durch die Programmierung der Ereignisprozedur Item_Open <\/b>im Skript-Editor des Formulars können Sie beispielsweise Werte ändern, die beim Erstellen eines neuen Termins automatisch von der Standardvorlage übernommen werden. Das folgende Skript soll beispielsweise dafür sorgen, dass beim Öffnen eines neuen Termins (das erkennen wir an Item.Size = 0<\/b>) die Dauer standardmäßig auf 15 Minuten festgelegt wird statt wie sonst auf 30 Minuten:<\/p>\n Wenn wir das Formular dann speichern und ausführen oder veröffentlichen und einen neuen Termin auf Basis dieser Version mit dem Formular anlegen, wird das Skript nicht ausgeführt. Mangels Debugging-Möglichkeiten haben wir noch MsgBox<\/b>-Anweisungen im Skript platziert, die jedoch nicht zur Anzeige von Meldungsfenstern führten. Woran kann das liegen<\/p>\n Benutzerdefinierter Formularcode standardmäßig deaktiviert<\/b><\/p>\n Die Lösung war schnell gefunden: Benutzerdefinierter Formularcode wie der in unserer Lösung ist seit einiger Zeit standardmäßig deaktiviert. Und die Ausführbarkeit kann auch nur durch Einstellungen an der Registry wiederhergestellt werden, also nicht etwa durch das Einstellen von Optionen über die Benutzeroberfläche. Dazu öffnen Sie zunächst den Registry-Editor. Dann gehen Sie für die 32-Bit-Variante von Office wie folgt vor:<\/p>\n Bild 9: Ausführung von Skripten erlauben per Registry<\/span><\/b><\/p>\n<\/ul>\n Danach müssen Sie noch die Klasse des Formulars angeben, für das Skripte ausgeführt werden dürfen. Diese müssen Sie erst einmal herausfinden. Dazu fügen wir unserer NewInspector<\/b>-Ereignisprozedur einen entsprechenden Befehl hinzu:<\/p>\n Das liefert für unser Formular Termin mit Details <\/b>das folgende Ergebnis:<\/p>\n Danach legen Sie einen neuen Schlüssel in der Registry an:<\/p>\n Für diesen fügen Sie einen REG_SZ<\/b>-Wert hinzu, der diesen Namen erhält:<\/p>\n Für die 64-Bit-Version von Office führen Sie beide Schritte ausgehend von diesem Registry-Schlüssel aus:<\/p>\nPrivate <\/span>WithEvents objInspectors As <\/span>Inspectors<\/pre>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2020_01\/pic_1223_002.png\")
<\/p>\nPrivate Sub <\/span>objInspectors_NewInspector(ByVal Inspector As <\/span>Inspector)\r\n \r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Application_Startup()\r\n Set<\/span> objInspectors = Outlook.Application.Inspectors\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>WithEvents objInspector As <\/span>Inspector<\/pre>\n![\"Ereignisse](\"..\/fileadmin\/_temp_\/2020_01\/pic_1223_003.png\")
<\/p>\nPrivate Sub <\/span>objInspectors_NewInspector( ByVal Inspector As <\/span>Inspector)\r\n Set<\/span> objInspector = Inspector\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objInspector_PageChange( ActivePageName As String<\/span>)\r\n Debug.Print<\/span> \"Aktuelle Seite: \" & ActivePageName\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>WithEvents objAppointmentItem As <\/span>AppointmentItem<\/pre>\nPrivate Sub <\/span>objInspectors_NewInspector( ByVal Inspector As <\/span>Inspector)\r\n Set<\/span> objInspector = Inspector\r\n Select Case Inspector.CurrentItem.Class\r\n Case <\/span>olAppointment\r\n Set<\/span> objAppointmentItem = Inspector.CurrentItem\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objAppointmentItem_PropertyChange( ByVal Name As String<\/span>)\r\n Debug.Print<\/span> \"Eigenschaft geändert: \" & Name\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objAppointmentItem_PropertyChange(ByVal Name As String<\/span>)\r\n Select Case Name\r\n Case <\/span>\"Subject\"\r\n Debug.Print<\/span> \"Die Eigenschaft '\" & Name & \"' wurde geändert.\"\r\n Debug.Print<\/span> \"Neuer Wert: \" & objAppointmentItem.Subject\r\n Case <\/span>\"Start\"\r\n Debug.Print<\/span> \"Die Eigenschaft '\" & Name & \"' wurde geändert.\"\r\n Debug.Print<\/span> \"Neuer Wert: \" & objAppointmentItem.Start\r\n End Select<\/span>\r\n Debug.Print<\/span> \"Eigenschaft geändert: \" & Name\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objAppointmentItem_CustomPropertyChange( ByVal Name As String<\/span>)\r\n Debug.Print<\/span> \"Benutzerdefinierte Eigenschaft geändert: \" & Name\r\n Debug.Print<\/span> \"Neuer Wert: \" & objAppointmentItem.UserProperties(Name)\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objAppointmentItem_Close(Cancel As Boolean<\/span>)\r\n If <\/span>objAppointmentItem.UserProperties(\"Mitarbeiter\") = \"\" Then<\/span>\r\n MsgBox<\/span> \"Tragen Sie den Mitarbeiter ein.\"\r\n Cancel = True<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objAppointmentItem_Close(Cancel As Boolean<\/span>)\r\n Dim <\/span>intResult As <\/span>VbMsgBoxResult\r\n If <\/span>objAppointmentItem.UserProperties(\"Mitarbeiter\") = \"\" Then<\/span>\r\n intResult = MsgBox<\/span>(\"Es ist kein Mitarbeiter zugeordnet. Noch eintragen\", vbYesNo)\r\n If <\/span>intResult = vbYes Then<\/span>\r\n objInspector.SetCurrentFormPage \"Termindetails\"\r\n Cancel = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Wechseln](\"..\/fileadmin\/_temp_\/2020_01\/pic_1223_004.png\")
<\/p>\nPrivate Sub <\/span>objInspectors_NewInspector( ByVal Inspector As <\/span>Inspector)\r\n Dim <\/span>objPages As <\/span>Outlook.Pages\r\n Set<\/span> objInspector = Inspector\r\n Select Case Inspector.CurrentItem.Class\r\n Case <\/span>olAppointment\r\n Set<\/span> objAppointmentItem = Inspector.CurrentItem\r\n Set<\/span> objPages = objInspector.ModifiedFormPages\r\n Debug.Print<\/span> objPages.Count\r\n Debug.Print<\/span> TypeName(objPages(1))\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>WithEvents objUserForm As <\/span>UserForm<\/pre>\n![\"Verweis](\"..\/fileadmin\/_temp_\/2020_01\/pic_1223_005.png\")
<\/p>\nDim <\/span>ctl As <\/span>MSForms.Control\r\nFor Each ctl In objUserForm.Controls\r\n Debug.Print<\/span> ctl.Name\r\nNext<\/span> ctl<\/pre>\nText<\/span>Box1\r\nLabel1<\/pre>\nPrivate <\/span>WithEvents txt As <\/span>MSForms.TextBox<\/pre>\nSet<\/span> txt = objUserForm.Controls(\"TextBox1\")<\/pre>\n\n
![\"Auswahl](\"..\/fileadmin\/_temp_\/2020_01\/pic_1223_006.png\")
<\/p>\n![\"Anzeigen](\"..\/fileadmin\/_temp_\/2020_01\/pic_1223_007.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2020_01\/pic_1223_008.png\")
<\/p>\nFunction <\/span>Item_Open()\r\n If <\/span>Item.Size = 0 Then<\/span>\r\n Item.Duration = 15\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\n\n
![\"Ausführung](\"..\/fileadmin\/_temp_\/2020_01\/pic_1223_009.png\")
<\/p>\nPrivate Sub <\/span>objInspectors_NewInspector( ByVal Inspector As <\/span>Inspector)\r\n ...\r\n Set<\/span> objAppointmentItem = Inspector.CurrentItem\r\n Debug.Print<\/span> objAppointmentItem.MessageClass\r\n ...\r\nEnd Sub<\/span><\/pre>\nIPM.Appointment.Termin mit Details<\/pre>\n
ComputerHKEY_LOCAL_MACHINESOFTWAREWOW6432NodeMicrosoftOffice16.0OutlookFormsTrustedFormScriptList<\/pre>\n
IPM.Appointment.Termin mit Details<\/pre>\n
HKEY_LOCAL_MACHINESOFTWAREMicrosoftOffice16.0Outlook...<\/pre>\n