<\/p>\n
André Minhorst, Duisburg<\/b><\/p>\n
Eines der größten Hindernisse bei der Verschmelzung von Datenbankanwendung und Textverarbeitung ist die fehlende Fähigkeit von Access, formatierte Texte zu verarbeiten. Dies ist aber zum Beispiel mit RTF-Editoren möglich, die es auch als ActiveX-Steuerelemente für Access gibt. Von den zwei bekanntesten Alternativen „Total Access Memo“ und „RTF2 Active Control“ lernen Sie im vorliegenden Beitrag das Letztere, Kostenlose kennen. Mit ein paar Tricks ist es damit sogar möglich, mehrseitige Dokumente mit sauberen Umbrüchen auf den Seiten eines Berichts zu verteilen. <\/b><\/p>\nHinweis<\/h3>\n
Sie finden die Beispieldatenbanken RTF97.mdb (Access 97) und RTF00.mdb (Access 2000 und höher) auf der beiliegenden Heft-CD im Verzeichnis \\mdb oder im Bereich Magazine von www.access-im-unternehmen.de. Bitte beachten Sie, dass für die Verwendung der Beispieldatenbanken die Installation eines zusätzlichen Steuerelements erforderlich ist (s. Kapitel 1). <\/p>\n
Die Darstellung von Texten mit unterschiedlich formatierten Bereichen ist mit den Bordmitteln von Access nur in bestimmten Fällen möglich – nämlich bei der Verwendung unterschiedlicher Steuerelemente für die verschiedenen Textformatierungen. Da dies nicht praxisrelevant ist, behilft man sich externer Steuerelemente.<\/p>\n
Das Rich Textbox Control von Microsoft kann zur Eingabe von Texten im RTF-Format in Formularen, aber nicht zu deren Ausgabe in Berichten verwendet werden. <\/p>\n
Eine kostenpflichtige Alternative ist das Steuerelement Total Access Memo von FMS. Es kann in Formularen und Berichten eingesetzt werden, schlägt aber mit knapp 300 Euro für eine einzelne Lizenz zu Buche. Dafür kann es als Bestandteil eigener Lösungen kostenlos verteilt werden (weitere Informationen unter www.fmsinc.com).<\/p>\n
Die Freeware-Alternative heißt RTF2 Active Control und ist bei Stephen Lebans unter www.lebans.com erhältlich. Da es sich hierbei um ein kostenloses Steuerelement handelt, soll es im vorliegenden Beitrag vorgestellt werden.<\/p>\n
Access lässt an keiner Stelle unterschiedlich formatierte Texte innerhalb eines Standardsteuerelements beziehungsweise Tabellenfeldes zu – es sei denn, Sie verwenden ein OLE-Feld und bringen dort ein Word-Dokument oder ähnliches unter. Für manche Anwendungen ist es aber durchaus sinnvoll, mit unterschiedlichen Formatierungen zu arbeiten. Eine dieser Anwendungen ist die in der vorliegenden Ausgabe von Access im Unternehmen vorgestellte Musterlösung zum Verwalten von Briefen.<\/p>\n
Die erwähnten RTF-Steuerelemente dienen zum Eingeben, Bearbeiten und Formatieren von Texten. Die beiden Letzteren und damit auch das hier vorgestellte RTF2 Active Control können außerdem in Berichten verwendet werden. Sollen die eingegebenen Texte inklusive Formatierungen in einer Tabelle gespeichert werden, ist dazu ein Memofeld erforderlich. Dort speichert Access den Inhalt des Steuerelements inklusive der benötigten Angaben zur Formatierung. Das Steuerelement wandelt die Steuerzeichen zur Anzeige in Formularen und Berichten entsprechend um.<\/p>\n
Das RTF2 Active Control kann von der Internetseite von Stephan Lebans (www.lebans.com) heruntergeladen werden. Nach dem Entpacken und Installieren steht das Steuerelement in Access in der Liste der ActiveX-Steuerelemente zur Verfügung.<\/p>\n
Um das Steuerelement einem Formular hinzuzufügen, gehen Sie folgendermaßen vor:<\/p>\n
![](\"..\/fileadmin\/_temp_\/{BB709B72-EA62-47F3-B9AF-93A2A9E5F460}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Bild 1: Das RTF2-Steuerelement in der Entwurfsansicht<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 2: Formateinstellungen per Kontextmenü<\/span><\/b><\/p>\n Wenn Sie das Formular nun in der Formularansicht anzeigen, können Sie zunächst einmal recht wenig mit dem Steuerelement anstellen. Ein Klick mit der rechten Maustaste öffnet aber direkt das Kontextmenü (siehe Bild 2). Damit lassen sich alle benötigten Formateinstellungen vornehmen (vorausgesetzt, Sie möchten mit Access keine mehrspaltigen Bücher schreiben – in diesem Fall sei Ihnen die Verwendung von Word empfohlen).<\/p>\n Wenn Sie den mit dem Steuerelement eingegebenen Text in einer Tabelle speichern möchten, müssen Sie zunächst die Datenherkunft des Formulars auf die Tabelle einstellen und die Eigenschaft Steuerelementinhalt des RTF2-Steuerelements auf das Feld einstellen, in dem die Daten gespeichert werden sollen.<\/p>\n Erstellen Sie zu Testzwecken eine Tabelle wie in Bild 3. öffnen Sie das Formular mit dem RTF2-Steuerelement in der Entwurfsansicht und stellen Sie die Eigenschaft Datenherkunft auf den Wert tblRTF ein.<\/p>\n Aktivieren Sie das RTF2-Steuerelement und wählen Sie für die Eigenschaft Steuerelementinhalt den Eintrag RTFInhalt aus.<\/p>\n Wechseln Sie nun in die Formularansicht und geben Sie einen beliebigen Text ein. Wenn Sie nach der Aktualisierung des Datensatzes die Tabelle öffnen, finden Sie die Fassung des Textes inklusive Formatdefinition vor (siehe Bild 4).<\/p>\n Wie hier gut zu erkennen ist, schart sich eine Menge kryptisch anmutendender Steuerelemente rund um den eigentlichen Text. Prinzipiell ähnelt RTF der Sprache HTML: Es gibt einen Kopf mit allgemeinen Informationen und verschiedene Absätze, denen absatzweit gültige Steuerelemente vorangestellt sind und die auch innerhalb des Textes Steuerelemente zur speziellen Auszeichnung bestimmter Textelemente enthalten können.<\/p>\n Das RTF2-Steuerelement enthält eine eigene Bibliothek von Methoden und Eigenschaften, mit denen sich das Steuerelement anpassen lässt. Einen Großteil der Möglichkeiten können Sie anhand der beiden ebenfalls auf der Internetseite von Stephen Lebans erhältlichen Beispieldatenbanken kennen lernen. Die beiden Beispieldatenbanken für Access 97 und Access 2000 enthalten speziell auf dieses Steuerelement zugeschnittene Menüleisten, die die Anwendung der zur Verfügung stehenden Eigenschaften ausreichend dokumentieren.<\/p>\n Falls Sie keine Menüleiste verwenden möchten, sondern mit im Formular integrierten Schaltflächen vorlieb nehmen, sollten Sie Folgendes beachten: Die Ausstattung von Schaltflächen mit Symbolen ist nur beschränkt möglich.<\/p>\n <\/b><\/p>\n Bild 3: Tabelle zum Speichern von RTF-Texten<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 4: Ein RTF-Text im Memofeld einer Tabelle<\/span><\/b><\/p>\n Da Microsoft mit Windows XP vom ehemaligen Einheitsgrau für Schaltflächen auf ein anderes Grau wechselte, führt die Verwendung von eigenen Schaltflächen zu optischer Verwirrung:<\/p>\n Der Hintergrund der Schaltflächen passt sich nämlich nicht dem neuen Grau an und hinterlässt damit einen sehr unprofessionell wirkenden Eindruck.<\/p>\n Die Verwendung von Schaltflächen auf einer Symbolleiste ist also zumindest dann sinnvoller, wenn Sie keinen Text, sondern Symbole zur Beschreibung der jeweiligen Funktion verwenden möchten.<\/p>\n Weitere Hinweise zur Erstellung von benutzerdefinierten Menüleisten erhalten Sie in den Beiträgen Dynamische Menüs mit VBA in Ausgabe 4\/2003 und Benutzerabhängige Befehlsleisten in der vorliegenden Ausgabe von Access im Unternehmen. <\/p>\n Ob Sie die Formatierung nun per Formular- oder Menüleistenschaltfläche anpassen möchten, bleibt Ihren persönlichen Vorlieben überlassen.<\/p>\n Tatsache ist, dass Sie die Funktionen zur Durchführung der Formatänderungen bereitstellen müssen.<\/p>\n Zur Nutzung des vollen Befehlsumfangs eines Steuerelements lohnt sich immer ein Blick in den Objektkatalog. Dazu aktivieren Sie das Testfenster (am schnellsten über die Tastenkombination Strg + G) und betätigen dann die Taste F2.<\/p>\n Im nun erscheinenden Objektkatalog (siehe Bild 5) wählen Sie den Eintrag RTF2Lib aus dem oberen Kombinationsfeld aus. Die Klasse RTF2 enthält eine übersicht über alle Methoden und Eigenschaften des Steuerelements, die übrigen Einträge sind Auflistungen von möglichen Parametern für einige Eigenschaften.<\/p>\n <\/b><\/p>\n Bild 5: Der Objektkatalog von Access<\/span><\/b><\/p>\n Quellcode 1<\/b><\/p>\n <\/p>\n Quellcode 2<\/b><\/p>\n Sie benötigen nun nur noch die Information, wie Sie auf die aktuelle Markierung im RTF2-Steuerelement zugreifen können. Dazu verwenden Sie den folgenden Ausdruck:<\/p>\n Er bezieht sich auf das jeweils aktuelle Steuerelement. Wenn das RTF-Steuerelement aktiv ist, wirken sich die Formatierungen auf die jeweils markierten Bereiche des Steuerelements aus.<\/p>\n Die in der Beispieldatenbank vorhandenen Funktionen zur Durchführung sind weitgehend den Beispieldatenbanken von Stephen Lebans entnommen und geringfügig angepasst worden. <\/p>\n Als Beispiel für die Funktion der unterschiedlichen Formatierungsfunktionen des Steuerelements dient das aus Quellcode 1. Die Funktion weist der Variablen Markierung das aktuelle Steuerelement hinzu, was gleichbedeutend mit der aktuellen Markierung ist. Sie überprüft, ob die Markierung nicht leer ist und führt dann die Formatierung für den markierten Bereich durch.<\/p>\n Einige Formatierungen können über den herkömmlichen Schriftarten-Dialog vorgenommen werden. Mit der Prozedur aus Quellcode 2 können Sie diesen Dialog aufrufen und die getroffenen Einstellungen auf die Markierung anwenden.<\/p>\n Der Grund für die Verwendung von Daten im RTF-Format ist die formatierte Ausgabe von Texten per Bericht. Das bringt einige Probleme mit, die sich allerdings mit ein wenig Programmieraufwand umgehen lassen. In den folgenden Abschnitten erfahren Sie, wie Sie mit dem RTF2-Steuerelement erstellte Texte optimal in Berichten anzeigen.<\/p>\n Fügen Sie dem Detailbereich eines neuen Berichts das RTF2-Steuerelement hinzu. Die Vorgehensweise ist die Gleiche wie beim Formular. Nach dem Hinzufügen des Steuerelements wählen Sie die Tabelle tblRTF als Datenherkunft des Berichtes und das Feld RTFINhalt als Steuerelementinhalt für das RTF-Steuerelement aus.<\/p>\n Das Ergebnis finden Sie in Bild 6. Die Anzeige erfolgt mit den festgelegten Formatierungen.<\/p>\n <\/b><\/p>\n Bild 6: Anzeigen eines RTF-Textes per Bericht<\/span><\/b><\/p>\n Das RTF2-Steuerelement bringt keine Vergrößerbar- beziehungsweise Verkleinerbar-Eigenschaft mit. Das bedeutet, dass Sie mit einem Trick arbeiten müssen.<\/p>\n Wenn Sie die Größe des Steuerelements und auch des Detailbereiches dynamisch an den Inhalt des Steuerelements anpassen möchten, gehen Sie folgendermaßen vor:<\/p>\n Quellcode 3<\/b><\/p>\n Die beschriebene Vorgehensweise ist weitgehend der FAQ des Total Access Memo (www.fmsinc.com) entnommen, funktioniert aber auch mit dem vorliegenden Steuerelement. <\/p>\n Mit der beschriebenen Vorgehensweise wird der Detailbereich des Berichts exakt der Höhe des RTF2-Steuerelements angepasst. Das funktioniert auch, wenn der Bericht mehrere RTF-Dokumente anzeigen soll – die Höhe wird an jedes einzelne in einem Datensatz enthaltene Dokument angepasst.<\/p>\n Die Verwendung des RTF2-Steuerelements in Berichten bringt das gleiche Problem wie die Verwendung jedes anderen Steuerelements mit sich, dessen Inhalt nicht auf eine Seite passt.<\/p>\n Es sieht keine Möglichkeit vor, den Inhalt kontrolliert zu umbrechen. Daher gibt es zwei Möglichkeiten: Entweder man verwendet mehrere Richtext-Elemente in einem Bericht, die beispielsweise einen Absatz lang sind, oder man versucht, den Seitenumbruch programmatisch zwischen zwei Textzeilen zu legen.<\/p>\n Beides ist mit Aufwand verbunden: Wenn Sie Textelemente auf mehrere mit dem Hauptdatensatz verbundene Elemente aufteilen, müssen Sie sicherstellen, dass die Reihenfolge der Elemente anpassbar und die Elemente an beliebigen Positionen vor oder hinter bestehenden Elementen platziert werden können.<\/p>\n Um ein einzelnes, langes Richtext-Element an der richtigen Stelle zu umbrechen, ist ebenfalls größerer Aufwand erforderlich. Access bricht automatisch am unteren Ende des Steuerelements ab und arbeitet dabei pixelgenau und nicht zeilenweise wie Textverarbeitungen wie Microsoft Word (siehe Bild 7). <\/p>\n <\/b><\/p>\n Bild 7: Pixelgenauer Umbruch des RTF2-Steuerelements<\/span><\/b><\/p>\n Ein Lösungsansatz wäre, die Zeile zu ermitteln, die den Seitenumbruch enthält, und vor dieser Zeile eine Leerzeile einzusetzen. So würde der Zeilenumbruch genau auf einer Leerzeile stattfinden und nicht zu sehen sein. Allerdings beginnt dann die folgende Seite beispielsweise mit einer halben Leerzeile, was möglicherweise die Optik stört. Hier anzusetzen würde aber wahrscheinlich bedeuten, ein komplett neues RTF-Steuerelement zu entwickeln.<\/p>\n Das Problem des Seitenumbruchs lässt sich allerdings auch auf einfache Weise lösen: Auch in Word und anderen Textverarbeitungen ist manchmal ein wenig Nacharbeiten erforderlich, um Schönheitsfehler wie Hurensöhne und Schusterjungen zu verhindern.<\/p>\n Wie die nachfolgenden Abschnitte zeigen werden, lassen sich mit einer Kombination aus den ersten beiden Vorschlägen recht beachtliche Ergebnisse erzielen.<\/p>\n Die in den vorherigen Abschnitten beschriebene Problematik soll durch ein paar Tricks und ein wenig RTF-Grundlagenkenntnis umgangen werden.<\/p>\n Dabei ist es wichtig zu wissen, dass RTF im Prinzip wie HTML aufgebaut ist: Der Anfang eines RTF-Dokumentes enthält einige allgemeine Informationen über die verwendete Syntax, Auflistungen von Schriftarten und so weiter. Die weiteren Absätze werden ähnlich wie in HTML durch einleitende Formatbeschreibungen wie Schriftart, Schriftgröße und so weiter definiert. Am Ende eines jeden Absatzes steht ein entsprechendes Element, um den Zeilenumbruch zu bewirken. Bereiche mit besonderen Markierungen wie beispielsweise fett gedruckte Worte werden von entsprechenden Markierungen eingeschlossen.<\/p>\n Der Trick beim Aufteilen eines langen Textes in die einzelnen Absätze ist nun, einen Parser zu programmieren, der zunächst den Kopf des Dokumentes ermittelt, das Dokument in seine Absätze aufteilt und anschließend durch Voranstellen des Kopfes viele neue RTF-Dokumente erstellt.<\/p>\n Das Ganze ist natürlich nicht so trivial, wie hier beschrieben, aber auch nicht gerade ungemein kompliziert.<\/p>\n Grundlage für die Entwicklung eines Algorithmus zur Aufteilung von RTF-Dokumenten ist die Kenntnis der Syntax der Steuerelemente einer solchen Datei. Die Syntax ist genormt und kann in dem unter ftp:\/\/ftp.microsoft.com\/softlib\/mslfiles\/GC0165.EXE zu findenden Word-Dokument eingesehen werden.<\/p>\n Die Aufteilung eines RTF-Dokuments bringt mit sich, dass änderungen nicht mehr so leicht zu realisieren sind. Daher behalten Sie einfach das Originaldokument und speichern die einzelnen Absätze für die Anzeige des Berichts temporär in einer speziell dafür vorgesehenen Tabelle.<\/p>\n Die Tabelle ist wie in Bild 8 aufgebaut. Die drei Felder Originalabsatz, Kopfdaten, Steuerzeichen und Inhalt sind prinzipiell überflüssig. Sie können bei eventuell auftretenden Problemen oder Weiterentwicklungen für das Debuging verwendet werden. Das Feld RTFID enthält die ID des Ursprungsdokuments. Der Inhalt der neuen Absätze wird im Feld RTFAbsatz gespeichert. Das Feld ReihenfolgeID enthält eine fortlaufende Nummerierung der Absätze in der richtigen Reihenfolge.<\/p>\n Quellcode 4 (Start)<\/b><\/p>\n <\/b><\/p>\n Bild 8: Aufbau der Tabelle tblRTFAbsaetze<\/span><\/b><\/p>\n Die Funktion RichtextAufteilen ist für das Aufteilen eines RTF-Dokumentes in seine einzelnen Abschnitte zuständig (s. Quellcode 4). Als übergabeparameter erwartet sie die ID des Datensatzes aus der Tabelle tblRTF, in dem sich das Originaldokument befindet.<\/p>\n Die Funktion öffnet zunächst die Tabelle tblRTFAbsaetze und löscht alle enthaltenen Datensätze. Dann liest sie den Quellcode des RTF-Dokuments in die Variable strRichtext ein. In den nächsten Schritten werden die umschließenden geschweiften Klammern entfernt, Zeilenumbrüche durch Leerzeichen ersetzt beziehungsweise gelöscht und der Kopf des Dokuments entfernt und in der Variablen strKopfdaten gespeichert. Die Zeilenumbrüche können entfernt werden, da das Steuerzeichen \\par bereits auf das Absatzende hinweist. Der in der Variablen strRichtext verbleibende Rest des RTF-Dokuments enthält den eigentlichen Inhalt des Dokuments mit den Steuerzeichen.<\/p>\n Quellcode 4<\/b><\/p>\n In einer Do While-Schleife werden die Absätze nach und nach in je einem Datensatz der Tabelle tblRTFAbsaetze gespeichert. Das geschieht in mehreren Etappen: Zunächst werden die einzelnen Informationen, die leicht aus dem jeweiligen Abschnitt bis zum nächsten \\par-Steuerelement zu ermitteln sind, eingelesen. Dabei wird der Teil mit den allgemein für den Absatz geltenden Formatelementen vom eigentlichen Text getrennt.<\/p>\n In der Funktion SteuerzeichenFuerNaechstenAbsatz wird genau ermittelt, welche änderungen sich innerhalb eines Absatzes befinden und ob diese auch für den nächsten Absatz gelten. Den Quellcode finden Sie in den Beispieldatenbanken auf der Heft-CD.<\/p>\n Quellcode 5<\/b><\/p>\n Quellcode 6<\/b><\/p>\n In der Menüleiste der Beispieldatenbanken finden Sie ebenfalls nur die hier aufgelisteten Möglichkeiten der Formatierung. Weitere Formate können bei Bedarf implementiert werden.<\/p>\n Nach der Ermittlung der allgemein gültigen Steuerelemente für den aktuellen Absatz wird aus dem Absatz eine gültige RTF-Datei erzeugt. Dazu werden die Kopfdaten, Steuerelemente und der eigentliche Inhalt zusammengesetzt, von geschweiften Klammern eingeschlossen und im Feld RTFAbsatz gespeichert.<\/p>\n <\/b><\/p>\n Bild 9: Beispiel für einen Bericht mit RTF-Inhalt<\/span><\/b><\/p>\n Zum Ersetzen der Zeilenumbrüche durch Leerzeichen wird die Funktion ZeichenErsetzen verwendet. Ab Access 2000 steht für diese Zwecke die eingebaute VBA-Funktion Replace zur Verfügung. Die Funktion ZeichenErsetzen erwartet die Ausgangszeichenkette, die zu ersetzende und die neue Zeichenkette als übergabeparameter (s. Quellcode 5).<\/p>\n Die Funktion SchliessendeKlammerFinden ist nicht so trivial, wie der Titel andeutet: In der Tat findet sie nicht einfach die nächste schließende Klammer, sondern die schließende Klammer, die zu der ersten in der übergebenen Zeichenkette gefundenen öffnenden Klammer gehört (s. Quellcode 6). Das bedeutet, dass eventuell vorhandene weitere Klammern ignoriert werden.<\/p>\n Um das aufgesplittete RTF-Dokument im Zusammenhang zu betrachten, können Sie im Prinzip den weiter oben beschriebenen Bericht verwenden.<\/p>\n Sie müssen lediglich die Eigenschaft Datenherkunft auf die Tabelle tblRTFAbsaetze einstellen und darauf achten, dass die Absätze in der richtigen Reihenfolge sortiert sind. Da die Absätze aber in der richtigen Reihenfolge angelegt wurden und Access ohne weitere Angaben nach dem Primärindex sortiert, sind hier keine weiteren Maßnahmen zu treffen. Das Ergebnis sieht beispielsweise wie in Bild 9 aus.<\/p>\n Die vorgestellte Verwendung des RTF2-Steuerelements berücksichtigt noch nicht all seine Fähigkeiten. Es fehlen noch die Möglichkeiten, automatische Nummerierungen und Auflistungen sowie eingerückte Absätze und Zeilen mit variablen Zeilenabständen auszuführen. Sie könnten diese Funktionen zwar mit wenigen Codezeilen hinzufügen, indem Sie die Menüleiste entsprechend erweitern und die Funktionen zum Zuweisen der entsprechenden Formatierungen hinzufügen. Der Knackpunkt ist aber, dass der Aufwand für das Anpassen der Funktion zum Umwandeln des RTF-Dokuments in viele kleine Dokumente und damit die Ermöglichung der Anzeige mehrseitiger RTF-Dokumente in Berichten relativ hoch ist.<\/p>\n Mit den in der Beispieldatenbank vorliegenden Funktionen sollte dies für ambitionierte Entwickler allerdings möglich sein.<\/p>\n Die volle Funktionalität entfalten die hier vorgestellten Möglichkeiten natürlich in einer Musterlösung, die wir Ihnen in zwei Teilen präsentieren: die Briefverwaltung. <\/p>\n Damit können Sie Access als Textverarbeitung für rudimentäre Anwendungen zweckentfremden und haben überdies die Möglichkeit, Serienbriefe, Mailverteiler, Adressdatenbank und so weiter unter einen Hut zu bringen.<\/p>\n Die vorliegenden Funktionen werden ständig weiterentwickelt. über neue Versionen informieren Sie sich am besten unter www.access-im-unternehmen.de.<\/p>\n","protected":false},"excerpt":{"rendered":" Eines der größten Hindernisse bei der Verschmelzung von Datenbankanwendung und Textverarbeitung ist die fehlende Fähigkeit von Access, formatierte Texte zu verarbeiten. Dies ist aber zum Beispiel mit RTF-Editoren möglich, die es auch als ActiveX-Steuerelemente für Access gibt. Von den zwei bekanntesten Alternativen „Total Access Memo‘ und „RTF2 Active Control‘ lernen Sie im vorliegenden Beitrag das Letztere, Kostenlose kennen. Mit ein paar Tricks ist es damit sogar möglich, mehrseitige Dokumente mit sauberen Umbrüchen auf den Seiten eines Berichts zu verteilen.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662003,66062003,44000024],"tags":[],"class_list":["post-55000135","post","type-post","status-publish","format-standard","hentry","category-662003","category-66062003","category-Berichte_und_Reporting"],"yoast_head":"\n![](\"..\/fileadmin\/_temp_\/{BB709B72-EA62-47F3-B9AF-93A2A9E5F460}\/pic002.png\")
<\/p>\nDas RTF-Steuerelement in Aktion<\/h3>\n
![](\"..\/fileadmin\/_temp_\/{BB709B72-EA62-47F3-B9AF-93A2A9E5F460}\/pic003.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{BB709B72-EA62-47F3-B9AF-93A2A9E5F460}\/pic004.png\")
<\/p>\nHinweis<\/h3>\n
Funktionen zur Formatierung<\/h2>\n
![](\"..\/fileadmin\/_temp_\/{BB709B72-EA62-47F3-B9AF-93A2A9E5F460}\/pic005.png\")
<\/p>\nPublic Function Fett()\r\n Dim Markierung As Object\r\n On Error Resume Next\r\n Set Markierung = Screen.ActiveControl\r\n If Not Markierung Is Nothing Then\r\n Markierung.FontBold = True\r\n End If\r\n Set Markierung = Nothing\r\nEnd Function<\/pre>\n
Public Function Schriftart()\r\n Dim Markierung As Object\r\n Dim Objekt As Object\r\n On Error Resume Next\r\n Set Markierung = Screen.ActiveControl\r\n If Not Markierung Is Nothing Then\r\n Set Objekt = Markierung.SelFont\r\n Set Objekt = Nothing\r\n End If\r\n Set Markierung = Nothing\r\nEnd Function<\/pre>\n
Screen.ActiveControl<\/pre>\n
Hinweis<\/h3>\n
Erstellen des Berichts<\/h2>\n
![](\"..\/fileadmin\/_temp_\/{BB709B72-EA62-47F3-B9AF-93A2A9E5F460}\/pic006.png\")
<\/p>\nGrößenanpassung desSteuerelements<\/h2>\n
Private Sub Detailbereich_Format(Cancel _ As Integer, FormatCount As Integer)\r\n Me!ctlRTF.Height = _ Me!ctlRTF.RTFheight\r\nEnd Sub<\/pre>\n
Hinweis<\/h3>\n
Problem Seitenumbruch<\/h2>\n
![](\"..\/fileadmin\/_temp_\/{BB709B72-EA62-47F3-B9AF-93A2A9E5F460}\/pic007.png\")
<\/p>\nLösung mit Pfiff<\/h3>\n
Verwendung mehrererRTF-Elemente je Dokument<\/h2>\n
Temporäre Aufteilung<\/h2>\n
Public Function RichtextAufteilen(RTFID As Integer) As String\r\n Dim db As Database\r\n Dim rst As Recordset\r\n Dim strRichtext As String\r\n Dim strKopfdaten As String\r\n Dim bolKopfdaten As Boolean\r\n Dim intStart As Integer\r\n Dim intEnde As Integer\r\n Dim strSteuerzeichenVorherigerDatensatz As String\r\n Dim strInhaltVorherigerDatensatz As String\r\n Dim i As Integer\r\n Set db = CurrentDb\r\n db.Execute \"DELETE FROM tblRTFAbsaetze\"\r\n Set rst = db.OpenRecordset(\"tblRTFAbsaetze\", dbOpenDynaset)\r\n strRichtext = DLookup(\"RTFINhalt\", \"tblRTF\", \"RTFID = \" & RTFID)\r\n strRichtext = Mid(strRichtext, 2, Len(strRichtext) - 1)\r\n strRichtext = ZeichenErsetzen(strRichtext, \"\\par\" & Chr(13) & Chr(10), \"\\par \")\r\n strRichtext = ZeichenErsetzen(strRichtext, Chr(13) & Chr(10), \"\")\r\n strKopfdaten = Mid(strRichtext, 1, InStr(1, strRichtext, \"{\") - 1)\r\n strRichtext = Mid(strRichtext, InStr(1, strRichtext, \"{\"))\r\n bolKopfdaten = True<\/pre>\n![](\"..\/fileadmin\/_temp_\/{BB709B72-EA62-47F3-B9AF-93A2A9E5F460}\/pic008.png\")
<\/p>\nAufteilen des RTF-Dokuments<\/h2>\n
Do While bolKopfdaten = True\r\n intStart = InStr(1, strRichtext, \"{\")\r\n If Mid(Trim(strRichtext), 2, 8) = \"\\fonttbl\" Or Mid(Trim(strRichtext), 2, 8) _ = \"\\filetbl\" Or Mid(Trim(strRichtext), 2, 9) = \"\\colortbl\" Or _ Mid(Trim(strRichtext), 2, 11) = \"\\stylesheet\" Or Mid(Trim(strRichtext), _ 2, 11) = \"\\listtables\" Or Mid(Trim(strRichtext), 2, 7) = \"\\revtbl\" Then\r\n intEnde = SchliessendeKlammerFinden(strRichtext)\r\n strKopfdaten = strKopfdaten & Mid(strRichtext, 1, intEnde)\r\n strRichtext = Mid(strRichtext, intEnde + 1)\r\n Else\r\n bolKopfdaten = False\r\n End If\r\n Loop\r\n intEnde = InStr(1, strRichtext, \"\\par \")\r\n i = 1\r\n Do While Not intEnde = 0\r\n rst.AddNew\r\n rst!RTFID = RTFID\r\n rst!Originalabsatz = Mid(strRichtext, 1, intEnde - 1)\r\n rst!Kopfdaten = strKopfdaten\r\n rst!ReihenfolgeID = i\r\n If Left(rst!Originalabsatz, 1) = \"\\\" Then\r\n rst!Steuerzeichen = Mid(rst!Originalabsatz, 1, InStr(1, _ rst!Originalabsatz, \" \"))\r\n rst!Inhalt = Mid(rst!Originalabsatz, InStr(1, rst!Originalabsatz, \" \") _ + 1)\r\n Else\r\n rst!Steuerzeichen = \"\"\r\n rst!Inhalt = rst!Originalabsatz\r\n End If\r\n rst!Steuerzeichen = SteuerzeichenFuerNaechstenAbsatz( _ strSteuerzeichenVorherigerDatensatz, strInhaltVorherigerDatensatz, _ rst!ReihenfolgeID, rst!RTFID, rst!Steuerzeichen)\r\n strSteuerzeichenVorherigerDatensatz = rst!Steuerzeichen\r\n strInhaltVorherigerDatensatz = rst!Inhalt\r\n rst!RTFAbsatz = \"{\" & rst!Kopfdaten & rst!Steuerzeichen & \" \" & rst!Inhalt _ & \"}\"\r\n rst.Update\r\n strRichtext = Mid(strRichtext, intEnde + 5)\r\n intEnde = InStr(1, strRichtext, \"\\par \")\r\n i = i + 1\r\n Loop\r\nEnd Function<\/pre>\nPublic Function ZeichenErsetzen(Zeichenkette As String, Zeichen As String, _ Ersetzen As String)\r\n Dim posZeilenumbruch As Integer\r\n ZeichenErsetzen = Zeichenkette\r\n posZeilenumbruch = InStr(1, ZeichenErsetzen, Zeichen)\r\n Do While Not posZeilenumbruch = 0\r\n ZeichenErsetzen = Left(ZeichenErsetzen, posZeilenumbruch - 1) & Ersetzen _ & Mid(ZeichenErsetzen, posZeilenumbruch + Len(Zeichen))\r\n posZeilenumbruch = InStr(1, ZeichenErsetzen, Zeichen)\r\n Loop\r\nEnd Function<\/pre>\n
Public Function SchliessendeKlammerFinden(Richtext As String) As Integer\r\n Dim i As Integer\r\n Dim KlammerAuf As Integer\r\n Dim KlammerZu As Integer\r\n KlammerAuf = 0\r\n KlammerZu = 0\r\n For i = 1 To Len(Richtext)\r\n If Mid(Richtext, i, 1) = \"{\" Then\r\n KlammerAuf = KlammerAuf + 1\r\n ElseIf Mid(Richtext, i, 1) = \"}\" Then\r\n KlammerZu = KlammerZu + 1\r\n End If\r\n If KlammerAuf = KlammerZu Then\r\n SchliessendeKlammerFinden = i\r\n Exit For\r\n End If\r\n Next i\r\nEnd Function<\/pre>\n![](\"..\/fileadmin\/_temp_\/{BB709B72-EA62-47F3-B9AF-93A2A9E5F460}\/pic009.png\")
<\/p>\nZeichen ersetzen<\/h3>\n
Finden von schließenden Klammern<\/h3>\n
Anzeigen des Dokuments<\/h2>\n