{"id":55000891,"date":"2013-08-01T00:00:00","date_gmt":"2020-05-22T21:29:14","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=891"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Word_automatisieren","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Word_automatisieren\/","title":{"rendered":"Word automatisieren"},"content":{"rendered":"

\"\"<\/p>\n

Word bietet als Textverarbeitung ganz andere Möglichkeiten als Access-Berichte, wenn es um die Ausgabe von Texten geht. Natürlich liegen die Schwerpunkte bei Word auch ganz anders – so ist es grundsätzlich dafür ausgelegt, seine Texte nacheinander zu erfassen und nicht, wie etwa ein Access-Bericht, in einer durch die verschiedenen Berichtsbereiche vorgegebenen Struktur. Wir schauen uns in diesem Beitrag an, wie Sie Texte von Access nach Word bewegen und umgekehrt.<\/b><\/p>\n

Im Gegensatz etwa zu Outlook ist Word eine Anwendung, von der man mehrere Instanzen erzeugen kann. Diese Erkenntnis ist wichtig, wenn Sie entscheiden, ob Sie für den VBA-gesteuerten Zugriff auf Word eine bestehende Instanz verwenden oder eine neue Instanz erstellen möchten. Dazu müssen Sie natürlich erst einmal herausfinden, ob auf dem Rechner bereits eine Word-Instanz geöffnet ist.<\/p>\n

Da man grundsätzlich sagen kann, dass eine eigene Instanz einfacher zu handhaben ist, legen wir uns gleich darauf fest, jeweils eine eigene Instanz zu erzeugen. So können Sie diese Instanz bei der Erzeugung referenzieren und, wenn Sie diese nicht mehr benötigen, auch wieder beenden.<\/p>\n

Wenn Sie von Access aus eine bestehende Instanz nutzen, müssten Sie sich diese gegebenenfalls mit einer anderen Anwendung teilen, die darauf zugreift, oder auch mit dem Benutzer, der gerade vor dem Rechner sitzt. Um eventuelle Seiteneffekte zu vermeiden, rufen wir für die Automation von Access aus lieber gleich eine eigene Instanz auf. Der einzige offensichtliche Nachteil ist, dass dies mehr Ressourcen benötigt als eine einzige Instanz.<\/p>\n

Early Binding oder Late Binding<\/b><\/p>\n

Die immerwährende Frage, ob Sie mit Early oder Late Binding arbeiten, kann man nur unter Betrachung des jeweiligen Kontext beurteilen. Wer eine Automation einer Office-Anwendung programmieren möchte, die unter allen gängigen Anwendungen läuft, sollte dies ohne Verwendung eines Verweises und dementsprechend mit Late Binding erledigen. Auf diese Weise verhindern Sie Probleme, die sonst beim Antreffen der falschen Version des Verweises auftreten.<\/p>\n

Allerdings nehmen Sie sich damit auch die Möglichkeit, auf die Ereignisse zu reagieren, die vom Word-Objekt oder vom Document<\/b>-Objekt ausgelöst werden. Interessant ist dies beispielsweise, wenn Sie beobachten wollen, ob der Benutzer ein Dokument öffnet oder schließt oder dieses speichert.<\/p>\n

Sollten Sie solche Funktionen nutzen wollen, arbeiten Sie mit Early Binding, also unter Verwendung eines fest integrierten Verweises auf die jeweils aktuelle Version der Word-Objektbibliothek.<\/p>\n

Diesen stellen Sie im Verweise<\/b>-Dialog ein, den Sie über den Menüpunkt Extras|Verweise <\/b>des VBA-Editors (Strg + G<\/b>) öffnen – s. Bild 1. Anschließend können Sie mit der folgenden Anweisung eine Word-Instanz erstellen und mit einer entsprechenden Objektvariablen referenzieren:<\/p>\n

\"Verweis<\/p>\n

Bild 1: Verweis auf die Word-Bibliothek<\/span><\/b><\/p>\n

Dim <\/span>objWord As <\/span>Word.Application\r\nSet<\/span> objWord = New<\/span> Word.Application\r\nSleep 3000\r\nobjWord.Quit\r\nSet<\/span> objWord = Nothing<\/pre>\n
Dies erstellt eine Word-Instanz und schließt diese nach drei Sekunden wieder. Die gleiche Variante sieht beim Late Binding so aus:<\/p>\n
Dim <\/span>objWord As Object<\/span>\r\nDim <\/span>objDocument As Object<\/span>\r\nSet<\/span> objWord = _\r\n     CreateObject(\"Word.Application\")\r\nSet<\/span> objDocument = objWord.Documents.Add<\/pre>\n
Um das Word-Fenster anzuzeigen und in den Vordergrund zu holen, sind ein paar Zeilen mehr nötig. Wir erzeugen zusätzlich ein neues, leeres Word-Dokument, machen die Word-Instanz mit der Visible<\/b>-Eigenschaft sichtbar und holen das Anwendungsfenster mit der AppActivate<\/b>-Methode nach vorn:<\/p>\n
Dim <\/span>objWord As <\/span>Word.Application\r\nDim <\/span>objDocument As <\/span>Word.Document\r\nSet<\/span> objWord = New<\/span> Word.Application\r\nSet<\/span> objDocument = objWord.Documents.Add\r\nobjWord.Visible = True<\/span>\r\nAppActivate objDocument.Name\r\nSleep 3000\r\nobjWord.Quit\r\nSet<\/span> objWord = Nothing<\/pre>\n
Auch diese Instanz soll nach drei Sekunden wieder verschwinden. Sie können auch ohne explizites Erzeugen eines Word-Objekts ein Dokument in Word erzeugen oder öffnen. Das geht schlicht so:<\/p>\n
Dim <\/span>objDocument As <\/span>Word.Document\r\nSet<\/span> objDocument = New<\/span> Word.Document\r\nobjDocument.Parent.Visible = True<\/span>\r\nAppActivate objDocument.Name\r\nSleep 3000\r\nobjDocument.Close<\/pre>\n
Nach dem Schließen bleibt die Word-Instanz allerdings bestehen. Sie müssen diese dann manuell schließen oder per Code über die Parent-Eigenschaft des Word-Dokuments:<\/p>\n
objDocument.Parent.Quit<\/pre>\n
Dazu muss das Dokument natürlich noch geöffnet sein. Wenn das Dokument vom Erzeugen beziehungsweise öffnen bis zum Schließen noch bearbeitet wird, erscheint beim Versuch, Word zu schließen, ein Dialog, der fragt, ob das Dokument gespeichert werden soll (s. Bild 2).<\/p>\n
\"Rückfrage<\/p>\n
Bild 2: Rückfrage vor dem Schließen eines Dokuments<\/span><\/b><\/p>\n
Dies können Sie verhindern, indem Sie festlegen, was beim Schließen geschehen soll: Soll Word das Dokument ohne Rückfrage speichern Oder die änderungen verwerfen Dies legen Sie mit einem der folgenden Werte für den ersten Parameter der Close<\/b>-Methode des Document<\/b>-Objekts fest:<\/p>\n