Die Basis: Die Application-Klasse<\/h2>\n
Die Grundlage für alle Zugriffe auf die Elemente der Benutzeroberfläche von Outlook ist die Application<\/b>-Klasse. Diese beschreiben wir mit allen Eigenschaften, Methoden und Ereignissen ausführlich im Artikel Outlook: Die Application-Klasse <\/b>(www.vbentwickler.de\/305<\/b>).<\/p>\nFenstertypen unter Outlook<\/h2>\n
Bevor wir beginnen, ein Fenster unter Outlook zu referenzieren, stellen wir zunächst die verschiedenen Fenster vor. Es gibt die folgenden beiden Fenstertypen:<\/p>\n
- \n
- Explorer<\/b>: Eigentliches Outlook-Fenster. Es kann auch mehrere davon geben, je nachdem, wie oft der Benutzer Outlook geöffnet hat. Auch mehrere Explorer-Fenster unterliegen jedoch immer einem einzigen Application<\/b>-Objekt. Der Aufruf der Quit<\/b>-Methode des übergeordneten Application<\/b>-Objekts schließt daher immer alle Explorer<\/b>-Fenster.<\/li>\n
- Inspector<\/b>: Ein Inspector<\/b>-Fenster ist eines der Fenster, mit dem Sie per Doppelklick auf eines der Elemente in den Ordnern eines Explorer<\/b>-Fensters die Details des jeweiligen Elements anzeigen – beispielsweise für E-Mails, Termine, Kontakte et cetera.<\/li>\n<\/ul>\n
Auf die Fenster von Outlook zugreifen<\/h2>\n
Bereits die verschiedenen Fenster von Outlook bieten einige Möglichkeiten zur Programmierung und halten dementsprechend auch einige Ereignisse bereit. Bevor wir diese vorstellen, müssen wir jedoch zunächst einmal Zugriff auf das gewünschte Fenster erhalten.<\/p>\n
Dafür gibt es zunächst die folgenden drei Methoden:<\/p>\n
- \n
- ActiveExplorer<\/b>: ActiveExplorer <\/b>liefert einen Verweis auf das oberste Element der geöffneten Outlook-Explorer <\/b>zurück, also das Element, das zuletzt aktiviert wurde. Das gilt auch, wenn zwischenzeitlich Fenster einer anderen Anwendung aktiviert wurden.<\/li>\n
- ActiveInspector<\/b>: Liefert einen Verweis auf das Inspector<\/b>-Element für das oberste Inspector<\/b>-Objekt, also das Element, das zuletzt aktiviert wurde. Es kann auch sein, dass gar kein Inspector<\/b>-Fenster geöffnet ist, dann liefert ActiveInspector <\/b>den Wert Nothing<\/b>.<\/li>\n
- ActiveWindow<\/b>: ActiveWindow <\/b>liefert immer einen Verweis auf das oberste Element der geöffneten Explorer<\/b>– und Inspector<\/b>-Elemente. Der Typ des zurückgelieferten Elements lautet dementsprechend entweder Explorer <\/b>oder Inspector<\/b>.<\/li>\n<\/ul>\n
Die folgenden Anweisungen geben jeweils den Titel des ermittelten Explorer<\/b>– beziehungsweise Inspector<\/b>-Elements aus:<\/p>\n
Application.ActiveExplorer.Caption\r\n Application.ActiveInspector.Caption\r\n Application.ActiveWindow.Caption<\/pre>\n
Wir können auch alle Explorer<\/b>– oder alle Inspector<\/b>-Elemente durchlaufen. Hier zunächst die Ausgabe der Titel aller aktuell geöffneten Explorer<\/b>-Elemente:<\/p>\n
Private Sub <\/span>AlleExplorer()\r\n Dim <\/span>objExplorer As <\/span>Explorer\r\n For Each objExplorer In Application.Explorers\r\n Debug.Print<\/span> objExplorer.Caption\r\n Next<\/span> objExplorer\r\nEnd Sub<\/span><\/pre>\nDas gelingt auch für alle geöffneten Inspector<\/b>-Elemente:<\/p>\n
Private Sub <\/span>AlleInspectors()\r\n Dim <\/span>objInspector As <\/span>Inspector\r\n For Each objInspector In Application.Inspectors\r\n Debug.Print<\/span> objInspector.Caption\r\n Next<\/span> objInspector\r\nEnd Sub<\/span><\/pre>\nEreignis beim Öffnen eines neuen Explorers<\/h2>\n
Mit dem Implementieren von Ereignissen können wir gleich beim Öffnen eines neuen Explorers beginnen. Wenn der Benutzer beispielsweise neben dem ersten Explorer<\/b>-Fenster ein weiteres öffnet, weil er eines mit E-Mails und eines mit Terminen nebeneinander anzeigen möchte, fangen wir das wie folgt ab. Dazu deklarieren wir im allgemeinen Teil der Klasse ThisOutlookSession <\/b>die folgende Variable:<\/p>\n
Dim <\/span>WithEvents objExplorers As <\/span>Explorers<\/pre>\nDiese Variable müssen wir füllen, am einfachsten in der beim Start von Outlook automatisch ausgeführten Ereignisprozedur Application_Startup<\/b>:<\/p>\n
Private Sub <\/span>Application_Startup()\r\n Set<\/span> objExplorers = Application.Explorers\r\nEnd Sub<\/span><\/pre>\nUnd für das Ereignis NewExplorer <\/b>der Auflistung objExplorers <\/b>hinterlegen wir dann die folgende Ereignisprozedur:<\/p>\n
Private Sub <\/span>objExplorers_NewExplorer(ByVal Explorer _\r\n As <\/span>Explorer)\r\n MsgBox<\/span> \"Neuer Explorer: \" & Explorer.Caption\r\nEnd Sub<\/span><\/pre>\nExplorer-Fenster referenzieren<\/h2>\n
Auch das Explorer<\/b>-Fenster bietet einige Ereignisse an, die wir implementieren können. Wollen wir diese implementieren, benötigen wir auch für dieses Fenster eine passende Objektvariable, die wir mit dem Schlüsselwort WithEvents <\/b>deklarieren:<\/p>\n
Dim <\/span>WithEvents objExplorer As <\/span>Explorer<\/pre>\nEigentlich können wir bereits das vorherige Beispiel nutzen, um diese Variable zu füllen:<\/p>\n
Private Sub <\/span>objExplorers_NewExplorer(ByVal Explorer _\r\n As <\/span>Explorer)\r\n Set<\/span> objExplorer = Explorer\r\nEnd Sub<\/span><\/pre>\nWenn wir hingegen direkt beim Starten von Outlook das aktuelle Explorer-Fenster mit dieser Variablen referenzieren wollen, gelingt dies wie folgt:<\/p>\n
Private Sub <\/span>Application_Startup()\r\n Set<\/span> objExplorer = Explorer\r\nEnd Sub<\/span><\/pre>\nAuf das Wechseln des Bereichs im Explorer reagieren<\/h2>\n
In Bild 1 sehen wir einen typischen Outlook-Explorer. Anhand dieses Beispiels wollen wir uns einige Ereignisse ansehen, die der Benutzer durch verschiedene Aktionen auslösen kann. Eines vorneweg: Das Betätigen der Elemente im modernisierten Ribbon werden wir in diesem Artikel nicht dokumentieren.<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2022_02\/pic_307_001.png\")
<\/p>\nBild 1: Die Benutzeroberfläche von Outlook mit den typischen Elementen<\/span><\/b><\/p>\n
Ob und wie wir auf das Betätigen der Ribbonbefehle durch den Benutzer reagieren können, zeigen wir in einem eigenen Artikel auf. Hier ermitteln und referenzieren wir zunächst einmal den aktuellen Ordner und reagieren dann darauf, wenn der Benutzer diesen Ordner wechselt. Unter Ordnern verstehen wir die in der Abbildung mit der Zahl 2 <\/b>und 3 <\/b>markierten Elemente.<\/p>\n
Wenn der Benutzer beispielsweise vom Ordner Posteingang <\/b>zu Gesendete Elemente <\/b>wechselt, löst er damit das Ereignis FolderSwitch <\/b>aus. Dieses implementieren wir beispielsweise wie folgt:<\/p>\n
Private Sub <\/span>objExplorer_FolderSwitch()\r\n Debug.Print<\/span> \"Der Ordner wurde gewechselt in: \", _\r\n objExplorer.CurrentFolder\r\nEnd Sub<\/span><\/pre>\nDies gibt nach dem Wechseln zum Ordner Gesendete Elemente <\/b>den Text Gesendete Elemente <\/b>aus. Das gleiche Ereignis wird ausgelöst, wenn wir zu einem der anderen Bereiche wechseln, die in der Abbildung mit der Zahl 1 <\/b>markiert sind.<\/p>\n
Durch das Wechseln beispielsweise vom Bereich E-Mails <\/b>zu Kalender <\/b>zeigt Outlook nämlich automatisch den zuletzt für diesen Bereich markierten Ordner an.<\/p>\n
Ereignisse beim Wechseln der Ansicht<\/h2>\n
Outlook bietet verschiedene Ansichten an, wenn wir im Ribbon zur Registerseite Ansicht <\/b>wechseln und dann auf Ansicht ändern <\/b>klicken. Wir erhalten dann die Auswahl der Ansichten aus Bild 2. Wählen wir hier einen anderen als den aktuellen Eintrag aus, lösen wir damit zwei Ereignisse aus: BeforeViewSwitch <\/b>und ViewSwitch<\/b>.<\/p>\n
![\"Ändern](\"..\/fileadmin\/_temp_\/2022_02\/pic_307_002.png\")
<\/p>\nBild 2: Ändern der Ansicht für die Elemente eines Ordners<\/span><\/b><\/p>\n
Die Prozedur für das Ereignis BeforeViewSwitch <\/b>liefert zwei Parameter – die Bezeichnung der gewählten neuen Ansicht mit NewView <\/b>und den Rückgabeparameter Cancel<\/b>. In dieser Prozedur können wir prüfen, ob die Bedingungen für den Wechsel der Ansicht erfüllt sind und falls nicht, können wir den Wechsel durch Einstellen von Cancel <\/b>auf den Wert True <\/b>stoppen.<\/p>\n
Im folgenden Beispiel geben wir jedoch nur den Namen der gewählten Ansicht aus:<\/p>\n
Private Sub <\/span>objExplorer_BeforeViewSwitch( _\r\n ByVal NewView As Variant<\/span>, Cancel As Boolean<\/span>)\r\n Debug.Print<\/span> \"Explorer_BeforeViewSwitch\", NewView\r\nEnd Sub<\/span><\/pre>\nDas zweite Ereignis ViewSwitch <\/b>wird nur ausgelöst, wenn der Wechsel der Ansicht tatsächlich erfolgt ist, also wenn der Parameter Cancel <\/b>in der Ereignisprozedur für das Ereignis BeforeViewSwitch <\/b>nicht auf True <\/b>eingestellt wurde. Hier geben wir nochmals die aktuelle Ansicht aus, die wir diesmal nicht per Parameter erhalten, sondern über die Eigenschaft CurrentView <\/b>ermitteln:<\/p>\n
Private Sub <\/span>objExplorer_ViewSwitch()\r\n Debug.Print<\/span> \"Die Ansicht wurde geändert in: \", _\r\n objExplorer.CurrentView\r\nEnd Sub<\/span><\/pre>\nAlle Explorer-Fenster referenzieren<\/h2>\n
Etwas komplizierter wird es, wenn wir Ereignisse für mehr als ein Explorer-Fenster nutzen wollen. In diesem Fall müssen wir für jedes Explorer-Fenster, das geöffnet ist, eine eigene Objektvariable reservieren und diese mit einem Verweis auf das jeweilige Explorer-Fenster versehen. Nun ist die Menge der zu erwartenden Explorer-Fenster in den meisten Fällen überschaubar. Ich selbst hatte genau genommen noch nie den Bedarf, mehr als einen Outlook-Explorer zu öffnen – ich bin einfach zwischen den verschiedenen Ordnern hin- und hergesprungen. Auf die Idee, beispielsweise zwei Explorer-Fenster für E-Mails und Termine nebeneinander zu platzieren, um diese gleichzeitig im Überblick zu haben, bin ich zuvor nie gekommen.<\/p>\n
Allerdings können wir nicht ausschließen, dass es da draußen Benutzer gibt, die diese sicher durchaus praktische Darstellung nutzen und daher kümmern wir uns auch um diesen Fall. Auch wenn die meisten Benutzer vermutlich eine begrenzte Anzahl von Explorern verwenden, was dazu verleiten könnte, einige Variablen wie objExplorer1<\/b>, objExplorer2 <\/b>und so weiter zu verwenden, so müsste man in diesem Fall doch für jedes dieser Objekte einzeln die jeweiligen Ereignisprozeduren anlegen. Und das würde zu viel Arbeit bedeuten, wenn man einmal eine der Prozeduren anpassen wollte – dann müssten diese Änderungen immer gleich mehrfach durchgeführt werden.<\/p>\n
Also wählen wir einen alternativen Ansatz, bei dem wir eine Wrapper-Klasse für die Explorer<\/b>-Elemente anlegen. Diese sieht wie in Listing 1 aus, wobei wir hier nur die vier bisher vorgestellten Ereignisse implementiert haben.<\/p>\n
Dim <\/span>WithEvents m_Explorer As <\/span>Outlook.Explorer\r\nPublic Property Set<\/span> <\/span>Explorer(obj As <\/span>Outlook.Explorer)\r\n Set<\/span> m_Explorer = obj\r\nEnd Property<\/span>\r\nPrivate Sub <\/span>m_Explorer_BeforeFolderSwitch(ByVal NewFolder As Object<\/span>, Cancel As Boolean<\/span>)\r\n Debug.Print<\/span> \"Folder wird zu ''\" & m_Explorer.CurrentFolder & \"'' geändert.\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>m_Explorer_BeforeViewSwitch(ByVal NewView As Variant<\/span>, Cancel As Boolean<\/span>)\r\n Debug.Print<\/span> \"View wird zu ''\" & m_Explorer.CurrentView & \"'' geändert.\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>m_Explorer_FolderSwitch()\r\n Debug.Print<\/span> \"Folder wurde zu ''\" & m_Explorer.CurrentFolder & \"'' geändert.\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>m_Explorer_ViewSwitch()\r\n Debug.Print<\/span> \"View wurde zu ''\" & m_Explorer.CurrentView & \"'' geändert.\"\r\nEnd Sub<\/span><\/pre>\nListing 1: Code der Wrapperklasse clsExplorerWrapper<\/span><\/b><\/p>\n
Schau Dir diese Konstellation genau an, denn sie wird immer und immer wieder auftreten – ob für einzelne Objekte, deren Ereignisse wir implementieren wollen oder für mehrere, die wir wie im vorliegenden Beispiel in einer Collection speichern.<\/p>\n
Wir legen also eine neue Klasse an, die wir in diesem Fall clsExplorerWrapper <\/b>nennen. Dazu betätigen wir als Erstes den Menübefehl Einfügen|Klassenmodul<\/b>. Danach ändern wir den Namen des Klassenmoduls beispielsweise von Klasse1 <\/b>in clsExplorerWrapper<\/b>, indem wir dieses im Projekt<\/b>-Explorer markieren und dann die Eigenschaft (Name) <\/b>im Eigenschaften<\/b>-Bereich einstellen. Übrigens: Im Gegensatz zu den VBA-Projekten beispielsweise von Access-Datenbanken bietet Outlook für neu angelegte Module, deren Standardname wie Modul1 <\/b>oder Klasse1 <\/b>nicht durch den Entwickler geändert wurde, beim Speichern nicht die Möglichkeit, den Modulnamen zu ändern.<\/p>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 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 - ActiveInspector<\/b>: Liefert einen Verweis auf das Inspector<\/b>-Element für das oberste Inspector<\/b>-Objekt, also das Element, das zuletzt aktiviert wurde. Es kann auch sein, dass gar kein Inspector<\/b>-Fenster geöffnet ist, dann liefert ActiveInspector <\/b>den Wert Nothing<\/b>.<\/li>\n
- Inspector<\/b>: Ein Inspector<\/b>-Fenster ist eines der Fenster, mit dem Sie per Doppelklick auf eines der Elemente in den Ordnern eines Explorer<\/b>-Fensters die Details des jeweiligen Elements anzeigen – beispielsweise für E-Mails, Termine, Kontakte et cetera.<\/li>\n<\/ul>\n