<\/p>\n
Ich weiß nicht, wie es Ihnen geht, aber ich gestehe: Mail, Facebook und Co. sind echte Zeitfresser in meinem Leben. Wenn ich gerade mal nicht vorwärts komme, lese ich abwechselnd E-Mails (manchmal im Minutentakt) oder schaue, was es bei Facebook oder anderen sozialen Netzwerken für Neuigkeiten gibt. Wie viel Zeit könnte man sparen, wenn man diese Ablenkungen nicht direkt vor der Nase hätte – direkt neben den zu bearbeitenden Dokumenten oder Anwendungen! Dieser Beitrag zeigt, wie Sie zumindest den Umgang mit E-Mails etwas achtsamer gestalten oder diesen gleich auf bestimmte Uhrzeiten einschränken können.<\/b><\/p>\n
Outlook ist auf meinem Desktop immer geöffnet. Kein Wunder: Ich rufe E-Mails damit ab, verwalte Kontakte damit und tracke die für meine Projekte aufgebrachte Arbeitszeit. Leider tracke ich damit nicht die Zeit, die für das Lesen von E-Mails oder für das Surfen im Internet draufgeht. Würde ich das mal vor Augen gehalten bekommen, wäre ich vielleicht ein wenig achtsamer bei diesem Thema.<\/p>\n
Letztlich gibt es nur einen ganz kleinen Prozentsatz von E-Mails, die so wichtig sind, dass sie ganz schnell erledigt werden müssen. Und wer wirklich dringend etwas von einem möchte, der wird wahrscheinlich ohnehin zum Hörer greifen.<\/p>\n
Und wenn wir ehrlich sind: Da immer mehr E-Mails, die wirklich nicht wichtig sind, mit der höchsten Priorität versendet werden, ist das rote Aufrufezeichen neben einer E-Mail auch nicht unbedingt Anlass für übertriebene Hektik (man munkelt, einige Benutzer hätten die höchste Priorität als Standard eingestellt und wüssten nicht, wie man diese Einstellung ändert …). Nun gibt es grob drei Typen von E-Mail-Konsumenten:<\/p>\n
Gerade beim Prokrastinierer ist Achtsamkeit ein wichtiges Schlüsselwort: Letztlich weiß er, dass es lediglich Zeit kostet und die Erledigung der eigentlichen Aufgabe hinauszögert, wenn er E-Mails abruft. Dennoch macht er es. Das ist genau wie der Griff zur Zigarette, zur Süßigkeit oder zum Kaffee. Wie aber können wir dem Dauer-Mail-Checker helfen, von seinem Verhalten loszukommen Dazu gibt es zwei Ansätze, die ich in den letzten Tagen testweise einsetze:<\/p>\n
Die erste Variante liefert im Kalender beispielsweise eine Ansicht wie in Bild 1. Jeder grüne Eintrag entspricht einem erfolgreichen Abruf einer E-Mail. <\/p>\n
![\"Jeder](\"..\/fileadmin\/_temp_\/2017_04\/pic_1095_001.png\")
<\/p>\n
Bild 1: Jeder grüne Eintrag entspricht einem erfolgreichen Mail-Abruf.<\/span><\/b><\/p>\n Was soll dies bewirken Es zeigt dem Benutzer, wie oft er an diesem Tag tatsächlich E-Mails abgerufen hat. Diese Tage sind schon recht diszipliziert, teilweise wurde weniger als jede halbe Stunde auf die Taste zum Abrufen geklickt. Das könnte auch anders aussehen …<\/p>\n Spätestens, wenn der Benutzer die übrigen Einträge im Kalender nicht mehr lesen kann, wird er über seinen E-Mail-Konsum nachdenken. Und falls nicht, haben wir ja später noch eine weitere Möglichkeit, die Achtsamkeit zu erhöhen.<\/p>\n Schauen wir uns zunächst die technische Umsetzung dieser Lösung an.<\/p>\n Dazu fügen wir dem Modul ThisOutlookSession <\/b>des VBA-Projekts von Outlook einige Zeilen Code hinzu. Den VBA-Editor von Outlook öffnen Sie übrigens am schnellsten mit der Tastenkombination Alt + F11<\/b>. Dort finden Sie dann auch das genannte Modul, in dem wir zunächst die folgenden drei Variablen deklarieren:<\/p>\n Außerdem benötigen wir noch eine Variable, in der wir das Datum der letzten E-Mail-Abfrage speichern:<\/p>\n Danach legen wir die Ereignisprozedur Application_Startup <\/b>an, was Sie durch die Auswahl des Eintrags Application <\/b>im linken Kombinationsfeld des Codefensters und Auswahl des Eintrags Startup <\/b>im rechten Kombinationsfeld erledigen können. Diese Prozedur füllt lediglich die drei zuvor deklarierten Objektvariablen mit den entsprechenden Objekten (s. Listing 1).<\/p>\n Listing 1: Diese Methode wird beim Start von Outlook ausgeführt.<\/span><\/b><\/p>\n objOutlook <\/b>erhält einen Verweis auf das Application<\/b>-Objekt der aktuellen Outlook-Instanz. objPosteingang <\/b>nimmt einen Verweis auf den Outlook-Ordner Posteingang <\/b>auf, den wir über den MAPI-Namespace und die Methode GetDefaultFolder <\/b>mit dem Wert olFolderInbox <\/b>als Parameter ermitteln. Schließlich erhält die Items<\/b>-Variable objPosteingangItems <\/b>einen Verweis auf die Items<\/b>-Auflistung des in objPosteingang <\/b>gespeicherten Ordners.<\/p>\n Für das Objekt objPosteingangItems <\/b>legen wir eine Ereignisprozedur an, die durch das Ereignis ItemAdd <\/b>ausgelöst wird. Um die leere Ereignisprozedur zu erstellen, wählen wir wieder zwei Einträge in den beiden Kombinationsfeldern des VBA-Editors aus – links den Eintrag objPosteingangItems <\/b>und rechts ItemAdd<\/b>. Diese Ereignisprozedur füllen wir wie in Listing 2.<\/p>\n Listing 2: Dieses Ereignis wird ausgelöst, wenn eine neue E-Mail in der Items-Liste landet.<\/span><\/b><\/p>\n Die Prozedur nimmt mit dem Parameter Item <\/b>das neue Element des Ordners entgegen, in diesem Fall eine E-Mail. Die Prozedur definiert eine Variable namens obj-Calendar<\/b>, welche den Kalender referenzieren soll und eine AppointmentItem<\/b>-Variable für den neu anzulegenden Termin. Außerdem ermitteln wir mit der DateSerial<\/b>-Funktion eine Zeitangabe, welche das aktuelle Datum und die aktuelle Uhrzeit ermittelt. Dabei soll als Anzahl der Sekunden der Wert 0 <\/b>übergeben werden, damit pro Minute nur ein Mail-Abruf aufgezeichnet werden kann. <\/p>\n Nun folgt eine Prüfung, ob der in der modulweit deklarierten Variablen datLastMail <\/b>gespeicherte Wert mit dem Wert aus datLastMailTemp <\/b>übereinstimmt. Ist dies der Fall, dann wurde in dieser Minute bereits einmal eine E-Mail abgerufen – und mehr als einen Eintrag pro Minute wollen wir dem Kalender nicht zumuten.<\/p>\n Anderenfalls wird die Variable objCalendar <\/b>mit dem Kalender-Ordner gefüllt, welchen wir über die Methode GetDefaultFolder <\/b>des MAPI-Ordners mit dem Wert olFolderCalendar <\/b>als Parameter referenzieren. objAppointment <\/b>füllen wir mit der Methode CreateItem<\/b>, der wir den Wert olAppointmentItem <\/b>übergeben. So wird ein AppointmentItem<\/b>-Element erstellt.<\/p>\n Danach stellt die Prozedur einige Werte für das neue AppointmentItem<\/b>-Element ein. Der Betreff (Subject<\/b>) soll den Text Mailabruf <\/b>sowie die aktuelle Uhrzeit im Format hh:nn <\/b>als Inhalt anzeigen. Die Eigenschaft Duration <\/b>legt mit dem Wert 30 <\/b>die Dauer des Elements in Minuten fest. Als Kategorie stellen wir Mail abrufen <\/b>ein. Diese Kategorie müssen Sie noch als Kategorie mit dem Dialog Farbkategorien <\/b>einrichten (s. Bild 2). Außerdem deaktivieren wir mit ReminderSet = False <\/b>die Anzeige von Erinnerungen zu diesem Termin. Schließlich speichert die Save<\/b>-Methode den Termin und sorgt so für dessen Anzeige in Outlook. Damit der Vergleich des Zeitpunkts des aktuellen Mailabrufs mit dem des vorherigen gelingt, müssen wir nun noch den Wert von datLastMailTemp <\/b>in datLastMail <\/b>eintragen.<\/p>\n Bild 2: Einstellen der Farbe für die Kategorie Mail abrufen<\/span><\/b><\/p>\n Wenn Sie nun direkt eine Testmail an sich selbst verschicken, Mails abrufen und sich wundern, warum kein entsprechender Termin im Kalender eingetragen wird – keine Sorge: Es fehlt nur noch ein kleiner Schritt. Sie müssen nämlich dafür sorgen, dass die Ereignisprozedur Application_Startup <\/b>ausgelöst wird. Diese füllt erst die Variablen mit den gewünschten Objekten und sorgt dann dafür, dass die Ereignisprozedur für die Variable objPosteingang-Items <\/b>beim nächsten Eingang einer E-Mail ausgelöst wird. Dies können Sie in diesem Fall manuell erledigen, indem Sie die Einfügemarke innerhalb der Prozedur platzieren und die Taste F5 <\/b>betätigen. Oder Sie starten Outlook einfach neu, um die Prozedur automatisch auszulösen.<\/p>\n Damit kommen wir nun zur zweiten Lösung, die direkt beim Klick auf die Schaltfläche Alle Ordner senden\/empfangen <\/b>ausgelöst wird und eine passende Meldungsbox anzeigen soll. Die schlechte Nachricht ist: Es gibt keine Möglichkeit, den Mausklick auf diese Schaltfläche des Ribbons mithilfe einer VBA-basierten Lösung abzufangen. Stattdessen benötigen wir ein COM-Add-In auf Basis von Visual Studio. Zum Glück gibt es Visual Studio 2015 in der Community-Edition kostenlos für einzelne Entwickler und kleinere Betriebe, sodass keine zusätzlichen Kosten für diese sehr interessante Programmierung einer Erweiterung von Outlook anfallen. Sie müssen sich lediglich Visual Studio 2015 Community herunterladen und dieses installieren. Außerdem benötigen Sie alle aktuellen Erweiterungen, die dann auch die für die Programmierung von COM-Add-Ins für die Office-Anwendungen benötigten Vorlagen mitliefern.<\/p>\n <\/p>\n Nach dem Starten von Visual Studio legen Sie ein neues Projekt des Typs Visual Basic|Office\/SharePoint|VSTO-Add-Ins|Outlook 2013 und 2016 VSTO-Add-In <\/b>an. Legen Sie als Name OutlookAddIn <\/b>fest (s. Bild 3).<\/p>\n Bild 3: Anlegen eines neuen Projekts auf Basis der Outlook-Vorlage <\/span><\/b><\/p>\n Visual Studio zeigt nun ein Modul mit den zwei Ereignismethoden ThisAddIn_Startup() <\/b>und ThisAddIn_Shutdown() <\/b>an. Diese beiden benötigen wir nicht. Wir wollen eine Ribbon-Definition hinzufügen, mit der wir die eigentliche Funktion der Schaltfläche Alle Ordner senden\/empfangen <\/b>unterbinden und eine eigene Funktion ausführen.<\/p>\n Dazu fügen wir dem Projekt zunächst ein Ribbon hinzu. Klicken Sie dazu im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen OutlookAddIn <\/b>und wählen Sie den Eintrag Hinzufügen|Neues Element<\/b>. Es erscheint der Dialog Neues Element hinzufügen<\/b>. Hier wählen Sie den Eintrag Menüband (Visueller Designer) <\/b>aus und geben den Namen Outlook_Ribbon <\/b>ein (s. Bild 4).<\/p>\n Bild 4: Hinzufügen eines Ribbons<\/span><\/b><\/p>\n Es erscheint der Designer für den Ribbon-Entwurf, der jeden Access-Entwickler, der sich bisher mit dem Ribbon herumschlagen durfte, neidisch werden lässt. Unser Ziel ist es nun, wie es auch unter Access möglich ist, ein Command-Element per Ribbon-Definition hinzuzufügen, das die Schaltfläche Alle Ordner senden\/empfangen <\/b>referenziert und für diese Schaltfläche eine neue Funktion hinterlegt. Dummerweise liefert die Toolbox aber überhaupt kein Element namens Command<\/b>.<\/p>\n Können wir also von einem VSTO-Add-In gar keine eingebauten Schaltflächen mit neuen Funktionen versehen Doch, wir sind nur etwas in die falsche Richtung gelaufen. Wir können nämlich durchaus auch mit einer klassischen XML-Definition für das Ribbon arbeiten. Dazu fügen wir einfach ein neues Objekt mit der Bezeichnung Menüband (XML) <\/b>zum Projekt hinzu (wie weiter oben – rechter Mausklick auf das Projekt-Element im Projektmappen-Explorer, dann den Eintrag Hinzufügen|Neues Element… <\/b>auswählen und im nun erscheinenden Dialog Menüband (XML) <\/b>wählen).<\/p>\n Legen Sie den Namen Ribbon_Outlook.vb <\/b>für das neue Element fest.<\/p>\n Dies legt zwei neue Objekte im Projekt an: die Datei Ribbon_Outlook.xml <\/b>mit der Ribbon-Definition und die Datei Ribbon_Outlook.vb <\/b>mit den Funktionen, um das Ribbon zur Laufzeit anzuzeigen. Die Datei Ribbon_Outlook.xml <\/b>ist bereits mit einer einfachen Ribbon-Definition ausgestattet, die ein neues Tab mit einer Gruppe und einer Schaltfläche hinzufügt:<\/p>\n Wenn Sie nun einfach das Add-In mit F5 <\/b>zum Testen starten und sich wundern, dass das Ribbon keine änderung aufweist, sind Sie genauso voreilig wie ich.<\/p>\n Die Ribbon_Outlook.vb<\/b>-Klasse enthält zwar fast alles, was zum Anzeigen des Ribbons benötigt wird, allerdings fehlt noch das Bindeglied.<\/p>\n Dabei handelt es sich um die folgende Methode, die Sie noch zur Klasse ThisAddIn.vb <\/b>hinzufügen müssen (diese Methode ist in den Kommentarzeilen von Ribbon_Outlook.vb <\/b>enthalten):<\/p>\n Direkt danach können Sie noch einen Test ausführen. Auch dies führt nicht zum Erfolg, denn für das Tab ist das eingebaute Element mit der idMso <\/b>namens TabAddIns <\/b>festgelegt.<\/p>\n Das heißt, dass die darunter definierten Elemente unterhalb eines eingebauten Tab-Elements namens TabAddIns <\/b>angelegt werden. Outlook besitzt aber kein solches Tab, also geschieht nichts. Also ändern wir für einen Test die XML-Definition des Tab-Elements in der Datei Ribbon_Outlook.xml <\/b>wie folgt:<\/p>\n Das Ribbon erscheint nun wie in Bild 5. Nun wollen wir allerdings nicht, dass eine zusätzliche Schaltfläche erscheint, sondern wir möchten die Schaltfläche Alle Ordner senden\/empfangen <\/b>mit einer neuen Funktion versehen.<\/p>\n Bild 5: Neues Tab mit Gruppe und Schaltfläche<\/span><\/b><\/p>\n Um die Funktion der eingebauten Schaltfläche zu überschreiben, fügen wir der Ribbon-Definition ein command<\/b>-Element hinzu, für das wir die idMso <\/b>des betroffenen Befehls angeben müssen.<\/p>\n Diese ermitteln wir aus einer Excel-Datei, die Sie unter der Adresse http:\/\/go.microsoft.com\/fwlink\/LinkID=181052<\/b> herunterladen können. Das in diesem Download enthaltene Setup erstellt einen Ordner auf Ihrem System und speichert einige Excel-Dateien mit den Auflistungen der idMsos <\/b>für verschiedene Anwendungen. Gerade für Outlook finden Sie hier eine ganze Reihe von Dateien, welche die für das Hauptfenster von Outlook und für die verschiedenen Fenster etwa zum Anzeigen von Mails, Kontakten et cetera benötigten OfficeIds liefern. Für das Hauptfenster benötigen Sie die Datei OutlookExplorerControls.xlsx<\/b>.<\/p>\n Hier suchen wir nach Einträgen, die etwa den Begriff Send <\/b>in der Spalte ControlName <\/b>enthalten, und finden recht weit oben den Eintrag SendReceive<\/b>, der offensichtlich der gesuchte Eintrag ist (s. Bild 6).<\/p>\n Bild 6: OfficeId-Bezeichnungen für die verschiedenen Ribbon-Elemente des Outlook-Hauptfensters<\/span><\/b><\/p>\n Die Ribbon-Definition können wir nun um das ribbon<\/b>-Element und die untergeordneten Elemente erleichtern. Dafür legen wir ein commands<\/b>-Element mit einem command <\/b>an, für dessen idMso<\/b>-Eigenschaft wir den Wert SendReceiveAll <\/b>einstellen:<\/p>\n Außerdem legen wir für das Attribut onAction <\/b>den Wert onAction_Command <\/b>fest. Warum onAction_Command <\/b>und nicht einfach onAction<\/b>, wie wir es unter Access immer tun Weil die Signatur der onAction<\/b>-Callbackfunktion für das command<\/b>-Element anders aussieht als die von onAction <\/b>etwa für button<\/b>-Elemente. Für das button<\/b>-Element erwarten wir nur einen Parameter, welcher einen Verweis auf das aufrufende Ribbon-Element liefert.<\/p>\n Die onAction<\/b>-Funktion für ein command<\/b>-Element benötigt jedoch noch einen zweiten Parameter, mit dem wir festlegen, ob die mit command <\/b>referenzierte Funktion nach dem Aufruf der onAction<\/b>-Methode eigentlich immer noch ausgeführt werden soll oder nicht.<\/p>\n Wir wollen nun testweise dafür sorgen, dass beim Betätigen der Alle Ordner senden\/empfangen<\/b>-Schaltfläche eine Meldung erscheint und danach wie üblich E-Mails abgerufen werden. Dazu fügen Sie der Klasse Ribbon_Outlook.vb <\/b>oben zunächst die folgende Anweisung hinzu:<\/p>\n Diese importiert den Namespace, der das MessageBox<\/b>-Objekt enthält. Danach fügen wir der Klasse die Methode onAction_Command <\/b>aus Listing 3 hinzu. Diese liefert, wie oben angegeben, mit den Parametern sowohl einen Verweis auf das aufrufende Element sowie den Boolean<\/b>-Parameter cancelDefault<\/b>.<\/p>\n Listing 3: Methode, die beim Aufrufen von Alle Ordner senden\/empfangen eine Meldung anzeigen soll<\/span><\/b><\/p>\n Die Methode soll eine Meldung anzeigen und dann die ausgelöste Funktion ausführen, daher wird cancelDefault <\/b>auf False <\/b>eingestellt. Der Wert True <\/b>würde dafür sorgen, dass durch das Betätigen von Alle Ordner senden\/empfangen <\/b>keine Mails abgerufen werden.<\/p>\n Das Ergebnis sehen Sie nach einem erneuten Start und dem Mausklick auf Alle Ordner senden\/empfangen <\/b>und in Bild 7. Nun liegt es an uns, statt dieser einfachen Meldung eine Funktion zu hinterlegen, welche es dem Benutzer erleichtert, nicht so oft E-Mails abzurufen.<\/p>\n Bild 7: Anzeigen einer Meldung beim Abrufen von E-Mails<\/span><\/b><\/p>\n Wenn Sie sich entscheiden, beispielsweise nur zwischen 12:00 und 13:00 Uhr E-Mails abrufen zu wollen, könnten Sie die Methode OnAction_Command <\/b>auch wie in Listing 4 definieren.<\/p>\n Listing 4: Diese Methode sorgt dafür, dass nur zwischen 12:00 und 13:00 Uhr E-Mails abgerufen werden können.<\/span><\/b><\/p>\n Die Methode verwendet drei DateTime<\/b>-Variablen. Die Variable datZeit <\/b>wird über die Methode Now <\/b>mit der aktuellen Zeit und dem aktuellen Datum gefüllt. datStart <\/b>erhält ebenfalls Datum und Zeit, wobei die Werte für das Jahr, den Monat und den Tag aus datZeit <\/b>entnommen werden. Die Uhrzeit wird auf 12<\/b>, die Minute auf 0 <\/b>und die Sekunde auf 0 <\/b>eingestellt. Für datEnde <\/b>gilt das Gleiche, nur dass wir hier die Uhrzeit auf 13 <\/b>einstellen.<\/p>\n Sollte sich der Wert der aktuellen Uhrzeit aus datZeit<\/b> zwischen datStart <\/b>und datEnde <\/b>befinden, ruft Outlook E-Mails wie gewohnt ab. Falls der Benutzer aber außerhalb dieses Zeitfensters auf die E-Mails zugreifen will, erscheint die Meldung aus Bild 8 und der Abruf der Mails wird durch das Einstellen des Wertes True <\/b>für den Rückgabeparameter cancelDefault <\/b>unterbunden.<\/p>\n Bild 8: Keine Mails zwischen 12:00 und 13:00 Uhr<\/span><\/b><\/p>\n Toll wäre es nun noch, wenn der Benutzer die Zeiten, in denen er auf die E-Mails zugreifen kann, per Option einstellen könnte. Dies soll dann etwa wie in Bild 9 aussehen. Der Backstage-Bereich von Outlook soll dann mit dem neu zu erstellenden vorletzten Tab auf der linken Seite den Text E-Mail-Abruf einschränken <\/b>anzeigen. Dieser Tab soll einen Bereich öffnen, der die Startzeit und die Endzeit für den Zugriff auf neue E-Mails regelt.<\/p>\n Bild 9: Optionen zum Einstellen der Zugriffszeiten für den E-Mail-Abruf<\/span><\/b><\/p>\n Zum Speichern der Optionen verwenden wir den Bereich Einstellungen<\/b> des Projekts, den Sie durch einen Doppelklick auf den Eintrag My Project <\/b>im Projektmappen-Explorer öffnen. Hier können Sie die für das Add-In benötigten Einstellungen speichern. Im vorliegenden Fall legen wir zwei Optionen namens Startzeit <\/b>und Endzeit <\/b>an, beide mit dem Typ Date <\/b>und dem Bereich Benutzer<\/b>. Als Wert stellen wir das aktuelle Datum plus die gewünschten Uhrzeiten ein (s. Bild 10).<\/p>\n Bild 10: Speichern der Anwendungsoptionen<\/span><\/b><\/p>\n Um den Backstage-Bereich zu definieren, öffnen Sie wieder die Datei Ribbon_Outlook.xml<\/b> (s. Listing 5). Die dortige Definition des Ribbons erweitern Sie um das backstage<\/b>-Element. Diesem fügen wir ein tab<\/b>-Element hinzu, wobei es sich um die Lasche am linken Rand handelt, die per Mausklick den eigentlichen Bereich öffnet. Das Element benötigt ein id<\/b>-Attribut, ein label<\/b>-Attribut und die Angabe, wo es eingefügt werden soll – in diesem Fall vor dem Beenden<\/b>-Tab. Die idMso <\/b>für dieses Element finden wir wieder in der bereits weiter oben verwendeten Excel-Tabelle. Sie heißt FileCloseAndLogOff<\/b>.<\/p>\n Listing 5: Definition des Ribbons inklusive Backstage-Bereich<\/span><\/b><\/p>\n Darin legen wir das firstColumn<\/b>-Element an, ein group<\/b>-Element (wieder mit id <\/b>und label<\/b>) und das topItems<\/b>-Element. Darin folgt die Beschreibung der folgenden Steuer-elemente mit einem labelControl<\/b>-Element. Die folgenden editBox<\/b>-Elemente sollen die Startzeit und die Endzeit aufnehmen. Sie heißen txtStartzeit <\/b>und txtEndzeit<\/b>.<\/p>\n Beide enthalten jeweils das getText<\/b>– und das onChange<\/b>-Callback-Attribut. Für das getText<\/b>-Attribut geben wir eine VB-Prozedur an, welche den im Textfeld anzuzeigenden Text ermittelt. Für das onChange<\/b>-Attribut erstellen wir eine Prozedur, welche nach dem ändern des Inhalts durch den Benutzer die änderungen in die zugrunde liegenden lokalen Variablen übertragen soll.<\/p>\n Fehlt noch die Schaltfläche Speichern<\/b>, die wir als button<\/b>-Element definieren. Sie bekommt außerdem noch das onAction<\/b>-Attribut, welches beim Anklicken der Schaltfläche die Methode onAction <\/b>aufruft.<\/p>\n Solange der Backstage-Bereich geöffnet ist, sollen die aktuellen Werte für die Startzeit und die Endzeit in den beiden Variablen datStartzeit <\/b>und datEndzeit <\/b>vorgehalten werden, die wir wie folgt im Modul Ribbon_Outlook.vb <\/b>deklarieren:<\/p>\n Beim Anzeigen des Backstage-Tabs mit den Optionen für unser Add-In wird zunächst für jedes Textfeld je einmal die Funktion GetText <\/b>aufgerufen. Diese füllt die Variablen datStartzeit <\/b>und datEndzeit<\/b>, indem sie die Werte aus den Einstellungen ausliest.<\/p>\n Der Zugriff darauf erfolgt ganz einfach über die entsprechenden Eigenschaften Startzeit <\/b>und Endzeit <\/b>des Objekts My.Settings<\/b>. Danach prüft die Funktion über den Wert der Eigenschaft id <\/b>des Parameters control<\/b>, von welchem Steuer-element sie aufgerufen wurde.<\/p>\n Handelt es sich um txtStartzeit<\/b>, wird der Wert aus datStartzeit <\/b>mit dem Funktionswert GetText <\/b>zurückgegeben. Gleiches gilt, wenn die Funktion von txtEndzeit <\/b>aufgerufen wird – dann landet der Inhalt der Variablen datEndzeit <\/b>im Rückgabewert:<\/p>\n Somit sind die Textfelder schon einmal gefüllt. Nun schauen wir uns an, was geschieht, wenn der Benutzer diese ändert. Dies löst dieMethode OnChange <\/b>für das jeweilige Steuer-element aus, das wieder mit dem Parameter control <\/b>übergeben wird. Der Parameter text <\/b>wiederum liefert den Wert des Textfeldes nach der änderung.<\/p>\nOutlook-Mailabrufe in den Kalender eintragen<\/h2>\n
Dim <\/span>WithEvents objOutlook As <\/span>Outlook.Application\r\nDim <\/span>WithEvents objPosteingang As <\/span>Outlook.Folder\r\nDim <\/span>WithEvents objPosteingangItems As <\/span>Outlook.Items<\/pre>\nDim <\/span>datLastMail As Date<\/span><\/pre>\nPublic Sub <\/span>Application_Startup()\r\n Set<\/span> objOutlook = Application\r\n Set<\/span> objPosteingang = objOutlook.GetNamespace(\"MAPI\").GetDefaultFolder(olFolderInbox)\r\n Set<\/span> objPosteingangItems = objPosteingang.Items\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objPosteingangItems_ItemAdd(ByVal Item As Object<\/span>)\r\n Dim <\/span>objCalendar As <\/span>Outlook.Folder\r\n Dim <\/span>datLastMailTemp As Date<\/span>\r\n Dim <\/span>objAppointment As <\/span>Outlook.AppointmentItem\r\n datLastMailTemp = DateSerial(Year(Now), Month(Now), Day(Now)) + TimeSerial(Hour(Now), Minute(Now), 0)\r\n If <\/span>Not<\/span> datLastMailTemp = datLastMail Then<\/span>\r\n Set<\/span> objCalendar = objOutlook.GetNamespace(\"MAPI\").GetDefaultFolder(olFolderCalendar)\r\n Set<\/span> objAppointment = objOutlook.CreateItem(olAppointmentItem)\r\n With<\/span> objAppointment\r\n .Subject = \"Mailabruf \" & Format(Now, \"hh:nn\")\r\n .Start = Now\r\n .Duration = 30\r\n .Categories = \"Mail abrufen\"\r\n .ReminderSet<\/span> = False<\/span>\r\n .Save\r\n Debug.Print<\/span> \"Geschrieben \" & .Subject\r\n End With<\/span>\r\n End If<\/span>\r\n datLastMail = datLastMailTemp\r\nEnd Sub<\/span><\/pre>\n![\"Einstellen](\"..\/fileadmin\/_temp_\/2017_04\/pic_1095_002.png\")
<\/p>\nWie funktioniert es<\/h2>\n
Achtsamkeit beim Mailabruf<\/h2>\n
Projekt anlegen<\/h2>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2017_04\/pic_1095_003.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2017_04\/pic_1095_004.png\")
<\/p>\nXML-Definition erstellen<\/h2>\n
<xml version=\"1.0\" encoding=\"UTF-8\">\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\" onLoad=\"Ribbon_Load\">\r\n <ribbon>\r\n <tabs>\r\n <tab idMso=\"TabAddIns\">\r\n <group id=\"MyGroup\"\r\n label=\"My Group\">\r\n <\/group>\r\n <\/tab>\r\n <\/tabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n
Protected Overrides Function CreateRibbonExtensibilityObject() As <\/span>Microsoft.Office.Core.IRibbonExtensibility\r\n Return New<\/span> Ribbon_Outlook()\r\nEnd Function<\/span><\/pre>\n<tab id=\"test\" label=\"Bla\">\r\n <group id=\"MyGroup\" label=\"My Group\">\r\n <button id=\"btnx\" label=\"bla\"\/>\r\n <\/group>\r\n<\/tab><\/pre>\n
![\"Neues](\"..\/fileadmin\/_temp_\/2017_04\/pic_1095_009.png\")
<\/p>\nEingebaute Schaltfläche referenzieren<\/h2>\n
![\"OfficeId-Bezeichnungen](\"..\/fileadmin\/_temp_\/2017_04\/pic_1095_005.png\")
<\/p>\n<xml version=\"1.0\" encoding=\"UTF-8\">\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\" onLoad=\"Ribbon_Load\">\r\n <commands>\r\n <command idMso=\"SendReceiveAll\" onAction=\"onAction_Command\"\/>\r\n <\/commands>\r\n<\/customUI><\/pre>\n
Imports System.Windows.Forms<\/pre>\n
Public Sub <\/span>OnAction_Command(ctl As <\/span>Office.IRibbonControl, ByRef cancelDefault As Boolean<\/span>)\r\n MessageBox.Show(\"Control: \" + ctl.Id.ToString())\r\n cancelDefault = False<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Anzeigen](\"..\/fileadmin\/_temp_\/2017_04\/pic_1095_010.png\")
<\/p>\nE-Mails nur in bestimmtem Zeitfenster laden<\/h2>\n
Public Sub <\/span>OnAction_Command(ctl As <\/span>Office.IRibbonControl, ByRef cancelDefault As Boolean<\/span>)\r\n Dim <\/span>datZeit As Date<\/span>Time\r\n Dim <\/span>datStart As Date<\/span>Time\r\n Dim <\/span>datEnde As Date<\/span>Time\r\n datZeit = DateTime.Now\r\n datStart = New<\/span> DateTime(datZeit.Year, datZeit.Month, datZeit.Day, 12, 0, 0)\r\n datEnde = New<\/span> DateTime(datZeit.Year, datZeit.Month, datZeit.Day, 13, 0, 0)\r\n If <\/span>(datZeit > datStart And datZeit < datEnde) Then<\/span>\r\n cancelDefault = False<\/span>\r\n Else<\/span>\r\n MessageBox.Show(\"Mails dürfen nur zwischen 12:00 und 13:00 Uhr abgerufen werden.\")\r\n cancelDefault = True<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Keine](\"..\/fileadmin\/_temp_\/2017_04\/pic_1095_011.png\")
<\/p>\nE-Mail-Zugriffszeiten in den Optionen einstellen<\/h2>\n
![\"Optionen](\"..\/fileadmin\/_temp_\/2017_04\/pic_1095_012.png\")
<\/p>\nOptionen speichern<\/h2>\n
![\"Speichern](\"..\/fileadmin\/_temp_\/2017_04\/pic_1095_013.png\")
<\/p>\nDefinition des Backstage-Bereichs<\/h2>\n
<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\" onLoad=\"Ribbon_Load\">\r\n <commands>\r\n <command idMso=\"SendReceiveAll\" onAction=\"onAction_Command\"\/>\r\n <\/commands>\r\n <backstage>\r\n <tab id=\"tabOutlookAddIn\" label=\"E-Mail-Abruf einschänken\" insertBeforeMso=\"FileCloseAndLogOff\">\r\n <firstColumn>\r\n <group id=\"grpZeiten\" label=\"E-Mail-Abruf einschränken\">\r\n <topItems>\r\n <labelControl id=\"lblDescription\" label=\"Legen Sie die Uhrzeiten fest, in denen E-Mail-Zugriff erlaubt \r\n sein soll.\"\/>\r\n <layoutContainer id=\"layStartzeit\" align=\"left\" layoutChildren=\"horizontal\">\r\n <editBox id=\"txtStartzeit\" label=\"Startzeit:\" getText=\"getText\" onChange=\"onChange\"\/>\r\n <\/layoutContainer>\r\n <layoutContainer id=\"layEndzeit\" align=\"left\" layoutChildren=\"horizontal\">\r\n <editBox id=\"txtEndzeit\" label=\"Endzeit:\" getText=\"getText\" onChange=\"onChange\"\/>\r\n <\/layoutContainer>\r\n <button label=\"Speichern\" onAction=\"onAction\" id=\"btnSpeichern\"\/>\r\n <\/topItems>\r\n <\/group>\r\n <\/firstColumn>\r\n <\/tab>\r\n <\/backstage>\r\n<\/customUI><\/pre>\n
Backstage mit Leben füllen<\/h2>\n
Public <\/span>datStartzeit As Date<\/span>Time\r\nPublic <\/span>datEndzeit As Date<\/span>Time<\/pre>\nFunction <\/span>GetText(control As <\/span>Office.IRibbonControl) _\r\n As String<\/span>\r\n datStartzeit = My.Settings.Startzeit\r\n datEndzeit = My.Settings.Endzeit\r\n Select Case control.Id\r\n Case <\/span>\"txtStartzeit\"\r\n GetText = datStartzeit.ToShortTimeString()\r\n Case <\/span>\"txtEndzeit\"\r\n GetText = datEndzeit.ToShortTimeString()\r\n Case Else<\/span>\r\n MessageBox.Show(\"GetText from: \" _\r\n + control.Id.ToString())\r\n End Select<\/span>\r\nEnd Function<\/span> <\/pre>\n