<\/p>\n
Wäre es nicht toll, wenn Sie eine Kundenanfrage, die keine individuelle Antwort erfordert, per Textbaustein beantworten könnten, der dennoch etwas Individualität aufweist Dazu würde es ja beispielsweise reichen, wenn Sie den Kunden ordentlich anreden, beispielsweise mit „Sehr geehrter Herr Müller“. Das Ganze sollte dann auch noch mit möglichst wenig Handgriffen geschehen, also beispielsweise über einen Klick auf einen Ribbon-Eintrag der zu beantwortenden Mail oder einen Kontextmenü-Eintrag. Wie dies gelingt und wie Sie Ihre Kundendatenbank einbeziehen, um Anrede und Name zur E-Mail-Adresse des Absenders zu ermitteln, zeigt dieser Beitrag.<\/b><\/p>\n
Textbausteine für Outlook-Mails<\/b><\/p>\n
Textbausteine etwa im Antworttext auf Support-Anfragen sind ja im Allgemeinen verpönt. Allerdings muss man auch sagen, dass es ermüdend sein kann, wenn man als Support-Mitarbeiter immer wieder die gleichen Anfragen mit ähnlichen Antworten zurücksendet. Entscheidend ist also vielleicht gar nicht einmal, dass man überhaupt Textbausteine verwendet, sondern dass man diese sinnvoll einsetzt €“ der Kunde darf auch durchaus erkennen, dass er eine Standardantwort auf seine Anfrage erhält. Das gilt allerdings nur, wenn er dadurch auch die Antwort erhält, die sein Problem löst.<\/p>\n
Wir wollen uns erstmal von diesen kommunikativen Problemen lösen und uns der technischen Umsetzung zuwenden. Auch wenn es ein Leichtes ist, den Posteingang und somit auch die Kundenanfragen etwa in die Kundendatenbank umzuleiten und von dort aus zu antworten, so ist der eine oder andere doch so sehr den Umgang mit Outlook gewöhnt, dass er sich ungern davon lossagen möchte. Also verlegen wir den Schwerpunkt der Lösung dieses Kapitels einmal nicht in die Access-Anwendung, sondern direkt nach Outlook.<\/p>\n
Die Lösung soll es ermöglichen, auf eine Kunden-Anfrage zu antworten und dabei Textbausteine aus der Datenbank abzurufen. Nun könnten Sie natürlich einfach ein paar unpersönliche Textbausteine verwenden, aber dafür müssten Sie beispielsweise die Anrede in der E-Mail (je nach Umgang Sehr geehrter Herr Müller<\/b>, Hallo Herr Müller <\/b>oder auch Lieber Herr Müller<\/b>) von Hand formulieren. Es wäre also praktisch, wenn die Lösung auch dies übernehmen könnte. Das würde erfordern, dass wir anhand der Absenderadresse der Anfrage-E-Mail erkennen, um welchen Kunden es sich handelt. Dazu müssten wir mit der E-Mail-Adresse auf die Kundendatenbank zugreifen und erstens herausfinden, ob der Kunde überhaupt ermittelt werden kann und zweitens Anrede, Vorname und\/oder Nachname ermitteln. Daraus bauen wir dann die E-Mail-Anrede zusammen.<\/p>\n
Fehlt nur noch der eigentliche Text. Wir gehen davon aus, dass diese Lösung einfache Anfragen beantworten soll, also beispielsweise danach, wo der Leser eines Access-Magazins seine Zugangsdaten für das Online-Archiv findet. Die verschiedenen Antworttexte sollen dabei einfach über das Kontextmenü in der Antwort-E-Mail auswählbar sein. Ein Klick soll den Text dann, versehen mit der personalisierten Anrede, in die Mail übertragen.<\/p>\n
Soweit zur Aufgabenstellung €“ fangen wir an!<\/p>\n
Technik: Outlook-Add-In<\/b><\/p>\n
Zu meinem Befremden hat Microsoft die Möglichkeit, Kontextmenüs in Outlook-Fenstern über die CommandBars<\/b>-Auflistung auszulesen und anzupassen, komplett gestrichen. Das wäre auch zu einfach gewesen: Wir hätten die komplette Funktion dann einfach in das VBA-Projekt von Outlook integrieren können. Stattdessen müssen (oder dürfen) wir uns nun mit der Programmierung eines COM-Add-Ins mittels Visual Studio 2013 beschäftigen. Dürfen deshalb, weil dies doch sehr interessante Möglichkeiten eröffnet. Die Grundlagen zur Erstellung eines COM-Add-Ins sowie zu seiner Weitergabe haben Sie bereits im Beitrag COM-Add-Ins mit Visual Studio Community 2013 <\/b>(www.access-im-unternehmen.de\/982<\/b>) kennengelernt, und wie Sie ein solches Add-In mit einem geeigneten Setup-Projekt weitergeben, erfahren Sie unter dem Titel COM-Add-Ins: Setup erstellen <\/b>(www.access-im-unternehmen.de\/983<\/b>). Also steigen wir gleich in die Materie ein.<\/p>\n
COM-Add-In erstellen<\/b><\/p>\n
Starten Sie zunächst Visual Studio. Dann wählen Sie den Menübefehl Datei|Neu|Projekt… <\/b>aus. Im nun erscheinenden Dialog entscheiden wir uns für ein Projekt mit der Vorlage Outlook 2010-Add-In <\/b>und legen den Projektnamen Textbausteine2010 <\/b>fest (s. Bild 1).<\/p>\n
![\"Neues](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_001.png\")
<\/p>\n
Bild 1: Neues Add-In für Outlook 2010 anlegen<\/span><\/b><\/p>\n Warum Outlook 2010 Nun: Auf dem Rechner mit Visual Studio ist nur Office 2010 installiert. Daher ist es praktisch, zunächst für Outlook 2010 zu entwickeln €“ so kann man den aktuellen Stand immer mal wieder zum Debuggen testen. Später schauen wir uns dann an, wie Sie das Projekt für Outlook 2013 bereitstellen. <\/p>\n Visual Studio erstellt nun das Projekt und zeigt das Klassenmodul ThisAddIn <\/b>mit den beiden Standard-Ereignisprozeduren der hier vorgesehenen Schnittstelle an. Hier müssen wir nun Code unterbringen, der dafür sorgt, dass die entsprechenden Kontextmenü-Einträge zum Kontextmenü des E-Mail-Entwurfs hinzugefügt werden.<\/p>\n Erster Test<\/b><\/p>\n Schauen wir uns gleich mal an, ob die mit einem einfachen Meldungsfenster ausgestattete Er-eig-nis-prozedur beim Debuggen mit Outlook funktioniert. Die Prozedur sieht nun so aus:<\/p>\n Klicken Sie dann auf die Schaltfläche mit dem Pfeil nach rechts und dem Text Starten<\/b>, auf den Menüeintrag Debuggen|Debugging starten <\/b>oder auf die Taste F5<\/b>. Dies öffnet Outlook und die frisch angelegte MsgBox <\/b>erscheint.<\/p>\n Kontextmenü-Erweiterung hinzufügen<\/b><\/p>\n Nun fügen wir zunächst die reine Kontextmenü-Erweiterung hinzu €“ zunächst in Form eines einzigen Eintrags. Dazu sind mehrere Schritte nötig, die dem Access-Entwickler ungewohnt vorkommen dürften. Dieser fügt ja der Anwendung eine Tabelle namens USysRibbons <\/b>hinzu, welche die Ribbon-Definition enthält, und gibt dann für die Eigenschaften der Anwendung und der Formulare an, welches Ribbon mit welchem Fenster angezeigt werden soll.<\/p>\n Grundstruktur zum Projekt hinzufügen<\/b><\/p>\n Hier benötigen Sie zunächst eine neue Klasse, welche die grundlegende Struktur für den Aufbau einer individuellen Ribbon-Definition liefert. Diese fügen Sie über den Menüeintrag Projekt|Neues Element hinzufügen… <\/b>von Visual Studio zum Projekt hinzu (s. Bild 2).<\/p>\n Bild 2: Hinzufügen eines neuen Elements<\/span><\/b><\/p>\n Dies zeigt den Dialog Neues Element hinzufügen <\/b>aus Bild 3 an. Hier finden Sie eine ganze Reihe möglicher Elemente vor, die nach Kategorien sortiert sind. Wählen Sie hier den Eintrag Menüband (XML) <\/b>aus. Geben Sie als Bezeichnung für die zu erstellende Klasse den Wert Ribbon_Mail.vb <\/b>ein und klicken Sie auf Hinzufügen<\/b>.<\/p>\n Bild 3: Auswahl des Elements Menüband (XML) namens Ribbon_Mail<\/span><\/b><\/p>\n Anschließend erscheint die automatisch generierte Klasse in Visual Studio (s. Bild 4). Die Klasse enthält die Implementierung der Schnittstelle IRibbonExtensibility<\/b>. Deren wichtigstes Element ist die Funktion GetCustomUI<\/b>. Diese wird beim Laden des Add-Ins ausgelöst und kann mit der anzuwendenden Ribbon-Definition gefüllt werden.<\/p>\n Bild 4: Die neu hinzugefügte Klasse<\/span><\/b><\/p>\n Diese Funktion sieht aktuell wie folgt aus:<\/p>\n Mit Return <\/b>übergibt sie das Ergebnis der Funktion GetResourceText<\/b>, welche den Inhalt einer im Projekt eingebundenen XML-Datei einliest €“ in diesem Fall namens Ribbon_Mail.xml<\/b>. Diese Datei finden Sie auch im Projektmappen-Explorer, s. Bild 5.<\/p>\n Bild 5: Der Projektmappen-Explorer mit der Ressourcen-Datei<\/span><\/b><\/p>\n Schauen wir uns diese Ressourcen-Datei einmal an:<\/p>\n Dies kommt dem Access-Entwickler nun doch wieder sehr bekannt vor €“ zumindest wenn er bereits einmal mit Access 2007 oder neuer gearbeitet hat.<\/p>\n Erster Test<\/b><\/p>\n Wollen wir einmal schauen, ob diese Erweiterung bereits angezeigt wird, und starten das Debugging mit F5<\/b>. Outlook wird geöffnet, unsere MsgBox<\/b>-Anweisung zeigt ihre Meldung an, aber am Ribbon ändert sich nichts.<\/p>\n Nun: Vielleicht ist ein Fehler aufgetreten, den wir nicht sehen, weil die entsprechende Option nicht aktiviert ist. Diese Einstellung finden Sie im Optionen-Dialog von Outlook im Bereich Erweitert|Entwickler <\/b>(s. Bild 6). Aktivieren Sie dort die Option Add-In-Benutzeroberflächenfehler anzeigen <\/b>und schließen Sie die Optionen wieder.<\/p>\n Bild 6: Aktivieren der Anzeige von Ribbon-Fehlern<\/span><\/b><\/p>\n Nun beenden wir das Debugging, indem wir Outlook schließen, und starten erneut mit F5<\/b>.<\/p>\n Es geschieht immer noch nichts. Um zu prüfen, ob die Prozedur GetCustom-UI <\/b>überhaupt aufgerufen wird, fügen wir dort eine MsgBox<\/b>-Anweisung ein. Allerdings ohne Erfolg. Dann zeigt sich, dass Lesen immer weiterhilft: Oben im automatisch erstellten Klassenmodul steht nämlich der Hinweis, dass man die folgende Prozedur in die Klasse ThisAddIn <\/b>kopieren soll:<\/p>\n Bingo! Nach dem erneuten Start des Debuggers öffnet sich Outlook und zeigt das Tab<\/b>-Element namens Add-Ins <\/b>mit dem Group<\/b>-Element MyGroup <\/b>an (s. Bild 7).<\/p>\n Bild 7: Die erste Ribbon-Anpassung<\/span><\/b><\/p>\n Ribbon im Mail-Fenster<\/b><\/p>\n Nun wollen wir allerdings nicht das Ribbon des Hauptfensters von Outlook anpassen, sondern ein Kontextmenü des Mail-Fensters. Nun bietet die Funktion GetCustomUI <\/b>ja den Parameter ribbonID <\/b>an. Dieser enthält den Namen des Objekts, von dem aus die Funktion aufgerufen wurde. Zu Testzwecken erweitern wir GetCustomUI <\/b>zunächst um ein Meldungsfenster, das den Inhalt von ribbonID <\/b>ausgibt (s. Listing 1).<\/p>\n Listing 1: Ausgabe der ribbonID des aktuell aufgerufenen Ribbons<\/span><\/b><\/p>\n Wenn Sie nun erneut debuggen, erscheint beim Start von Outlook zunächst ein Meldungsfenster mit dem Inhalt Microsoft.Outlook.Explorer<\/b>. Dies ist also anscheinend die Bezeichnung des Hauptfensters von Outlook. Ã\u0192-ffnen Sie nun ein neues E-Mail-Fenster, erscheint die Meldung aus Bild 8. Dieser Abbildung entnehmen wir erstens, dass das Mail-Fenster Microsoft.Outlook.Mail.Compose <\/b>heißt, und zweitens, dass das Ribbon dieses Fensters sich zum Zeitpunkt des Aufrufs von GetCustomUI <\/b>offensichtlich noch im Aufbau befindet. Wenn Sie eine bereits vorhandene Mail öffnen, heißt das Fenster übrigens Microsoft.Outlook.Mail.Read<\/b>. Wir müssen also nun zunächst eine Prüfung auf den Wert von ribbonID <\/b>in die Funktion Get-Cus-tomUI <\/b>einbauen, die nur im Falle des Wertes Microsoft.Outlook.Mail.Compose <\/b>eine neue Ribbon-Definition zurückgibt. Dazu verwenden wir eine Select Case<\/b>-Anweisung, die so aussieht:<\/p>\n Bild 8: Die Funktion GetCustomUI wird auch beim Ã\u0192-ffnen eines E-Mail-Fensters aufgerufen.<\/span><\/b><\/p>\n Diese änderung allein führt nun dazu, dass die bereits bekannte Ribbon-Definition nun auf das Fenster zum Erstellen einer neuen E-Mail angewendet wird (s. Bild 9). Wo wir schon einmal soweit sind: Eigentlich können wir die Bezeichnungen der Textbausteine ja auch über das Ribbon verfügbar machen. Damit müsste der Benutzer zwar erst die Stelle im Text markieren, an welcher der Textbaustein eingefügt werden soll, aber immerhin wäre dieser Befehl dann immer sichtbar. Die Erfahrung zeigt, dass Benutzer nicht unbedingt immer das Kontextmenü auf der Suche nach nützlichen Befehlen durchsuchen. Fügen wir also zunächst Steuerelemente zum Ribbon hinzu, die vorerst einige statische Texte in die Mail einfügen.<\/p>\n Bild 9: Ribbon-Definition im Mail-Fenster<\/span><\/b><\/p>\n Textbaustein-Auswahlmenü zum Ribbon hinzufügen<\/b><\/p>\n Die Textbausteine sollen per Menu<\/b>-Steuerelement auswählbar sein. Wo auf den verschiedenen Tabs des Ribbons der neuen E-Mail platzieren wir dieses Ein eigenes Tab wäre wohl übertrieben. Wenn Sie die Funktion zum Einsetzen von Textbausteinen oft nutzen möchten, können Sie diese direkt auf dem Ribbon-Tab namens Nachricht <\/b>anzeigen, das direkt beim Ã\u0192-ffnen der neuen Mail erscheint. Besser geeignet scheint jedoch das Tab Einfügen<\/b>. Also wollen wir dort ein Menu-Element mit vorerst vier Einträgen unterbringen, die jeweils die Bezeichnung Textbaustein 1<\/b>, Textbaustein 2<\/b>, Textbaustein 3 <\/b>und Textbaustein 4 <\/b>enthalten.<\/p>\n Grundlegender XML-Code für die Ribbon-Anpassung<\/b><\/p>\n Der dazu benötigte XML-Code sieht wie in Listing 2 aus.<\/p>\n Listing 2: Ribbon-Definition mit einem Menü und vier Unterpunkten<\/span><\/b><\/p>\n In dieser Definition stecken eine Reihe Elemente, die wir erläutern müssen €“ gerade für Ribbon-Neulinge, aber auch für Entwickler, die schon einmal mit Ribbons entwickelt haben. Die Ribbon-Definition beschreibt die Struktur der Ribbon-Steuerelemente.<\/p>\n Das customUI<\/b>-Element ist das Hauptelement. Darunter finden wir das ribbon<\/b>-Element, das alle Elemente enthält, welche das Aussehen der Ribbon-Leiste oben in der Anwendung beschreiben. Es gibt noch andere Elemente wie etwa Kontextmenüs, aber dazu kommen wir ja gleich.<\/p>\n Unterhalb des ribbon<\/b>-Elements folgt ein zusammenfassendes tabs<\/b>-Element, das die einzelnen tab<\/b>-Elemente einfasst. Die tab<\/b>-Elemente enthalten beispielsweise ein Attribut namens label<\/b>, mit dem Sie die Beschriftung eines benutzerdefinierten tab<\/b>-Elements festlegen. In diesem Fall wollen wir aber kein tab<\/b>-Element hinzufügen, sondern ein group<\/b>-Element zu einem eingebauten tab<\/b>-Element hinzufügen. Dazu müssen wir den Namen dieses tab<\/b>-Elements ermitteln und diesen für die Eigenschaft idMso <\/b>des tab<\/b>-Elements angeben.<\/p>\n idMso für eingebaute Ribbon-Elemente ermitteln<\/b><\/p>\n Aber woher erfahren wir den Namen dieses Elements Dies ist insbesondere unter Outlook eine Herausforderung, denn hier gibt es nicht nur ein Ribbon, sondern eines für die Hauptanwendung und je ein weiteres für die vielen weiteren Fenster €“ etwa zum Verfassen einer Mail, zum Anzeigen einer Mail, zum Anzeigen eines Termins, zum Anzeigen eines Kontakts und viele mehr. Microsoft hat eine Reihe von Excel-Dateien bereitgestellt, die jeweils eine Liste aller Elemente eines Ribbons enthalten. Sie finden diese zum Download unter und . In Bild 10 haben wir beispielsweise die Dateien für Office 2013 dargestellt, die von uns benötigte ist markiert.<\/p>\n Bild 10: Liste aller Dateien mit Ribbon-Elementen für die verschiedenen Anwendungen und Outlook-Inspektoren<\/span><\/b><\/p>\n Wir möchten nun beispielsweise wissen, wie das tab<\/b>-Element heißt, dem wir unser group<\/b>-Element hinzufügen möchten. Wir wissen lediglich, dass die deutsche Fassung Einfügen <\/b>heißt. Und so öffnen wir die Datei outlookmailitemcontrols.xlsx <\/b>und schauen, ob wir einen Eintrag finden, der in der Spalte Control Type <\/b>den Wert Tab<\/b> besitzt und der übersetzt etwas mit Einfügen <\/b>zu tun hat. Diesen finden wir recht schnell, wie Bild 11 zeigt.<\/p>\n Bild 11: Ermitteln des Namens eines tab-Elements<\/span><\/b><\/p>\n Somit erhalten wir den Wert TabInsert <\/b>für das Attribut idMso<\/b>. Nun haben wir also einen Bezug zum Einfügen-Tab hergestellt. Wir möchten nun ein neues group<\/b>-Element namens Textbausteine <\/b>einfügen.<\/p>\n Das ist kein Problem, wird aber zumindest interessanter, wenn wir es nicht einfach ganz hinten, sondern an einer bestimmten Position einfügen möchten €“ in unserem Fall gleich neben der wichtigsten Gruppe Einschließen<\/b>, die sich ganz links befindet (s. Bild 12). In der Abbildung sehen Sie auch schon den zu erstellenden Eintrag.<\/p>\n Bild 12: Hier möchten wir landen.<\/span><\/b><\/p>\n Der Name dieses group<\/b>-Elements ist in der Excel-Tabelle outlookmailitemcontrols.xlsx<\/b> nun nicht mehr schwer zu finden €“ es folgt hinter dem soeben bereits ermittelten tab<\/b>-Element TabInsert <\/b>und heißt GroupInclude<\/b>. Damit unsere Gruppe direkt hinter dieser Gruppe landet, fügen wir diesem Element das Attribut insertAfterMso <\/b>den Namen der Gruppe als Wert hinzu.<\/p>\n Nun folgt das eigentliche Steuerelement, nämlich ein menu<\/b>-Element mit der Beschriftung Text-bau-stein <\/b>auswählen, dessen Größe mit dem Attribut size <\/b>auf large <\/b>eingestellt ist und dem wir mit dem image<\/b>-Attribut ein Bild mit der Referenzbezeichnung text_32 <\/b>zuweisen:<\/p>\n Wie wir diese Bilder holen, erfahren Sie gleich im Anschluss. Erst werfen wir noch einen Blick auf einen der Menüeinträge, die etwa so definiert werden:<\/p>\n Die Menüeinträge werden als button<\/b>-Elemente definiert, die zunächst eine Bezeichnung (label<\/b>) und die eindeutige Kennzeichnung (id<\/b>) aufweisen. Dann folgt das Attribut onAction<\/b>, mit dem wir den Namen der Visual-Basic-Callback-Funktion angeben, die beim Anklicken dieses Elements ausgelöst werden soll. Und schließlich haben wir auch dem Menü-Eintrag wieder eine Bildreferenz zugewiesen, die diesmal text_16 <\/b>heißt.<\/p>\n Bei Mausklick …<\/b><\/p>\n Zunächst kommen wir zum onAction<\/b>-Attribut. Die dort angegebene Funktion onAction <\/b>legen Sie wie in Listing 3 im Klassenmodul Ribbon_Mail.vb <\/b>an.<\/p>\n <\/p>\n Listing 3: Prozedur, die durch das Ereignis onAction einer der Schaltflächen ausgelöst wird<\/span><\/b><\/p>\n Diese Prozedur nimmt mit dem Parameter control <\/b>einen Verweis auf das aufrufende Steuer-element aus dem Ribbon entgegen, hier also etwa die Schaltfläche btnTextbaustein1<\/b>. Die Eigen-schaft id <\/b>dieses Objekts des Typs IRibbonControl <\/b>liefert den Namen des Steuerelements, den die Prozedur dann in einer Select Case<\/b>-Bedingung auswertet. Hier legen wir jeweils zwei An-wei-sungen an: Die erste ermittelt das aktuelle Mail-Objekt. Dazu ermittelt sie aus der Klasse Glo-bals<\/b>, die viele wichtige Informationen liefert, einen Verweis auf die Klasse ThisAddIn<\/b>, deren Eigen-schaft Application <\/b>wiederum einen Verweis auf die aktuelle Anwendung liefert, in diesem Fall also Outlook. Die Eigenschaft ActiveInspector <\/b>liefert wiederum einen Verweis auf das aktuelle Fenster mit der frisch erzeugen E-Mail.<\/p>\n Das MailItem<\/b>-Objekt weist die Prozedur dabei der Variablen objMail <\/b>zu. Wir wollen den Inhalt der E-Mail anpassen, also müssen wir auf die Body<\/b>-Eigenschaft zugreifen. Dieser fügen wir vorn einen Beispieltext an, den Rest der E-Mail behalten wir bei. Wie es funktioniert, schauen wir uns weiter unten an.<\/p>\n Benutzerdefinierte Bilder in die Ribbon-Steuerelemente einfügen<\/b><\/p>\n Interessant ist das Einfügen benutzerdefinierter Bilder in das Ribbon beziehungsweise in die von uns hinzugefügten Steuerelemente. Wir beginnen damit, dass wir die gewünschten Bild-Dateien mit dem Datentyp .png <\/b>als Ressource zum VB-Projekt hinzufügen. Dazu klicken Sie den Eintrag Projekt|Testbausteine2010-Eigenschaften… <\/b>an (s. Bild 13).<\/p>\n Bild 13: Aufrufen der Projekt-Eigenschaften<\/span><\/b><\/p>\n Damit öffnen Sie die Projekteigenschaften. Hier wechseln Sie zum Bereich Ressourcen<\/b>. Dieser ist noch vollständig leer, was wir aber nun ändern: Ziehen Sie per Drag and Drop die .png<\/b>-Dateien, die Sie im Ribbon anzeigen möchten, in den leeren Bereich. Dieser sieht dann etwa wie in Bild 14 aus. Zusätzlich finden Sie die Ressourcen rechts im Projektmappen-Explorer im Verzeichnis Ressourcen<\/b>. <\/p>\n Bild 14: Die Ressourcen des Projekts<\/span><\/b><\/p>\n Nun müssen wir die Bilder noch im Ribbon anzeigen. Den ersten Schritt erledigen wir, indem wir dem customUI<\/b>-Element das Attribut loadImage<\/b> zuweisen, das auf die gleichnamige Callback-Funktion verweist:<\/p>\n Diese Callback-Funktion legen Sie wie folgt im Klassenmodul Ribbon_Mail.vb <\/b>an:<\/p>\n Außerdem benötigen wir noch eine Anweisung, welche die Bibliothek System.Drawing <\/b>verfügbar macht:<\/p>\n Die Prozedur LoadImage <\/b>wird nun, da Sie mit dem loadImage<\/b>-Attribut des customUI<\/b>-Elements angegeben wurde, für jedes Steuerelement mit dem Attribut image <\/b>je einmal aufgerufen, wenn das Element sichtbar wird.<\/p>\n Die Prozedur erwartet mit dem Wert imageID <\/b>den Wert des Attributs image <\/b>für das Steuer-element, für das sie aufgerufen wurde. Sie füllt eine Variable namens objResourceManager <\/b>mit einem Verweis auf das ResourceManager<\/b>-Objekt des aktuellen Projekts. Dieses bietet mit der Funktion GetObject <\/b>die Möglichkeit, das Ressourcen-Element mit dem als Parameter übermittelten Namen zurückzugeben.<\/p>\n Dies machen wir uns zunutze und weisen die Ressource der Variablen objImage <\/b>zu. Dieses wird schließlich noch in ein Bitmap umgewandelt und als Ergebnis der Funktion zurückgegeben.<\/p>\n Auf diese Weise landen die beiden Bilddateien an der richtigen Stelle im Ribbon (s. Bild 15).<\/p>\n Bild 15: Neues Ribbon-Element samt schicker Icons<\/span><\/b><\/p>\n Textbaustein per Mausklick<\/b><\/p>\n Schauen wir uns nun an, wie das Einfügen der provisorischen Textbausteine funktioniert. Starten Sie dazu den Debugger (Menüeintrag Debuggen|Debugging starten<\/b>). Dies startet Outlook und zeigt, sofern Sie diese MsgBox<\/b>-Anweisung noch nicht entfernt haben, die Meldung aus der Prozedur ThisAddIn_Startup <\/b>an. Klicken Sie auf die Schaltfläche Start|Neue E-Mail-Nachricht <\/b>im Ribbon von Outlook. Es erscheint eine neue, leere E-Mail (gegebenenfalls natürlich mit einer Signatur gefüllt). Dieser fügen Sie nun mit einem Klick auf den Ribbon-Eintrag Textbaustein auswählen|Textbaustein 2 <\/b>einen Textbaustein hinzu. Und es funktioniert, wie Bild 16 zeigt.<\/p>\n Bild 16: Einfügen eines Textbausteins per Ribbon-Befehl<\/span><\/b><\/p>\n Ob die Funktion die Textbausteine vor einen bestehenden Text setzt, also etwa vor eine Signatur oder den zitierten Text der E-Mail, auf die Sie antworten, prüfen wir auch gleich, indem wir direkt noch einen der Einträge des Menüs aufrufen. Und auch dies gelingt.<\/p>\n Nun kommt der Praxistest: Wir antworten auf eine beliebige Mail im Posteingang. Auch dies gelingt: Das menu<\/b>-Element Textbaustein auswählen <\/b>erscheint und der Text wird eingefügt. Wenn die beantwortete Mail jedoch im HTML-Format vorliegt, gibt es ein Problem. Bevor wir den Textbaustein einfügen, sieht die E-Mail wie in Bild 17 aus.<\/p>\n Bild 17: E-Mail im HTML-Format vor dem Einfügen eines Textbausteins …<\/span><\/b><\/p>\n Danach ändert sich das Aussehen jedoch radikal: Die Formatierungen und Bilder verschwinden, weil Outlook den Inhalt der Antwort in reinen Text umgewandelt hat (s. Bild 18). Wenn Sie die ursprüngliche Mail des Kunden so verhunzen, brauchen Sie sich nicht zu wundern, wenn dieser etwas ungehalten reagiert …<\/p>\n Bild 18: … und nach dem Einfügen.<\/span><\/b><\/p>\n Also müssen wir wohl vor dem Einfügen der Antwort prüfen, ob es sich um eine HTML-E-Mail oder um Plain Text handelt, und entsprechend reagieren.<\/p>\n Da wir dazu etwas mit den Eigenschaften des MailItem<\/b>-Objekts experimentieren müssen, nutzen wir einmal die Debugging-Funktionen von Visual Studio und setzen dort vor dem nächsten Start einen Haltepunkt in der Prozedur OnAction<\/b>. Wenn Sie nun den Debugger starten, in Outlook auf eine E-Mail im HTML-Format antworten und dann auf einen der Menüeinträge zum Hinzufügen eines Textbausteins klicken, erhalten Sie etwa das Bild aus Bild 19.<\/p>\n Bild 19: Debuggen beim Beantworten einer E-Mail<\/span><\/b><\/p>\n Hier schauen wir uns unten im Bereich Lokal <\/b>(zu aktivieren mit Strg+Alt+V, L <\/b>€“ also erst Strg+Alt+V <\/b>und dann L<\/b>) das Objekt objMail <\/b>an und suchen die Eigenschaft, die Aufschluss über das verwendete Format gibt. Dabei handelt es sich um die Eigenschaft BodyFormat<\/b>, das hier den Wert 2 <\/b>aufweist.<\/p>\n Wenn Sie solche Werte wie im VBA-Editor per Direktfenster abfragen wollen, betätigen Sie die Tastenkombination Strg+Alt+I <\/b>und geben dort die gewünschten Ausdrücke ein €“ zum Beispiel diesen:<\/p>\n Interessant ist auch die Ermittlung des bei der Erstellung der Mail verwendeten E-Mail-Editors. Diesen ermitteln Sie mit der Eigenschaft EditorType <\/b>des Inspector<\/b>-Objekts (wie Sie diesen referenzieren, erläutern wir gleich):<\/p>\n Bei einigen Experimenten stellte sich schnell heraus, dass dies immer den Wert 4 <\/b>(olEditorWord<\/b>) zurückgibt. Es scheint also gar keine Rolle zu spielen, welchen Wert Sie in den Outlook-Optionen aus Bild 20 für das Nachrichtenformat eingestellt haben. In unserem Fall war als Format Nur-Text <\/b>eingestellt. Beim Erstellen einer neuen Nachricht legen Sie zwar reine Textnachrichten an, aber dies geschieht dennoch im Word-Editor. Und wenn Sie auf eine Nachricht im HTML- oder Rich-Text-Format antworten, geschieht dies zwar im entsprechenden Format €“ den Word-Editor verwenden Sie aber dennoch.<\/p>\n Bild 20: Einstellung des Formats beim Verfassen von E-Mails<\/span><\/b><\/p>\n Dies machen wir uns zunutze: Während wir bei Antworten auf Nur-Text-Mails einfach die Antwort als Wert der Eigenschaft objMail.Body <\/b>einfügen können, ist das etwa für HTML-Nachrichten nicht so einfach möglich. Dort enthält die HTMLBody<\/b>-Eigenschaft ja auch noch die ganzen HTML-Auszeichnungen. Wenn wir dort, wie oben geschehen, einfach einen Text vorn anfügen, verwirft Outlook das jeweilige Format und zeigt alles im Nur-Text-Format an.<\/p>\n Aber wenn wir schon den Word-Editor nutzen, können wir uns doch gleich das in den vorherigen Kapiteln erworbene Wissen über das Objektmodell von Word und den Zugriff auf die Inhalte eines Word-Dokuments zunutze machen!<\/p>\n Also fügen wir zunächst einen Verweis auf die Word-Bibliothek zum Projekt hinzu. Dazu wählen Sie den Menüeintrag Projekt|Verweis hinzufügen… <\/b>aus. Hier wechseln Sie zum Bereich COM <\/b>und geben dann rechts oben den Suchbegriff Word <\/b>ein. Damit ist die Menge der Suchergebnisse so weit eingeschränkt, dass wir den Eintrag Microsoft Word 14.0 Object Library <\/b>leicht finden und hinzufügen können.<\/p>\n Mit der Word-Bibliothek fügt Visual Studio gegebenenfalls auch gleich die Office-Bibliothek mit hinzu (beim ersten Erstellen der Beispiele war dies der Fall, beim zweiten Versuch nicht mehr). Dies führt allerdings zu einigen Fehlermeldungen, wie Bild 21 zeigt.<\/p>\n Bild 21: Die automatisch hinzugefügte Office-Bibliothek sorgt für Fehlermeldungen.<\/span><\/b><\/p>\n Also entfernen Sie den Verweis auf die Bibliothek Microsoft Office x.0 Object Library <\/b>gleich wieder. Dies können Sie gleich in der übersicht der Verweise erledigen, indem Sie den zu entfernenden Eintrag markieren und dann auf Entfernen <\/b>klicken. Im gleichen Zuge sollten auch die Fehlermeldungen wieder verschwinden.<\/p>\n Nun können wir etwa über den Ausdruck Microsoft.Office.Interop.Word.Document <\/b>auf ein Document<\/b>-Objekt zugreifen. Dies verkürzen wir etwas, indem wir der Klasse oben die folgende Anweisung hinzufügen:<\/p>\n Damit können wir nun vereinfacht etwa über Word.Document <\/b>auf ein Document<\/b>-Objekt zugreifen. Und damit schlagen wir gleich mehrere Fliegen mit einer Klappe: Dies gelingt nämlich auch mit reinen Textnachrichten. Also brauchen wir gar nicht erst eine Fallunterscheidung nach Editor und\/oder Nachrichtenformat zu integrieren, sondern greifen direkt auf die Nachricht über den Word-Editor zu. Die neue Version der Prozedur onAction<\/b> haben wir drastisch gekürzt:<\/p>\n Sie ruft nur noch die folgende Prozedur aus Listing 4 auf und übergibt den Namen des Ribbon-Steuerelements.<\/p>\n Listing 4: Neue Prozedur zum Einfügen des Textbausteins<\/span><\/b><\/p>\n Die Prozedur ermittelt wieder per Select Case<\/b>-Bedingung den einzusetzenden Textbaustein. Dann ermittelt sie einen Verweis auf das aktuelle Inspector<\/b>-Fenster und referenziert das darin angezeigte Word-Dokument über die WordEditor<\/b>-Eigenschaft.<\/p>\n Schließlich fügt sie den Textbaustein aus strTextbaustein<\/b> vorn in der Nachricht ein. Wie Bild 22 zeigt, funktioniert dies reibungslos.<\/p>\n Bild 22: Erfolgreiches Einfügen eines einfachen Textes in eine Antwort auf eine HTML-E-Mail<\/span><\/b><\/p>\n Kontextmenü per Ribbon-Definition ändern<\/b><\/p>\n Nun wollen wir aber nicht das Ribbon, sondern das Kontextmenü dieses Elements ändern €“ und zwar jenes, das beim Klick mit der rechten Maustaste in den Mailtext angezeigt wird.<\/p>\n Wird beim Anzeigen eines Kontextmenüs auch immer das Ereignis GetCustomUI <\/b>ausgelöst Ein kurzer Test belegt, dass dies nicht der Fall ist. Wir müssen das Kontextmenü also wohl schon beim Ã\u0192-ffnen des Mail-Fensters definieren, was aber auch kein Problem ist.<\/p>\n Wir wissen nur noch nicht, welche Elemente zur Umgestaltung des Kontextmenüs nötig sind. Das ist auch nicht so einfach zu ermitteln, denn die idMso<\/b>-Werte für die Kontextmenüs finden sich nicht in den Excel-Tabellen, die alle anderen Ribbon-Elemente auflisten.<\/p>\n Also haben wir etwas im Internet gestöbert und haben schließlich herausgefunden, dass die idMso <\/b>für das Kontextmenü des Fensters zum Bearbeiten von Mails ContextMenuText <\/b>heißt. Damit lässt sich unsere Ribbon-Definition wie in Listing 5 erweitern.<\/p>\n Listing 5: Ribbon-Definition mit Kontextmenü<\/span><\/b><\/p>\n Die Ribbon-Definition kann verschiedene Kontextmenüs aufnehmen, daher finden Sie hier noch ein Element namens contextMenus <\/b>vor. Dieses enthält für jedes Kontextmenü ein contextMenu<\/b>-Element. Darunter haben wir ein menu<\/b>-Element angelegt, da es ja durchaus einmal mehrere Einträge für die einzelnen Textbausteine werden können. Darunter folgenden dann die eigentlichen Einträge in Form von button<\/b>-Elementen. Wir haben also grundsätzlich den gleichen Aufbau wie im Ribbon. Der Unterschied ist, dass wir die Eigenschaft id <\/b>der Elemente jeweils um das Präfix ctx <\/b>(für ContextMenu<\/b>) ergänzt haben.<\/p>\n Deshalb brauchten wir auch die Prozedur TextbausteinEinfuegen<\/b>, welche die Textbausteine entsprechend der übergebenen Steuerelement-ID einfügt, nur um je einen Parameter in den Case<\/b>-Zweigen der Select Case<\/b>-Bedingung zu erweitern:<\/p>\n Das Kontextmenü sieht nun wie in Bild 23 aus.<\/p>\n Bild 23: Einfügen eines Textbausteins per Kontextmenü<\/span><\/b><\/p>\n Kundennamen und Textbausteine aus der Datenbank einlesen<\/b><\/p>\n Nun wird es Zeit, die Textbausteine dynamisch aus der Kundendatenbank einzulesen und beim Einfügen eines Textbausteins eventuelle Platzhalter wie [Vorname] <\/b>oder [Nachname] <\/b>durch die Kundendaten aus der Datenbank zu ersetzen €“ und dies alles aufgrund der E-Mail-Adresse des Absenders der E-Mail.<\/p>\n Beginnen wir mit der Datenbank. Diese soll drei Tabellen enthalten:<\/p>\n Aufbau der Tabellen<\/b><\/p>\n Bild 24 zeigt die beiden Tabellen tblKunden <\/b>und tblAnreden <\/b>mit ein paar Beispiel-da-ten-sätzen.<\/p>\n Bild 24: Die beiden Tabellen mit den Kundendaten<\/span><\/b><\/p>\n Die Tabelle mit den Textbausteinen sieht etwa so wie in Bild 25 aus. Das Feld Textbaustein <\/b>enthält in diesem Fall komplette E-Mail-Texte. Sie können natürlich auch einzelne Absätze in den Datensätzen der Tabelle speichern.<\/p>\n Bild 25: Tabelle mit Textbausteinen<\/span><\/b><\/p>\n Datenzugriff vorbereiten<\/b><\/p>\n Der Datenzugriff erfolgt nicht, wie für einen Access-Entwickler gewohnt, über die Elemente der DAO-Bibliothek, sondern über die entsprechenden Elemente von Visual Basic. In diesem Fall benötigen wir die folgende Bibliothek, die wir per Imports<\/b>-Anweisung einfach verfügbar machen:<\/p>\n Zusammenstellen der Ribbon- und Kontextmenü-Einträge aus der Datenbank<\/b><\/p>\n Nachdem wir bisher eine XML-Datei genutzt haben, die als Element des Projekts in einem eigenen Element namens Ribbon_Mail.xml<\/b> gespeichert war, wollen wir die Ribbon-Definition nun dynamisch zusammenstellen. Das heißt, dass wir zwar einen groben statischen Kern haben, aber auch ein paar Elemente, die wir aufgrund der Daten in der Tabelle tblTextbausteine <\/b>in der Datenbank Textbausteine.accdb <\/b>angelegt haben.<\/p>\n Deshalb bohren wir die Prozedur GetCustomUI<\/b> nun komplett auf. Da diese etwas umfangreicher ist, haben wir einige Markierungen im Quellcode untergebracht, auf die wir in den folgenden Abschnitten verweisen. Die Prozedur wird wie zuvor aufgerufen und deklariert dann einige Variablen (s. Listing 6).<\/p>\n Listing 6: Neue Funktion zum Anzeigen der Ribbon-Menüs<\/span><\/b><\/p>\n Gleich zu Beginn prüft die Prozedur, welches Fenster gerade überhaupt geöffnet ist. Der erste Case-Zweig der Select Case-Bedingung wird nur angesteuert, wenn es sich um das Fenster zum Erstellen einer neuen Mail handelt [1].<\/p>\n Die Variable strConnection <\/b>legt dann die Verbindungszeichenfolge fest, in diesem Fall für die Datenbank, die am angegebenen Speicherort untergebracht ist. Den Platzhalter Private Sub <\/span>ThisAddIn_Startup() Handles Me.Startup\r\n MsgBox<\/span>(\"Startup\")\r\nEnd Sub<\/span><\/pre>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_003.png\")
<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_002.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_004.png\")
<\/p>\nPublic Function <\/span>GetCustomUI(ByVal ribbonID As String<\/span>) _\r\n As String<\/span> Implements _\r\n Office.IRibbonExtensibility.GetCustomUI\r\n Return GetResourceText( _\r\n \"Textbausteine2010.Ribbon_Mail.xml\")\r\nEnd Function<\/span><\/pre>\n![\"Der](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_005.png\")
<\/p>\n<xml version=\"1.0\" encoding=\"UTF-8\">\r\n<customUI ... onLoad=\"Ribbon_Load\">\r\n <ribbon>\r\n <tabs>\r\n <tab idMso=\"TabAddIns\">\r\n <group id=\"MyGroup\" label=\"My Group\">\r\n <\/group>\r\n <\/tab>\r\n <\/tabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n
![\"Aktivieren](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_018.png\")
<\/p>\nProtected Overrides Function _\r\n CreateRibbonExtensibilityObject() As <\/span>_\r\n Microsoft.Office.Core.IRibbonExtensibility\r\n Return New<\/span> Ribbon_Mail()\r\nEnd Function<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_007.png\")
<\/p>\nPublic Function <\/span>GetCustomUI(ByVal ribbonID As String<\/span>) As String<\/span> Implements Office.IRibbonExtensibility.GetCustomUI\r\n MsgBox<\/span>(ribbonID)\r\n Return GetResourceText(\"Textbausteine2010.Ribbon_Mail.xml\")\r\nEnd Function<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_008.png\")
<\/p>\nSelect Case ribbonID\r\n Case <\/span>\"Microsoft.Outlook.Mail.Compose\"\r\n Return GetResourceText( _\r\n \"Textbausteine2010.Ribbon_Mail.xml\")\r\nEnd Select<\/span><\/pre>\n![\"Ribbon-Definition](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_009.png\")
<\/p>\n<xml version=\"1.0\" encoding=\"UTF-8\">\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\" loadImage=\"loadImage\">\r\n <ribbon>\r\n <tabs>\r\n <tab idMso=\"TabInsert\">\r\n <group id=\"grpEinfuegen\" label=\"Textbausteine\" insertAfterMso=\"GroupInclude\">\r\n <menu label=\"Textbaustein auswählen\" id=\"mnuTextbausteine\" size=\"large\" image=\"text_32\">\r\n <button label=\"Textbaustein 1\" id=\"btnTextbaustein1\" onAction=\"onAction\" image=\"text_16\"\/>\r\n <button label=\"Textbaustein 2\" id=\"btnTextbaustein2\" onAction=\"onAction\" image=\"text_16\"\/>\r\n <button label=\"Textbaustein 3\" id=\"btnTextbaustein3\" onAction=\"onAction\" image=\"text_16\"\/>\r\n <button label=\"Textbaustein 4\" id=\"btnTextbaustein4\" onAction=\"\"nAction\"\"image=\"text_16\"\/>\r\n <\/menu>\r\n <\/group>\r\n <\/tab>\r\n <\/tabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n
![\"Liste](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_196.png\")
<\/p>\n![\"Ermitteln](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_197.png\")
<\/p>\n![\"Hier](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_198.png\")
<\/p>\n<menu label=\"Textbaustein auswählen\" id=\"mnuTextbausteine\" size=\"large\" image=\"text_32\"><\/pre>\n
<button label=\"Textbaustein 1\" id=\"btnTextbaustein1\" onAction=\"onAction\" image=\"text_16\"\/><\/pre>\n
Sub OnAction(control As <\/span>Office.IRibbonControl)\r\n Dim <\/span>objMail As <\/span>Outlook.MailItem\r\n Select Case control.Id\r\n Case <\/span>\"btnTextbaustein1\"\r\n objMail = Globals.ThisAddIn.Application.ActiveInspector().CurrentItem()\r\n objMail.Body = \"Dies ist der Textbaustein mit der Nummer 1.\" & objMail.Body\r\n Case <\/span>\"btnTextbaustein2\"\r\n objMail = Globals.ThisAddIn.Application.ActiveInspector().CurrentItem()\r\n objMail.Body = \"Dies ist der Textbaustein mit der Nummer 2.\" & objMail.Body\r\n Case <\/span>\"btnTextbaustein3\"\r\n objMail = Globals.ThisAddIn.Application.ActiveInspector().CurrentItem()\r\n objMail.Body = \"Dies ist der Textbaustein mit der Nummer 3.\" & objMail.Body\r\n Case <\/span>\"btnTextbaustein4\"\r\n objMail = Globals.ThisAddIn.Application.ActiveInspector().CurrentItem()\r\n objMail.Body = \"Dies ist der Textbaustein mit der Nummer 4.\" & objMail.Body\r\n End Select<\/span>\r\n End Sub<\/pre>\n![\"Aufrufen](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_010.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_011.png\")
<\/p>\n<customUI ... loadImage=\"loadImage\"><\/pre>\n
Public Function <\/span>LoadImage(imageId As String<\/span>) As <\/span>Bitmap\r\n Dim <\/span>objResourceManager As <\/span>Resources.ResourceManager\r\n Dim <\/span>objImage As <\/span>Image\r\n objResourceManager = My.Resources.ResourceManager\r\n objImage = objResourceManager.GetObject(imageId)\r\n Return New<\/span> Bitmap(objImage)\r\nEnd Function<\/span><\/pre>\nImports System.Drawing<\/pre>\n
![\"Neues](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_012.png\")
<\/p>\n![\"Einfügen](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_013.png\")
<\/p>\n![\"E-Mail](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_014.png\")
<\/p>\n![\"...](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_015.png\")
<\/p>\n![\"Debuggen](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_016.png\")
<\/p>\n objMail.BodyFormat<\/pre>\n
objInspector.EditorType<\/pre>\n
![\"Einstellung](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_017.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_212.png\")
<\/p>\nImports Word = Microsoft.Office.Interop.Word<\/pre>\n
Sub OnAction(control As <\/span>Office.IRibbonControl)\r\n TextbausteinEinfuegen(control.Id)\r\n End Sub<\/pre>\nSub <\/span>TextbausteinEinfuegen(strEintrag As String<\/span>)\r\n Dim <\/span>objInspector As <\/span>Outlook.Inspector\r\n Dim <\/span>objDocument As <\/span>Word.Document\r\n Dim <\/span>objSelection As <\/span>Word.Selection\r\n Dim <\/span>strTextbaustein As String<\/span> = \"\"\r\n Select Case strEintrag\r\n Case <\/span>\"btnTextbaustein1\"\r\n strTextbaustein = \"Dies ist der Textbaustein mit der Nummer 1.\"\r\n Case <\/span>\"btnTextbaustein2\"\r\n strTextbaustein = \"Dies ist der Textbaustein mit der Nummer 2.\"\r\n Case <\/span>\"btnTextbaustein3\"\r\n strTextbaustein = \"Dies ist der Textbaustein mit der Nummer 3.\"\r\n Case <\/span>\"btnTextbaustein4\"\r\n strTextbaustein = \"Dies ist der Textbaustein mit der Nummer 4.\"\r\n End Select<\/span>\r\n objInspector = Globals.ThisAddIn.Application.ActiveInspector()\r\n objDocument = objInspector.WordEditor\r\n objSelection = objDocument.Application.Selection\r\n objSelection.InsertBefore(strTextbaustein)\r\nEnd Sub<\/span><\/pre>\n![\"Erfolgreiches](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_019.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\" loadImage=\"loadImage\">\r\n <ribbon>\r\n ...\r\n <\/ribbon>\r\n <contextMenus>\r\n <contextMenu idMso=\"ContextMenuText\">\r\n <menu image=\"text_16\" label=\"Textbausteine\" id=\"ctxmnuTextbausteine\">\r\n <button label=\"Textbaustein 1\" id=\"ctxbtnTextbaustein1\" \r\n onAction=\"onAction\" image=\"text_16_add\"\/>\r\n <button label=\"Textbaustein 2\" id=\"ctxbtnTextbaustein2\" \r\n onAction=\"onAction\" image=\"text_16_add\"\/>\r\n <button label=\"Textbaustein 3\" id=\"ctxbtnTextbaustein3\" \r\n onAction=\"onAction\" image=\"text_16_add\"\/>\r\n <button label=\"Textbaustein 4\" id=\"ctxbtnTextbaustein4\" \r\n onAction=\"onAction\" image=\"text_16_add\"\/>\r\n <\/menu>\r\n <\/contextMenu>\r\n <\/contextMenus>\r\n<\/customUI><\/pre>\n
Sub TextbausteinEinfuegen(strEintrag As String<\/span>)\r\n ...\r\n Select Case strEintrag\r\n Case <\/span>\"btnTextbaustein1\", \"ctxbtnTextbaustein1\"\r\n strTextbaustein = _\r\n \"Dies ist der Textbaustein mit der Nummer 1.\"\r\n ...\r\n End Select<\/span>\r\n ...\r\n End Sub<\/pre>\n![\"Einfügen](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_020.png\")
<\/p>\n\n
![\"Die](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_021.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2015_03\/pic_986_022.png\")
<\/p>\nImports System.Data.OleDb<\/pre>\n
Public Function <\/span>GetCustomUI(ByVal ribbonID As String<\/span>) As String<\/span> Implements Office.IRibbonExtensibility.GetCustomUI\r\n Dim <\/span>strRibbon As String<\/span> = \"\", strConnection As String<\/span> = \"\"\r\n Dim <\/span>objConnection As <\/span>OleDbConnection, objDataReader As <\/span>OleDbDataReader, objOleDbCommand As <\/span>OleDbCommand\r\n Dim <\/span>strSQL As String<\/span> = \"\", strButtons As String<\/span> = \"\", strContextbuttons As String<\/span> = \"\"\r\n Select Case ribbonID\r\n Case \"Microsoft.Outlook.Mail.Compose\"\r\n strConnection = \"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=<Datenbankpfad>\\Kundendatenbank.accdb\"\r\n objConnection = New<\/span> OleDbConnection\r\n objConnection.ConnectionString = strConnection\r\n objConnection.Open()\r\n strSQL = \"SELECT * FROM tblTextbausteine\"\r\n objOleDbCommand = New<\/span> OleDbCommand(strSQL, objConnection)\r\n objDataReader = objOleDbCommand.ExecuteReader\r\n While objDataReader.Read()\r\n strButtons = strButtons & \" <button label=\"\"\" & objDataReader(\"Bezeichnung\") _\r\n & \"\"\" id=\"\"btnTextbaustein\" & objDataReader(\"TextbausteinID\") & \"\"\" onAction=\"\"onAction\"\" \" _\r\n & \"image=\"\"text_16_add\"\" tag=\"\"\" & objDataReader(\"TextbausteinID\") & \"\"\"\/>\"\r\n strContextbuttons = strContextbuttons & \" <button label=\"\"\" _\r\n & objDataReader(\"Bezeichnung\") & \"\"\" id=\"\"ctxbtnTextbaustein\" & objDataReader(\"TextbausteinID\") _\r\n & \"\"\" onAction=\"\"onAction\"\" image=\"\"text_16_add\"\" tag=\"\"\" _\r\n & objDataReader(\"TextbausteinID\") & \"\"\"\/>\"\r\n End While\r\n strRibbon = \"<xml version=\"\"1.0\"\" encoding=\"\"UTF-8\"\">\"\r\n strRibbon = strRibbon & \"<customUI xmlns=\"\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\"\"\" _\r\n & \" onLoad=\"\"Ribbon_Load\"\" loadImage=\"\"loadImage\"\">\"\r\n strRibbon = strRibbon & \" <ribbon>\"\r\n strRibbon = strRibbon & \" <tabs>\"\r\n strRibbon = strRibbon & \" <tab idMso=\"\"TabInsert\"\">\"\r\n strRibbon = strRibbon & \" <group id=\"\"grpEinfuegen\"\" \" _\r\n & \"label=\"\"Textbausteine\"\" insertAfterMso=\"\"GroupInclude\"\">\"\r\n strRibbon = strRibbon & \" <menu label=\"\"Textbaustein \" _\r\n & \"auswählen\"\" id=\"\"mnuTextbausteine\"\" size=\"\"large\"\" image=\"\"text_32\"\">\"\r\n strRibbon = strRibbon & strButtons\r\n strRibbon = strRibbon & \" <\/menu>\"\r\n strRibbon = strRibbon & \" <\/group>\"\r\n strRibbon = strRibbon & \" <\/tab>\"\r\n strRibbon = strRibbon & \" <\/tabs>\"\r\n strRibbon = strRibbon & \" <\/ribbon>\"\r\n strRibbon = strRibbon & \" <contextMenus>\"\r\n strRibbon = strRibbon & \" <contextMenu idMso=\"\"ContextMenuText\"\">\"\r\n strRibbon = strRibbon & \" <menu image=\"\"text_16\"\" \" _\r\n & \"label=\"\"Textbausteine\"\" id=\"\"ctxmnuTextbausteine\"\">\"\r\n strRibbon = strRibbon & strContextbuttons\r\n strRibbon = strRibbon & \" <\/menu>\"\r\n strRibbon = strRibbon & \" <\/contextMenu>\"\r\n strRibbon = strRibbon & \" <\/contextMenus>\"\r\n strRibbon = strRibbon & \"<\/customUI>\"\r\n Return strRibbon\r\n Case Else<\/span>\r\n Return \"\"\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\n