<\/p>\n
![\"Als](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_001.png\")
<\/p>\n
Bild 1: Als ActiveX-Steuerelemente einfügbare Outlook-Elemente <\/span><\/b><\/p>\n Es gibt sehr viele Möglichkeiten für Interaktion zwischen Outlook und Access. Sie können Termine, E-Mails, Kontakte oder Aufgaben zwischen den beiden Anwendungen abfragen, synchronisieren, erstellen oder bearbeiten. Sehr stiefmütterlich wurde bisher allerdings das Thema der Anzeige von Outlook-Elementen in Access behandelt. Zum Glück brachte mich neulich ein Leser auf die Idee, das Thema noch einmal aufzugreifen – und lieferte mir auf mein Zögern hin direkt noch ein Beispiel, wie die Integration funktioniert. Wir haben uns dies einmal genau angesehen. Das Ergebnis und die resultierenden Möglichkeiten finden Sie im vorliegenden Beitrag.<\/b><\/p>\n Bereits vor einigen Jahren habe ich aus Neugier einmal versucht, eines der interessant aussehenden Elemente des Dialogs zum Einfügen von ActiveX-Steuerelementen in Formulare zu nutzen (siehe Bild 1).<\/p>\n Bild 1: Als ActiveX-Steuerelemente einfügbare Outlook-Elemente <\/span><\/b><\/p>\n Allerdings bin ich damals nicht besonders weit gekommen – vermutlich war die Dokumentation dieser Elemente damals noch lückenhafter als heute.<\/p>\n Dank unseres Lesers Oliver Specht habe ich das Thema allerdings nochmal angesehen und dank seiner Vorarbeit lief es nun direkt wesentlich besser.<\/p>\n Die erste Idee war, den Outlook-Explorer mit den E-Mails einmal in einem Access-Formular anzuzeigen.<\/p>\n Dazu gehen Sie wie folgt vor:<\/p>\n Danach sieht das Formular wie in Bild 2 aus.<\/p>\n Bild 2: Das Microsoft Outlook View Control in einem Access-Formular<\/span><\/b><\/p>\n Wenn wir nun in die Formularansicht wechseln, erhalten wir die Meldung In diesem Steuerelement befindet sich kein Objekt<\/b>.<\/p>\n Die gleiche Meldung erscheint auch nochmal beim Wechsel zurück zur Entwurfsansicht, danach aber nicht mehr.<\/p>\n Wenn wir das Steuerelement nochmal löschen und erneut einfügen, können Sie einen Test machen: Klicken Sie, bevor Sie in die Formularansicht wechseln, einmal in der Entwurfsansicht doppelt auf das hinzugefügte Steuerelement.<\/p>\n Dieses zeigt dann wie in Bild 3 die Liste der E-Mails an – und zwar die aktuellen, in Outlook angezeigten Einträge. Nach einem Wechsel in die Formularansicht erhalten wir allerdings das gleiche Ergebnis wie zuvor.<\/p>\n Bild 3: Anzeige von Outlook-Daten im Entwurf<\/span><\/b><\/p>\n Die Lösung ist das Einbetten des Outlook View Control<\/b>-Steuerelements in ein weiteres Steuerelement, nämlich das Frame<\/b>-Steuerelement der Forms<\/b>-Bibliothek.<\/p>\n Der Vorgang ist nicht besonders intuitiv, daher hier die ausführliche Beschreibung:<\/p>\n Bild 4: Hinzufügen eines Frames<\/span><\/b><\/p>\n Bild 5: Freischalten weiterer Steuerelemente<\/span><\/b><\/p>\n Bild 6: Auswahl des Outlook View Control-Steuerelements<\/span><\/b><\/p>\n Bild 7: Hinzufügen des ViewCtl-Steuerelements per Drag and Drop<\/span><\/b><\/p>\n Wechseln Sie nun in die Formularansicht, haben wir das erste Zwischenziel erreicht: Das Formular zeigt die Liste der E-Mails an (siehe Bild 8). Sie können die angezeigten Elemente genau wie in Outlook nutzen, also die Spalten anpassen, E-Mails löschen oder diese per Doppelklick öffnen. Nach dem Öffnen einer E-Mail wird diese in dem von Outlook bekannten Fenster angezeigt.<\/p>\n Bild 8: Anzeige der E-Mails im Formular<\/span><\/b><\/p>\n Nun wollen wir herausfinden, wie wir per VBA auf das Microsoft Outlook View Control <\/b>zugreifen können. Nun befindet sich das Steuerelement in einem weiteren Steuerelement des Typs Frame<\/b>. Wir stellen einmal nach, wie wir herausfinden, wie das Steuerelement zu referenzieren ist.<\/p>\n Als Erstes wollen wir das Frame<\/b>-Steuerelement per VBA-Variable referenzieren. Dazu müssen wir herausfinden, welchen Typ das Frame<\/b>-Steuerelement hat.<\/p>\n Dazu öffnen wir das Formular, das aktuell nur das Frame<\/b>-Steuerelement mit dem View-Steuerelement enthält, in der Formularansicht. Im Direktbereich können wir nun mithilfe der TypeName<\/b>-Funktion den Typ des Frame<\/b>-Steuerelements herausfinden. Dazu setzen Sie dort den folgenden Befehl ab:<\/p>\n Wir referenzieren mit Screen.ActiveForm <\/b>zunächst das aktuelle Formulare. Dieses könnten wir auch mit Forms! Da das Formular nur ein Steuerelement enthält, können wir dieses mit Controls(0) <\/b>ansprechen. Das Ergebnis lautet CustomControl<\/b>. Das ist nicht das gewünschte Ergebnis.<\/p>\n Der Grund ist: ActiveX-Steuerelemente spricht man immer noch zusätzlich über die Object<\/b>-Eigenschaft an.<\/p>\n Das ergibt dann:<\/p>\n Damit ist bestätigt, dass wir eine Objektvariable für das Frame<\/b>-Objekt beispielsweise in der Prozedur, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst wird, mit dem Datentyp Frame <\/b>deklarieren können:<\/p>\n Warum wollen wir dieses Steuerelement überhaupt per Objektvariable referenzieren Weil wir so über IntelliSense auf seine Eigenschaften zugreifen können!<\/p>\n In einer weiteren Anweisung der obigen Prozedur können wir nun den Typ des einzigen Elements der Controls<\/b>-Auflistung des Frame<\/b>-Steuerelements ermitteln:<\/p>\n Dies liefert das Ergebnis IViewCtl<\/b>, was eine Schnittstelle beschreibt. Wir verwenden allerdings ViewCtl <\/b>und weisen das Steuerelement wie folgt zu:<\/p>\n Damit können wir dann per IntelliSense die Eigenschaften und Methoden dieses Steuerelements ansteuern (siehe Bild 9).<\/p>\n Bild 9: Zugriff per IntelliSense auf die Eigenschaften und Methoden des View-Steuerelements<\/span><\/b><\/p>\n Damit können wir uns nun die Eigenschaften und Methoden ansehen und unter anderem die Ansicht des Steuerelements damit steuern. Einige davon können wir uns aber auch bereits über die Benutzeroberfläche ansehen. Das wollen wir hier noch vorziehen. Dazu zeigen Sie das Formular in der Entwurfsansicht an.<\/p>\n Klicken Sie doppelt auf das Frame<\/b>-Steuerelement, sodass das View<\/b>-Steuerelement erscheint. Wählen Sie dann aus dem Kontextmenü des View<\/b>-Steuerelements den Eintrag Eigenschaften <\/b>aus. Dies liefert das Eigenschaften-Fenster aus Bild 10.<\/p>\n Bild 10: Eigenschaften des View-Steuerelements<\/span><\/b><\/p>\n Eine interessante Eigenschaft lautet ViewXML<\/b>. Diese liefert offensichtlich den Aufbau der Ansicht im XML-Format.<\/p>\n Wollen Sie dieses XML-Dokument betrachten, können Sie es einfach durch Hinzufügen des folgenden Befehls zur Prozedur Form_Load <\/b>im Direktbereich des VBA-Editors ausgeben:<\/p>\n In diesem XML-Dokument finden Sie einige Attribute, die das Layout der E-Mail-Liste beschreiben (siehe Listing 1). Am Beispiel der Sortierung können Sie prüfen, dass die XML-Definition jeweils an die aktuellen Einstellungen im View<\/b>-Steuerelement angepasst wird. Wenn Sie beispielsweise eine andere Spalte als Sortierkriterium festlegen, schlägt sich dies direkt im Unterelement orderby <\/b>nieder. Im folgenden Beispiel ist die Sortierreihenfolge auf die Spalte Erhalten <\/b>festgelegt:<\/p>\n Listing 1: XML-Definition der aktuellen Ansicht<\/span><\/b><\/p>\n Ändern wir die Sortierung auf die Spalte Von <\/b>und fragen die XML-Definition erneut ab, erhalten wir für das Element orderby <\/b>den folgenden Code:<\/p>\n In den folgenden Abschnitten werden wir einige Dinge zur Steuerung des View-Steuerelements per VBA über den Direktbereich des VBA-Editors ausprobieren. Da es wenig Spaß macht, immer den kompletten Ausdruck zum Referenzieren dieses Steuerelements im aktuell geöffneten Formular einzugeben, bauen wir uns zu diesem Zweck eine kleine Hilfsfunktion in einem Standardmodul.<\/p>\n <\/p>\n Diese Funktion heißt OutlookView <\/b>und Sie finden diese in Listing 2. Damit können Sie nun einfach mit OutlookView <\/b>auf das Steuerelement und seine Eigenschaften und Methoden zugreifen.<\/p>\n Listing 2: VBA-Prozedur für den Zugriff auf das View-Steuerelement<\/span><\/b><\/p>\n Die XML-Definition liefert eine Menge Informationen, aber wir können dieser nicht entnehmen, welcher Ordner-Inhalt gerade angezeigt wird. Dies lässt sich allerdings mit der Folder<\/b>-Eigenschaft realisieren.<\/p>\n Diese liefert, wenn Sie den aktuellen Wert ausgeben, für die aktuelle Ansicht allerdings keinen Wert – wie wir mit unserer Funktion OutlookView <\/b>im Direktbereich des VBA-Editors belegen können:<\/p>\n Eine zweite wichtige Eigenschaft lautet View<\/b>. Diese liefert direkt nach dem Anzeigen bereits einen Wert:<\/p>\n Interessanterweise erscheinen die Werte offensichtlich in der jeweiligen Landessprache. Woher aber bekommen wir die möglichen Werte für diese Eigenschaften Der Objektkatalog liefert jedenfalls kein Element mit dem Text Vorschau<\/b>. Und welche Werte können wir für die Eigenschaft Folder <\/b>verwenden<\/p>\n Die Folder<\/b>-Werte entsprechen schlicht den Ordnerbezeichnungen aus Outlook. Um alle möglichen Einträge zu sehen, brauchen Sie nur die Ansicht des Ordnerbereichs von Outlook auf Ordner <\/b>umzustellen.<\/p>\n Das erledigen Sie mit einem Klick auf die Schaltfläche mit den drei Punkten unten im Ordnerbereich und anschließende Auswahl des Eintrags Ordner<\/b> (siehe Bild 11).<\/p>\n Bild 11: Ordner in Outlook<\/span><\/b><\/p>\n Danach brauchen Sie die Eigenschaft Folder <\/b>nur noch auf den Namen des Ordners einzustellen, also beispielsweise wie folgt:<\/p>\n Wenn Sie dem Posteingang noch weitere Ordner hinzugefügt haben und ihren Inhalt anzeigen wollen, geben Sie die Namen der Ordner von oben nach unten an – getrennt durch das Backslash-Zeichen (\\<\/b>):<\/p>\n Wenn ein Ordner nicht vorhanden ist, quittiert Access das durch eine entsprechende Fehlermeldung.<\/p>\n Wir wollen die Ordner des aktuellen Outlook-Namespace in einem Listenfeld anzeigen, damit der Benutzer diese auswählen und somit die Anzeige des jeweiligen Ordnerinhalts im View<\/b>-Steuerelement steuern kann. Im ersten Schritt nehmen wir dabei die beiden Variablen objFrame <\/b>und objView <\/b>aus der Prozedur Form_Load <\/b>heraus und deklarieren diese im Kopf des Klassenmoduls des Formulars:<\/p>\n Die Prozedur Form_Load <\/b>sieht danach wie folgt aus:<\/p>\n Nun fügen wir eine Schaltfläche namens cmdOrdnerAnzeigen <\/b>hinzu, welche das Listenfeld mit den Ordnern aus Outlook füllen soll. Außerdem legen wir das Listenfeld namens lstOrdner <\/b>an. Da wir dieses mit der AddItem<\/b>-Methode füllen wollen, stellen wir seine Eigenschaft Herkunftsart <\/b>über das Eigenschaften-Fenster auf den Wert Wertliste <\/b>ein (siehe Bild 12). Die Schaltfläche cmdOrdnerAnzeigen <\/b>soll die folgende Prozedur auslösen:<\/p>\n Bild 12: Listenfeld für die Anzeige und Auswahl des im View-Steuerelement anzuzeigenden Ordners<\/span><\/b><\/p>\n Die Prozedur referenziert das Application<\/b>-Objekt von Outlook und den davon bereitgestellten MAPI-Namespace. Dieser wiederum stellt eine Auflistung namens Folders <\/b>bereit, mit der wir alle Folder<\/b>-Objekte von Outlook durchlaufen können. Bevor wir dies tun, leeren wir das Listenfeld noch durch Einstellen der Eigenschaft RowSource auf eine leere Zeichenkette. Auf diese Weise werden die vorhandenen Inhalte gelöscht, wenn das Listenfeld erneut gefüllt werden soll. Danach durchlaufen wir die Folder<\/b>-Elemente in einer For Each<\/b>-Schleife und verwenden dabei die Variable objFolder<\/b>, um den jeweiligen Ordner zu referenzieren. Innerhalb der Schleife rufen wir die rekursive definierte Prozedur OrdnerAnzeigen_Rek <\/b>auf, der wir den aktuellen Ordner aus objFolder <\/b>übergeben sowie den Wert Null<\/b>.<\/p>\n Die aufgerufene Prozedur OrdnerAnzeigen_Rek <\/b>erwartet einen Ordner, dessen Unterordner zur Liste hinzugefügt werden sollen, als ersten Parameter. Der zweite Parameter mit dem Datentyp Variant <\/b>ist der Name des übergeordneten Ordners. Beim Aufruf durch die Prozedur cmdOrdnerAnzeigen_Click <\/b>übergeben wir für den zweiten Parameter den Wert Null<\/b>, obwohl das obersten Element standardmäßig Outlook <\/b>heißt.<\/p>\n Warum das Weil dieses übergeordnete Element kein Ordner ist, der angezeigt werden könnte und weil Outlook auch nicht als oberstes Element der Hierarchie wie etwa bei Outlook\\Posteingang\\Bestellungen <\/b>angegeben werden darf. Die Folder<\/b>-Eigenschaft verarbeitet nur Einträge, die mit einem Element der zweiten Ebene beginnen, also beispielsweise Posteingang\\Bestellungen<\/b>. Die Prozedur OrdnerAnzeigen_Rek <\/b>sieht wie folgt aus:<\/p>\n Sie durchläuft diesmal alle Unterordner des mit dem Parameter objParentFolder <\/b>übergebenen in einer For Each<\/b>-Schleife und referenziert das jeweilige Folder<\/b>-Objekt mit der Variablen objFolder<\/b>.<\/p>\n Dabei ruft sie die AddItem<\/b>-Methode des Listenfeld-Steuerelements auf und übergibt einen Ausdruck, der sich aus dem Namen des mit dem Parameter varFolder <\/b>und dem Namen des aktuellen Ordners aus objFolder <\/b>zusammensetzt – getrennt durch das Backslash-Zeichen (\\<\/b>).<\/p>\n Der Grund, warum wir den Parameter varFolder <\/b>als Variant deklarieren, liegt darin, dass wir so den Wert Null <\/b>übergeben können – wie beim Aufruf von cmdOrdnerAnzeigen <\/b>aus geschehen. Als Parameter der AddItem<\/b>-Methode des Listenfeldes verwenden wir den Ausdruck varFolder + „\\“ & objFolder.Name<\/b>.<\/p>\n Das sorgt dafür, dass das Backslash-Zeichen nur hinzugefügt, wenn varFolder <\/b>nicht den Wert Null <\/b>enthält. Hat varFolder <\/b>den Wert Null<\/b>, sorgt der Plus-Operator (+<\/b>) dafür, dass auch das mit dem Wert Null <\/b>verknüpfte Element zu Null <\/b>wird – also das Backslash-Zeichen. Dadurch verhindern wir, dass ein Eintrag mit einem führenden Backslash-Zeichen hinzugefügt wird. Nach dem Anklicken dieser Schaltfläche sieht das Formular etwa wie in Bild 13 aus.<\/p>\n Bild 13: Auswahl eines Ordners per Listenfeld<\/span><\/b><\/p>\n Wollen Sie nun noch einen der im Listenfeld angezeigten Ordner auswählen und diesen im View<\/b>-Steuerelement anzeigen, hinterlegen Sie die folgende Prozedur für das Ereignis Beim Doppelklicken <\/b>des Listenfeld-Steuerelements:<\/p>\n Die Anzeige der Elemente im View<\/b>-Steuerelement von Outlook ist nicht auf die Listenform wie bisher beim E-Mail-Ordner gesehen beschränkt. Sie können auch beispielsweise den Kalender von Outlook anzeigen – dazu klicken Sie in der Beispieldatenbank doppelt auf den Eintrag Kalender<\/b>. Das View<\/b>-Steuerelement zeigt daraufhin den Kalender an (siehe Bild 14). Mit einem Klick der rechten Maustaste auf einen der Tage des Kalenders öffnen Sie das Kontextmenü, mit dessen Befehlen Sie beispielsweise neue Termine oder Terminserien anlegen können.<\/p>\n Bild 14: Anzeige des Kalenders nach der Auswahl des entsprechenden Eintrags im Listenfeld<\/span><\/b><\/p>\n Neben dem anzuzeigenden Ordner gibt es noch unterschiedliche Ansichten. Bisher wurde uns immer eine Standardansicht gezeigt und wir konnten diese nicht ändern. Und während wir die Bezeichnungen der Ordner von Outlook aus Outlook auslesen konnten, finden wir zunächst keine offensichtliche Möglichkeit, wie die Bezeichnungen für die Eigenschaft View <\/b>lauten könnten.<\/p>\n Einen ersten Hinweis erhalten wir, indem wir einfach einmal den Wert dieser Eigenschaft im Direktbereich des VBA-Editors ausgeben und dabei unsere Funktion OutlookView <\/b>für den einfachen Zugriff auf das Steuerelement nutzen:<\/p>\n Die aktuelle Ansicht heißt also Einzeln<\/b>. Ein Blick in die Benutzeroberfläche von Outlook und hier auf die Registerseite Ansicht <\/b>des Ribbons liefert uns unter der Schaltfläche Ansicht ändern <\/b>unter anderem den Eintrag Einzeln <\/b>– sowie zwei weitere Einträge namens Kompakt <\/b>und Vorschau<\/b> (siehe Bild 15).<\/p>\n Bild 15: Einstellen einer Ansicht über die Benutzeroberfläche<\/span><\/b><\/p>\n Probieren wir also, ob eine der anderen beiden Einstellungen, per VBA angewendet, einen Fehler auslöst oder eine andere Ansicht bewirkt. Und in der Tat liefert die folgende Anweisung, abgesetzt über den Direktbereich des VBA-Editors, die Anzeige einer anderen Ansicht:<\/p>\n Können wir also die drei Ansichten einfach in einem Listenfeld anzeigen und zur Auswahl anbieten – und funktionieren diese auch mit den anderen Ordnern Schauen wir uns die Ansichten eines anderen Ordners in Outlook an, landen wir auf dem Boden der Realität.<\/p>\n Der Ordner Aufgaben <\/b>beispielsweise bietet gleich elf verschiedene Ansichten (siehe Bild 16). Und darüber hinaus gibt es für den Benutzer sogar die Möglichkeit, eigene Ansichten zu kreieren und diese zu speichern. Wir müssen also einen Weg finden, die Ansichten per VBA auszulesen.<\/p>\n Bild 16: Jeder Ordner kann eigene Ansichten aufweisen.<\/span><\/b><\/p>\n Auch zum Ermitteln der Ansichten gibt es vermutlich eine Möglichkeit per VBA. Allerdings ist diese nicht so einfach zu nutzen wie die zur Auflistung der Ordner aus dem vorherigen Abschnitt.<\/p>\n Grundsätzlich sollte es so laufen: Sie holen ein Folder<\/b>-Objekt für den aktuell im Outlook View Control <\/b>angezeigten Ordner. Dann können Sie über die Views-Auflistung des Folder<\/b>-Objekts auf die View<\/b>-Objekte zugreifen und ihre Namen beispielsweise in einem weiteren Listenfeld ausgeben.<\/p>\n Der Haken an der Sache ist, dass wir keine Möglichkeit gefunden haben, das im Outlook View Control <\/b>angezeigte Folder<\/b>-Objekt zu referenzieren. Sowohl die Eigenschaft Folder <\/b>als auch ActiveFolder <\/b>sind immer leer, auch wenn wir diese zuvor per VBA gefüllt haben. Also müssen wir die möglichen Ansichten für den aktuellen Ordner auf andere Weise holen.<\/p>\n Dazu erstellen wir parallel ein Folder<\/b>-Objekt, das den aktuell angezeigten Ordner referenziert. Da wir den angezeigten Ordner nicht aus dem Outlook View Control <\/b>auslesen können, müssen wir diesen beim Anzeigen des Formulars zuweisen und dabei gleichzeitig das Folder<\/b>-Objekt mit einem Verweis auf den gleichen Ordner füllen. Das erledigen wir auch jeweils beim Auswählen eines anderen Ordners aus dem Listenfeld lstFolder<\/b>.<\/p>\n Wie das gelingt, zeigen wir zusammen mit der Programmierung einiger weiterer Funktionen in den folgenden Abschnitten.<\/p>\n In einer abschließenden kleinen Lösung wollen wir das Outlook View Control <\/b>sowie zwei Listenfelder zur Anzeige und Auswahl der Ordner und der Ansichten bereistellen. Der Entwurf des Formulars sieht wie in Bild 17 aus. Das erste Listenfeld heißt lstOrdner<\/b>, das zweite lstAnsichten<\/b>. Die beiden Variablen objFrame <\/b>und objView <\/b>halten wir weiterhin modulweit verfügbar. Damit wir auch auf die Ereignisse des Outlook View Control-Elements reagieren können, statten wir die Deklaration der entsprechenden Objektvariablen mit dem Schlüsselwort WithEvents <\/b>aus:<\/p>\n Bild 17: Entwurfsansicht des Formulars mit Ordnern und Ansichten<\/span><\/b><\/p>\n Beim Laden des Formulars führen wir einige Schritte mehr aus als in der vorherigen Version. Die vollständige Prozedur, die durch das Ereignis Beim Laden <\/b>ausgelöst wird, finden Sie in Listing 3.<\/p>\n Listing 3: Prozedur zum Initialisieren des Formulars<\/span><\/b><\/p>\n Die Prozedur referenziert wie zuvor das Frame<\/b>– und das View<\/b>-Element mit den beiden Variablen objFrame <\/b>und objView<\/b>. Dann ruft es die Prozedur OrdnerAnzeigen <\/b>auf. Die davon aufgerufene rekursiv definierte Prozedur OrdnerAnzeigen_Rek <\/b>haben wir gegenüber der vorherigen Version leicht geändert. Das hängt damit zusammen, dass wir im Listenfeld lstOrdner <\/b>nun nicht mehr nur den Ordner in der für die Zuweisung zum Outlook View Control <\/b>nötigen Form speichern wollen, sondern zusätzlich den vollständigen unter Outlook verwenden Pfad benötigen.<\/p>\n Für das Listenfeld stellen wir dazu die Eigenschaft Spaltenanzahl <\/b>auf 2 <\/b>und Spaltenbreiten <\/b>auf 0cm <\/b>ein. Die erste Spalte soll dabei den kompletten Pfad wie \\\\Outlook\\Posteingang\\Bestellungen<\/b> aufnehmen, die zweite, sichtbare Spalte den Wert für das Outlook View Control<\/b>, also beispielsweise Posteingang\\Bestellungen<\/b>. In der Prozedur OrdnerAnzeigen_Rek <\/b>ergänzen wir die Zeile, welche die Einträge zum Listenfeld hinzufügt, vorn um das Element objFolder.FolderPath <\/b>und hängen erst danach durch ein Semikolon getrennt den Pfad für das Outlook View Control <\/b>an:<\/p>\n Damit geht es weiter in der Prozedur Form_Load<\/b>. Diese referenziert dann das Outlook.Application<\/b>-Objekt, den MAPI-Namespace und mit der Variablen objDefaultFolder<\/b> den Standardordner, den sie mit der Methode GetDefaultFolder <\/b>des Namespace<\/b>-Objekts unter Verwendung des Parameters olFolderInbox <\/b>für den Posteingang holt.<\/p>\n Das Listenfeld lstOrdner <\/b>stellt die Prozedur dann auf genau diesen Standard-Ordner für den Posteingang ein, was das Selektieren des entsprechenden Eintrags bewirkt (siehe Bild 18).<\/p>\n Bild 18: Anzeige des Posteingangs <\/span><\/b><\/p>\n Danach ruft sie die Prozedur OrdnerAktualisieren <\/b>auf (siehe Listing 4). Die Prozedur referenziert wiederum die Outlook-Anwendung und das MAPI-Namespace-Objekt. Dann liest diese aus der ersten, nicht sichtbaren Spalte des Listenfeldes den Outlook-Pfad zum selektierten Ordner aus, also beispielsweise \\\\Outlook\\Posteingang<\/b>, und trägt diesen in die Variable strFolder <\/b>ein. Die Hilfsfunktion GetFolder<\/b> ermittelt das Folder<\/b>-Objekt zu diesem Ordner-Pfad. Diese Funktion beschreiben wir im Detail im Beitrag Outlook-Mails per Tastenkombination verschieben <\/b>(www.access-im-unternehmen.de\/1290<\/b>).<\/p>\n<\/p>\nE-Mails im Access-Formular anzeigen<\/h2>\n
\n
![\"Das](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_002.png\")
<\/p>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_003.png\")
<\/p>\nOutlook-View in Frame<\/h2>\n
\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_004.png\")
<\/p>\n![\"Freischalten](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_005.png\")
<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_006.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_007.png\")
<\/p>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_008.png\")
<\/p>\nView-Steuerelement per VBA referenzieren<\/h2>\n
Debug.Print<\/span> TypeName(Screen.ActiveForm.Controls(0))\r\nCustomControl<\/pre>\nDebug.Print<\/span> TypeName(Screen.ActiveForm.Controls(0).Object)\r\nFrame<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Dim <\/span>objFrame As <\/span>Frame\r\n Set<\/span> objFrame = Me!ctlFrame.Object\r\nEnd Sub<\/span><\/pre>\nDebug.Print<\/span> TypeName(objFrame.Controls(0).Object)<\/pre>\nDim <\/span>objFrame As <\/span>Frame\r\nDim <\/span>objView As <\/span>ViewCtl\r\nSet<\/span> objFrame = Me!ctlFrame.Object\r\nSet<\/span> objView = objFrame.Controls(0)<\/pre>\n![\"Zugriff](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_009.png\")
<\/p>\nEigenschaften und Methoden des View-Steuerelements<\/h2>\n
![\"Eigenschaften](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_010.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n ...\r\n Debug.Print<\/span> objView.ViewXML\r\nEnd Sub<\/span><\/pre>\n<xml version=\"1.0\">\r\n<view type=\"table\">\r\n <viewname>Vorschau<\/viewname>\r\n <viewstyle>font-family:Segoe UI;...;table-layout:fixed;width:100%<\/viewstyle>\r\n <viewtime>0<\/viewtime>\r\n <linecolor>8421504<\/linecolor>\r\n <linestyle>3<\/linestyle>\r\n <previewlines>0<\/previewlines>\r\n <previewlineschangenum>2<\/previewlineschangenum>\r\n <autopreview>1<\/autopreview>\r\n <previewunreadonly>1<\/previewunreadonly>\r\n <ensuredcategoriesfield>1<\/ensuredcategoriesfield>\r\n <collapsestate\/>\r\n <rowstyle>background-color:White;color:Black<\/rowstyle>\r\n <headerstyle>background-color:#D3D3D3<\/headerstyle>\r\n <previewstyle\/>\r\n <arrangement>\r\n <autogroup>1<\/autogroup>\r\n <enablexfc>1<\/enablexfc>\r\n <collapseclient>01000000<\/collapseclient>\r\n <collapseconv\/>\r\n <upgradetoconvchangenum>2<\/upgradetoconvchangenum>\r\n <\/arrangement>\r\n ...\r\n <column>\r\n <heading>Von<\/heading>\r\n <prop>urn:schemas:httpmail:fromname<\/prop>\r\n <type>string<\/type>\r\n <width>38<\/width>\r\n <style>text-align:left;padding-left:3px<\/style>\r\n <editable>0<\/editable>\r\n <displayformat>1<\/displayformat>\r\n <\/column>\r\n ...\r\n <orderby>\r\n <order>\r\n <heading>Erhalten<\/heading>\r\n <prop>urn:schemas:httpmail:datereceived<\/prop>\r\n <type>datetime<\/type>\r\n <sort>desc<\/sort>\r\n <\/order>\r\n <\/orderby>\r\n <groupbydefault>2<\/groupbydefault>\r\n <previewpane>\r\n <markasread>0<\/markasread>\r\n <\/previewpane>\r\n<\/view><\/pre>\n
<orderby>\r\n <order>\r\n <heading>Erhalten<\/heading>\r\n <prop>urn:schemas:httpmail:datereceived<\/prop>\r\n <type>datetime<\/type>\r\n <sort>desc<\/sort>\r\n <\/order>\r\n<\/orderby><\/pre>\n
<orderby>\r\n <order>\r\n <heading>Von<\/heading>\r\n <prop>urn:schemas:http mail:fromname<\/prop>\r\n <type>string<\/type>\r\n <sort>asc<\/sort>\r\n <\/order>\r\n<\/orderby><\/pre>\n
Funktion für den Zugriff auf das View-Steuerelement per VBA<\/h2>\n
Public Function <\/span>OutlookView() As <\/span>ViewCtl\r\n Set<\/span> OutlookView = Forms!frmEMails!ctlFrame.Object.Controls(0)\r\nEnd Function<\/span><\/pre>\nVerschiedene Ansichten einstellen mit Folder und View<\/h2>\n
OutlookView.Folder\r\n<leere Zeichenkette><\/pre>\n
OutlookView.View\r\nVorschau<\/pre>\n
Folder-Werte herausfinden<\/h2>\n
![\"Ordner](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_011.png\")
<\/p>\nOutlookView.Folder = \"Kalender\"\r\nOutlookView.Folder = \"Aufgaben\"\r\nOutlookView.Folder = \"Gesendete Elemente\"<\/pre>\n
OutlookView.Folder = \"Posteingang\\Bestellungen\"<\/pre>\n
Ordner zur Auswahl anzeigen<\/h2>\n
Private <\/span>objFrame As <\/span>Frame\r\nPrivate <\/span>objView As <\/span>ViewCtl<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objFrame = Me!ctlFrame.Object\r\n Set<\/span> objView = objFrame.Controls(0)\r\nEnd Sub<\/span><\/pre>\n![\"Listenfeld](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_012.png\")
<\/p>\nPrivate Sub <\/span>cmdOrdnerAnzeigen_Click()\r\n Dim <\/span>objOutlook As <\/span>Outlook.Application\r\n Dim <\/span>objNamespace As <\/span>Outlook.Namespace\r\n Dim <\/span>objFolder As <\/span>Outlook.Folder\r\n Set<\/span> objOutlook = New<\/span> Outlook.Application\r\n Set<\/span> objNamespace = objOutlook.GetNamespace(\"MAPI\")\r\n lstOrdner.RowSource = \"\"\r\n For Each objFolder In objNamespace.Folders\r\n OrdnerAnzeigen_Rek objFolder, Null\r\n Next<\/span> objFolder\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>OrdnerAnzeigen_Rek(objParentFolder As <\/span> Outlook.Folder, varFolder As Variant<\/span>)\r\n Dim <\/span>objFolder As <\/span>Outlook.Folder\r\n For Each objFolder In objParentFolder.Folders\r\n lstOrdner.AddItem varFolder + \"\\\" & objFolder.Name\r\n OrdnerAnzeigen_Rek objFolder, varFolder + \"\\\" & objFolder.Name\r\n Next<\/span> objFolder\r\nEnd Sub<\/span><\/pre>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_013.png\")
<\/p>\nPrivate Sub <\/span>lstOrdner_DblClick(Cancel As Integer<\/span>)\r\n objView.Folder = Me!lstOrdner\r\nEnd Sub<\/span><\/pre>\nKalender und andere Ordner anzeigen<\/h2>\n
![\"Anzeige](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_014.png\")
<\/p>\nEinstellen der Ansicht<\/h2>\n
OutlookView.View\r\nEinzeln<\/pre>\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_015.png\")
<\/p>\nOutlookView.View = \"Kompakt\"<\/pre>\n
![\"Jeder](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_016.png\")
<\/p>\nAnsichten ermitteln<\/h2>\n
Ordner und Ansichten komfortabel anzeigen<\/h2>\n
![\"Entwurfsansicht](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_017.png\")
<\/p>\nPrivate <\/span>objFrame As <\/span>Frame\r\nPrivate <\/span>objView As <\/span>ViewCtl<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Dim <\/span>objOutlook As <\/span>Outlook.Application\r\n Dim <\/span>objNamespace As <\/span>Outlook.Namespace\r\n Dim <\/span>objDefaultFolder As <\/span>Outlook.Folder\r\n Set<\/span> objFrame = Me!ctlFrame.Object\r\n Set<\/span> objView = objFrame.Controls(0)\r\n OrdnerAnzeigen\r\n Set<\/span> objOutlook = New<\/span> Outlook.Application\r\n Set<\/span> objNamespace = objOutlook.GetNamespace(\"MAPI\")\r\n Set<\/span> objDefaultFolder = objNamespace.GetDefaultFolder(olFolderInbox)\r\n Me!lstOrdner = objDefaultFolder.FolderPath\r\n OrdnerAktualisieren\r\n AnsichtenAnzeigen\r\nEnd Sub<\/span><\/pre>\nlstOrdner.AddItem objFolder.FolderPath & \";\" & varFolder + \"\\\" & objFolder.Name<\/pre>\n
![\"Anzeige](\"..\/fileadmin\/_temp_\/2021_02\/pic_1292_018.png\")
<\/p>\nPrivate Sub <\/span>OrdnerAktualisieren()\r\n Dim <\/span>objOutlook