<\/p>\n
Eines der meistgefragten Themen im Office-Bereich ist immer wieder: Wie schaufle ich am einfachsten die Daten einer Access-Tabelle nach Word und fülle damit einen Serienbrief Sie können dazu natürlich einfach eine Abfrage mit den relevanten Daten vorbereiten und den Rest von Word aus mit den entsprechenden Werkzeugen der Benutzeroberfläche erledigen. Wenn Sie dem Nutzer aber wirklich Arbeit ersparen möchten, zwingen Sie ihn nicht, seine geliebte Access-Anwendung zu verlassen …<\/b><\/p>\n
In der Regel verläuft das Erstellen eines Dokuments für den Seriendruck so:<\/p>\n
Details wollen wir uns an dieser Stelle ersparen, Anleitungen für den üblichen Weg gibt es wie Sand am Meer.<\/p>\n
Optimaler Seriendruck mit Access und Word<\/b><\/p>\n
Wir haben uns gefragt, wie man dem Benutzer die Seriendruckerstellung eines Serienbriefs so einfach wie möglich machen kann. Tatsache ist, dass er um die folgenden drei Aufgaben nicht herumkommt:<\/p>\n
Der Seriendruck-Assistent<\/b><\/p>\n
Der Seriendruck-Assistent dieses Beitrags kann auf zweierlei Arten eingesetzt werden: Erstens können Sie ihn natürlich in eigene Anwendungen einbauen, wenn diese eine Funktion zum Erstellen von Serienbriefen mitliefern soll. Zweitens können Sie ihn als Access-Add-In in Access integrieren, sodass dieser in jeder beliebigen Anwendung zur Verfügung steht. Sie können dann also beispielsweise Ihre Adressverwaltung öffnen, die bis dato gar keine Seriendruckfunktion enthielt, und auf Basis beliebiger Tabellen oder Abfragen Serienbriefdokumente füllen.<\/p>\n
Add-In installieren<\/b><\/p>\n
Schauen wir uns zunächst an, wie der Serienbrief-Assistent als Add-In funktioniert. Sie müssen dazu zunächst die Datei aiuSeriendruck.mda <\/b>aus dem Download zu diesem Beitrag in ein beliebiges Verzeichnis kopieren. Dann starten Sie Access und öffnen eine Datenbank Ihrer Wahl. Unter Access 2007 finden Sie im Ribbon unter Datenbanktools|Datenbanktools|Add-Ins|Add-In-Manager <\/b>das Werkzeug, um Add-Ins zu installieren. Im Dialog Add-In-Manager <\/b>klicken Sie auf die Schaltfläche Hinzufügen… <\/b>(siehe Bild 1) und wählen im folgenden Datei öffnen<\/b>-Dialog die Datei aiuSeriendruck.mda <\/b>aus.<\/p>\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2010_02\/Serienbrief-web-images\/pic002.png\")
<\/p>\n
Bild 1: Hinzufügen eines Access-Add-Ins<\/span><\/b><\/p>\n Anschließend finden Sie unter Access 2007 in der Ribbon-Liste Add-Ins <\/b>einen neuen Eintrag namens aiuSeriendruck <\/b>(siehe Bild 2).<\/p>\n Bild 2: Aufrufen des Seriendruck-Assistenten <\/span><\/b><\/p>\n Unter Access 2003 und älter finden Sie die Möglichkeit zum Installieren und Aufrufen des Assistenten übrigens unter dem Menüeintrag Extras|Add-Ins<\/b>.<\/p>\n Vorbereitung<\/b><\/p>\n Bevor Sie den Seriendruck-Assistenten aufrufen, müssen Sie nur eine Voraussetzung schaffen: Sie benötigen eine Tabelle oder Abfrage, die alle zum Füllen des Seriendruck-Dokuments nötigen Daten enthält. Insbesondere gilt das für Tabellen, die Daten aus verknüpften Tabellen enthalten. Dies betrifft etwa den klassischen Fall der Anrede: Diese wird oft in einer Lookup-Tabelle namens tblAnreden <\/b>gespeichert, in der eigentlichen Adresstabelle <\/b>befindet sich dann ein Nachschlagefeld zur Auswahl der richtigen Anrede (siehe Bild 3). Die Tabelle tblAdressen <\/b>allein ist hier nicht als Datenquelle für den Seriendruck zu gebrauchen, da das Feld AnredeID <\/b>nur eine Zahl, aber keinen Ausdruck wie Herrn <\/b>oder Frau <\/b>enthält. Dem Seriendruck-Assistenten ist aber schon Genüge getan, wenn Sie die Daten der beiden Tabellen in einer einfachen Abfrage wie in Bild 4 zusammenfassen.<\/p>\n Bild 3: Typischer Fall einer Adressen- und einer Anreden-Tabelle<\/span><\/b><\/p>\n Bild 4: Diese Abfrage ist eine prima Datenquelle für einen Serienbrief.<\/span><\/b><\/p>\n Seriendruck durchführen<\/b><\/p>\n Nun kann es endlich losgehen: Starten Sie aiuSeriendruck <\/b>und schauen Sie sich das einzige Formular des Assistenten an, das wie in Bild 5 aussieht.<\/p>\n Bild 5: Der Serienbrief-Assistent<\/span><\/b><\/p>\n Im ersten Schritt des Assistenten wählen Sie die Datenquelle für den Seriendruck aus. Der Assistent bietet alle Tabellen und Abfragen in einer Auswahlliste an – lediglich eventuell zur Ansicht freigegebene Systemtabellen, die mit MSys… <\/b>beginnen, werden ausgeblendet (siehe Bild 6).<\/p>\n Bild 6: Auswahl der Datenquelle für den Serienbrief<\/span><\/b><\/p>\n Nach der Auswahl der Datenquelle geschieht etwas im Hintergrund: aiuSeriendruck <\/b>speichert die Daten der Datenquelle in einer temporären Tabelle, ergänzt diese um ein Feld zur manuellen Auswahl der Datensätze und zeigt diese im Bereich Schritt 2 <\/b>des Assistenten an (siehe Bild 7).<\/p>\n Bild 7: Auswahl der Datensätze, mit denen der Serienbrief gefüllt werden soll<\/span><\/b><\/p>\n Hier liefert aiuSeriendruck <\/b>deutlich mehr Möglichkeiten als die Seriendruck-Funktion von Word. Sie können Folgendes erledigen:<\/p>\n Außerdem können Sie mit der Optionsgruppe Anzeigen <\/b>festlegen, ob das Datenblatt alle Datensätze anzeigen soll oder nur die markierten oder nur die nicht markierten.<\/p>\n Word-Dokument vorbereiten<\/p>\n Nachdem der Benutzer die Daten für den Serienbrief mit den vorhandenen Hilfsmitteln vorbereitet hat, kann er sich dem Ausgangsdokument zuwenden. Hier gibt es zunächst drei Möglichkeiten, ein Dokument auszuwählen (siehe Bild 8). Diese drei sind über die folgenden Schaltflächen zu erreichen:<\/p>\n Bild 8: Auswahl einer Option zum Erstellen oder Öffnen eines Dokuments als Seriendruck-Vorlage<\/span><\/b><\/p>\n Nachdem Sie auf eine der drei Arten das gewünschte Dokument ausgewählt haben, sehen Sie dieses entweder schon vor sich (bei Betätigung der zweiten oder dritten Schaltfläche) oder Sie können das Dokument, dessen Dateiname nun im Textfeld Ausgangsdokument <\/b>angezeigt wird, mit einem Klick auf die Schaltfläche Bearbeiten <\/b>in Word öffnen.<\/p>\n Platzhalter einfügen<\/b><\/p>\n Für das nun geöffnete Word-Dokument gibt es eine ganz wichtige Regel: Sie müssen es mit dem Kontextmenüeintrag Alle Platzhalter gesetzt <\/b>wieder schließen.<\/p>\n Davon abgesehen brauchen Sie eigentlich nur die Einfügemarke an der Stelle zu positionieren, an der Sie einen Platzhalter einfügen möchten, mit der rechten Maustaste das Kontextmenü aufzurufen und den einzufügenden Platzhalter auszuwählen (siehe Bild 9).<\/p>\n Bild 9: Einfügen von Platzhaltern per Kontextmenü<\/span><\/b><\/p>\n Dort finden Sie nach getaner Arbeit auch den Eintrag Alle Platzhalter gesetzt<\/b>, mit dem die Arbeiten am Dokument beendet werden müssen.<\/p>\n Seriendruck starten<\/b><\/p>\n Nach getaner Arbeit brauchen Sie, wenn Sie möchten, nur noch ein Zieldokument für den Seriendruck auszuwählen. Dies erledigen Sie mit der Schaltfläche mit den drei Punkten (…). Der Name der per Datei speichern<\/b>-Dialog ermittelten Datei wird anschließend in das Textfeld Zieldatei <\/b>eingetragen. Mit einem Klick auf die Schaltfläche Seriendruck starten <\/b>stoßen Sie den Seriendruck schließlich an. Sollten Sie nicht vorab einen Speichernamen für die zu erstellende Datei angegeben haben, bleibt das erstellte Dokument einfach geöffnet, sodass Sie selbst das Speichern übernehmen können (siehe Bild 10).<\/p>\n Bild 10: Anstoßen des Seriendrucks<\/span><\/b><\/p>\n Als Ergebnis erhalten Sie je nach der Anzahl der ausgewählten Datensätze ein Dokument mit der entsprechenden Anzahl Seiten – fertig!<\/p>\n Technische Hintergründe<\/b><\/p>\n Die Beispielanwendung enthält einige interessante Techniken, die wir uns auf den folgenden Seiten ansehen werden. Beginnen wir mit dem Datenmodell der Datenbank: Das geht schnell, denn die Anwendung kommt als Add-In fast ohne Tabellen aus. Die einzige, die wir benötigen, wird temporär angelegt und mit der Auswahl einer neuen Datenquelle wieder gelöscht.<\/p>\n Nur für die Installation des Add-Ins ist die Tabelle USysRegInfo <\/b>interessant, die wie in Bild 11 aussieht und beim Installieren des Add-Ins entsprechend der obigen Beschreibung ausgelesen wird. Die erste Zeile gibt an, welche VBA-Funktion beim Anklicken des Menüeintrags unter Add-Ins <\/b>aufgerufen wird, die zweite Zeile den Namen der Add-In-Datei und die dritte den Text, der im Add-In-Manager angezeigt wird.<\/p>\n Bild 11: Diese Informationen werden zur Installation des Add-Ins benötigt.<\/span><\/b><\/p>\n Die Funktion Autostart() <\/b>öffnet schlicht und einfach das Hauptformular des Add-Ins:<\/p>\n Quelltabelle auswählen<\/b><\/p>\n Beim Öffnen des Formulars frmSerienbrief <\/b>löst das Ereignis Beim Öffnen <\/b>die folgende Ereignisprozedur aus. Diese weist der Datensatzherkunft des Kombinationsfeldes cboSourceObject <\/b>eine Abfrage zu, die alle als Datenquelle für den Seriendruck infrage kommenden Tabellen und Abfragen aus der Systemtabelle MSysObjects <\/b>ausliest. Die zweite Anweisung dieser Prozedur ruft die Routine SteuerelementAktualisieren <\/b>auf, die den Inhalt einiger Steuerelemente prüft und in Abhängigkeit davon andere Steuerelemente aktiviert oder deaktiviert (s. Listing 1).<\/p>\n Listing 1: Füllen der Datenquellen-Liste beim Öffnen des Formulars<\/p>\n Daten der Quelltabelle anzeigen<\/b><\/p>\n Wenn der Benutzer die Quelle für den Seriendruck ausgewählt hat, beginnt die Anwendung mit einer Menge Arbeit. Den Startschuss markiert das Auslösen der Ereignisprozedur cblSourceObject_AfterUpdate<\/b> (s. Listing 2). Diese leert als Erstes das Unterformularsteuerelement sfmAdressen<\/b>, das später die Daten anzeigen soll (nur für den Fall, dass zuvor schon eine andere Quelle ausgewählt wurde).<\/p>\n Listing 2: Anzeige der Daten der Quelltabelle <\/p>\n Nach einer Prüfung, ob tatsächlich ein Eintrag ausgewählt wurde, ruft die Prozedur eine weitere Prozedur namens TempTabelleErstellen <\/b>auf (s. Listing 3) und übergibt als einzigen Parameter den Namen der Quelltabelle oder -abfrage. Nachdem diese ihren Dienst verrichtet hat (mehr dazu weiter unten), liegt eine temporäre Tabelle namens tblSerienbrief_Temp <\/b>vor.<\/p>\n Listing 3: Anzeige der Daten der Quelltabelle <\/p>\n <\/p>\n Unterformularen kann man auch eine Tabelle oder Abfrage als Herkunftsobjekt zuweisen, man muss dann allerdings je nach Typ den Ausdruck Table.<Tabellenname> <\/b>beziehungsweise Query.<Tabellenname> <\/b>voranstellen. In unserem Fall ist dies einfach: Wir wissen, dass wir mit einer Tabelle namens tblSerienbrief_Temp <\/b>arbeiten, also lautet das neue Herkunftsobjekt Table.tblSerienbrief_Temp<\/b>.<\/p>\n Anschließend geschehen noch zwei wichtige Schritte: Die per Code in der Prozedur TempTabelleErstellen <\/b>erzeugte Tabelle besitzt unter anderem ein Ja\/Nein<\/b>-Feld, mit dem der Benutzer individuell auswählen soll, welche Datensätze beim Seriendruck berücksichtigt werden sollen. Dieses ist das letzte Feld der dynamisch erzeugten temporären Tabelle, soll aber als erste Spalte angezeigt werden, damit der Benutzer nicht unnötig scrollen muss. Dazu stellen wir die Eigenschaft ColumnIndex <\/b>dieses Feldes auf den Wert 0 <\/b>ein – alle anderen Felder rutschen so einen Platz weiter nach rechts. Außerdem zeigt Access die Daten in Datenblättern standardmäßig in Schriftgröße 11 an. Damit das Datenblatt zu den übrigen Steuerelementen passt, stellen wir diese mit der Eigenschaft DatasheetFontHeight <\/b>auf Schriftgröße 9 <\/b>ein (da wir mit einer Tabelle als Herkunftsobjekt des Unterformulars arbeiten, lässt sich dies nicht anderweitig festlegen). Schließlich ruft auch diese Prozedur die Routine SteuerelementeAktualisieren <\/b>auf.<\/p>\n Temporäre Tabelle erstellen<\/b><\/p>\n Das Erstellen der temporären Tabelle erfolgt in der Prozedur TempTabelleErstellen<\/b>, welche den Namen der ausgewählten Tabelle oder Abfrage als Parameter erwartet. Im ersten Schritt löscht diese Prozedur eine eventuell noch vorhandene Tabelle namens tblSerienbrief_Temp<\/b>, da diese gleich neu erstellt wird. Dies erledigt eine einfache SELECT INTO<\/b>-Abfrage, die eine neue Tabelle auf Basis der angegebenen Tabelle oder Abfrage erstellt. Wichtig ist hier, da wir das erste Mal in dieser Anwendung DAO-Elemente einsetzen, dass wir sowohl auf die Tabellen beziehungsweise Abfragen der Datenbank zugreifen, die das Add-In aufgerufen hat, als auch auf die in der Add-In-Datenbank erstellte Tabelle tblSerienbrief_Temp <\/b>zugreifen müssen. Dazu haben wir zwei kleine Funktionen namens dbc <\/b>und dbs <\/b>im Modul mdlDatabase <\/b>untergebracht, welche über die Eigenschaften CodeDB <\/b>und CurrentDB <\/b>den Verweis auf die jeweils benötigte Datenbank liefern und diesen für weitere Zugriffe zwischenspeichern:<\/p>\n Diese beiden Funktionen kommen gleich in der Prozedur TempTabelleErstellen <\/b>zum Einsatz. Die Tabelle wird zunächst über die Execute<\/b>-Methode des von der Funktion dbc <\/b>zurückgelieferten Verweises auf das Database<\/b>-Objekt des Add-Ins gelöscht. Die erneute Erstellung dieser Tabelle über die SELECT INSERT<\/b>-Abfrage verwendet gleich beide Database<\/b>-Objekte: Das erste führt die Abfrage aus, das andere liefert den Namen der Datenbank, aus der die Daten stammen.<\/p>\n Danach folgen noch ein paar Ergänzungen: So erhält die Tabelle tblSerienbrief_Temp <\/b>noch ein Ja\/Nein<\/b>-Feld namens Serienbrief<\/b>, das zum Auswählen der Datensätze für den Seriendruck dient. Dieses Feld erhält auch gleich für alle Datensätze den Wert True<\/b>. Und damit das Ja\/Nein<\/b>-Feld anschließend auch noch gut aussieht und der Benutzer die Datensätze über ein Kontrollkästchen statt der manuellen Eingabe der Werte 0 <\/b>und -1 <\/b>auswählen kann, legt die Prozedur noch eine Property <\/b>namens DisplayControl <\/b>an und weist ihr den Wert 106 <\/b>zu, was der Konstanten acCheckBox <\/b>und somit einem Kontrollkästchen entspricht.<\/p>\n Daten für den Seriendruck auswählen<\/b><\/p>\n Kommen wir zu Schritt 2 des Assistenten. Dort wählt der Benutzer mit einigen Hilfsmitteln des Add-Ins die Datensätze für den Seriendruck aus. Beginnen wir mit dem einfacheren Teil – der Optionsgruppe ogrAnzeige<\/b>. Diese löst nach der Aktualisierung die folgende Ereignisprozedur aus und stellt je nach der Auswahl des Benutzers den Filter des Unterformulars so ein, dass er entweder alle, alle markierten oder alle nicht markierten Datensätze anzeigt:<\/p>\n Die Schaltfläche cmdAlleAbwaehlen <\/b>soll alle Datensätze abwählen, also das Feld Serienbrief <\/b>für alle Datensätze auf False <\/b>einstellen. Die dazu verwendete UPDATE<\/b>-Abfrage wird wiederum über die Execute<\/b>-Methode des von der dbc<\/b>-Funktion gelieferten Database<\/b>-Objekts aufgerufen.<\/p>\n Anschließend aktualisiert die Requery<\/b>-Methode den Inhalt des Unterformulars:<\/p>\n Die Schaltfläche cmdAlleAuswaehlen <\/b>erledigt genau das Gegenteil: Sie stellt das Feld Serienbrief <\/b>nämlich für alle Datensätze auf True <\/b>ein. Die durch das Ereignis Beim Klicken <\/b>ausgelöste Prozedur sieht so aus:<\/p>\n Wie bereits weiter oben erwähnt, stehen dem Benutzer die Filter- und Sortiermöglichkeiten der Datenblattansicht zur Verfügung. Wenn er nun über verschiedene Filterkriterien der einzelnen Spalten die gewünschten Datensätze im Datenblatt zur Anzeige gebracht hat, möchte er diese Auswahl wahrscheinlich auch für die Weiterverwendung im Seriendruck nutzen. Dabei hilft die Schaltfläche cmdAuswahlMarkieren <\/b>weiter, welche das Feld Serienbrief <\/b>für alle aktuell angezeigten Datensätze auf True <\/b>einstellt. Die für die verschiedenen Spalten eingestellten Filterkriterien lassen sich leicht über die Eigenschaft Filter <\/b>des Form<\/b>-Objekts des Unterformular-Steuerelements auslesen und in Form einer WHERE<\/b>-Bedingung an eine UPDATE<\/b>-Anweisung anhängen, um die aktuell sichtbaren Datensätze anzupassen:<\/p>\n Genau das Gegenteil erledigt die Schaltfläche cmdMarkierteAbwaehlen<\/b>. Sie stellt das Feld Serienbrief <\/b>für alle Datensätze auf False <\/b>ein, die aktuell angezeigt werden:<\/p>\n Bei der Betrachtung dieser beiden Prozeduren ist wichtig, dass beide sich nicht auf die aktuell nicht angezeigten Datensätze auswirken! Wenn der Benutzer also mit den Filterkriterien Datensätze ausblendet, die schon für den Seriendruck ausgewählt wurden, dann werden diese durch einen Klick auf die Schaltfläche Ausgewählte abwählen <\/b>nicht aus der Auswahl herausgenommen.<\/p>\n Seriendruck-Ausgangsdokument vorbereiten<\/b><\/p>\n Nun entwickeln wir die verschiedenen Möglichkeiten, ein Ausgangsdokument für den Seriendruck auszuwählen. Die erste Variante ist die einfachste, da sie nur zur Auswahl dient und nicht gleich das Dokument zum Vorbereiten öffnet. Die Schaltfläche Ein bestehendes Dokument auswählen <\/b>löst folgende Ereignisprozedur aus:<\/p>\n Die Routine ruft lediglich die Funktion OpenFileName <\/b>auf, die einen Datei öffnen<\/b>-Dialog anzeigt und die Auswahl einer Datei erlaubt. Diese Funktion finden Sie im Modul mdlTools <\/b>der Add-In-Datenbank. Das Ergebnis dieser Funktion landet gleich im Textfeld txtDokument<\/b>.<\/p>\n Obligatorisch: Verweis auf die Word-Bibliothek<\/b><\/p>\n Wenn Sie mit Early Binding <\/b>arbeiten möchten, was sich zumindest für den Entwicklungsprozess anbietet, benötigen Sie für die folgenden Schritte einen Verweis auf die Bibliothek Microsoft Word x.0 Object Library<\/b>.<\/p>\n Leeres Dokument erstellen<\/b><\/p>\n Für die Prozedur, die durch einen Klick auf die Schaltfläche Leeres Dokument erstellen <\/b>ausgelöst wird, brauchen wir noch zwei modulweit gültige Variablen, welche die Verweise auf die noch zu öffnende Word-Instanz und das zu erstellende Dokument enthalten. Diese sehen so aus:<\/p>\n Das Anlegen eines neuen Dokuments ist scheinbar schnell erledigt, wie die folgende Prozedur zeigt. Allerdings steckt darin noch der unscheinbare Aufruf der Prozedur EditPopup<\/b>, die kurz gefasst für das Hinzufügen der Kontextmenüeinträge zum Einfügen der Platzhalter verantwortlich ist und weiter unten beschrieben wird:<\/p>\n Etwas komplizierter ist die Anzeige eines Dokuments auf Basis einer Dokumentvorlage. Sie verwendet die bereits bekannte Funktion OpenFileName<\/b>, um die Vorlage auszuwählen. Damit diese auch gleich den aktuell eingestellten Ordner für Dokumentvorlagen anzeigt, muss vorher bereits eine Word-Instanz erstellt werden. Die Option objWord.Options.DefaultFilePath(wdUserTemplatesPath) <\/b>liefert genau diesen Ordner. Falls der Benutzer eine Vorlage auswählt, wird diese gleich geöffnet – nicht, ohne gleich noch die oben erwähnten und im Anschluss beschriebenen Kontextmenü-Erweiterungen zu erstellen (s. Listing 4).<\/p>\n Listing 4: Erstellen eines neuen Dokuments auf Basis einer Dokumentvorlage<\/p>\n Bereits ausgewähltes Dokument bearbeiten<\/b><\/p>\n Ob Sie nun ein neues Dokument anlegen oder ein vorhandenes verwenden – Sie können in jedem Falle jederzeit änderungen am Dokument und damit auch an den darin verwendeten Platzhaltern vornehmen. Dafür sorgt die Schaltfläche Bearbeiten<\/b>, die das im Textfeld txtDokument <\/b>angegebene Dokument erneut öffnet und mithilfe der Prozedur EditPopup <\/b>die für das Einfügen von Platzhaltern notwendigen Kontextmenüeinträge anlegt:<\/p>\n Kontextmenüs in Word anpassen<\/p>\n Normalerweise ist das Anlegen oder ändern von Kontextmenüs, deren Einträge benutzerdefinierte Funktionen aufrufen sollen, kein Problem: Sie fügen über das CommandBars<\/b>-Objektmodell einfach die gewünschten Elemente hinzu und geben für die Eigenschaft OnAction <\/b>den Namen der Funktion an, die ausgelöst werden soll.<\/p>\n Wenn Sie aber von Access (oder einer anderen externen Anwendung) die Menüs von Word (oder einer anderen Office-Anwendung) anpassen und mit benutzerdefinierten Funktionen ausstatten möchten, die sich in der Anwendung befinden, welche die Kontextmenüs anpasst, müssen Sie ein wenig tiefer in die Tasche greifen.<\/p>\n Zunächst benötigen wir zwei Variablen, welche zwei Objekte auf Basis des gleichen Klassenmoduls deklarieren, das wir gleich erläutern werden:<\/p>\n Beide sind mit dem Schlüsselwort WithEvents <\/b>deklariert, was bedeutet, dass diese Ereignisse auslösen, auf die wir mit entsprechenden Ereignisprozeduren reagieren können.<\/p>\n Kontextmenüs in Word anpassen<\/b><\/p>\n Die oben bereits mehrfach erwähnte Prozedur EditPopup <\/b>hat nur eine einzige Aufgabe: Sie soll einigen Word-Kontextmenüs Einträge hinzufügen, und zwar je einen für jedes Feld der Datenquelle für den Seriendruck und noch einen zusätzlichen, mit dem der Benutzer das Vorbereiten des Seriendruckdokuments kontrolliert abschließen kann.<\/p>\n Für das Anlegen eines Kontextmenüeintrags für jedes Feld der Datenquelle verwenden wir ein Recordset<\/b>-Objekt, das auf dieser Datenquelle basiert (aber wegen des Kriteriums keine Datensätze liefert). Daraus entnimmt die Prozedur in einer For Each<\/b>-Schleife alle Feldnamen und legt die entsprechenden Kontextmenüeinträge an.<\/p>\n Es werden zwei Kontextmenüs erweitert, und zwar Text <\/b>und Table Text<\/b>. Für jedes Kontextmenü wird ein Objekt des Typs clsCommandbar <\/b>angelegt. Diesem weisen wir dann je eine Referenz auf das betroffene Kontextmenü und das geöffnete Word-Dokument zu und rufen dann für jedes Feld der Datenquelle je einmal die Methode AddCommandbarButton <\/b>mit dem in eckigen Klammern eingefassten Feldnamen auf.<\/p>\n Schließlich wird die Methode AddCommandbarButton <\/b>noch einmal für jedes der beiden betroffenen Kontextmenüs mit dem Wert Alle Platzhalter gesetzt <\/b>als Parameter aufgerufen (s. Listing 5).<\/p>\n Listing 5: Anlegen der Kontextmenüerweiterungen in Word<\/p>\n Name eines Kontextmenüs herausfinden<\/b><\/p>\n Das Bestücken der Kontextmenüs mit den Einträgen zum Einfügen der Platzhalter bringt ein Problem mit sich: Wie finde ich die Namen der betroffenen Kontextmenüs heraus, die beispielsweise beim Klick auf einen einfachen Absatz, in ein Textfeld oder in eine Tabelle angezeigt werden<\/p>\n Dabei handelt es sich nämlich mitnichten immer um die gleichen Kontextmenüs. <\/p>\n Wir haben folgenden Trick verwendet: <\/p>\n Die Prozedur KontextmenuenamenFinden <\/b>stellt zunächst das aktuelle Dokument als Ziel für änderungen etwa der Menüleisten ein. Hintergrund: Unter Word funktioniert der Parameter Temporary <\/b>der Add<\/b>-Methode des Commandbar<\/b>-Objekts nicht, der etwa unter Access dafür sorgt, dass von einer Anwendung angelegte Kontextmenüs nach dem Schließen wieder verschwinden.<\/p>\n Unter Word werden änderungen an den Menüs immer mit einem Dokument gespeichert, und das soll in diesem Fall das aktive Dokument sein. Anschließend durchläuft die Prozedur alle Kontextmenüs und fügt einen Eintrag hinzu, der den Ausdruck *NAME: <\/b>und den Namen des Kontextmenüs enthält:<\/p>\n Wenn Sie nun zum Word-Dokument wechseln und beispielsweise in einem normalen Absatz das Kontextmenü betätigen, finden Sie ganz unten einen Eintrag *NAME: Text <\/b>vor, was uns den Namen dieses Kontextmenüs liefert (siehe Bild 12).<\/p>\n Bild 12: Ermitteln des Namens eines Kontextmenüs unter Word<\/span><\/b><\/p>\n Kontextmenü-Klassen<\/p>\n Wir benötigen eine ganze Menge Kontextmenü-Erweiterungen, die fast alle die gleiche Funktion auslösen sollen – nämlich eine, die einen Platzhalter in das Word-Dokument einfügt.<\/p>\n Normalerweise schreibt man den Namen einer solchen Funktion einfach in die OnAction<\/b>-Eigenschaft, und die Funktion selbst landet in einem Standardmodul. Leider findet eine auf diese Weise in einer fremden Anwendung wie Word eingebaute Kontextmenü-Schaltfläche die in der Access-Anwendung untergebrachte Funktion nicht, sodass wir hier zu etwas aufwendigeren Mitteln greifen müssen. Um den Rahmen dieses Beitrags nicht zu sprengen, haben wir diese Technik in einem weiteren Beitrag namens Trojanische Kontextmenüs<\/b> (www.access-im-unternehmen.de\/713<\/b>) untergebracht.<\/p>\n In unserem Falle sind lediglich noch zwei Ereignisse interessant, die durch die Klassen zum Einbau der Schaltflächen in die Word-Kontextmenüs ausgelöst werden und wie folgt aussehen:<\/p>\n Diese Ereignisprozeduren (hier stellvertretend für das Kontextmenü Text<\/b>) liefern als Parameter den Wert der Vorlagendatei, die soeben bearbeitet wurde. Außerdem werden das bearbeitete Dokument und Word von Access aus kontrolliert geschlossen.<\/p>\n änderungen des Namens der Ausgangsdatei überwachen<\/b><\/p>\n Damit später keine Fehler passieren, falls der Benutzer versehentlich den Pfad und Namen einer nicht vorhandenen Datei eingibt oder das Textfeld Ausgangsdokument <\/b>gar komplett leer lässt, prüfen wir dies mit zwei Ereignisprozeduren, die nach Aktualisierung des Feldinhalts und nach jeder einzelnen änderung ausgelöst werden. Beide so ausgelösten Ereignisprozeduren rufen die Prozedur SeriendruckAktualisieren <\/b>auf:<\/p>\n Diese prüft schließlich mit der Dir<\/b>-Funktion, ob der aktuelle Inhalt des Textfeldes zu einer vorhandenen Datei führt.<\/p>\n Abhängig vom Ergebnis wird die Schaltfläche cmdSerienbriefErstellen <\/b>aktiviert oder deaktiviert, sodass kein Seriendruck gestartet werden kann, wenn keine gültige Ausgangsdatei vorliegt:<\/p>\n Zieldokument auswählen<\/b><\/p>\n Die Schaltfläche hinter dem Textfeld Zieldatei <\/b>ruft die folgende Ereignisprozedur auf, mit welcher der Benutzer das Verzeichnis und den Namen der zu speichernden Datei auswählen kann.<\/p>\n Als Dateiendung wird dabei die Dateiendung der als Ausgangsdokument verwendeten Datei eingesetzt:<\/p>\n Seriendruck starten<\/b><\/p>\n Schließlich können wir uns endlich dem Seriendruck selbst widmen. Den kompletten Ablauf zeigt Listing 6.<\/p>\n Listing 6: Durchführen des Seriendrucks<\/p>\n Die Routine erstellt zunächst eine neue Word-Instanz, öffnet das im Textfeld txtDokument <\/b>angegebene Ausgangsdokument und macht Word sichtbar, damit der Anwender sieht, was geschieht. Dann erstellt sie ein neues MailMerge<\/b>-Objekt.<\/p>\n Dieses kümmert sich um alle Belange rund um den Seriendruck. Damit dies reibungslos verläuft, stellen wir seine Eigenschaft MainDocumentType <\/b>auf wdFormLetters <\/b>ein und öffnen die Datenquelle für den Seriendruck mit der Methode OpenDataSource<\/b>.<\/p>\n Diese Methode erwartet eine Reihe Parameter:<\/p>\n Dann folgt der für einen Seriendruck untypische Vorgang: Unser Seriendruckdokument verfügt ja noch über keine der typischen Seriendruckfelder, sondern nur über Platzhalter der Form [<Feldname>]<\/b>. Die folgende For Each<\/b>-Schleife durchläuft alle Felder der Datenherkunft.<\/p>\n Dabei sucht sie jeweils nach dem Platzhalter für das aktuelle Feld und ersetzt diesen durch ein entsprechendes Seriendruckfeld, das den Namen des Quellfeldes erhält. Die Do While<\/b>-Schleife für die Suche nach dem jeweiligen Platzhaltertext stellt sicher, dass auch mehrere Vorkommen des gleichen Platzhalters durch Seriendruckfelder ersetzt werden.<\/p>\n Nach diesem Vorgang sorgt das Einstellen der Eigenschaft ViewMailMergeFieldCodes <\/b>auf den Wert True <\/b>dafür, dass die Seriendruckfelder sichtbar werden. Der Wert wdSendToNewDocument <\/b>für die Eigenschaft Destination <\/b>des MailMerge<\/b>-Objekts sorgt dafür, dass der Seriendruck in einem neuen Dokument landet.<\/p>\n Die Execute-Anweisung führt schließlich die Datensätze der Datenquelle und das Ausgangsdokument zu einem neuen Dokument zusammen. Wenn der Benutzer zuvor einen Dateinamen angegeben hat, unter dem das Seriendruckdokument gespeichert werden soll, wird das Dokument direkt gespeichert und geschlossen, anderenfalls wird dieses eingeblendet und der Benutzer erhält die Möglichkeit, das Dokument selbst zu speichern.<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Den aiuSeriendruck<\/b>-Assistenten können Sie in allen Datenbankanwendungen global einsetzen. Es fehlt noch eine Möglichkeit, die Konfiguration für einen Seriendruck zu speichern, doch dies würde den Rahmen dieses Beitrags sprengen.<\/p>\n Wenn Sie die Lösung nicht als Add-In, sondern als Teil einer anderen Anwendung einsetzen möchten, dann brauchen Sie eigentlich nur alle Elemente in diese Anwendung zu kopieren und an geeigneter Stelle den Aufruf des Formulars frmSerienbrief <\/b>zu integrieren.<\/p>\n Enthaltene Beispieldateien:<\/p>\n aiuSeriendruck.mda<\/p>\n![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2010_02\/Serienbrief-web-images\/pic003.png\")
<\/p>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2010_02\/Serienbrief-web-images\/pic004.png\")
<\/p>\n![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2010_02\/Serienbrief-web-images\/pic005.png\")
<\/p>\n![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2010_02\/Serienbrief-web-images\/pic001.png\")
<\/p>\n![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2010_02\/Serienbrief-web-images\/pic006.png\")
<\/p>\n![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2010_02\/Serienbrief-web-images\/pic007.png\")
<\/p>\n\n
![\"pic010.png\"](\"..\/fileadmin\/_temp_\/2010_02\/Serienbrief-web-images\/pic010.png\")
<\/p>\n\n
![\"pic009.png\"](\"..\/fileadmin\/_temp_\/2010_02\/Serienbrief-web-images\/pic009.png\")
<\/p>\n![\"pic011.png\"](\"..\/fileadmin\/_temp_\/2010_02\/Serienbrief-web-images\/pic011.png\")
<\/p>\n![\"pic012.png\"](\"..\/fileadmin\/_temp_\/2010_02\/Serienbrief-web-images\/pic012.png\")
<\/p>\nPublic Function Autostart()\r\n DoCmd.OpenForm "frmSerienbrief", WindowMode:=acDialog\r\nEnd Function<\/pre>\n
Private Sub Form_Open(Cancel As Integer)\r\n Me!cboSourceObject.RowSource = "SELECT Name FROM MSysObjects IN ''" & dbs.Name _\r\n & "'' WHERE (Type=1 Or Type=5) AND Name NOT LIKE ''MSys*'' AND Name NOT LIKE ''~*'' "\r\n SteuerelementeAktualisieren\r\nEnd Sub<\/pre>\n
Private Sub cboSourceObject_AfterUpdate()\r\n Me!sfmAdressen.SourceObject = ""\r\n If Not Len(Me!cboSourceObject) = 0 Then\r\n TempTabelleErstellen (Me!cboSourceObject)\r\n With Me!sfmAdressen\r\n .SourceObject = "Table.tblSerienbrief_Temp"\r\n .Form.Controls("Serienbrief").ColumnOrder = 0\r\n .Form.DatasheetFontHeight = 9\r\n End With\r\n End If\r\n Call SteuerelementeAktualisieren\r\nEnd Sub<\/pre>\nPublic Sub TempTabelleErstellen(strSource As String)\r\n Dim tdf As DAO.TableDef\r\n Dim fld As DAO.Field\r\n Dim prp As DAO.Property\r\n On Error Resume Next\r\n dbc.Execute "DROP TABLE tblSerienbrief_Temp", dbFailOnError\r\n On Error GoTo 0\r\n dbc.Execute "SELECT * INTO tblSerienbrief_Temp FROM " & strSource & " IN ''" & dbs.Name _\r\n & "''", dbFailOnError\r\n dbc.Execute "ALTER TABLE tblSerienbrief_Temp ADD Serienbrief BIT", dbFailOnError\r\n dbc.Execute "UPDATE tblSerienbrief_Temp SET Serienbrief = TRUE", dbFailOnError\r\n Set tdf = dbc.TableDefs("tblSerienbrief_Temp")\r\n Set fld = tdf.Fields("Serienbrief")\r\n Set prp = fld.CreateProperty("DisplayControl", DB_INTEGER, 106, True)\r\n On Error Resume Next\r\n fld.Properties.Delete "DisplayControl"\r\n On Error GoTo 0\r\n fld.Properties.Append prp\r\nEnd Sub<\/pre>\nDim m_dbc As DAO.Database\r\nDim m_dbs As DAO.Database\r\nPublic Function dbc() As Database\r\n If m_dbc Is Nothing Then\r\n Set m_dbc = CodeDb\r\n End If\r\n Set dbc = m_dbc\r\nEnd Function\r\nPublic Function dbs() As Database\r\n If m_dbs Is Nothing Then\r\n Set m_dbs = CurrentDb\r\n End If\r\n Set dbs = m_dbs\r\nEnd Function<\/pre>\n
Private Sub ogrAnzeige_AfterUpdate()\r\n Select Case Me!ogrAnzeige\r\n Case 1\r\n Me!sfmAdressen.Form.Filter = ""\r\n Me!sfmAdressen.Form.FilterOn = False\r\n Case 2\r\n Me!sfmAdressen.Form.Filter = _\r\n "Serienbrief = True"\r\n Me!sfmAdressen.Form.FilterOn = True\r\n Case 3\r\n Me!sfmAdressen.Form.Filter = _\r\n "Serienbrief = False"\r\n Me!sfmAdressen.Form.FilterOn = True\r\n End Select\r\nEnd Sub<\/pre>\n
Private Sub cmdAlleAbwaehlen_Click()\r\n dbc.Execute "UPDATE tblSerienbrief_Temp\r\n SET Serienbrief = False", dbFailOnError\r\n Me!sfmAdressen.Form.Requery\r\nEnd Sub<\/pre>\n
Private Sub cmdAlleAuswaehlen_Click()\r\n dbc.Execute "UPDATE tblSerienbrief_Temp\r\n SET Serienbrief = True", dbFailOnError\r\n Me!sfmAdressen.Form.Requery\r\nEnd Sub<\/pre>\n
Private Sub cmdAuswahlMarkieren_Click()\r\n Dim strFilter As String\r\n strFilter = Me!sfmAdressen.Form.Filter\r\n If Len(strFilter) > 0 Then\r\n strFilter = " WHERE " & strFilter\r\n End If\r\n dbc.Execute "UPDATE tblSerienbrief_Temp\r\n SET Serienbrief = True "\r\n & strFilter, dbFailOnError\r\n Me!sfmAdressen.Form.Requery\r\nEnd Sub<\/pre>\n
Private Sub cmdMarkierteAbwaehlen_Click()\r\n Dim strFilter As String\r\n strFilter = Me!sfmAdressen.Form.Filter\r\n If Len(strFilter) > 0 Then\r\n strFilter = " WHERE " & strFilter\r\n End If\r\n dbc.Execute "UPDATE tblSerienbrief_Temp\r\n SET Serienbrief = False " & strFilter,\r\n dbFailOnError\r\n Me!sfmAdressen.Form.Requery\r\nEnd Sub<\/pre>\n
Private Sub cmdDokumentAuswaehlen_Click()\r\n Me!txtDokument = OpenFileName(\r\n CurrentProject.Path, "Word-Dokument mit\r\n Platzhaltern auswählen", "Word-Dokument\r\n (*.doc, *.docx)")\r\nEnd Sub<\/pre>\n
Dim objWord As Word.Application\r\nDim objDocument As Word.Document<\/pre>\n
Private Sub cmdNeuesDokument_Click()\r\n Set objWord = _\r\n CreateObject("Word.Application")\r\n Set objDocument = objWord.Documents.Add()\r\n Call EditPopup\r\n objWord.Visible = True\r\n objWord.Activate\r\nEnd Sub<\/pre>\nPrivate Sub cmdNeuVonVorlage_Click()\r\n Dim strTemplate As String\r\n Set objWord = CreateObject("Word.Application")\r\n strTemplate = OpenFileName(objWord.Options.DefaultFilePath(wdUserTemplatesPath), _\r\n "Vorlage auswählen", "Word 2007 (*.dotx,*.dotm)|Word 2003 und älter (*.dot)")\r\n If Len(strTemplate) = 0 Then\r\n MsgBox "Sie haben keine Vorlage ausgewählt. Der Vorgang wird abgebrochen."\r\n objWord.Quit\r\n Set objWord = Nothing\r\n Exit Sub\r\n End If\r\n Set objDocument = objWord.Documents.Add(strTemplate)\r\n Call EditPopup\r\n objWord.Visible = True\r\n objWord.Activate\r\nEnd Sub<\/pre>\nPrivate Sub cmdBearbeiten_Click()\r\n If Len(Nz(Me.txtDokument)) = 0 Then\r\n Exit Sub\r\n End If\r\n Set objWord = _\r\n CreateObject("Word.Application")\r\n Set objDocument = GetObject(Me.txtDokument)\r\n Call EditPopup\r\n objWord.Visible = True\r\n objWord.Activate\r\nEnd Sub<\/pre>\nDim WithEvents objCommandbarText As clsCommandbar\r\nDim WithEvents objCommandbarTableText As clsCommandbar<\/pre>\n
Private Sub EditPopup()\r\n Dim rst As DAO.Recordset\r\n Dim fld As DAO.Field\r\n Set rst = dbc.OpenRecordset("SELECT * FROM tblSerienbrief_Temp WHERE 1=2")\r\n Set objCommandbarText = New clsCommandbar\r\n Set objCommandbarText.Commandbar = objWord.CommandBars("Text")\r\n Set objCommandbarText.Document = objDocument\r\n For Each fld In rst.Fields\r\n objCommandbarText.AddCommandbarButton "[" & fld.Name & "]"\r\n Next fld\r\n objCommandbarText.AddCommandbarButton "Alle Platzhalter gesetzt"\r\n Set objCommandbarTableText = New clsCommandbar\r\n Set objCommandbarTableText.Commandbar = objWord.CommandBars("Table Text")\r\n Set objCommandbarTableText.Document = objDocument\r\n For Each fld In rst.Fields\r\n objCommandbarTableText.AddCommandbarButton "[" & fld.Name & "]"\r\n Next fld\r\n objCommandbarTableText.AddCommandbarButton "Alle Platzhalter gesetzt"\r\nEnd Sub<\/pre>\n\n
Public Sub KontextmenuenamenFinden()\r\n Dim cbr As CommandBar\r\n Dim cbc As CommandBarControl\r\n Application.CustomizationContext = ThisDocument\r\n For Each cbr In CommandBars\r\n If cbr.Type = msoBarTypePopup Then\r\n On Error Resume Next\r\n Set cbc = cbr.Controls.Add(1)\r\n cbc.Caption = "*NAME: " & cbr.Name\r\n On Error GoTo 0\r\n End If\r\n Next cbr\r\nEnd Sub<\/pre>\n
![\"pic008.png\"](\"..\/fileadmin\/_temp_\/2010_02\/Serienbrief-web-images\/pic008.png\")
<\/p>\nPrivate Sub objCommandbarText_VorlageErstellt(strVorlage As String)\r\n On Error Resume Next\r\n Me!txtDokument = strVorlage\r\n Set objDocument = Nothing\r\n objWord.Quit\r\n Set objWord = Nothing\r\nEnd Sub<\/pre>\n
Private Sub txtDokument_AfterUpdate()\r\n Call SeriendruckAktualisieren\r\nEnd Sub\r\nPrivate Sub txtDokument_Change()\r\n Call SeriendruckAktualisieren\r\nEnd Sub<\/pre>\n
Private Sub SeriendruckAktualisieren()\r\n Dim strAusgangsdokument As String\r\n Dim bolAusgangsdokumentVorhanden As Boolean\r\n On Error Resume Next\r\n strAusgangsdokument = _\r\n Dir(Me!txtDokument.Text)\r\n On Error GoTo 0\r\n If Len(strAusgangsdokument) = 0 Then\r\n bolAusgangsdokumentVorhanden = False\r\n Else\r\n bolAusgangsdokumentVorhanden = True\r\n End If\r\n Me!cmdSerienbriefErstellen.Enabled = _\r\n bolAusgangsdokumentVorhanden\r\nEnd Sub<\/pre>\n
Private Sub cmdSaveAs_Click()\r\n Dim strExtension As String\r\n strExtension = Mid(Me!txtDokument, _\r\n InStrRev(Me!txtDokument, ".") + 1)\r\n Me!txtSerienbrief = _\r\n GetSaveFile(CurrentProject.Path, , _\r\n "Word-Dokument (*." & strExtension _\r\n & ")", "Speichern unter")\r\nEnd Sub<\/pre>\n
Private Sub cmdSerienbriefErstellen_Click()\r\n ''...Variablendeklaration\r\n Set objWord = CreateObject("Word.Application")\r\n Set objDocument = objWord.Documents.Open(Chr(34) & Me!txtDokument & Chr(34))\r\n objDocument.Application.Visible = True\r\n Set objMerge = objDocument.MailMerge\r\n strDatabase = dbc.Name\r\n strConnection = "DSN=Microsoft Access-Datenbank;DBQ=" & strDatabase & ";DriverId=25;\r\n FIL=MS Access;MaxBufferSize=2048;PageTimeout=5;"\r\n objMerge.MainDocumentType = wdFormLetters\r\n objMerge.OpenDataSource Name:=dbc.Name, LinkToSource:=True, Connection:=strConnection, _\r\n SQLStatement:="SELECT * FROM [tblSerienbrief_Temp] WHERE [Serienbrief] = True", _\r\n SubType:=wdMergeSubTypeAccess\r\n Set tdf = dbc.TableDefs("tblSerienbrief_Temp")\r\n For Each fld In tdf.Fields\r\n Set objRange = objDocument.Range\r\n Set objRangeFound = objDocument.Range(0, 0)\r\n strPlatzhalter = "[" & fld.Name & "]"\r\n With objRange.Find\r\n .Text = strPlatzhalter\r\n .Execute\r\n Do While .Found = True\r\n objRangeFound.SetRange objRange.Start, objRange.End\r\n objRange.SetRange objRange.End, objDocument.Range.End\r\n Set objMailMergeField = objMerge.Fields.Add(objRangeFound, fld.Name)\r\n .Text = strPlatzhalter\r\n .Execute\r\n Loop\r\n End With\r\n Next fld\r\n objMerge.ViewMailMergeFieldCodes = True\r\n objMerge.Destination = wdSendToNewDocument\r\n objMerge.Execute\r\n Set objMailMergeDocument = objWord.Documents(1)\r\n If Len(Nz(Me!txtSerienbrief)) = 0 Then\r\n objMailMergeDocument.Application.Visible = True\r\n Else\r\n objMailMergeDocument.SaveAs Chr(34) & Me!txtSerienbrief & Chr(34)\r\n objMailMergeDocument.Close\r\n Set objMailMergeDocument = Nothing\r\n End If\r\n objDocument.Close False\r\n Set objDocument = Nothing\r\n objWord.Quit\r\n Set objWord = Nothing\r\nEnd Sub<\/pre>\n\n
Downloads zu diesem Beitrag<\/h3>\n