<\/p>\n
Im Beitrag „Outlook-Folder in Access anzeigen“ haben wir gezeigt, wie Sie das Outlook View Control in ein Formular integrieren, um damit die Ordner von Outlook anzuzeigen. Im vorliegenden Beitrag bauen wir auf den dort vorgestellten Techniken auf und gehen genauer auf den Umgang mit dem E-Mail-Ordnern ein. Dabei wollen wir Details wie den Betreff, den Inhalt oder den Empfänger oder Absender der aktuell markierten E-Mail in entsprechenden Steuerelementen anzeigen. Außerdem wollen wir die Anzeige der Outlook-Ordner in ein TreeView-Steuerelement verlagern.<\/b><\/p>\n
Das Outlook View Control <\/b>ist eine tolle Erweiterung, wenn Sie beispielsweise die Outlook-Ordner zur Anzeige von E-Mails wie Posteingang<\/b>, Postausgang<\/b>, Gesendete <\/b>Elemente oder auch benutzerdefinierte Ordner in einer Access-Anwendung anzeigen wollen.<\/p>\n
Das Outlook View Control <\/b>können Sie jedoch nicht einfach zu einem Access-Formular hinzufügen, sondern Sie müssen es in ein Frame<\/b>-Steuerelement einbetten. Wie das gelingt, zeigen wir im Beitrag Outlook-Folder in Access anzeigen <\/b>(www.access-im-unternehmen.de\/****<\/b>).<\/p>\n
In diesem Beitrag haben wir gezeigt, wie Sie die Outlook-Ordner in ein Listenfeld einlesen und ihre Inhalte durch Anklicken des jeweiligen Listeneintrags im Outlook View Control <\/b>anzeigen.<\/p>\n
Da die Anzeige in einem Listenfeld wenig professionell aussieht, haben wir in einem weiteren Beitrag namens TreeView für Outlook-Ordner <\/b>ein TreeView<\/b>-Steuerelement zum Formular hinzugefügt, das alle Ordner mit E-Mails anzeigt (www.access-im-unternehmen.de\/****<\/b>). Der Zwischenstand nach diesem Beitrag sieht wie in Bild 1 aus.<\/p>\n
![\"Outlook-Ordner](\"..\/fileadmin\/_temp_\/2021_02\/pic_1295_001.png\")
<\/p>\n
Bild 1: Outlook-Ordner und der Inhalt eines E-Mail-Ordners<\/span><\/b><\/p>\n Damit kommen wir zum Ziel des vorliegenden Beitrags. Hier wollen wir die übrigen Elemente, die für den Umgang mit E-Mails notwendig sind, hinzufügen. Dazu gehören die folgenden:<\/p>\n Das Formluar frmEMailDetails <\/b>enthält das TreeView<\/b>-Steuerelement namens ctlTreeView <\/b>sowie ein Frame<\/b>-Objekt und ein ViewCtl<\/b>-Objekt. Das ViewCtl<\/b>-Objekt ist in das Frame<\/b>-Objekt eingebettet.<\/p>\n Das Frame<\/b>– und das ViewCtl<\/b>-Objekt deklarieren wir im Kopf des Klassenmoduls des Formulars wie folgt:<\/p>\n In der beim Laden des Formulars ausgelösten Prozedur Form_Load <\/b>ini-tialisieren wir das TreeView<\/b>-Steuerelement (siehe Beitrag TreeView für Outlook-Ordner<\/b>) und weisen den beiden Variablen die Elemente zu:<\/p>\n Nun wollen wir dafür sorgen, dass der vom Benutzer im TreeView<\/b>-Steuerelement angeklickte Ordner im Outlook View Control <\/b>angezeigt wird. Dazu legen wir eine Ereignisprozedur an, die beim Anklicken eines der Elemente des TreeView<\/b>-Steuerelements ausgelöst wird:<\/p>\n Das wir das mit dem Parameter Node <\/b>übergebene Node<\/b>-Objekt noch einer Variablen des Typs MSComctlLib.Node <\/b>zuweisen, liegt daran, dass wir so die IntelliSense-Funktion für diese Variable nutzen können. So können wir den in der Key<\/b>-Eigenschaft des Node<\/b>-Elements gespeicherten Outlook-Pfad wie zum Beispiel \\\\Outlook\\Posteingang <\/b>nutzen und diesen der Folder<\/b>-Eigenschaft des Outlook View Control<\/b>-Steuerelements zuweisen.<\/p>\n Nun, da das Outlook View Control <\/b>den Outlook-Ordner anzeigt, den der Benutzer im TreeView<\/b>-Steuerelement ausgewählt hat, wollen wir diesen auch speichern, damit dieser beim nächsten Öffnen auch wieder angezeigt werden kann. Dazu legen wir eine Optionen-Tabelle namens tblOptions <\/b>an. Diese soll lediglich zwei Felder enthalten – ein Primärschlüsselfeld namens OptionID <\/b>und ein Textfeld namens CurrentMailfolder<\/b>. Den Entwurf dieser Tabelle zeigen wir in Bild 2.<\/p>\n Bild 2: Tabelle zum Speichern von Optionen<\/span><\/b><\/p>\n Wann speichern wir den zuletzt gewählten Outlook-Ordner in der Optionen-Tabelle Am sichersten ist es, diesen nach jeder Auswahl erneut zu speichern. Wir können den Speichervorgang also direkt in die oben vorgestellte Ereignisprozedur integrieren, die beim Anklicken eines der Node<\/b>-Elemente im TreeView<\/b>-Steuerelement ausgelöst wird. Diese erweitern wir um den Aufruf einer Prozedur namens SaveCurrentMailfolder<\/b>, der wir den Pfad zum angeklickten Ordner als Parameter übergeben:<\/p>\n Die Prozedur SaveCurrentMailfolder<\/b> finden Sie in Listing 1. Sie nimmt mit dem Parameter strFolder <\/b>den zuletzt aufgerufenen Ordner entgegen. Dann führt sie eine UPDATE<\/b>-Abfrage aus, die das Feld CurrentMailfolder <\/b>der Tabelle tblOptions <\/b>auf den übergebenen Wert einstellt. Es kann sein, dass die Tabelle leer ist, weil Sie diese beispielsweise vor dem Weitergeben an einen Benutzer geleert haben. In diesem Fall liefert die folgende Abfrage der von der UPDATE<\/b>-Abfrage betroffenen Datensätze den Wert 0<\/b>. In dem dann ausgelösten Zweig der If…Then<\/b>-Bedingung legen wir diesen Datensatz dann einfach neu an und weisen dem Feld CurrentMailfolder <\/b>den Wert aus strFolder <\/b>zu.<\/p>\n Listing 1: Prozedur zum Speichern des aktuell gewählten Mail-Ordners<\/span><\/b><\/p>\n Nach dem Speichern des Wertes sieht die Tabelle tblOptions <\/b>beispielsweise wie in Bild 3 aus.<\/p>\n Bild 3: Zuletzt verwendeter Ordner in der Tabelle tblOptions<\/span><\/b><\/p>\n Die so gespeicherte Information wollen wir natürlich beim nächsten Öffnen des Formulars nutzen, indem wir den entsprechenden Eintrag im TreeView<\/b>-Steuerelement selektieren und im Outlook View Control <\/b>den passenden Ordner anzeigen. Dazu legen wir eine neue Prozedur namens SetCurrentMailfolder <\/b>an, den wir in der Prozedur Form_Load <\/b>beim Laden des Formulars aufrufen:<\/p>\n Diese Prozedur liefert Listing 2. Die Prozedur ermittelt zunächst den Wert des Feldes CurrentMailFolder <\/b>aus der Tabelle tblOptions<\/b> und schreibt diesen in die Variable strFolder<\/b>. Wenn noch kein Eintrag in dieser Tabelle vorliegt oder das Feld leer ist, sorgt die Nz<\/b>-Funktion dafür, dass strFolder <\/b>mit einer leeren Zeichenkette gefüllt wird.<\/p>\n Listing 2: Prozedur zum Auswählen des zuletzt betrachteten E-Mail-Ordners<\/span><\/b><\/p>\n Die folgende If…Then<\/b>-Bedingung prüft, ob strFolder <\/b>eine leere Zeichenkette enthält und somit kein zuletzt geöffneter E-Mail-Ordner in der Tabelle tblOptions <\/b>vorliegt. In diesem Fall füllt sie strFolder <\/b>mit dem Ergebnis der Funktion GetDefaultFolder<\/b>. Diese finden Sie in Listing 3.<\/p>\n Listing 3: Funktion zum Ermitteln eines Standardordners<\/span><\/b><\/p>\n GetDefaultFolder <\/b>erwartet eine der Konstanten der Auflistung Outlook.OlDefaultFolders <\/b>als Parameter. Es gibt bereits eine Methode namens GetDefaultFolder<\/b>, die zum Namespace<\/b>-Objekt gehört. Um dieses zu referenzieren, benötigen wir zuvor noch ein Outlook.Application<\/b>-Objekt. Die von uns definierte Funktion GetDefaultFolder <\/b>vereinfacht den Zugriff auf einen der Standardordner von Outlook, indem es das Erstellen einer Instanz von Outlook.Application <\/b>und das Zuweisen des MAPI-Namespace an die Variable objNamespace <\/b>kapselt und das Folder<\/b>-Objekt ermittelt, das dem Parameter intFolder <\/b>entspricht, also beispielsweise olFolderInbox <\/b>für den Posteingang. Die Funktion GetDefaultFolder <\/b>gibt schließlich den Pfad zu dem angegebenen Ordner zurück.<\/p>\n Dadurch, dass wir den Parameter mit dem Typ Outlook.OlDefaultFolders <\/b>deklarieren, können wir beim Aufruf per IntelliSense aus der Liste der verfügbaren Werte auswählen (siehe Bild 4).<\/p>\n Bild 4: Auswahl des gewünschten Standardordners per IntelliSense<\/span><\/b><\/p>\n Diesen nimmt die Prozedur SetCurrentMailFolder <\/b>entgegen und speichert ihn in der Variablen strFolder<\/b>. Damit stellt sie nun zunächst die Folder<\/b>-Eigenschaft des Outlook View Controls <\/b>ein. Danach referenziert sie das TreeView<\/b>-Steuerelement mit der Variablen objTreeView <\/b>und stellt die Eigenschaft SelectedItem <\/b>auf das Node<\/b>-Element ein, dass die Nodes<\/b>-Auflistung für den als Parameter verwenden Wert aus strFolder <\/b>(zum Beispiel \\\\Outlook\\Posteingang<\/b>) liefert.<\/p>\n Schließlich wird der Fokus auf das TreeView<\/b>-Steuerelement verschoben, damit der Benutzer direkt den selektierten Ordner erkennen kann.<\/p>\n Müssen wir die übergeordneten Ordner aufklappen, damit der markierte Eintrag sichtbar wird Es kann ja auch sein, dass der Benutzer einen Ordner auswählt und dann alle Ordner einklappt, sodass der gewählte Ordner nicht mehr im TreeView<\/b>-Steuerelement sichtbar ist. Hier besteht kein Grund zur Sorge: Das TreeView<\/b>-Steuerelement klappt automatisch alle Elemente bis zum aktuell selektierten Element auf.<\/p>\n <\/p>\n Nun wollen wir die Inhalte der aktuell im Outlook View Control <\/b>ausgewählten E-Mail in dafür vorgesehenen Steuerelementen anzeigen. In Outlook sieht der Bereich wie in Bild 5 aus. Die Ansicht im Outlook View Control <\/b>liefert leider nur den oberen Teil mit der Liste der E-Mails, sodass wir den Rest selbst anlegen müssen.<\/p>\n Bild 5: Anzeige einer E-Mail in Outlook<\/span><\/b><\/p>\n Wir wollen uns dabei auf folgende Elemente beschränken:<\/p>\n Um auch nur eine dieser Informationen anzuzeigen, benötigen wir nicht nur die entsprechenden Steuerelemente, sondern wir müssen auch erst einmal an die betreffenden Daten kommen. Sprich: Wir benötigen das MailItem<\/b>-Objekt, das sich hinter dem selektierten Eintrag befindet.<\/p>\n Doch zuerst zu den Steuerelementen. Diese fügen wir wie in Bild 6 hinzu. Die Textfelder heißen von oben nach unten txtSubject<\/b>, txtFrom<\/b>, txtTo <\/b>und txtBody<\/b>. Rechts befindet sich txtReceived<\/b>. Die drei Schaltflächen heißen cmdReply<\/b>, cmdReplyAll <\/b>und cmdForward<\/b>.<\/p>\n Bild 6: Hinzufügen von Steuerelementen zum Anzeigen einer E-Mail<\/span><\/b><\/p>\n Anschließend kümmern wir uns um eine Prozedur, die beim Auswählen eines der Einträge des Outlook View Control<\/b>-Steuerelements ausgelöst wird. Diese fügen wir hinzu, indem wir im Codefenster des Klassenmoduls des Formulars im linken Kombinationsfelder den Eintrag objView <\/b>auswählen und im rechten den Eintrag SelectionChange<\/b>. Diese füllen wir lediglich mit einem einzigen Befehl, der eine weitere Prozedur namens ShowMail <\/b>aufruft.<\/p>\n Die Prozedur ShowMail<\/b> finden Sie in Listing 4. Sie ermittelt mit der Funktion GetFirstSelectedMailItem <\/b>die aktuell selektierte E-Mail. Ist objMailItem <\/b>danach nicht leer, wurde also ein MailItem<\/b>-Element markiert, stellt die Prozedur die Textfelder des Formulars auf die Eigenschaften des MailItem<\/b>-Elements ein. Dabei füllt sie txtFrom <\/b>mit dem Namen des Absenders gefolgt von der E-Mail-Adresse in Klammern. Die übrigen Textfelder werden mit den Werten der Eigenschaften To<\/b>, Body<\/b>, Subject <\/b>und ReceivedTime <\/b>bestückt. Außerdem aktiviert die Prozedur die drei Schaltflächen. Hat objMailItem <\/b>hingegen den Wert Nothing<\/b>, leert die Prozedur im Else<\/b>-Zweig der Bedingung die Textfelder und deaktiviert die drei Schaltflächen.<\/p>\n Listing 4: Prozedur zum Anzeigen der Daten einer E-Mail<\/span><\/b><\/p>\n Die von ShowMail <\/b>aufgerufene Funktion GetFirstSelectedMailItem <\/b>deklariert Variablen zum Referenzieren des Selection<\/b>-Objekts sowie eines MailItem<\/b>-Objekts von Outlook (siehe Listing 5). Die Variable objSelection <\/b>füllt sie mit der aktuellen Auswahl im Outlook View Control<\/b>. Dann prüft sie in einer If…Then<\/b>-Bedingung, ob die Auswahl überhaupt mindestens ein Element enthält. Falls ja, untersucht sie in einer Select Case<\/b>-Bedingung den Typ des ersten Elements der aktuellen Auswahl, das sie mit objSelection.Item(1) <\/b>referenziert. Die TypeName<\/b>-Funktion liefert den Namen des Typs des Elements. Dieses sollte in der Regel MailItem <\/b>heißen. In diesem Fall referenziert die Prozedur das Element mit der Variablen objMailItem<\/b>. Anschließend stellt die Funktion den Rückgabewert GetFirstSelectedMailItem <\/b>auf den Inhalt von objMailItem <\/b>ein.<\/p>\n Listing 5: Funktion zum Ermitteln der aktuell markierten E-Mail<\/span><\/b><\/p>\n Das Formular sieht nach der Auswahl wie in Bild 7 aus. Hier ist je nach den Anforderungen des Benutzers noch Finetuning möglich. Zum Beispiel wird hier nicht geprüft, ob die Mail im Text- oder HTML-Format kommt und auch in der E-Mail enthaltene Anlagen werden noch nicht angezeigt. Schließlich haben wir unter Access nur die Möglichkeit, eines der Steuerelemente oben und unten gleichzeitig zu verankern, sodass sich seine Größe beim Ändern der Größe des Formulars anpasst. Wir können also in der aktuellen Konstellation nur entweder das Outlook View Control <\/b>oder das Textfeld txtBody <\/b>vergrößerbar gestalten.<\/p>\n Bild 7: Anzeige von Ordnern, Ordnerinhalt und Mailinhalt<\/span><\/b><\/p>\n Die Schaltflächen haben wir mit passenden Icons versehen. Außerdem haben wir die Eigenschaft Hintergrundart <\/b>auf den Wert Transparent <\/b>eingestellt. Nachfolgend erläutern wir die Ereignisprozeduren dieser Schaltflächen.<\/p>\n Die Schaltfläche cmdReply <\/b>soll die gleiche Funktion erfüllen wie die entsprechende Schaltfläche in Outlook. Dort wird eine neue E-Mail erstellt, die automatisch mit einigen Voreinstellungen versehen wird – der Sender der ursprünglichen E-Mail wird als Empfänger eingestellt, der Inhalt wird als Zitat eingefügt et cetera. Das können wir mit wenigen Zeilen Code abbilden. Dazu verwenden wir zwei MailItem<\/b>-Variablen namens objMailItem <\/b>und objMailItemReply<\/b>.<\/p>\n Die Variable objMailItem <\/b>füllen wir mit einem Verweis auf die aktuell im Outlook View Control <\/b>markierte E-Mail, deren Eigenschaften in den Steuerelementen im unteren Bereich des Formulars angezeigt werden. Dazu verwenden wir die bereits weiter oben verwendete Funktion GetFirstSelectedMailItem<\/b>. Liefert diese ein MailItem<\/b>-Objekt zurück, sind zwei Schritte nötig:<\/p>\n Bild 8: Anzeige einer Antwort-E-Mail<\/span><\/b><\/p>\n<\/ul>\n Die Prozedur sieht wie folgt aus:<\/p>\n Die Prozedur zum Versenden einer Antwort an alle Beteiligten, also auch an die per Cc: <\/b>angegebenen Empfänger, wird durch die Schaltfläche cmdReplyAll <\/b>ausgelöst und sieht wie folgt aus. Diese Prozedur unterscheidet sich lediglich durch den Aufruf der Methode ReplyAll <\/b>statt Reply <\/b>von der zuvor beschriebenen Prozedur – und durch die Benennung der Variablen für das neue MailItem<\/b>-Objekt:<\/p>\n\n
Gewählten Ordner im Outlook View Control anzeigen<\/h2>\n
Private <\/span>objFrame As <\/span>Frame\r\nPrivate <\/span>WithEvents objView As <\/span>ViewCtl<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n InitializeTreeView\r\n Set<\/span> objFrame = Me!ctlFrame.Object\r\n Set<\/span> objView = objFrame.Controls(0)\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>ctlTreeView_NodeClick(ByVal Node As Object<\/span>)\r\n Dim <\/span>objNode As <\/span>MSComctlLib.Node\r\n Set<\/span> objNode = Node\r\n objView.Folder = objNode.Key\r\nEnd Sub<\/span><\/pre>\nZuletzt gewählten Ordner speichern und beim Öffnen wiederherstellen<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2021_02\/pic_1295_002.png\")
<\/p>\nPrivate Sub <\/span>ctlTreeView_NodeClick(ByVal Node As Object<\/span>)\r\n ...\r\n SaveCurrentMailFolder objNode.Key\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>SaveCurrentMailfolder(strFolder As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"UPDATE tblOptions SET CurrentMailfolder = ''\" & strFolder & \"''\", dbFailOnError\r\n If <\/span>db.RecordsAffected = 0 Then<\/span>\r\n db.Execute \"INSERT INTO tblOptions(CurrentMailfolder) VALUES(''\" & strFolder & \"'')\", dbFailOnError\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Zuletzt](\"..\/fileadmin\/_temp_\/2021_02\/pic_1295_003.png\")
<\/p>\nZuletzt gewählten Ordner beim Öffnen markieren und anzeigen<\/h2>\n
Private Sub <\/span>Form_Load()\r\n ...\r\n SetCurrentMailfolder\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>SetCurrentMailfolder()\r\n Dim <\/span>strFolder As String<\/span>\r\n Dim <\/span>objTreeView As <\/span>MSComctlLib.TreeView\r\n strFolder = Nz(DLookup(\"CurrentMailfolder\", \"tblOptions\"), \"\")\r\n If <\/span>Len<\/span>(strFolder) = 0 Then<\/span>\r\n strFolder = GetDefaultFolder(olFolderInbox)\r\n End If<\/span>\r\n objView.Folder = strFolder\r\n Set<\/span> objTreeView = ctlTreeView.Object\r\n objTreeView.SelectedItem = objTreeView.Nodes(strFolder)\r\n Me!ctlTreeView.SetFocus\r\nEnd Sub<\/span><\/pre>\nPrivate Function <\/span>GetDefaultFolder(intFolder As <\/span>Outlook.OlDefaultFolders) As String<\/span>\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 Set<\/span> objFolder = objNamespace.GetDefaultFolder(intFolder)\r\n GetDefaultFolder = objFolder.FolderPath\r\nEnd Function<\/span><\/pre>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2021_02\/pic_1295_004.png\")
<\/p>\nInhalt der aktuell markierten E-Mail anzeigen<\/h2>\n
![\"Anzeige](\"..\/fileadmin\/_temp_\/2021_02\/pic_1295_005.png\")
<\/p>\n\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2021_02\/pic_1295_006.png\")
<\/p>\nPrivate Sub <\/span>objView_SelectionChange()\r\n ShowMail\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>ShowMail()\r\n Dim <\/span>objMailItem As <\/span>Outlook.MailItem\r\n Set<\/span> objMailItem = GetFirstSelectedMailItem\r\n If <\/span>Not<\/span> objMailItem Is Nothing Then<\/span>\r\n Me!txtFrom = objMailItem.SenderName & \" (\" & objMailItem.SenderEmailAddress & \")\"\r\n Me!txtTo = objMailItem.To\r\n Me!txtBody = objMailItem.Body\r\n Me!txtSubject = objMailItem.Subject\r\n Me!txtReceived = objMailItem.ReceivedTime\r\n Me!cmdForward.Enabled = True<\/span>\r\n Me!cmdReply.Enabled = True<\/span>\r\n Me!cmdReplyAll.Enabled = True<\/span>\r\n Else<\/span>\r\n Me!txtFrom = \"\"\r\n Me!txtTo = \"\"\r\n Me!txtBody = \"\"\r\n Me!txtSubject = \"\"\r\n Me!txtReceived = \"\"\r\n Me!cmdForward.Enabled = False<\/span>\r\n Me!cmdReply.Enabled = False<\/span>\r\n Me!cmdReplyAll.Enabled = False<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Function <\/span>GetFirstSelectedMailItem() As <\/span>MailItem\r\n Dim <\/span>objSelection As <\/span>Outlook.Selection\r\n Dim <\/span>objMailItem As <\/span>Outlook.MailItem\r\n Set<\/span> objSelection = objView.Selection\r\n If <\/span>Not<\/span> objSelection.Count = 0 Then<\/span>\r\n Select Case TypeName(objSelection.Item(1))\r\n Case <\/span>\"MailItem\"\r\n Set<\/span> objMailItem = objSelection.Item(1)\r\n End Select<\/span>\r\n Set<\/span> GetFirstSelectedMailItem = objMailItem\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2021_02\/pic_1295_007.png\")
<\/p>\nFunktionen der Schaltflächen zum Antworten und Weiterleiten<\/h2>\n
Dem Sender der E-Mail antworten<\/h2>\n
\n
![\"Anzeige](\"..\/fileadmin\/_temp_\/2021_02\/pic_1295_008.png\")
<\/p>\nPrivate Sub <\/span>cmdReply_Click()\r\n Dim <\/span>objMailItem As <\/span>Outlook.MailItem\r\n Dim <\/span>objMailItemReply As <\/span>Outlook.MailItem\r\n Set<\/span> objMailItem = GetFirstSelectedMailItem\r\n If <\/span>Not<\/span> objMailItem Is Nothing Then<\/span>\r\n Set<\/span> objMailItemReply = objMailItem.Reply\r\n objMailItemReply.Display\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nAllen Beteiligten einer E-Mail antworten<\/h2>\n
Private Sub <\/span>cmdReplyAll_Click()\r\n