<\/p>\n
Früher oder später möchten Sie vielleicht einmal Inhalte aus Word-Dokumenten in Access-Tabellen einlesen. Dabei gilt es einiges zu beachten: Zum Beispiel, dass sich die Inhalte nicht etwa über ein seiten- oder spaltenorientiertes Objektmodell einlesen lassen, sondern dass der Inhalt prinzipiell eine einzige Abfolge von Absätzen ist. Wie Sie diese einlesen und dabei auch die unterschiedlichen Absatz- und Zeichenformatvorlagen berücksichtigen, zeigt dieser Beitrag.<\/b><\/p>\n
In diesem Beitrag gehen wir davon aus, dass Ihnen ein Word-Dokument mit einigen Absatzformatvorlagen und Zeichenformatvorlagen vorliegt. Dieses könnte beispielsweise wie in Bild 1 aussehen.<\/p>\n
![\"Beispiel-Dokument](\"..\/fileadmin\/_temp_\/2014_04\/pic_943_001.png\")
<\/p>\n
Bild 1: Beispiel-Dokument dieses Beitrags<\/span><\/b><\/p>\n Wir möchten in diesem Beitrag die Techniken vorstellen, die dazu notwendig sind, die einzelnen Texte samt der Formatierung in eine Access-Tabelle einzulesen. Dazu werden wir den Text zunächst Absatz für Absatz durchlaufen und die Inhalte speichern, später schauen wir uns noch an, wie Sie die in den einzelnen Absätzen enthaltenen Zeichenformatvorlagen identifizieren können. Diese werden wir in Form entsprechender Auszeichnungen wie unter HTML in den in der Tabelle gespeicherten Texten unterbringen.<\/p>\n Formatvorlagen erstellen<\/b><\/p>\n Wenn Sie zuvor noch nicht mit Formatvorlagen gearbeitet haben, benötigen Sie noch einige grundlegende Informationen darüber. Es gibt einige verschiedene Typen von Formatvorlagen, von denen wir die folgenden berücksichtigen werden:<\/p>\n Neue Vorlage anlegen<\/b><\/p>\n Wenn die von Ihnen gewünschten Vorlagen noch nicht vorhanden sind, legen Sie diese zunächst an. Dazu öffnen Sie etwa unter Word 2010 zunächst den Dialog Formatvorlagen<\/b>, indem Sie auf den kleinen Pfeil unten rechts in der Ribbongruppe Start|Formatvorlagen <\/b>klicken. Der Dialog sieht wie in Bild 2 aus.<\/p>\n Bild 2: Formatvorlagen-Dialog<\/span><\/b><\/p>\n Klicken Sie hier auf die Schaltfläche Neue Formatvorlage<\/b>, erscheint ein weiterer Dialog namens Neue Formatvorlage<\/b> (s. Bild 3). Hier legen Sie zunächst den Namen für die neue Formatvorlage fest, zum Beispiel H1<\/b> für die erste überschriftenebene. Als Formatvorlagentyp verwenden wir zunächst Absatz<\/b>. Da dies die oberste überschriftenebene sein soll, legen Sie für die Eigenschaft Formatvorlage basiert auf <\/b>den Eintrag (Keine Formatvorlage) <\/b>fest. Fehlt noch die Formatvorlage für den folgenden Absatz. Damit stellen Sie ein, welche Formatvorlage automatisch für Absätze verwendet werden soll, die nach Einfügen eines Zeilenumbruchs etwa durch Betätigen der Eingabetaste von einem Absatz mit der Formatvorlage H1 <\/b>aus zugewiesen werden soll. Dieses Absatzformat haben wir bislang noch nicht festgelegt, also lassen wir die Eigenschaft auf H1 <\/b>stehen.<\/p>\n Bild 3: Der Dialog Neue Formatvorlage<\/span><\/b><\/p>\n Nun können Sie mit den Elementen im Bereich Formatierung <\/b>die grundlegenden Formatierungen festlegen:<\/p>\n Danach folgen noch einige weitere Optionen:<\/p>\n Bild 4: Schnellformatvorlagen<\/span><\/b><\/p>\n Weiter unten geht es dann ans Eingemachte: Mit einem Klick auf die Schaltfläche Format <\/b>klappen Sie ein Menü auf, mit dem Sie weitere Dialoge zum Einstellen folgender Parameter öffnen können:<\/p>\n Wir wollen an dieser Stelle nicht ins Detail gehen – wichtig ist, dass Sie die wichtigen Schritte zum Erstellen der Formatvorlagen kennen.<\/p>\n Wenn Sie neben den Absatzformatvorlagen für eine oder mehrere überschriften auch eine für den Fließtext erstellt haben (im Beispieldokument heißt dieses p<\/b>), können Sie diese bei den überschrift-Formatvorlagen für die Eigenschaft Formatvorlage für den folgenden Absatz <\/b>einstellen.<\/p>\n Auf diese Weise erstellen wir einige Formatvorlagen und legen ein einfaches Dokument an, das wir im Folgenden einlesen und in einer Tabelle speichern.<\/p>\n Verweis auf die Word-Bibliothek<\/b><\/p>\n Damit Sie gleich einfach auf das Objektmodell von Word zugreifen können, fügen Sie dem VBA-Projekt der aktuellen Datenbank noch einen Verweis auf die Word-Bibliothek hinzu. Dazu wählen Sie im VBA-Editor den Menüpunkt Extras|Verweise <\/b>aus. Dort aktivieren Sie den Eintrag Microsoft Word x.0 Object Library <\/b>(s. Bild 5).<\/p>\n Bild 5: Einfügen eines Verweises auf die Word-Bibliothek<\/span><\/b><\/p>\n Word-Dokument öffnen<\/b><\/p>\n Nun wollen wir das Word-Dokument öffnen, die Inhalte der einzelnen Absätze einlesen und zunächst im Direktbereich des VBA-Editors ausgeben und schließlich das Dokument und Word wieder schließen.<\/p>\n Dazu verwenden wir die Prozeduren und Funktionen aus Listing 1. Zunächst deklarieren wir dort eine Objektvariable zum Aufnehmen eines Verweises auf eine Instanz von Word namens objWord<\/b>. Um die gewünschten Aufgaben durchzuführen, programmieren wir eine Hauptprozedur namens WordDokumentEinlesen<\/b>. Diese deklariert eine Variable namens strDokument<\/b>, die den Namen des einzulesenden Dokuments aufnimmt. Diese Variable füllt die Prozedur mit dem Verzeichnis der aktuellen Datenbank plus dem Namen des Beispieldokuments Beispiel.docx<\/b>. Beim Aufruf der Funktion DokumentOeffnen<\/b> übergibt die Prozedur den Dokumentnamen und erhält einen Verweis auf das geöffnete Dokument zurück. Dokument-Oeffnen <\/b>füllt sowohl die Objektvariable objWord <\/b>mit einem Verweis auf eine neu erstellte Word-Instanz als auch die Rückgabevariable objDokument <\/b>mit einem Verweis auf das soeben geöffnete Dokument.<\/p>\n <\/p>\n Listing 1: Prozeduren zum öffnen, Einlesen und Schließen eines Word-Dokuments<\/span><\/b><\/p>\n Die Prozedur WordDokumentEinlesen<\/b> stellt dann die Eigenschaft Visible <\/b>von objWord <\/b>auf True <\/b>ein und macht das Word-Fenster so sichtbar. Nun kommt die Hauptarbeit: In einer For Each<\/b>-Schleife über alle Elemente der Paragraphs<\/b>-Auflistung des Word-Dokuments durchläuft die Prozedur alle Absätze des Dokuments. Dabei gibt sie jeweils den Inhalt der Text<\/b>-Eigenschaft des zum aktuellen Absatz gehörenden Range<\/b>-Objekts im Direktfenster aus. Das Ergebnis sieht schließlich wie in Bild 6 aus. Anschließend ruft die Prozedur noch die Funktion DokumentSchliessen <\/b>auf, die zunächst das aktuelle Dokument mit der Close<\/b>-Methode schließt.<\/p>\n Bild 6: Ausgabe des Inhalts der einzelnen Absätze im Direktbereich<\/span><\/b><\/p>\n Der Wert False <\/b>für den ersten Parameter dieser Methode sorgt dafür, dass keine änderungen gespeichert werden. Anschließend beendet sie die Word-Instanz mit der Quit<\/b>-Methode und leert die Objektvariable objWord<\/b>.<\/p>\n Von hier aus könnten Sie nun auch einfach die Inhalte der Absätze in jeweils einen Datensatz einer Tabelle schreiben. Wir benötigen aber noch weitere Informationen – zum Beispiel die Bezeichnung der Absatzformatvorlage, die dem jeweiligen Absatz zugeordnet wurde. Also erweitern wir die Ausgabe innerhalb der Schleife wie folgt:<\/p>\n Die ParagraphStyle<\/b>-Eigenschaft gibt nun den Namen der jeweils verwendeten Formatvorlage aus, sodass die Ausgabe im Direktbereich nun wie in Bild 7 aussieht.<\/p>\n Bild 7: Ausgabe der Absätze plus Name der Absatzformatvorlage<\/span><\/b><\/p>\n Für den Fall, dass das Word-Dokument aufgrund eines Fehlers einmal geöffnet bleibt oder Sie das Dokument zum Bearbeiten geöffnet haben, erweitern wir außerdem die Funktion Dokument-Oeffnen <\/b>noch um einen Parameter für die Open<\/b>-Methode:<\/p>\n Der hier verwendete Parameter heißt ReadOnly<\/b> und sorgt dafür, dass die Meldung aus Bild 8 ausbleibt.<\/p>\n Bild 8: Meldung, wenn eine bereits geöffnete Datei geöffnet werden soll<\/span><\/b><\/p>\n Damit können wir nun die Texte der einzelnen Absätze und ihre Formatierungen in einer Tabelle speichern. Aber was geschieht, wenn innerhalb eines Absatzes nur ein oder mehrere Wörter mit einer Zeichenformatvorlage versehen sind<\/p>\n Zeichenformatvorlagen erkennen<\/b><\/p>\n Dies ist etwas komplizierter als das Durchlaufen der Absätze – zumindest, wenn man es auf einem etwas umständlicheren Weg probiert. Vor einiger Zeit habe ich einmal alle Zeichen eines Absatzes durchlaufen, bis ich auf ein Zeichen gestoßen bin, das mit einer entsprechenden Zeichenformatvorlage versehen war.<\/p>\n Dies habe ich dann als Startpunkt der Formatierung registriert und habe den Text dann Zeichen für Zeichen weiter untersucht, bis ich zum nächsten Zeichen ohne diese Zeichenformatvorlage gelangte. Um diese formatierten Zeichen habe ich dann eine entsprechende Markierung gesetzt, beispielsweise <\/b>und <\/b><\/b>. Das hat bei längeren Texten natürlich eine Weile gedauert.<\/p>\n Wenn man sich jedoch etwas mit Word und mit den Möglichkeiten zum Suchen und Ersetzen beschäftigt, stößt man schnell auf eine wesentlich effizientere und schnellere Technik.<\/p>\n Diese sieht beispielsweise wie in Listing 2 aus.<\/p>\n Listing 2: Suchen und Ersetzen nach bestimmten Zeichenformatvorlagen<\/span><\/b><\/p>\n Die Prozedur FettErsetzen <\/b>erwartet einen Verweis auf das zu untersuchende Word-Dokument als Parameter. Sie verwendet eine weitere Objektvariable des Typs Find <\/b>mit dem Variablennamen objFind<\/b>.<\/p>\n Für dieses Find<\/b>-Objekt legen Sie zunächst einige Eigenschaften fest:<\/p>\n Schließlich ruft die Prozedur die Execute<\/b>-Methode auf, die wiederum zwei Parameter verwendet:<\/p>\n Als Ergebnis ändert der Aufruf dieser Prozedur den Inhalt des Dokuments. Kein Problem, da wir dieses ohnehin schreibgeschützt geöffnet haben und die änderungen anschließend auch explizit nicht speichern. Das Ergebnis sieht wie in Bild 9 aus – die Zeile wird auch so per VBA eingelesen.<\/p>\n Bild 9: Texte mit bestimmten Zeichenformatvorlagen werden um öffnende und schließende Tags erweitert.<\/span><\/b><\/p>\n Makrorekorder nutzen<\/b><\/p>\n Wie aber kommt man von einer eher umständlichen Lösung zu so einer einfachen und fast schon genialen Lösung, um die Tags zu einem speziell formatierten Text hinzuzufügen Die notwendigen Informationen liefert Word selbst. Im Gegensatz zu Access bieten Word und Excel die Möglichkeit, verschiedene Benutzeraktionen per Makrorekorder aufzuzeichnen.<\/p>\n Sprich: Sie führen ein paar Schritte unter Word durch und Word erstellt den Code, um diese Schritte zu reproduzieren. Diesen Code können Sie natürlich, wie in diesem Fall geschehen, auch als Vorlage für eine eigene Prozedur verwenden, die dann von Access aus aufgerufen wird.<\/p>\n Wenn Sie den Makrorekorder etwa unter Word 2010 nutzen möchten, müssen Sie zunächst ein spezielles Ribbon-Tab einblenden. Dies erledigen Sie in den Word-Optionen, wo Sie den Bereich Menüband anpassen <\/b>einblenden. Hier finden Sie auf der rechten Seite unter Hauptregisterkarten den Eintrag Entwicklertools<\/b> (s. Bild 10). Diesen Eintrag aktivieren Sie nun und schließen den Dialog dann wieder. Im Ribbon erscheint nun ein neues Tab-Element wie in Bild 11. Dort finden Sie ganz links die relevanten Befehle.<\/p>\n Bild 10: Ribbon-Befehl zum Start der Aufzeichnung eines Makros<\/span><\/b><\/p>\n Bild 11: Einblenden der Entwicklerwerkzeuge im Ribbon von Word<\/span><\/b><\/p>\n Klicken Sie dort auf die Schaltfläche Makro aufzeichn.<\/b>, erscheint der Dialog aus Bild 12. Hier geben Sie den Namen des zu erstellenden Makros ein (beziehungsweise der VBA-Prozedur, um bei den unter Access gängigen Bezeichnungen zu bleiben) und legen fest, dass das Makro nur im aktuellen Dokument gespeichert werden soll. Klicken Sie auf OK<\/b>, um die Aufzeichnung des Makros zu starten.<\/p>\n Bild 12: Start der Aufzeichnung eines Makros<\/span><\/b><\/p>\n Ausgehend davon, dass Sie das zu durchsuchende Dokument bereits geöffnet haben, aktivieren Sie nun den Ersetzen<\/b>-Dialog (unter Word 2010 unter dem Ribbon-Eintrag Start|Bearbeiten|Ersetzen <\/b>zu finden). Dieser sieht im Rohzustand wie in Bild 13 aus.<\/p>\n Bild 13: Eingeben der Suchparameter für ein Word-Dokument<\/span><\/b><\/p>\n Hier nehmen Sie nun die folgenden Schritte vor:<\/p>\n Word zeigt das Resultat dieses Vorgangs nun in einem Meldungsfenster an (s. Bild 14). Damit ist die aufzuzeichnende Aktion beendet. Sie können den Ma-kro-rekorder mit dem Ribbon-Eintrag Ent-wick–lertools|Code|Aufzeichnung be-en-den <\/b>stoppen.<\/p>\n Bild 14: Ergebnis des Suchen-Ersetzen-Vorgangs<\/span><\/b><\/p>\n Nun schauen wir uns den aufgezeichneten Code an, den Sie im VBA-Editor von Word (Alt + F11<\/b>) im Modul Module|New Macros <\/b>finden. Dieser sieht wie in Listing 3 aus.<\/p>\n Listing 3: Suchen und Ersetzen mit dem aufgezeichneten Makro<\/span><\/b><\/p>\n Mit ein wenig Experimentierfreude lässt sich daraus der für unsere Zwecke geeignete und weiter oben vorgestellte Code ermitteln.<\/p>\n Weitere Zeichenformatvorlagen<\/b><\/p>\n Wenn Sie nun auch noch eine Zeichenformatvorlage anwenden möchten, welche die markierten Zeichen kursiv setzt, ist auch das kein Problem: Sie fügen einfach eine neue Zeichenformatvorlage hinzu, nennen diese Kursiv <\/b>und aktivieren die Option für die kursive Schrift. Speichern Sie das Dokument, nachdem Sie ein paar Zeichen mit dieser Zeichenformatvorlage formatiert haben.<\/p>\n Nun fügen wir dem VBA-Modul unter Access eine weitere kleine Prozedur namens KursivErsetzen<\/b> hinzu, die wie in Listing 4 aussieht. Diese ist genauso aufgebaut wie die Prozedur zum Ersetzen der fett gesetzten Schrift. Der Unterschied ist, dass Sie nach der Formatvorlage Kursiv <\/b>sucht und entsprechende Zeichen in die Tags <\/b>und <\/i> <\/b>einschließt.<\/p>\n Listing 4: Prozedur zum Auszeichnen kursiv gesetzter Schrift<\/span><\/b><\/p>\n Ein kleiner Test zeigt, dass auch diese Formatierung erfolgreich ausgezeichnet wird.<\/p>\n Mehrere Formatvorlagen gleichzeitig<\/b><\/p>\n Nun stellt sich noch die Frage, wie man Texte auszeichnet, die mit mehreren Zeichenformatvorlagen gleichzeitig ausgezeichnet sind – zum Beispiel fett und kursiv. Oder wo solche Formatierungen ineinander übergehen – wie hier:<\/p>\n Von fett über fett-kursiv zu kursiv<\/p>\n Die Antwort lautet: Sie brauchen sich keine Sorgen darum zu machen.<\/p>\n Wenn Sie konsequent mit Zeichenformatvorlagen arbeiten, benötigen Sie hier ja drei Vorlagen – eine fette, eine fett-kursive und eine kursive. Dies sieht dann mit Auszeichnungen so aus:<\/p>\n Word-Dokument ausgeben<\/b><\/p>\n An dieser Stelle wollen wir den Inhalt nun zunächst im Direktfenster des VBA-Editors ausgeben – zusammen mit den HTML-Auszeichnungen für die Textformatierungen und mit der Angabe des jeweiligen Absatzformates. Dies sieht dann wie in Listing 5 aus.<\/p>\n\n
![\"Formatvorlagen-Dialog\"](\"..\/fileadmin\/_temp_\/2014_04\/pic_943_002.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2014_04\/pic_943_003.png\")
<\/p>\n\n
\n
![\"Schnellformatvorlagen\"](\"..\/fileadmin\/_temp_\/2014_04\/pic_943_004.png\")
<\/p>\n\n
![\"Einfügen](\"..\/fileadmin\/_temp_\/2014_04\/pic_943_005.png\")
<\/p>\nDim <\/span>objWord As <\/span>Word.Application\r\nPublic Function <\/span>DokumentOeffnen(strDokument As String<\/span>) As <\/span>Word.Document\r\n Dim <\/span>objDokument As <\/span>Word.Document\r\n Set<\/span> objWord = New<\/span> Word.Application\r\n Set<\/span> objDokument = objWord.Documents.Open(strDokument)\r\n Set<\/span> DokumentOeffnen = objDokument\r\nEnd Function<\/span>\r\nPublic Function <\/span>DokumentSchliessen(objDokument As <\/span>Word.Document)\r\n objDokument.Close False<\/span>\r\n objWord.Quit\r\n Set<\/span> objWord = Nothing\r\nEnd Function<\/span>\r\nPublic Sub <\/span>WordDokumentEinlesen()\r\n Dim <\/span>objDokument As <\/span>Word.Document\r\n Dim <\/span>strDokument As String<\/span>\r\n Dim <\/span>objAbsatz As <\/span>Word.Paragraph\r\n strDokument = CurrentProject.Path & \"\\Beispiel.docx\"\r\n Set<\/span> objDokument = DokumentOeffnen(strDokument)\r\n objWord.Visible = True<\/span>\r\n For Each objAbsatz In objDokument.Paragraphs\r\n Debug.Print<\/span> objAbsatz.Range.Text\r\n Next<\/span> objAbsatz\r\n DokumentSchliessen objDokument\r\nEnd Sub<\/span><\/pre>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2014_04\/pic_943_006.png\")
<\/p>\nDebug.Print<\/span> objAbsatz.Range. ParagraphStyle, objAbsatz.Range.Text<\/pre>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2014_04\/pic_943_007.png\")
<\/p>\nSet<\/span> objDokument = objWord.Documents. Open(strDokument, , True<\/span>)<\/pre>\n![\"Meldung,](\"..\/fileadmin\/_temp_\/2014_04\/pic_943_008.png\")
<\/p>\nPublic Sub <\/span>FettErsetzen(objDokument As <\/span>Word.Document)\r\n Dim <\/span>objFind As <\/span>Word.Find\r\n Set<\/span> objFind = objDokument.Parent.Selection.Find\r\n With<\/span> objFind\r\n .Style = \"Fett\"\r\n .Text = \"\"\r\n .Replacement.Text = \"<b>^&<\/b>\"\r\n .Execute Replace:=wdReplaceAll, Format:=True<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
\n
![\"Texte](\"..\/fileadmin\/_temp_\/2014_04\/pic_943_009.png\")
<\/p>\n![\"Ribbon-Befehl](\"..\/fileadmin\/_temp_\/2014_04\/pic_943_011.png\")
<\/p>\n![\"Einblenden](\"..\/fileadmin\/_temp_\/2014_04\/pic_943_010.png\")
<\/p>\n![\"Start](\"..\/fileadmin\/_temp_\/2014_04\/pic_943_012.png\")
<\/p>\n![\"Eingeben](\"..\/fileadmin\/_temp_\/2014_04\/pic_943_013.png\")
<\/p>\n\n
![\"Ergebnis](\"..\/fileadmin\/_temp_\/2014_04\/pic_943_014.png\")
<\/p>\nSub <\/span>macFormatierungErsetzen()\r\n''\r\n'' macFormatierungErsetzen Makro\r\n''\r\n Selection.Find.ClearFormatting\r\n Selection.Find.Style = ActiveDocument.Styles(\"Fett\")\r\n Selection.Find.Replacement.ClearFormatting\r\n With<\/span> Selection.Find\r\n .Text = \"\"\r\n .Replacement.Text = \"<b>^&<\/b>\"\r\n .Forward = True<\/span>\r\n .Wrap = wdFindContinue\r\n .Format = True<\/span>\r\n .MatchCase = False<\/span>\r\n .MatchWholeWord = False<\/span>\r\n .MatchWildcards = False<\/span>\r\n .MatchSoundsLike = False<\/span>\r\n .MatchAllWordForms = False<\/span>\r\n End With<\/span>\r\n Selection.Find.Execute Replace:=wdReplaceAll\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>KursivErsetzen(objDokument As <\/span>Word.Document)\r\n Dim <\/span>objFind As <\/span>Word.Find\r\n Set<\/span> objFind = objDokument.Parent.Selection.Find\r\n With<\/span> objFind\r\n .Style = \"Kursiv\"\r\n .Text = \"\"\r\n .Replacement.ClearFormatting\r\n .Replacement.Text = \"<i>^&<\/i>\"\r\n .Execute Replace:=wdReplaceAll, Format:=True<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nVon <b>fett über<\/b><b><i> fett-kursiv<\/i><\/b><i>zu kursiv<\/i><\/pre>\n
Public Sub <\/span>WordDokumentEinlesen(strDokument As String<\/span>)\r\n Dim <\/span>objDokument As <\/span>Word.Document\r\n Dim <\/span>objAbsatz As <\/span>Word.Paragraph\r\n Dim <\/span>lngDokumentID As Long<\/span>\r\n Set<\/span> objDokument = DokumentOeffnen(strDokument)\r\n If <\/span>objDokument Is Nothing Then<\/span>\r\n MsgBox<\/span> \"Das Dokument wurde nicht gefunden.\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n objWord.Visible = True<\/span>\r\n FettErsetzen objDokument\r\n KursivErsetzen objDokument\r\n For Each objAbsatz In objDokument.Paragraphs\r\n Debug.Print<\/span> objAbsatz.Range.ParagraphStyle, objAbsatz.Range.Text\r\n Next<\/span> objAbsatz\r\n DokumentSchliessen objDokument\r\nEnd Sub<\/span><\/pre>\n