<\/p>\n
Ein großer Teil der Kommunikation mit Kunden läuft per E-Mail. Das ist vor allem dann der Fall, wenn der Kunde ein Anliegen per E-Mail vorbringt. Manchmal muss man den Kunden aber auch aus anderen Gründen kontaktieren – beispielsweise weil eine Lieferung per Post zurückgekommen ist. Wollen Sie dann die Kundenverwaltung öffnen, die E-Mail-Adresse des Kunden ermitteln, nach Outlook wechseln, dort eine neue E-Mail an den Kunden anlegen und Ihre Nachricht samt Betreff von Hand eingeben Nein, denn die meisten Anfragen lassen sich leicht mit einer geeigneten Vorlage erledigen.<\/b><\/p>\n
Als Ausgangspunkt für die Lösung aus diesem Beitrag nehmen wir eine zurückgesendete Lieferung an einen Kunden (das war der konkrete Anlass für diesen Beitrag). In diesem Fall wollen wir dem Kunden eine Mitteilung schicken, dass eine Sendung zurückgeschickt wurde und ihn bitten, die beim Versand verwendete Adresse zu prüfen und gegebenenfalls zu korrigieren.<\/p>\n
Bisher habe ich dazu die Kundenverwaltung gestartet, dort das Kundenformular geöffnet und über das Suchfeld den Datensatz zu diesem Kunden ermittelt. Dann habe ich eine neue E-Mail in Outlook angelegt, die E-Mail-Adresse in das An-Feld eingetragen, eine Betreff zur E-Mail hinzugefügt und einen entsprechenden Text geschrieben.<\/p>\n
Dieser enthielt dann die beim Versand genutzte Adresse, die ich praktischerweise per Mausklick generieren kann und nur noch als Adressblock in die E-Mail zu kopieren brauche.<\/p>\n
Alles in allem eine Menge Schritte, die ich etwa bei einem Versand eines Magazins zwischen fünf und zehn Mal wiederholen muss. Für jemanden, der gern automatisierte Wege für Standardaufgaben entwickelt und nutzt, ist das eine wenig erfreuliche Aufgabe. Allerdings hat bisher auch die Motivation nicht gereicht, um hierfür eine Lösung zu programmieren – immerhin würde das doch noch etwas länger dauern als die manuelle Erstellung von fünf bis zehn individuellen Mails. Wenn es aber der Zufall so will, dass ich gerade Beiträge für Access im Unternehmen schreibe, lässt sich das prima kombinieren – ich habe eine praktische Lösung und kann diese auch noch an meine Leser weitergeben. Also: Ran ans Werk!<\/p>\n
Als Daten für die Anwendung nutzen wir eine Tabelle namens tblKunden<\/b>, die in der Datenblattansicht wie in Bild 1 aussieht und deren Anreden über ein Fremdschlüsselfeld namens AnredeID <\/b>aus der per 1:n-Beziehung verknüpften Tabelle tblAnreden <\/b>festgelegt werden.<\/p>\n
![\"Datenherkunft](\"..\/fileadmin\/_temp_\/2017_03\/pic_1088_001.png\")
<\/p>\n
Bild 1: Datenherkunft für die Lösung<\/span><\/b><\/p>\n Wir gehen an dieser Stelle davon aus, dass Sie ein Kundenformular verwenden, in dem Sie die Kundendaten eines bestimmten Kunden zügig über eine entsprechende Suchfunktion anzeigen können. Wir nutzen dazu die Suchfunktion aus dem Beitrag Flexible Suche in Formularen <\/b>(http:\/\/www.access-im-unternehmen.de\/965<\/b>) beziehungsweise Suchen mit der clsFlexSearch-Klasse <\/b>(http:\/\/www.access-im-unternehmen.de\/964<\/b>).<\/p>\n Falls Sie kein solches Formular verwenden, erstellen wir auf die Schnelle eines. Dazu legen Sie ein neues Formular namens frmKunde <\/b>an.<\/p>\n Diesem weisen Sie als Datenherkunft die Tabelle tblKunden <\/b>zu. Ziehen Sie alle Felder aus der Feldliste in den Detailbereich der Entwurfsansicht (s. Bild 2).<\/p>\n Bild 2: Entwurf des Kundenformulars<\/span><\/b><\/p>\n Außerdem fügen Sie die Klasse clsFlexSearch <\/b>aus der Beispieldatenbank zu obigem Beitrag (oder aus der Datenbank zu diesem Beitrag) in das VBA-Projekt Ihrer Lösung.<\/p>\n Daneben benötigen wir noch eine Abfrage namens qryKundensuche<\/b>, welche die Felder der beiden Tabellen tblKunden <\/b>und tblAnreden <\/b>so zusammenführt, dass alle Felder der Tabelle tblKunden <\/b>(außer AnredeID<\/b>) und nur das Feld Anrede <\/b>der Tabelle tblAnreden <\/b>zurückgegeben werden (s. Bild 3).<\/p>\n Bild 3: Abfrage als Datenherkunft für die Suchfunktion<\/span><\/b><\/p>\n Nun fügen Sie dem Kundenformular ganz oben ein Textfeld namens txtSuche <\/b>hinzu. Schließlich legen Sie für die Ereignisprozedur Beim Laden <\/b>des Formulars den Wert [Ereignisprozedur] <\/b>an und klicken auf die Schaltfläche rechts daneben, um die entsprechende Prozedur zu erstellen. Diese füllen Sie dann wie folgt:<\/p>\n Dies erstellt ein Objekt auf Basis der Klasse clsFlexSearch <\/b>und teilt dieser mit, dass es qryKundensuche <\/b>als Grundlage für die Suche nutzen soll, dass KundeID <\/b>das Primärschlüsselfeld ist und dass dieses nicht in die Suche eingeschlossen werden soll.<\/p>\n Außerdem wird das Textfeld txtSuche <\/b>als Suchfeld festgelegt. objFlexSearch <\/b>müssen Sie natürlich im gleichen Formular deklarieren, und zwar wie folgt im Kopf des Moduls:<\/p>\n Danach legen Sie noch eine Ereignisprozedur für das Ereignis Beim Entladen <\/b>an, die nur die Objektvariable objFlexSearch <\/b>leert:<\/p>\n Schließlich definieren Sie, was geschehen soll, wenn der Benutzer einen Suchausdruck in das Textfeld txtSuche <\/b>eingegeben hat und dann die Eingabetaste betätigt. Dazu wählen Sie aus dem linken Kombinationsfeld oben im VBA-Fenster des Klassenmoduls Form_frmKunde <\/b>den Eintrag objFlexSearch <\/b>aus, was automatisch die leere Ereignisprozedur objFlexSearch_Suchen <\/b>anlegt. Diese füllen Sie dann wie folgt:<\/p>\n Dadurch wird der Filter des Formulars auf einen Ausdruck eingestellt, der mit dem Wert des Parameters strWhere <\/b>der Prozedur geliefert wird.<\/p>\n Wenn Sie das Kundenformular nun öffnen, können Sie die Feldnamen eingeben, die direkt entsprechend ergänzt werden. Ein Klick auf Tab <\/b>vervollständigt das Suchfeld und trägt einen Doppelpunkt ein, hinter dem Sie den Vergleichswert eintragen. Mehrere Ausdrücke können Sie mit And <\/b>voneinander trennen. Sie können aber auch einfach einen Wert wie andre@minhorst.com <\/b>eingeben, dann werden alle Felder aller Datensätze nach diesem Wert untersucht (s. Bild 4).<\/p>\n Bild 4: Suchfunktion im Einsatz<\/span><\/b><\/p>\n Nun benötigen wir eine Tabelle, mit der wir die Vorlagen für die E-Mails verwalten können. Diese Tabelle soll schlicht tblMailvorlagen <\/b>heißen und sieht im Entwurf wie in Bild 5 aus. Das Feld Bezeichnung <\/b>haben wir mit einem eindeutigen Index versehen. Die Felder Betreff<\/b>, Inhalt <\/b>und EMail <\/b>nehmen die Vorlagen für die entsprechenden Texte auf. Hier können Sie Gebrauch von Platzhaltern machen, die später aus den Daten der Kundentabelle gefüllt werden – mehr dazu weiter unten in der Beschreibung der Nutzung des Formulars, das diese Daten anzeigt.<\/p>\n Bild 5: Die Tabelle tblMailvorlagen<\/span><\/b><\/p>\n Wichtig sind noch die beiden Felder TabelleAbfrage <\/b>und PKFeld<\/b>. TabelleAbfrage <\/b>nimmt den Namen der Tabelle oder Abfrage auf, welche die Daten für den Kunden liefern soll, PKFeld <\/b>den Namen des in dieser Tabelle oder Abfrage zur Identifizierung des Kunden notwendigen Primärschlüsselfeldes.<\/p>\n Die Daten dieser Tabellen wollen wir in einem separaten Formular bearbeiten. Dieses heißt frmMailvorlagen <\/b>und sieht in der Entwurfsansicht wie in Bild 6 aus. Damit es die Daten der Tabelle tblMailvorlagen<\/b> in alphabetischer Reihenfolge liefert, verwenden wir den folgenden SQL-Ausdruck als Datenherkunft für das Formular:<\/p>\n Bild 6: Das Formular frmMailvorlagen in der Entwurfsansicht<\/span><\/b><\/p>\n Allerdings soll das Formular ja ohnehin nur die Details eines Datensatzes anzeigen, daher stellen wir die Eigenschaften Bildlaufleisten<\/b>, Datensatzmarkierer <\/b>und Navigationsschaltflächen <\/b>auf den Wert Nein <\/b>und Automatisch zentrieren <\/b>auf Ja <\/b>ein. Wieso dann die Datensätze nach dem Alphabet sortieren Ganz einfach: Weil auch das Kombinationsfeld cboAuswahl <\/b>seine Daten aus der Tabelle tblMailvorlagen <\/b>bezieht und beide den gleichen Datensatz anzeigen sollen. Hier bietet es sich einfach an, die Mailvorlage zu liefern, deren Bezeichnung in der alphabetischen Sortierung als erste erscheint.<\/p>\n Das Kombinationsfeld benötigt nur die beiden Felder MailvorlageID <\/b>und Bezeichnung<\/b>, daher verwenden wir eine verkürzte Version der Abfrage, die wir als Datenherkunft für das Formular genutzt haben, als Datensatzherkunft:<\/p>\n Das Formular zeigt ja nun bereits automatisch den ersten Datensatz nach alphabetischer Reihenfolge an. Damit das Kombinationsfeld den gleichen Datensatz anzeigt, fügen wir dem Formular für das Ereignis Beim Laden <\/b>die folgende Ereignisprozedur hinzu:<\/p>\n Diese wählt den gleichen Eintrag aus, der auch im Formular angezeigt wird.<\/p>\n Damit nach der Auswahl eines der Einträge des Kombinationsfeldes die gewählte Mailvorlage im Formular angezeigt wird, legen Sie für das Ereignis Nach Aktualisierung <\/b>des Kombinationsfeldes die folgende Ereignisprozedur an:<\/p>\n Dies filtert das Formular nach dem im Kombinationsfeld ausgewählten Eintrag.<\/p>\n Damit beim Klick auf die Schaltfläche cmdNeu <\/b>ein neuer, leerer Datensatz im Formular erscheint, hinterlegen wir für das Beim Klicken<\/b>-Ereignis der Schaltfläche diese Prozedur:<\/p>\n Damit erscheint ein neuer, leerer Datensatz. Dieser ist natürlich noch nicht in der Datensatzherkunft des Kombinationsfeldes enthalten.<\/p>\n Daher legen wir die folgende Prozedur an, die in diesem Fall den Wert des Kombinationsfeldes auf den Wert Null <\/b>einstellt (im Falle eines Wechsels zu einem anderen Datensatz wird dieser auch im Kombinationsfeld angezeigt):<\/p>\n <\/p>\n Das Aktualisieren der Datensatzherkunft des Kombinationsfeldes dient dazu, den neu angelegten Datensatz direkt nach dem Wechsel zu einem anderen Datensatz in das Kombinationsfeld aufzunehmen.<\/p>\n Fehlt noch die Schaltfläche zum Schließen des Formulars:<\/p>\n In Aktion sieht das Formular nun wie in Bild 7 aus. Für das Feld Bezeichnung<\/b> geben Sie eine sinnvolle Bezeichnung an, unter der Sie die Mailvorlage schnell finden. Das Feld Tabelle\/Abfrage<\/b> soll die Datenquelle aufnehmen, aus der die Daten für die Platzhalter in den nachfolgenden Eigenschaften der Mailvorlage entnommen werden sollen. Wir geben hier die Abfrage qryKunden <\/b>an, welche die Felder der Tabellen tblKunden <\/b>und tblAnreden <\/b>wie in Bild 8 zusammenführt.<\/p>\n Bild 7: Die Abfrage qryKunden dient als Datenquelle für das Ersetzen der Platzhalter<\/span><\/b><\/p>\n Bild 8: Das Formular frmMailvorlagen in der Formularansicht<\/span><\/b><\/p>\n Das Feld E-Mail <\/b>statten Sie mit dem Namen des Feldes der Datenherkunft aus, welche die E-Mail-Adresse des Kunden liefert, in diesem Fall schlicht EMail<\/b>. Betreff<\/b> füllen Sie mit dem gewünschten Betreff der E-Mail. In diesem Fall benötigen wir keinen Platzhalter. Das Feld Inhalt <\/b>jedoch enthält einen Platzhalter für das Feld Briefanrede <\/b>der Tabelle tblAnreden <\/b>und Nachname <\/b>aus der Tabelle tblKunden<\/b>. Das ist noch verständlich. Aber was geschieht mit dem folgenden Platzhalter, der ja offensichtlich keinem Feld der Datenherkunft entspricht<\/p>\n Hierbei handelt es sich nicht um einen normalen Platzhalter, sondern um eine VBA-Funktion, die den Text bereitstellt, der für den Platzhalter eingesetzt werden soll. Wenn Sie den Beitrag Dynamischer Adressblock <\/b>(www.access-im-unternehmen.de\/1090<\/b>) bereits gelesen haben, kennen Sie die hier verwendete Funktion Adressblock<\/b> bereits: Sie ermittelt aufgrund der Konfiguration in der Konfigurationstabelle tblKonfiguration <\/b>einen Adressblock mit den Daten des Kunden.<\/p>\n Sie erwartet drei Parameter: Der erste gibt an, ob man die Liefer- oder die Rechnungsadresse holen will (hier 0 <\/b>für die Lieferadresse), die zweite, welche Konfiguration der Tabelle tblKonfigurationen<\/b> genutzt werden soll, und die dritte enthält den Primärschlüsselwert für den Kundendatensatz, der die Daten liefert. (Hinweis: Im Beitrag Dynamischer Adressblock <\/b>haben wir als ersten Parameter noch die Konstante Lieferadresse <\/b>verwendet. Das funktioniert hier leider nicht, daher verwenden wir den entsprechenden Zahlenwert der Enumeration – den Grund erfahren Sie gleich.)<\/p>\n Die hier in eckigen Klammern angegebene Funktion Adressblock <\/b>enthält mit [KundeID] <\/b>wiederum einen Platzhalter. Dieser wird in der Prozedur, die wir weiter unten beschreiben, zuerst mit dem entsprechenden Wert der Datenherkunft gefüllt. Dann erst wird die Funktion ausgeführt, um den einzusetzenden Wert zu liefern.<\/p>\n Damit kommen wir zum Formular, mit dem der Benutzer die Vorlage auswählt, die Texte mit und ohne Platzhalter präsentiert bekommt und schließlich die E-Mail erstellt.<\/p>\n Zuvor müssen wir allerdings noch dem Formular frmKunde <\/b>eine Schaltfläche zum öffnen dieses Formulars hinzufügen. Dieses legen Sie wie in Bild 9 an. Die durch diese Schaltfläche ausgelöste Prozedur sieht so aus:<\/p>\n Bild 9: Schaltfläche zum Verschicken einer Mail an den Kunden<\/span><\/b><\/p>\n Sie öffnet also das Formular frmMailNachVorlage <\/b>und übergibt mit dem öffnungsargument den Wert des Primärschlüsselfeldes des aktuellen Datensatzes.<\/p>\n Der Entwurf des Formulars frmMailNachVorlage<\/b> sieht wie in Bild 10 aus. Das Formular enthält ein Listenfeld namens lstVorlage<\/b>, mit dem Sie die gewünschte Vorlage auswählen können. Als Datensatzherkunft dient die folgende Abfrage:<\/p>\n Bild 10: Entwurf des Formulars frmMailNachVorlage<\/span><\/b><\/p>\n Damit das Listenfeld nur die Bezeichnungen anzeigt, stellen Sie die Eigenschaft Spaltenanzahl <\/b>auf 2 <\/b>und die Eigenschaft Spaltenbreiten <\/b>auf 0cm <\/b>ein.<\/p>\n Die übrigen Felder sind sämtlich ungebundene Textfelder mit den folgenden Namen (von oben nach unten):<\/p>\n Für die beiden großen Textfelder txtInhaltVorlage <\/b>und txtInhalt <\/b>stellen Sie die Eigenschaft Bildlaufleisten<\/b> auf Vertikal <\/b>ein.<\/p>\n Nach dem öffnen des Formulars zeigt zunächst nur das Listenfeld seine Daten an, die übrigen Felder sind leer. Wenn der Benutzer einen der Einträge des Listenfeldes auswählt, kommt Bewegung in die Sache: Dann lädt das Formular nämlich zunächst die Daten zur ausgewählten Mailvorlage in die drei Textfelder txtEMailVorlage<\/b>, txtBetreffVorlage <\/b>und txtInhaltVorlage<\/b>. Danach treten weitere Automatismen auf den Plan und tragen die Texte der drei Textfelder mit gefüllten Platzhaltern in die unteren drei Textfelder txtEMail<\/b>, txtBetreff <\/b>und txtInhalt <\/b>ein.<\/p>\n Dafür sorgt initial die Prozedur, die durch das Ereignis Beim Klicken<\/b> des Listenfeldes ausgelöst wird (s. Listing 1). Die Prozedur liest zunächst den Namen der Tabelle oder Abfrage aus dem Feld TabelleAbfrage <\/b>der Tabelle tblMailvorlagen <\/b>ein und speichert ihn in der Variablen strTabelleAbfrage<\/b>.<\/p>\n Listing 1: Aktionen beim Klick auf einen der Einträge des Listenfeldes lstVorlagen<\/span><\/b><\/p>\n Gleiches geschieht mit dem Feld PKFeld<\/b>, dessen Inhalt in der Variablen strPKFeld <\/b>landet. Den Wert des Primärschlüsselfeldes des Datensatzes der angegebenen Tabelle bekommen wir ja beim öffnen des Formulars mit dem öffnungsargument, das wir mit Me.OpenArgs <\/b>abfragen und in die Variable lngID <\/b>eintragen. Danach liest die Prozedur die drei Werte für die ersten drei Felder mit den Vorlagen aus den Feldern EMail<\/b>, Betreff <\/b>und Inhalt <\/b>der Tabelle tblMailvorlagen <\/b>ein.<\/p>\n Danach geht es mit den unteren drei Textfeldern weiter. Dabei verwenden wir die Funktion PlatzhalterErsetzen<\/b>, der wir den Text mit den Platzhaltern, die Datenquelle, den Namen des Primärschlüsselfeldes der Datenquelle und den Wert des Primärschlüsselfeldes übergeben.<\/p>\n Diese Funktion sieht wie in Listing 2 aus. Sie erwartet drei Parameter:<\/p>\n Listing 2: Die Funktion PlatzhalterErsetzen<\/span><\/b><\/p>\n Die Tabelle erstellt nun ein Recordset auf Basis der mit strTabelleAbfrage <\/b>gelieferten Tabelle oder Abfrage, die nach dem Wert lngID <\/b>im Feld aus strPK <\/b>gefiltert ist. Dann trägt sie den Wert des Parameters strVorlage <\/b>in die Variable strTemp <\/b>ein. Anschließend durchläuft sie in einer For Each<\/b>-Schleife alle Felder des Recordsets rst<\/b>, also des Datensatzes der Tabelle oder Abfrage, welche die Platzhalter-Daten liefert. Hier ersetzt sie in strTemp<\/b> einen Ausdruck, der aus dem in eckigen Klammern eingefassten aktuellen Feldnamen besteht, durch den Wert dieses Feldes.<\/p>\n Danach prüft die Funktion, ob es in strTemp <\/b>die Zeichenkette [= <\/b>gibt, was darauf hindeutet, dass es dort statt eines statischen Platzhalters eine auszuführende Funktion gibt, deren Ergebnis den Platzhalter ersetzen soll. Ist dies der Fall, speichert die Funktion die Position dieses Ausdrucks in der Variablen lngStart<\/b>. Wurde eine solche Zeichenkette gefunden, ist lngStart <\/b>größer als 0<\/b>, was dazu führt, dass die folgende Do While<\/b>-Schleife zum ersten Mal ausgeführt wird. Hier sucht die Funktion nun nach der ersten schließenden eckigen Klammer hinter der Zeichenkette [=<\/b>. Die Variable strFunktion<\/b> nimmt dann die Zeichenkette auf, die zwischen [= <\/b>und ] <\/b>liegt, in unserem Beispiel also etwa Adressblock(0, 5, 1)<\/b> aus [=Adressblock(0, 5, 1)]<\/b>. Die letzte Zahl 1 <\/b>ist bereits der ersetzte Platzhalter [KundeID]<\/b>.<\/p>\n Der Funktionsaufruf wird nun als Parameter an die Eval<\/b>-Funktion übergeben, die das Ergebnis der Funktion an die Variable strErgebnis <\/b>zurückliefert.<\/p>\n Damit können Sie auch selbst definierte Funktionen als Platzhalter einsetzen und sich damit ein sehr mächtiges Werkzeug schaffen.<\/p>\n Das Ergebnis der Funktion wird nun an Stelle des Platzhalters, der aus der öffnenden eckigen Klammer, dem Gleichheitszeichen, dem Funktionsnamen samt Parametern und der schließenden eckigen Klammer besteht, eingesetzt.<\/p>\n Die Variable lngStart <\/b>erhält nun die Position der nächsten Zeichenkette, die mit [= <\/b>beginnt. Ist diese ungleich 0<\/b>, beginnt der Schleifendurchlauf von vorn und es werden weitere Funktionen aufgerufen. Anderenfalls erhält der Rückgabewert der Funktion den Inhalt der Variablen strTemp<\/b>.<\/p>\n Auf diese Weise werden nun die drei Felder EMail<\/b>, Betreff <\/b>und Inhalt <\/b>des Formulars gefüllt, das nun wie in Bild 11 aussieht. Die Platzhalter in den Vorlagentexten wurden durch die entsprechenden Texte aus der Datenbank ersetzt, sodass nun nur noch ein Klick auf die Schaltfläche Mail erstellen <\/b>nötig ist.<\/p>\n Bild 11: Formular mit Vorlage und Inhalten mit gefüllten Platzhaltern<\/span><\/b><\/p>\n Dies löst wiederum die Prozedur aus Listing 3 aus. Die Prozedur verwendet Outlook, um die E-Mail zu erstellen. Daher müssen Sie zuvor noch einen Verweis auf die Bibliothek Microsoft Outlook x.0 Object Library <\/b>hinzufügen (VBA-Editor, Menüeintrag Extras|Verweise<\/b>).<\/p>\n Listing 3: Die Prozedur zum Erstellen einer E-Mail auf Basis der Daten aus dem Formular<\/span><\/b><\/p>\n Die Prozedur erstellt eine neue Instanz des Objekts Outlook.Application <\/b>und referenziert diese mit der Variablen objOutlook<\/b>. Dann erstellt sie mit der CreateItem<\/b>-Methode und dem Parameter olMailItem <\/b>eine neue Mail. Diese erhält für die Eigenschaften To<\/b>, Subject <\/b>und Body <\/b>die Werte der drei Textfelder txtEMail<\/b>, txtBetreff <\/b>und txtInhalt<\/b>. Anschließend zeigt die Display<\/b>-Methode mit dem Parameter True <\/b>die neue E-Mail als modalen Dialog an, der nur noch durch einen Klick auf die Senden<\/b>-Schaltfläche abgeschickt werden muss.<\/p>\n Wenn Sie die E-Mail nicht mehr kontrollieren wollen, was ja prinzipiell nicht nötig ist, denn es werden ja genau die Texte aus dem Formular verwendet, können Sie hier auch gleich die Send<\/b>-Methode statt der Display<\/b>-Methode verwenden.<\/p>\n Das Resultet sehen Sie in Bild 12 – die E-Mail ist erstellt und zum Versand bereit.<\/p>\n Bild 12: Per Datenbank erstellte E-Mail<\/span><\/b><\/p>\n Das Bearbeiten der Vorlage im Formular frmMailNachVorlage <\/b>ist nicht vorgesehen. Der Benutzer ist sich unter Umständen nicht bewusst, dass diese änderungen dauerhaft sind. Stattdessen haben wir eine Ereignisprozedur zum Formular hinzugefügt, die dafür sorgt, dass bei einem Doppelklick auf einen Eintrag des Listenfeldes das Formular frmMailvorlagen <\/b>geöffnet wird und den angeklickten Eintrag der Tabelle tblMailvorlagen <\/b>anzeigt.<\/p>\n Die Prozedur finden Sie in Listing 4. Sie prüft, ob im Listenfeld überhaupt ein Eintrag markiert ist, und öffnet in diesem Fall das Formular mit der DoCmd.OpenForm<\/b>-Methode. Dabei übergibt sie mit dem Parameter WhereCondition<\/b> eine Bedingung, die für die Anzeige des markierten Datensatzes sorgt. Falls der Benutzer doppelt auf einen leeren Bereich im Listenfeld klickt, wird eine entsprechende Meldung angezeigt.<\/p>\n Listing 4: Prozedur zum Anzeigen einer Vorlage nach Doppelklick auf einen Eintrag im Listenfeld<\/span><\/b><\/p>\n Das Formular frmMailNachVorlage <\/b>hat zwei größere Textfelder, welche die Inhalte von Memofeldern abbilden (txtInhaltVorlage <\/b>und txtInhalt<\/b>).<\/p>\n Mit den beiden Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>können wir leider nur eines der beiden Textfelder so einstellen, dass es beim Vergrößern des Formulars durch den Benutzer ebenfalls mit vergrößert wird. Dazu stellen wir beide Eigenschaften eines der beiden großen Textfelder auf Beide <\/b>ein.<\/p>\n Außerdem müssen wir die Eigenschaft Vertikaler Anker <\/b>für die Steuer-elemente, die unter dem entsprechenden Textfeld liegen, auf den Wert Unten <\/b>einstellen, damit diese beim Vergrößern des Formulars nach unten nicht vom automatisch mit vergrößerten Textfeld überdeckt werden.<\/p>\n Nun möchte der Benutzer aber vielleicht die Inhalte beider Textfelder, also txtVorlageInhalt <\/b>und txtInhalt<\/b>, in voller Pracht betrachten können. Nun: Gleichzeitig geht das nicht, aber durch den Einsatz zweier Ereignisprozeduren, die jeweils beim Fokuserhalt der beiden betroffenen Textfelder ausgelöst werden, können wir dies geschickt lösen.<\/p>\n Wir stellen also zunächst die Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>des Textfeldes txtInhaltVorlage <\/b>auf Beide <\/b>ein und die Eigenschaft Vertikaler Anker <\/b>der darunter liegenden Steuer-elemente auf den Wert Unten<\/b>.<\/p>\n Damit wird beim Vergrößern des Formulars nun das Textfeld txtInhaltVorlage <\/b>vergrößert, die darunter liegenden Steuer-elemente werden analog nach unten verschoben. Wenn der Benutzer nun nicht den vollständigen Inhalt von txtInhaltVorlage <\/b>ansehen will, sondern den von txtInhalt<\/b>, soll er dieses durch einfaches Anklicken vergrößern können.<\/p>\n Dazu legen Sie die beiden Ereignisprozeduren aus Listing 5 an. Die erste wird ausgelöst, wenn das Textfeld txtInhalt <\/b>den Fokus erhält. Es stellt die Eigenschaft Vertikaler Anker <\/b>(VerticalAnchor<\/b>) von txtInhaltVorlage <\/b>auf Oben <\/b>ein (acVerticalAnchorTop<\/b>) und die gleiche Eigenschaft von txtInhalt <\/b>auf acVerticalAnchorBoth<\/b>.<\/p>\n Listing 5: Diese Prozeduren vergrößern abwechselnd die großen Textfelder txtInhaltVorlage und txtInhalt.<\/span><\/b><\/p>\n Die zwischen den beiden Steuerelementen liegenden Textfelder txtBetreff <\/b>und txtEMail <\/b>erhalten für die Eigenschaft Ausgangspunkt<\/h2>\n
Kundenformular erstellen<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2017_03\/pic_1088_002.png\")
<\/p>\n![\"Abfrage](\"..\/fileadmin\/_temp_\/2017_03\/pic_1088_003.png\")
<\/p>\nSuchfeld hinzufügen<\/h2>\n
Private Sub <\/span>Form_Load()\r\n Set<\/span> objFlexSearch = New<\/span> clsFlexSearch\r\n With<\/span> objFlexSearch\r\n .Suchabfrage = \"qryKundensuche\"\r\n .PKFeld = \"KundeID\"\r\n .PKFeldEinschliessen = False<\/span>\r\n Set<\/span> .Suchfeld = Me!txtSuche\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nDim <\/span>WithEvents objFlexSearch As <\/span>clsFlexSearch<\/pre>\nPrivate Sub <\/span>Form_Unload(Cancel As Integer<\/span>)\r\n Set<\/span> objFlexSearch = Nothing\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objFlexSearch_Suchen(strWhere As String<\/span>)\r\n Me.Filter = strWhere\r\n Me.FilterOn = True<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Suchfunktion](\"..\/fileadmin\/_temp_\/2017_03\/pic_1088_004.png\")
<\/p>\nVorlagen verwalten<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2017_03\/pic_1088_005.png\")
<\/p>\nFormular zum Bearbeiten der Mailvorlagen<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2017_03\/pic_1088_006.png\")
<\/p>\nSELECT tblMailvorlagen.MailvorlageID, tblMailvorlagen.Bezeichnung, tblMailvorlagen.Betreff, tblMailvorlagen.Inhalt, tblMailvorlagen.EMail, tblMailvorlagen.TabelleAbfrage, tblMailvorlagen.PKFeld \r\nFROM tblMailvorlagen \r\nORDER BY tblMailvorlagen.Bezeichnung;<\/pre>\n
SELECT tblMailvorlagen.MailvorlageID, tblMailvorlagen.Bezeichnung FROM tblMailvorlagen \r\nORDER BY tblMailvorlagen.Bezeichnung;<\/pre>\n
Private Sub <\/span>Form_Load()\r\n Me!cboAuswahl = Me!MailvorlageID\r\nEnd Sub<\/span> <\/pre>\nPrivate Sub <\/span>cboAuswahl_AfterUpdate()\r\n Me.Filter = \"MailvorlageID = \" & Me!cboAuswahl\r\n Me.FilterOn = True<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdNeu_Click()\r\n DoCmd.GoToRecord Record:=acNewRec\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Current()\r\n Me!cboAuswahl.Requery\r\n Me!cboAuswahl = Me!MailvorlageID\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdOK_Click()\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\nVorlage anlegen<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2017_03\/pic_1088_008.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2017_03\/pic_1088_007.png\")
<\/p>\n[=Adressblock(0, 5, [KundeID])]<\/pre>\n
Formular zum Verschicken von Mails nach Vorlage<\/h2>\n
![\"Schaltfläche](\"..\/fileadmin\/_temp_\/2017_03\/pic_1088_009.png\")
<\/p>\nPrivate Sub <\/span>cmdMailNachVorlage_Click()\r\n If <\/span>Not<\/span> Nz(Me!KundeID) = 0 Then<\/span>\r\n DoCmd.OpenForm \"frmMailNachVorlage\", _\r\n OpenArgs:=Me!KundeID\r\n Else<\/span>\r\n MsgBox<\/span> \"Kein Kunde ausgewählt.\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2017_03\/pic_1088_010.png\")
<\/p>\nSELECT tblMailvorlagen.MailvorlageID, tblMailvorlagen.Bezeichnung \r\nFROM tblMailvorlagen \r\nORDER BY tblMailvorlagen.Bezeichnung;<\/pre>\n
\n
Vorlage auswählen<\/h2>\n
Private Sub <\/span>lstVorlagen_Click()\r\n Dim <\/span>strTabelleAbfrage As String<\/span>\r\n Dim <\/span>strPKFeld As String<\/span>\r\n Dim <\/span>lngID As String<\/span>\r\n strTabelleAbfrage = DLookup(\"TabelleAbfrage\", \"tblMailvorlagen\", \"MailvorlageID = \" & Me!lstVorlagen)\r\n strPKFeld = DLookup(\"PKFeld\", \"tblMailvorlagen\", \"MailvorlageID = \" & Me!lstVorlagen)\r\n lngID = Me.OpenArgs\r\n Me!txtEMailVorlage = DLookup(\"EMail\", \"tblMailvorlagen\", \"MailvorlageID = \" & Me!lstVorlagen)\r\n Me!txtBetreffVorlage = DLookup(\"Betreff\", \"tblMailvorlagen\", \"MailvorlageID = \" & Me!lstVorlagen)\r\n Me!txtInhaltVorlage = DLookup(\"Inhalt\", \"tblMailvorlagen\", \"MailvorlageID = \" & Me!lstVorlagen)\r\n Me!txtEMail = PlatzhalterErsetzen(Me!txtEMailVorlage, strTabelleAbfrage, strPKFeld, lngID)\r\n Me!txtBetreff = PlatzhalterErsetzen(Me!txtBetreffVorlage, strTabelleAbfrage, strPKFeld, lngID)\r\n Me!txtInhalt = PlatzhalterErsetzen(Me!txtInhaltVorlage, strTabelleAbfrage, strPKFeld, lngID)\r\nEnd Sub<\/span><\/pre>\nPrivate Function <\/span>PlatzhalterErsetzen(strVorlage As String<\/span>, strTabelleAbfrage As String<\/span>, strPK As String<\/span>, _\r\n lngID As Long<\/span>) As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strTemp As String<\/span>\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>lngStart As String<\/span>\r\n Dim <\/span>lngEnde As String<\/span>\r\n Dim <\/span>strFunktion As String<\/span>\r\n Dim <\/span>strErgebnis As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM \" & strTabelleAbfrage & \" WHERE \" & strPK & \" = \" & lngID, dbOpenDynaset)\r\n strTemp = strVorlage\r\n For Each fld In rst.Fields\r\n strTemp = Replace<\/span>(strTemp, \"[\" & fld.Name & \"]\", Nz(fld.Value, \"\"))\r\n Next<\/span> fld\r\n lngStart = InStr<\/span>(1, strTemp, \"[=\")\r\n Do While<\/span> Not<\/span> lngStart = 0\r\n lngEnde = InStr<\/span>(lngStart + 2, strTemp, \"]\")\r\n strFunktion = Mid<\/span>(strTemp, lngStart + 2, lngEnde - lngStart - 2)\r\n strErgebnis = Eval(strFunktion)\r\n strTemp = Replace<\/span>(strTemp, \"[=\" & strFunktion & \"]\", strErgebnis)\r\n lngStart = InStr<\/span>(lngStart + Len<\/span>(strErgebnis) + 1, strTemp, \"[=\")\r\n Loop<\/span>\r\n PlatzhalterErsetzen = strTemp\r\nEnd Function<\/span><\/pre>\n\n
![\"Formular](\"..\/fileadmin\/_temp_\/2017_03\/pic_1088_011.png\")
<\/p>\nMail nach Vorlage erstellen<\/h2>\n
Private Sub <\/span>cmdMailErstellen_Click()\r\n Dim <\/span>objOutlook As <\/span>Outlook.Application\r\n Dim <\/span>objMailItem As <\/span>Outlook.MailItem\r\n Set<\/span> objOutlook = New<\/span> Outlook.Application\r\n Set<\/span> objMailItem = objOutlook.CreateItem(olMailItem)\r\n With<\/span> objMailItem\r\n .To = Me!txtEMail\r\n .Subject = Me!txtBetreff\r\n .Body = Me!txtInhalt\r\n .Display True<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Per](\"..\/fileadmin\/_temp_\/2017_03\/pic_1088_012.png\")
<\/p>\nAnzeigen einer Vorlage zum Bearbeiten<\/h2>\n
Private Sub <\/span>lstVorlagen_DblClick(Cancel As Integer<\/span>)\r\n If <\/span>Not<\/span> IsNull(Me!lstVorlagen) Then<\/span>\r\n DoCmd.OpenForm \"frmMailvorlagen\", WhereCondition:=\"MailvorlageID = \" & Me!lstVorlagen, WindowMode:=acDialog\r\n Else<\/span>\r\n MsgBox<\/span> \"Keine Vorlage ausgewählt.\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nFormular benutzerfreundlich gestalten<\/h2>\n
Private Sub <\/span>txtInhalt_GotFocus()\r\n Me!txtInhaltVorlage.VerticalAnchor = acVerticalAnchorTop\r\n Me!txtInhalt.VerticalAnchor = acVerticalAnchorBoth\r\n Me!txtBetreff.VerticalAnchor = acVerticalAnchorTop\r\n Me!txtEMail.VerticalAnchor = acVerticalAnchorTop\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>txtInhaltVorlage_GotFocus()\r\n Me!txtInhaltVorlage.VerticalAnchor = acVerticalAnchorBoth\r\n Me!txtInhalt.VerticalAnchor = acVerticalAnchorBottom\r\n Me!txtBetreff.VerticalAnchor = acVerticalAnchorBottom\r\n Me!txtEMail.VerticalAnchor = acVerticalAnchorBottom\r\nEnd Sub<\/span><\/pre>\n