<\/p>\n
Das mit Access 2007 eingeführte Richtext-Format ist für viele Anwendungen interessant. Die Eingabe und Formatierung ist aber nicht wirklich ergonomisch – da sind Sie von Word mehr Komfort gewohnt. Warum aber nicht die Texte in Word eingeben und dann nach Access übernehmen Alles, was Sie brauchen, sind einige Grundlagenkenntnisse über den Aufbau von Dokumenten in Word und die Absatz- und Zeichenvorlagen sowie zwei oder drei Tricks – schon haben Sie den Inhalt eines Word-Dokuments samt Formatierungen in ein Memofeld mit Richtext-Formatierung überführt.<\/b><\/p>\n
Damit erschlagen Sie dann gleich zwei Fliegen mit einer Klappe: Sowohl bereits existierende als auch neu erstellte Dokumente können Sie so recht einfach nach Access überführen.<\/p>\n
Einzige Voraussetzung für die Verwendung der in diesem Beitrag vorgestellten Techniken ist, dass Sie die Absätze mit entsprechenden Absatzformatvorlagen versehen haben und hervorgehobene Texte mit entsprechenden Zeichenformatvorlagen. Wenn Sie das nicht tun, wäre nun ein guter Zeitpunkt, um damit zu beginnen!<\/p>\n
Schauen wir uns zunächst einmal an, welche Formatierungen uns das Richtext-Format von Access bietet.<\/p>\n
Eins vorweg: Wir können keine eigenen Formate definieren und auch nicht die gängigen Absatzformate wie h1<\/b>, h2<\/b>, h3 <\/b>oder p <\/b>verwenden. Deshalb ist das übertragen von Inhalten mit benannten Absatz- und Zeichenformatvorlagen eine Einbahnstraße.<\/p>\n
Um die einzelnen Formatierungen zu erkennen, erstellen wir ein Experimentierformular mit zwei Textfeldern. Das erste zeigt den Inhalt im Richtext-Format an, das zweite soll den Inhalt mit HTML-Auszeichnungen anzeigen. In der Formularansicht sieht dies wie in Bild 1 aus.<\/p>\n
![\"Anzeige](\"..\/fileadmin\/_temp_\/2014_04\/pic_944_001.png\")
<\/p>\n
Bild 1: Anzeige der HTML-Version der formatierten Texte<\/span><\/b><\/p>\n Der jeweils eingegebene oder formatierte Text wird gleich nach jeder änderung im rechten Textfeld mit HTML-Auszeichnungen angezeigt. Dafür sorgt die folgende Ereignisprozedur, die durch das Ereignis Bei änderung <\/b>ausgelöst wird:<\/p>\n Damit das Betätigen der Eingabetaste im linken Textfeld zum Einfügen eines Zei-len-umbruchs führt und nicht zum Wechsel zum rechten Textfeld, stellen Sie die Eigenschaft Eingabetastenverhalten <\/b>auf den Wert Neue Zeile im Feld <\/b>ein.<\/p>\n Nun brauchen Sie nur noch die zur Verfügung stehenden Formatierungen anzuwenden und können dann rechts die jeweiligen HTML-Auszeichnungen abgreifen.<\/p>\n Das Ergebnis sieht wie folgt aus – hier zunächst für die Absatzformatierungen:<\/p>\n Dokumentinhalt speichern<\/b><\/p>\n Nun schauen wir uns an, wie wir das Dokument beziehungsweise die einzelnen Absätze in der Datenbank speichern können. Die einfachste Möglichkeit ist, einfach für jeden Absatz einen neuen Datensatz zu einer Tabelle hinzuzufügen. Auf diese Weise können wir später ganz einfach auf die einzelnen Absätze zugreifen und diese nach Wunsch beispielsweise mit verschiedenen Formatierungen ausstatten.<\/p>\n Die Tabelle für diesen Zweck soll nicht nur ein Dokument gleichzeitig aufnehmen, sondern gegebenenfalls auch einmal mehrere – deshalb müssen wir der Tabelle noch ein Feld hinzufügen, welches einen Hinweis auf das Ursprungsdokument liefert. Da dies typischerweise der Dateiname sein wird und wir dieses nicht in jedem Datensatz für dieses Dokument wiederholen möchten, gliedern wir den Dateinamen in eine eigene Tabelle aus, die wir dann mit der Tabelle mit den Inhalten verknüpfen.<\/p>\n Diese Tabelle heißt tblDokumente<\/b> und enthält neben dem Primärschlüsselfeld DokumentID <\/b>lediglich ein weiteres Feld namens Dokument, welches den Pfad zu der betroffenen Datei enthält. Dieses Feld versehen wir mit einem eindeutigen Index, damit jedes Dokument nur einmal angegeben werden kann (s. Bild 2).<\/p>\n Bild 2: Tabelle zum Speichern der Dokumentnamen<\/span><\/b><\/p>\n Die Tabelle tblAbsaetze<\/b>, welche die Inhalte der einzelnen Absätze aufnehmen soll, finden Sie im Entwurf in Bild 3. Diese Tabelle enthält natürlich ein Fremdschlüsselfeld, mit dem das Dokument aus der Tabelle tblDokumente <\/b>ausgewählt werden kann, zu dem der Absatz gehört. Außerdem besitzt die Tabelle das Feld Inhalt zum Speichern des Inhalts des jeweiligen Absatzes. Schließlich fehlt noch das Feld AbsatzformatID<\/b>. Genau wie bei den Dokumenten könnten wir die Bezeichnung des Absatzformats direkt in ein Textfeld der Tabelle tblAbsaetze <\/b>eintragen. Allerdings verwenden wir auch hier eine Lookup-Tabelle, die in diesem Fall noch weitere Felder enthält – zum Beispiel HTML-Tags, die wir später zum Erzeugen eines Dokuments im Richtext-Format von Access nutzen können (dazu später mehr). Diese Tabelle heißt tblAb-satz-formate <\/b>und sieht in der Entwurfsansicht wie in Bild 4 aus. Auch für das Feld Absatzformat dieser Tabelle legen wir einen eindeutigen Index fest, damit jede Bezeichnung eines Absatzformats nur einmal in der Tabelle gespeichert werden kann.<\/p>\n Bild 3: Tabelle zum Speichern der Absatzformate eines Dokuments<\/span><\/b><\/p>\n Bild 4: Tabelle zum Speichern der Absätze eines Dokuments<\/span><\/b><\/p>\n Formular zum Einlesen der Dokumente<\/b><\/p>\n Um die Absätze, Formate und den Richtext für die eingelesenen Dokumente anzuzeigen, verwenden wir das Formular frmDokumente <\/b>aus Bild 5.<\/p>\n Bild 5: Formular zum Einlesen und Anzeigen der Dokumente<\/span><\/b><\/p>\n Dieses verwendet die Tabelle tblDokumente <\/b>als Datenherkunft. Das Unterformular in diesem Formular wiederum heißt sfmDokumente <\/b>und soll die in der Tabelle tblAbsaetze <\/b>gespeicherten Absätze zu dem im Hauptformular angezeigten Formular darstellen. Es verwendet die Tabelle tblAbsaetze <\/b>als Datenherkunft. Damit das Unterformular jeweils die passenden Datensätze anzeigt, stellen Sie die beiden Eigenschaften Verknüpfen von <\/b>und Verknüpfen nach <\/b>des Unterformular-Steuerelements auf den Wert DokumentID <\/b>ein.<\/p>\n Neben dem Textfeld txtDokument<\/b>, das an das Feld Dokument der Datenherkunft gebunden ist, finden Sie eine Schaltfläche namens cmdDateiAuswaehlen<\/b>. Diese ruft die Prozedur aus Listing 1 auf.<\/p>\n Listing 1: Auswählen und Einlesen des Inhalts eines Word-Dokuments<\/span><\/b><\/p>\n Die Prozedur öffnet zunächst einen Datei öffnen<\/b>-Dialog und weist das Ergebnis der Variablen strDokument <\/b>zu. Dann ruft es eine Funktion namens WordDokumentEinlesen <\/b>auf und übergibt dieser den Namen des einzulesenden Word-Dokuments. Diese Funktion steuert das Einlesen des Word-Dokuments und trägt die Inhalte der einzelnen Absätze in die Tabellen tblDokumente <\/b>und tblAbsaetze <\/b>ein. War dieser Vorgang erfolgreich, liefert sie den Primärschlüsselwert des neuen Datenatzes der Tabelle tblDokumente <\/b>zurück. Die Prozedur cmdDateiAus-waehlen_Click <\/b>aktualisiert dann seine Datenherkunft, stellt den Datensatzzeiger auf den neuen Datensatz ein und aktualisiert auch den Inhalt des Unterformulars. Dann erstellt sie mithilfe der Funktion RichtextErstellen <\/b>aus den gewonnenen Daten einen Text im Richtext-Format von Access.<\/p>\n In der Praxis sollte dies dann wie in Bild 6 aussehen.<\/p>\n Bild 6: Darstellung eines Dokuments mit den einzelnen Absätzen und mit dem resultierenden Richtext-Dokument<\/span><\/b><\/p>\n Dokument einlesen<\/b><\/p>\n Die grundlegenden Techniken zum öffnen und Einlesen des Word-Dokuments sowie zum Ausstatten des Word-Dokuments mit entsprechenden Format- und Zeichenformatvorlagen finden Sie im Beitrag Word-Dokumente einlesen <\/b>(www.access-im-unternehmen.de\/943<\/b>). Die dort vorgestellte Prozedur WordDokumentEinlesen <\/b>haben wir noch etwas verfeinert, sodass diese nun wie in Listing 2 aussieht. Auch hier benötigen wir eine Variable, die den Verweis auf die Word-Instanz speichert – diese deklarieren wir wie folgt:<\/p>\n Listing 2: Steuerungsprozedur zum Einlesen des Word-Dokuments<\/span><\/b><\/p>\n Die Prozedur erwartet den Namen der einzulesenden Datei als Parameter. Die Prozedur DokumentOeffnen <\/b>(siehe im oben genannten Beitrag) öffnet das Dokument und übergibt einen Verweis auf dieses Dokument an die Objektvariable objDokument<\/b>.<\/p>\n Sollte diese Variable anschließend leer sein, konnte das Dokument offensichtlich nicht geöffnet werden, was in einer entsprechenden Meldung resultiert. Das Word-Fenster wird eingeblendet (dies können Sie auch weglassen) und die beiden Prozeduren FettErsetzen<\/b> und KursivErsetzen <\/b>sorgen dafür, dass die entsprechenden formatierten Passagen im Dokument mit öffnenden und schließenden HTML-Tags wie …<\/b> <\/b>oder …<\/i> <\/b>eingeschlossen werden.<\/p>\n <\/p>\n Dann legt die Prozedur über die Funktion DokumentSpeichern <\/b>einen neuen Datensatz für das Dokument in der Tabelle tblDokumente <\/b>an.<\/p>\n Die Funktion liefert den Primärschlüsselwert des neuen Datensatzes zurück, damit diese beim Anlegen der Datensätze in der Tabelle tblAbsaetze <\/b>als Fremdschlüsselwert verwendet werden kann. Mehr zu dieser Funktion lesen Sie weiter unten.<\/p>\n Sollte die Funktion einen Primärschlüsselwert ungleich 0 <\/b>zurückliefern, durchläuft die Prozedur in einer For Each<\/b>-Schleife alle Absätze des Word-Dokuments, welche über die Paragraphs<\/b>-Auflistung bereitgestellt werden.<\/p>\n Innerhalb der Schleife ruft die Prozedur dann die Routine AbsatzSpeichern <\/b>auf, die sich um das Anlegen des Datensatzes für den aktuellen Absatz in der Tabelle tblAbsaetze <\/b>kümmert – siehe weiter unten. Anschließend ruft sie die Prozedur DokumentSchliessen <\/b>auf, um das soeben eingelesene Dokument zu schließen.<\/p>\n Dokument-Datensatz speichern<\/b><\/p>\n Die Funktion DokumentSpeichern <\/b>erwartet als Parameter die Angabe des Dokumentpfades, für das ein neuer Datensatz in der Tabelle tblDokumente <\/b>angelegt werden soll (s. Listing 3).<\/p>\n Listing 3: Speichern des Datensatzes für das Word-Dokument<\/span><\/b><\/p>\n Sie versucht dann zunächst, einen Datensatz mit dem angegebenen Dokumentpfad in der Tabelle tblDokument<\/b> zu speichern – und zwar etwa mit der folgenden INSERT INTO<\/b>-Anweisung:<\/p>\n Wenn bereits ein Datensatz mit diesem Dokumentpfad vorhanden ist, löst dies einen Fehler aus, da das Feld Dokument <\/b>mit einem eindeutigen Index ausgestattet wurde. Damit dies nicht die übliche Fehlermeldung hervorruft, haben wir mit der Anweisung On Error Resume Next <\/b>die Fehlerbehandlung deaktiviert. Stattdessen speichern wir nach dem Ausführen der INSERT INTO<\/b>-Anweisung die Fehlernummer in der Variablen intError <\/b>und aktivieren die Fehlerbehandlung mit On Error Goto 0 <\/b>wieder.<\/p>\n Danach analyisiert die Prozedur den Inhalt von intError <\/b>in einer Select Case<\/b>-Bedingung. Hat intError <\/b>den Wert 3022<\/b>, war offensichtlich bereits ein Datensatz mit diesem Dokument vorhanden. In diesem Fall fragt die Anwendung, ob dieser Datensatz überschrieben werden soll (Ja<\/b>) oder ob der Benutzer einen neuen Pfad angeben möchte (Nein<\/b>).<\/p>\n Im ersten Fall haben wir es leicht: Wir müssen einfach nur den Primärschlüsselwert für den bereits vorhandenen Datensatz per DLookup <\/b>ermitteln und die bereits in der Tabelle tblAbsaetze<\/b> gespeicherten Datensätze löschen, da diese ja gleich neu eingelesen werden sollen. Dies erledigt beispielsweise die folgende SQL-Anweisung:<\/p>\n Möchte der Benutzer hingegen einen neuen Dokumentpfad angeben, müssen wir diesen zunächst abfragen. Dazu nutzen wir die Funktion Bezeichnung-Ermitteln<\/b>, die den Benutzer solange nach einem neuen Dokumentpfad fragt, bis diese einen noch nicht in der Tabelle enthaltenen Text angegeben oder den Vorgang abgebrochen hat. Die Funktion schreibt die neue Bezeichnung in die Variable strDokument<\/b>, die anschließend weiter verwendet wird – aber nur, wenn BezeichnungErmitteln <\/b>den Wert True <\/b>zurückliefert. Diese Funktion schauen wir uns im Beitrag Neue Werte in eindeutigen Feldern <\/b>(www.access-im-unternehmen.de\/941<\/b>) an.<\/p>\n Wenn der Benutzer einen gültigen Dokumentpfad angegeben hat, fügt die Prozedur den entsprechenden Datensatz per INSERT INTO<\/b>-Abfrage zur Tabelle tblDokumente <\/b>hinzu. Den Wert des Primärschlüssels für den neuen Datensatz ermittelt sie dann mit der Abfrage SELECT @@IDENTITY<\/b> und speichert diesen in der Variablen lngDokumentID<\/b>.<\/p>\n Tritt beim ersten Versuch, den Datensatz zur Tabelle hinzuzufügen, kein Fehler auf (intError <\/b>hat dann den Wert 0<\/b>), ermittelt die Prozedur den neuen Primärschlüsselwert auf die gleiche Weise. Für alle anderen Werte von intError <\/b>gibt die Funktion eine entsprechende Fehlermeldung aus. In jedem Fall gibt die Funktion aber den Wert der Variablen lngDokumentID <\/b>zurück.<\/p>\n Absätze speichern<\/b><\/p>\n Die Prozedur AbsatzSpeichern <\/b>speichert jeweils einen Absatz in der Tabelle tblAbsaetze<\/b> (s. Listing 4). Dabei erwartet sie folgende Parameter:<\/p>\n Listing 4: Speichern eines einzelnen Absatzes in der Tabelle tblAbsaetze<\/span><\/b><\/p>\n Die Prozedur ermittelt zunächst den Primärschlüsselwert des Datensatzes der Tabelle tblAbsatzformate<\/b>, welcher der Bezeichnung des Absatzes aus strAbsatzformat <\/b>entspricht.<\/p>\n Dies erledigt eine weitere Hilfsfunktion namens LookupID-Ermitteln<\/b>, die wir ebenfalls im Beitrag Neue Werte für eindeutig indizierte Felder <\/b>beschreiben. Diese ermittelt den Primärschlüsselwert eines gegebenenfalls vorhandenen Datensatzes oder erstellt diesen gleich neu und liefert dessen Primärschlüsselwert zurück.<\/p>\n In jedem Fall ist nach dieser Anweisung die Variable lngAbsatzformatID <\/b>mit einem Wert ungleich 0 <\/b>gefüllt, sodass wir alle Informationen zum Anlegen eines neuen Datensatzes in der Tabelle tblAbsaetze <\/b>ermittelt haben. Diesen legt die Prozedur dann auch gleich mit einer entsprechenden INSERT INTO<\/b>-Anweisung an, die etwa wie folgt lautet:<\/p>\n Bei der Zusammenstellung der INSERT INTO<\/b>-Anweisung ist zu beachten, dass dort drei verschachtelte Replace<\/b>-Anweisungen einige Ersetzungen vornehmen:<\/p>\n Auf diese Weise legt die Prozedur einen Absatz nach dem anderen in Form eines Datensatzes der Tabelle tblAbsaetze <\/b>in der Datenbank an.<\/p>\n Damit haben wir bereits alle benötigten Daten in die Tabellen der Datenbank geschrieben. Für unsere kleine Beispieldatei sieht dies wie in Bild 7 aus.<\/p>\n Bild 7: Daten des Word-Dokuments in den drei Tabellen der Beispieldatenbank<\/span><\/b><\/p>\n Die Richtext-Auszeichnungen<\/b><\/p>\n Bevor wir uns an die Aufgabe heranwagen, aus den in der Tabelle tblAbsaetze <\/b>gespeicherten Daten Richtext zu erstellen, müssen wir uns noch um die dazu benötigten HTML-Tags kümmern.<\/p>\n Immerhin muss der nun zu erstellende Code ja wissen, in welche HTML-Tags er etwa einen Absatz einfassen soll, die mit der Formatvorlage h1 <\/b>formatiert wurde. Das Problem ist, dass das Richtext-Format von Access nicht alle HTML-Tags unterstützt. Das zweite ist, dass wir diese dementsprechend selbst definieren und an geeigneter Stelle in der Datenbank hinterlegen müssen.<\/p>\n Welcher Ort aber bietet sich dafür mehr an als die Tabelle tblAbsatzformate<\/b> Hier legen wir also zunächst zwei neue Felder an, die HTMLAuszeichnungStart <\/b>und HTMLAuszeichnungEnde <\/b>heißen. Diese füllen wir dann beispielsweise für das Absatzformat h1 <\/b>mit den Werten <div><font size=4> <\/b>und <\/font><\/div><\/b>. Aber reicht dies aus Nein: Es gibt ein paar verschachtelte Formate, zum Beispiel die Auflistungen mit und ohne Nummerierungen. Wenn Sie eine solche mit HTML-Tags im Richtext abbilden möchten, fassen Sie nicht nur die einzelnen Absätze in <li> <\/b>und <\/li><\/b>-Tags ein. Sie müssen auch noch die zusammengehörenden Auflistungspunkte entweder mit <ol><\/b> und <\/ol><\/b> (Auflistung ohne Nummerierung) beziehungsweise <ul><\/b> und <\/ul><\/b> einfassen (Auflistung mit Nummerierung). Für eine Auflistung mit Nummerierung sieht das beispielsweise wie folgt aus:<\/p>\n Für diese absatzübergreifenden Markierungen fügen wir der Tabelle tblAb-satzformate <\/b>also zwei weitere Felder namens HTMLAuszeichnungStartExtra <\/b>und HTMLAuszeichnungEndeExtra <\/b>hinzu.<\/p>\n Die Tabelle sieht dann, mit den für unser Beispieldokument notwendigen Absätzen, wie in Bild 8 aus.<\/p>\n Bild 8: HTML-Auszeichnungen in der Tabelle tblAbsatzformate<\/span><\/b><\/p>\n Richtext erstellen<\/b><\/p>\n Nun wollen wir noch den Inhalt der drei Tabellen in ein Dokument im Richtext-Format von Access umwandeln. Dies erledigt die Prozedur RichtextErstellen<\/b>, die als einzigen Parameter den Primärschlüssel des Datensatzes der Tabelle tblDokumente <\/b>erwartet (s. Listing 5).<\/p>\nPrivate Sub <\/span>txtRichtext_Change()\r\n Me!txtHTML = Me!txtRichtext.Text\r\nEnd Sub<\/span><\/pre>\n\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2014_04\/pic_944_015.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2014_04\/pic_944_017.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2014_04\/pic_944_016.png\")
<\/p>\n![\"Formular](\"..\/fileadmin\/_temp_\/2014_04\/pic_944_018.png\")
<\/p>\nPrivate Sub <\/span>cmdDateiAuswaehlen_Click()\r\n Dim <\/span>strDokument As String<\/span>\r\n Dim <\/span>lngDokumentID As Long<\/span>\r\n strDokument = OpenFileName(CurrentProject.Path, \"Dokument auswählen\", _\r\n \"Word-Dokumente (*.doc;*.docx)\")\r\n lngDokumentID = WordDokumentEinlesen(strDokument)\r\n If <\/span>Len<\/span>(lngDokumentID) > 0 Then<\/span>\r\n Me.Requery\r\n Me.Recordset.FindFirst \"DokumentID = \" & lngDokumentID\r\n Me!sfmDokumente.Form.Requery\r\n Me!txtRichtext = RichTextErstellen(Me!DokumentID)\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Darstellung](\"..\/fileadmin\/_temp_\/2014_04\/pic_944_002.png\")
<\/p>\nPublic 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 lngDokumentID = DokumentSpeichern(strDokument)\r\n If <\/span>Not<\/span> lngDokumentID = 0 Then<\/span>\r\n For Each objAbsatz In objDokument.Paragraphs\r\n AbsatzSpeichern objAbsatz.Range.ParagraphStyle, objAbsatz.Range.Text, lngDokumentID\r\n Next<\/span> objAbsatz\r\n End If<\/span>\r\n DokumentSchliessen objDokument\r\nEnd Sub<\/span><\/pre>\nDim <\/span>objWord As <\/span>Word.Application<\/pre>\nPublic Function <\/span>DokumentSpeichern(strDokument As String<\/span>) As Long<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>intError As Integer<\/span>\r\n Dim <\/span>lngDokumentID As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n On Error Resume Next<\/span>\r\n db.Execute \"INSERT INTO tblDokumente(Dokument) VALUES(''\" & strDokument & \"'')\", dbFailOnError\r\n intError = Err.Number\r\n On Error GoTo<\/span> 0\r\n Select Case intError\r\n Case <\/span>3022\r\n If MsgBox<\/span>(\"Ein gleichnamiges Dokument ist bereits vorhanden. " _\r\n & "überschreiben (Ja) oder unter neuem \" _\r\n & \"Namen speichern (Nein)\", vbYesNo, \"Dokument vorhanden\") = vbYes Then\r\n lngDokumentID = DLookup(\"DokumentID\", \"tblDokumente\", _\r\n & \"Dokument = ''\" & strDokument & \"''\")\r\n db.Execute \"DELETE FROM tblAbsaetze WHERE DokumentID = \" & lngDokumentID\r\n Else<\/span>\r\n If <\/span>BezeichnungErmitteln(strDokument, \"tblDokumente\", \"DokumentID\", \"Dokument\") _\r\n = True<\/span> Then<\/span>\r\n db.Execute \"INSERT INTO tblDokumente(Dokument) VALUES(''\" & strDokument & \"'')\"\r\n lngDokumentID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n End If<\/span>\r\n End If<\/span>\r\n Case <\/span>0\r\n lngDokumentID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Fehler \" & Err.Number & \", ''\" & Err.Description & \"''\"\r\n End Select<\/span>\r\n DokumentSpeichern = lngDokumentID\r\n Set<\/span> db = Nothing\r\nEnd Function<\/span><\/pre>\nINSERT INTO tblDokumente(Dokument) VALUES(''c:\\Beispiel.docx'')<\/pre>\nDELETE FROM tblAbsaetze \r\nWHERE DokumentID = 5<\/pre>\n
Public Sub <\/span>AbsatzSpeichern(strAbsatzformat As String<\/span>, strAbsatzinhalt As String<\/span>, lngDokumentID As Long<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>lngAbsatzformatID As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n lngAbsatzformatID = LookupIDErmitteln(\"tblAbsatzformate\", \"AbsatzformatID\", _\r\n \"Absatzformat\", strAbsatzformat)\r\n db.Execute \"INSERT INTO tblAbsaetze(DokumentID, AbsatzformatID, Inhalt) VALUES(\" _\r\n & lngDokumentID & \", \" & lngAbsatzformatID & \", ''\" _\r\n & Replace<\/span>(Replace<\/span>(Replace<\/span>(strAbsatzinhalt, \"''\", \"''''\"), vbCr<\/span>, \"\"), vbLf<\/span>, \"\") _\r\n & \"'')\", dbFailOnError\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n\n
INSERT INTO tblAbsaetze(DokumentID, AbsatzformatID, Inhalt) \r\nVALUES(37, 2, ''Einleitung des Textes'')<\/pre>\n
\n
![\"Daten](\"..\/fileadmin\/_temp_\/2014_04\/pic_944_003.png\")
<\/p>\n<ul>\r\n<li>Erster Auflistungspunkt<\/li>\r\n<li>Zweiter Auflistungspunkt<\/li>\r\n<\/ul><\/pre>\n
![\"HTML-Auszeichnungen](\"..\/fileadmin\/_temp_\/2014_04\/pic_944_004.png\")
<\/p>\nPublic Function <\/span>RichTextErstellen(lngDokumentID As Long<\/span>) As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strText As String<\/span>\r\n Dim <\/span>strFormatVorher As String<\/span>\r\n Dim <\/span>strExtraAuszeichnungVorherigerAbsatz As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM qryAbsaetzeHTML WHERE DokumentID = \" _\r\n & lngDokumentID, dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n If <\/span>Len<\/span>(rst!HTMLAuszeichnungStartExtra) > 0 Then<\/span>\r\n If <\/span>Not<\/span> rst!Absatzformat = strFormatVorher Then<\/span>\r\n If <\/span>Len<\/span>(strExtraAuszeichnungVorherigerAbsatz) > 0 Then<\/span>\r\n strText = strText & strExtraAuszeichnungVorherigerAbsatz & vbCrLf<\/span>\r\n End If<\/span>\r\n strText = strText & rst!HTMLAuszeichnungStartExtra & vbCrLf<\/span>\r\n End If<\/span>\r\n strExtraAuszeichnungVorherigerAbsatz = rst!HTMLAuszeichnungEndeExtra & vbCrLf<\/span>\r\n Else<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(strExtraAuszeichnungVorherigerAbsatz) = 0 Then<\/span>\r\n strText = strText & strExtraAuszeichnungVorherigerAbsatz\r\n strExtraAuszeichnungVorherigerAbsatz = \"\"\r\n