<\/p>\n
Haben Sie schon einmal einen Access-Bericht missbraucht Um beispielsweise ein Kalenderblatt zu erstellen oder ein Sudoku zu drucken Dann haben Sie sicher auf eine entsprechende Datenherkunft zurückgegriffen, denn ohne diese lassen Berichte sich nur bedingt mit Informationen füllen. Dieser Beitrag zeigt, wie Sie auch ohne Daten eine Menge mit Berichten anstellen. Dabei sollen zunächst der Inhalt einer Textdatei und später der eines Moduls in Berichtsform abgebildet werden – Letzteres mit entsprechender Färbung von Kommentarzeilen und Schlüsselwörtern!<\/b><\/p>\n
Normalerweise läuft die Berichtserstellung etwa so ab: Sie überlegen sich den Aufbau des Berichts, stellen dann die benötigten Tabellen in einer Abfrage zusammen (oder auch in mehreren, wenn Unterberichte zum Einsatz kommen) und positionieren dann die an die Datenherkunft gebundenen Steuerelemente im Bericht.<\/p>\n
Was aber, wenn die auszugebenden Daten gar nicht in Tabellenform vorliegen Vielleicht möchten Sie ja einfach mal eine Textdatei in Berichtsform abbilden oder auch ein Codemodul (wobei dies den Charme hätte, dass man bestimmte Code-Elemente farbig darstellen könnte – der VBA-Editor bietet diese Möglichkeit nicht).<\/p>\n
Zunächst kümmern wir uns um die Anzeige einer einfachen Textdatei in einem Bericht. In diesem Fall haben wir einfach den Inhalt einer Prozedur in eine Textdatei geschrieben. Diese soll nun wie in Bild 1 in einem Bericht dargestellt werden.<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2010_06\/BerichteOhneDatenherkunft-web-images\/pic001.png\")
<\/p>\n
Bild 1: Dieser Bericht druckt den Inhalt einer Textdatei.<\/span><\/b><\/p>\n Zur einfachen Auswahl der Textdatei finden Sie in der Beispielanwendung ein kleines Formular mit einem Textfeld zur Anzeige des Dateinamens und einer Schaltfläche zum Öffnen eines Dateiauswahl-Dialogs (s. Bild 2). Die Schaltfläche mit der Beschriftung Datei in Bericht anzeigen <\/b>erledigt nichts weiter als das Öffnen des Berichts rptTextdatei <\/b>in der Vorschauansicht. Dabei übergibt die durch die Schaltfläche ausgelöste Prozedur den Namen der anzuzeigenden Textdatei als Öffnungsparameter an den Bericht (da dies erst ab Access 2002 möglich ist, prüft der Bericht beim Öffnen, ob OpenArgs<\/b> einen Wert enthält, und fragt gegebenenfalls direkt den Inhalt des Textfelds mit dem Dateinamen ab).<\/p>\n Bild 2: Die Auswahl der auszugebenden Textdatei erfolgt komfortabel per Formular.<\/span><\/b><\/p>\n Bericht aus Datei füllen<\/b><\/p>\n Damit bewegen wir uns nun aus der Komfortzone der bekannten Techniken heraus und betrachten die Vorgehensweise, einen Bericht zeilenweise mit dem Inhalt einer Textdatei zu füllen.<\/p>\n Die Daten sollen in einem Bericht namens rptTextdatei<\/b> erscheinen. Diesen legen Sie neu an und stellen die Größe seiner Bereiche etwa wie in Bild 3 ein.<\/p>\n Bild 3: Entwurf des Berichts zur Ausgabe von Textdateien<\/span><\/b><\/p>\n Danach benötigen Sie zwei Variablen, die Sie gleich oben im Klassenmodul des Berichts unterbringen. Das Klassenmodul fügen Sie am einfachsten zum Bericht hinzu, indem Sie die Berichtseigenschaft Enthält Modul <\/b>auf Ja <\/b>einstellen. Die Variablen speichern den Namen der Textdatei sowie die aktuell bearbeitete Zeile der Textdatei:<\/p>\n Im Prinzip durchlaufen wir dann die Textdatei auf die gewohnte Weise, also etwa mit folgenden Anweisungen:<\/p>\n Allein die Aufteilung und die Realisierung der Schleife sieht anders aus. Beginnen wir mit dem Öffnen des Berichts und somit auch der Textdatei. Beim Öffnen des Berichts soll das Ereignis Beim Öffnen <\/b>ausgelöst werden, weshalb Sie dem gleichnamigen Ereignis den Wert [Ereignisprozedur] <\/b>zuweisen und nach einem Klick auf die Schaltfläche rechts von der Eigenschaft den automatisch angelegten Prozedurrumpf wie folgt ergänzen:<\/p>\n Diese Prozedur prüft, ob das Öffnungsargument einen Dateinamen enthält. Falls nein, wird dieser direkt aus dem Textfeld txtDatei<\/b> des aufrufenden Formulars ermittelt. Ist dieses gar nicht geöffnet, bricht die Anzeige des Berichts an dieser Stelle mit einer kurzen Meldung ab. Ist jedoch eine Textdatei angegeben, wird ihr Name in die Variable strTextdatei <\/b>eingetragen. Die letzte Zeile öffnet die Datei schließlich für den lesenden Zugriff. Nun prüft der Bericht, ob er irgendwelche Daten in den Detailbereich schreiben soll. Auch wenn die Datenherkunft des Berichts wie in diesem Fall leer ist, löst er dabei trotzdem zumindest einmalig die beiden Ereignisse Beim Formatieren <\/b>und Beim Drucken <\/b>des Detailbereichs aus. Wenn Sie keine außergewöhnlichen Anweisungen in den entsprechenden Ereignisprozeduren hinterlegen, geschieht nichts und der Bericht wird ohne Daten im Detailbereich angezeigt.<\/p>\n Das gilt es zu verhindern: Wir wollen dafür sorgen, dass der Bericht im Detailbereich die Zeilen unserer Textdatei anzeigt. Dazu gibt es nun zwei Möglichkeiten:<\/p>\n Die erste Variante wäre einfach, denn dies können wir durch einen schlichten Aufruf der Print<\/b>-Methode des Berichts erledigen. Wir müssen einfach nur den Detailbereich so groß wie möglich machen, damit dieser (mit ein wenig Glück) die komplette Textdatei fasst.<\/p>\n Aber was geschieht, wenn die Datei nicht auf eine Berichtsseite passt Der Rest wird schlicht abgeschnitten. Dem können wir nur entgegenwirken, indem wir berechnen, wie viele Zeilen in einen Detailbereich passen, und den Inhalt der Textdatei darauf aufteilen. Das scheint kompliziert zu sein, also schauen wir uns zunächst die zweite Variante an.<\/p>\n Wenn wir jede Zeile in einen Detailbereich schreiben, gibt es kaum Probleme – zumindest, wenn sich der Bericht beim Hinzufügen von Inhalten mit der Print<\/b>-Methode genau so verhält wie sonst: Er sollte einen Detailbereich, der nicht mehr auf die aktuelle Seite passt, einfach auf die folgende Seite verschieben.<\/p>\n Bleibt das Problem, dass wir nicht wissen, wie wir den Bericht dazu bewegen, auch ohne Datenquelle mehr als einen Detailbereich anzuzeigen.<\/p>\n Hier kommen zwei Eigenschaften des Berichts zum Tragen. Diese können Sie jeweils im Beim Formatieren<\/b>-Ereignis der einzelnen Berichtsereignisse unterbringen:<\/p>\n Diese beiden Eigenschaften machen wir uns zunutze: Mit Me.MoveLayout = True <\/b>sorgen wir dafür, dass die folgende Zeile der Textdatei links unter der aktuellen Zeile ausgegeben wird. Dazu muss es aber erst einmal kommen: Der Bericht druckt nämlich den Detailbereich nur einmal, wenn die Datenherkunft keine weiteren Daten enthält. Und in unserem Fall enthält diese ja gar keine Daten – nach dem ersten Durchlauf wäre also eigentlich Schluss.<\/p>\n Dieser hier unerwünschten Arbeitsverweigerung des Berichts können wir durch Setzen der Eigenschaft Me.NextRecord <\/b>auf False <\/b>vorbeugen: Dann versucht der Bericht nämlich nicht, zum nicht vorhandenen zweiten Datensatz zu springen, sondern druckt den aktuellen Bereich nochmals.<\/p>\n Im Detail profitieren wir davon in den beiden Ereignisprozeduren Beim Formatieren <\/b>und Beim Drucken<\/b>. In Beim Formatieren <\/b>lesen wir jeweils eine Zeile der Textdatei ein. Dort stellen wir auch die Höhe des Bereichs auf einen passenden Wert ein. Schließlich erhält die Eigenschaft MoveLayout <\/b>den Wert True<\/b>, wenn noch die letzte Zeile eingelesen wurde, und False<\/b>, wenn dies die letzte Zeile war. Sprich: Enthält die Textdatei noch ungedruckte Zeilen, mache noch einen Detailbereich auf und fahre fort.<\/p>\n Die Eigenschaft NextRecord <\/b>bestücken wir mit dem umgekehrten Wert der Eigenschaft MoveLayout<\/b>: Wenn noch Zeilen vorliegen, soll der Bericht nicht zum nächsten Datensatz springen. Dort würde er ja bemerken, dass eigentlich gar keine Daten vorliegen, und die Ausgabe gegebenenfalls mit dem übrigen Bereich wie etwa dem Seitenfuß beenden:<\/p>\n Im Ereignis Beim Drucken <\/b>erfolgt schließlich die eigentliche Ausgabe der aktuellen Zeile der Textdatei. Vorher stellen wir jedoch noch einige Texteigenschaften ein und geben dann mit der Print<\/b>-Methode des Berichts den Inhalt der Textzeile in den Bericht aus:<\/p>\n Diese beiden Prozeduren werden entsprechend der Zeilenzahl der Textdatei wiederholt. Probieren Sie dies später ruhig auch mit einer Textdatei aus, die mehr als eine Berichtsseite lang ist – der Bericht wird die Zeilen, die nicht auf die erste Seite passen, auf den folgenden Seiten ausgeben. Schließlich soll der Bericht im Seitenkopfbereich den Namen der Datei anzeigen. Das ist leicht: Die Ereignisprozedur Seitenkopfbereich_Print <\/b>braucht dazu nur die Schrifteigenschaften nach Wunsch einzustellen und den Dateinamen mit der Print<\/b>-Methode auszugeben:<\/p>\n Schließlich soll beim Schließen des Berichts noch die Textdatei geschlossen werden:<\/p>\n Offene Baustellen<\/b><\/p>\n Das hat doch schon was, oder Textdateien einfach mal so in einem Access-Bericht anzeigen Immerhin lassen sich diese nach Gusto mit zusätzlichen Informationen ausstatten, zum Beispiel mit einer Zeilenzahl, mit Seitenzahlen et cetera. Alles Dinge, die der geneigte Access-Entwickler schneller programmiert, als er die entsprechenden Konfigurationsmöglichkeiten im Texteditor seiner Wahl gefunden hat.<\/p>\n Leider hat die Lösung noch eine kleine Schwachstelle: Wenn nämlich eine Zeile länger als die Berichtsbreite ist, wird sie einfach abgeschnitten. Die Länge der Zeile können wir in Abhängigkeit von Schriftgröße et cetera mit der Funktion TextWidth <\/b>des Berichts ermitteln. Aber wie genau nutzen wir das Wissen um die Breite der Textzeile Wir könnten ungefähr festlegen, auf wie viele Zeilen wir den Text aufteilen müssen, damit er nicht abgeschnitten wird.<\/p>\n Aber wie schneiden wir die Textzeilen auseinander Am einfachsten wird es wohl sein, zunächst nur überlange Textzeilen mit einer kleinen Spezialbehandlung zu versehen. Dabei müssen wir zunächst prüfen, wann eine Zeile nicht mehr in die Spaltenbreite des Berichts passt. In diesem Falle muss der Text umbrochen, die Höhe des Detailbereichs angepasst und erst dann der Text in den Bericht gedruckt werden.<\/p>\n Textzeilen umbrechen<\/b><\/p>\n Die Version des Berichts mit der Funktion zum Umbrechen überlanger Textzeilen finden Sie in der Beispieldatenbank unter dem Namen rptTextdateiMitZeilenumbruch<\/b>.<\/p>\n Den Hauptteil der änderungen finden Sie in der Ereignisprozedur Beim Formatieren <\/b>(s. Listing 1<\/a><\/span>). Hier werden wie gehabt zunächst der Inhalt der aktuellen Textzeile ermittelt und die Schrifteigenschaften festgelegt. Dann kommt frischer Code: Die TextWidth<\/b>-Funktion des Berichtsobjekts ermittelt die Breite des aktuell in der Variablen strTextzeile <\/b>enthaltenen Textes. Ist diese breiter als die Berichtsspalte, unterzieht die Prozedur den Text einer Sonderbehandlung in der Funktion NarrowText<\/b>. Diese haben wir bereits im Beitrag Zeichenketten zerlegen <\/b>(www.access-im-unternehmen.de\/560<\/b>) vorgestellt. Die Funktion erwartet einen Text und die maximale Zeichenanzahl pro Zeile. Die Prozedur liefert einen an den Leerzeichen umbrochenen Text zurück. Der Aufruf<\/p>\n Listing 1: Formatieren des Detailbereichs und optimieren des Textes im Hinblick auf die Spaltenbreite<\/p>\n <\/p>\n wird bei Angabe einer maximalen Zeichenanzahl von 12<\/b> etwa folgenden Text liefern:<\/p>\n Nach dem Umbrechen des Textes mit einer Breite von maximal 80 Zeichen ermittelt die Funktion TextHeight <\/b>die Höhe des Textes, die gleich im Anschluss der Eigenschaft Height <\/b>des Detailbereichs zugewiesen wird. Nun folgen die übrigen Schritte, also das Prüfen auf die letzte Zeile der Textdatei sowie das Drucken der aktuellen Zeile in den Bericht.<\/p>\n Begrenzte Print-Kapazität<\/p>\n Wenn Sie ein wenig mit dem Bericht experimentieren und dabei zufällig eine recht lange Zeile abdrucken möchten, stoßen Sie auf einen Fehler: Die Print<\/b>-Anweisung kann nur eine begrenzte Anzahl Zeichen im Bericht ausgeben. Dummerweise ist diese nicht fix vorgegeben, sondern hängt anscheinend von weiteren Faktoren wie der Schriftgröße ab. Wir fangen dies ab, indem wir die Beim Drucken<\/b>-Ereignisprozedur des Berichts wie in Listing 2<\/a><\/span> erweitern.<\/p>\n Listing 2: Wenn der Text zu lang für die Print-Methode ist, zeigt diese Prozedur eine Fehlermeldung an.<\/p>\n Die dort im Fehlerfall ausgelöste MsgBox<\/b>-Anweisung liefert eine Meldung wie in Bild 4.<\/p>\n Bild 4: Hinweismeldung beim Versuch, einen überlangen Text abzudrucken<\/span><\/b><\/p>\n Sollten Sie Dokumente mit überlangen Zeilen wie in diesem Beitrag per Bericht ausgeben wollen, können Sie diese Zeilen theoretisch auf mehrere Detailbereiche aufteilen. Aus Platzgründen gehen wir auf die dazu notwendigen Anpassungen an dieser Stelle nicht ein.<\/p>\n Wechsel von der Vorschau zur Druckansicht<\/b><\/p>\n In der jetzigen Form können Sie den Bericht nicht von der Vorschauansicht aus drucken. Der Bericht wird zum Drucken erneut gerendert, was ein erneutes Auslösen der Ereignisprozeduren zur Folge hat. Der Ablauf beim Öffnen, Einlesen und Schließen der Datei müsste speziell an das aufeinanderfolgende Rendern der Vorschau- und der Druckvariante angepasst werden.<\/p>\n Code-Dokumentation per Bericht<\/b><\/p>\n Natürlich können Sie nicht nur Texte aus Dokumenten, sondern beliebige Texte in Berichten ausgeben – Hauptsache, diese liegen in Zeilenform vor. Als Nächstes nehmen wir uns die Module beziehungsweise den Code einer Anwendung vor. Wir wollen zunächst grundsätzlich die Module und den enthaltenen Code strukturiert ausgeben und dann Elemente wie Schlüsselwörter oder Kommentare einfärben.<\/p>\n Die Lösung soll eines oder alle Module ausgeben. Um einzelne Module für die Ausgabe auszuwählen, sollen diese in einem Formular per Kombinationsfeld auswählbar sein. Für den Zugriff auf die Module und später auf deren Inhalte benötigen Sie einen Verweis auf die Bibliothek Microsoft Visual Basic for Applications Extensibility 5.3<\/b> (s. Bild 5).<\/p>\n Bild 5: Verweis auf die Bibliothek für den Zugriff auf das VBA-Projekt und die enthaltenen Module<\/span><\/b><\/p>\n Schauen wir uns den ersten Anlauf für das Modul des Berichts selbst an. Praktischerweise zeigt der Screenshot mit dem Ergebnis aus Bild 6 gleich den Code, der diesen hervorgerufen hat.<\/p>\n Bild 6: Ausgabe eines kompletten Code-Moduls per Bericht<\/span><\/b><\/p>\n Es gibt kaum Unterschiede zu der Variante des Berichts, der den Inhalt einer Textdatei anzeigte. Hier benötigen wir je eine Objektvariable für die aktive VB-Komponente und das enthaltene CodeModule<\/b>-Objekt sowie eine Zählervariable namens intLine<\/b>, welche die aktuell bearbeitete Zeilennummer speichert. Diese wird im Beim Formatieren<\/b>-Ereignis des Detailbereichs jeweils um eins erhöht. Die folgenden Zeilen brechen wieder zu lange Textzeilen um und passen die Höhe des Detailbereichs an. Schließlich erhalten die Eigenschaften MoveLayout <\/b>und NextRecordset <\/b>des Berichtsobjekts wieder die Werte, die dazu führen, dass solange Detailbereiche mit Codezeilen gefüllt werden, bis das Ende des Moduls erreicht wurde. Für die Ausgabe ist wiederum die Print<\/b>-Methode in der Ereignisprozedur Beim Drucken <\/b>verantwortlich.<\/p>\n Ausbaufähig<\/p>\n Mit dieser Basisversion können wir uns an den Ausbau machen. Aktuell zeigt der Bericht nur den Inhalt des Moduls an. Damit wir uns mit jemandem über den Code unterhalten können, wären Zeilennummern hilfreich. Für den Beginn geben wir uns mit durchlaufenden Zeilennummern zufrieden, die Vielfache von Zehn sind und im Format 0000<\/b> angezeigt werden – also etwa so wie in Bild 7<\/a><\/span>. Dazu erweitern Sie die Prozedur Detailbereich_Print<\/b> der vorherigen Version um einige Zeilen (s. Listing 3).<\/p>\n Listing 3: Erweiterung des Beim Drucken-Ereignisses zur Ausgabe von Zeilennummern<\/p>\n Bild 7: Modulcode mit Zeilennummern<\/span><\/b><\/p>\n Hier kommen erstmals die beiden Eigenschaften CurrentX <\/b>und CurrentY <\/b>ins Spiel. Diese legen fest, in welcher Position die nächste Ausgabe etwa mit der Print<\/b>-Methode landet. Die Prozedur prüft den Wert der Variablen bolZeilennummern<\/b>, der an geeigneter Stelle eingestellt werden muss (in diesem Fall schlicht im Ereignis Beim Öffnen <\/b>des Formulars).<\/p>\n Hat dieser den Wert True<\/b>, sorgt eine erste Print<\/b>-Anweisung für die Ausgabe der Zeilenzahl, die auf dem Wert der Zählervariablen intLine <\/b>basiert. Die CurrentX<\/b>-Eigenschaft verschiebt die X-Position für den folgenden Aufruf von Print <\/b>entsprechend nach rechts. Weil nach dem ersten Print<\/b>-Befehl der in CurrentY <\/b>gespeicherte Wert entsprechend der Zeilenhöhe des ausgegebenen Textes eingestellt wird, würde der eigentliche, mit der folgenden Print<\/b>-Anweisung ausgegebene Text um eine Zeile nach unten verschoben. Damit dies nicht geschieht, stellen wir CurrentY <\/b>wieder auf 0<\/b>. Erst danach wird der eigentliche Code der Zeile ausgegeben.<\/p>\n Zeilenschlucker<\/b><\/p>\n Dummerweise geht bei mehrseitigen Listings zwischen zwei Seiten immer genau eine Zeile verloren. Dies verhindern wir, indem wir das Ereignis Seitenkopf_Print <\/b>um die folgenden drei Zeilen erweitern und somit den Zeilenzähler korrigieren:<\/p>\n Umbrochene Zeilen optimieren<\/b><\/p>\n Der Zeilenumbruch mit der Funktion NarrowText<\/b> liefert nicht ganz das gewünschte Ergebnis. Wenn eine damit bearbeitete Zeile nämlich führende Leerzeichen enthält, werden diese entfernt.<\/p>\n Dadurch wird die Einrückung der Zeile zunichte gemacht. Überdies werden die folgenden, neu umbrochenen Zeilen garantiert nicht eingerückt dargestellt.<\/p>\n Um die Einrückung wiederherzustellen, nehmen wir eine änderung an der Prozedur Beim Formatieren <\/b>des Detailbereichs vor. Die erste Zeile ermittelt dabei den vorhandenen Einschub, indem sie die Länge der um die führenden Leerzeichen erleichterte Textzeile von der Länge der unberührten Textzeile subtrahiert:<\/p>\n Die durch die NarrowText<\/b>-Funktion bearbeitete Zeichenkette in strTextzeile <\/b>besitzt nun mindestens zwei Zeilen, von denen keine einen Einzug aufweist. Wir fügen also zuerst den entsprechenden Einzug zur ersten Zeile hinzu, indem wir der Zeichenkette mit der Space<\/b>-Funktion die benötigte Anzahl Leerzeichen voranstellen.<\/p>\n Bei den folgenden Zeilen erledigen wir das auf einen Rutsch: Wir ersetzen einfach die Konstante für den Zeilenumbruch vbCrLf <\/b>durch die gleiche Konstante plus der notwendigen Menge Leerzeichen, wieder bereitgestellt durch die Space<\/b>-Funktion:<\/p>\n Kommentarzeilen grün färben<\/b><\/p>\n Damit sich Kommentarzeilen farblich von den übrigen Zeilen abheben, färben wir diese grün ein. Dies soll wie in Bild 8 aussehen (in der gedruckten Fassung möglicherweise nicht erkennbar – schauen Sie sich in diesem Fall den Bericht rptEinModul_Zeilennummern_Kommentarzeilen <\/b>der Beispieldatenbank an).<\/p>\n Bild 8: Bericht mit grünen Kommentarzeilen<\/span><\/b><\/p>\n Die Vorgehensweise ist ebenfalls recht einfach: Wir prüfen, ob das erste Zeichen hinter eventuellen führenden Leerzeichen ein Hochkomma ist, und stellen in diesem Fall die Farbe mit der ForeColor<\/b>-Eigenschaft auf einen Wert ein, welcher der Farbe Grün entspricht. Ist dies nicht der Fall, muss die Farbe natürlich wieder auf Schwarz umgestellt werden.<\/p>\n Kommentare hinter Befehlen grün färben<\/p>\n Etwas schwieriger wird es bei Kommentaren, die sich rechts neben einem Befehl befinden. Das Ermitteln des Hochkommas, das den Kommentar hinter der Anweisung einleitet, ist recht kompliziert: Es kann nämlich vorkommen, dass bereits in einer Anweisung ein Hochkomma verwendet wird – beispielsweise innerhalb eines durch Anführungszeichen eingefassten Ausdrucks.<\/p>\n In diesem Fall müssen wir zunächst ermitteln, an welcher Position sich das Kommentar-Hochkomma befindet, und dann den ersten Teil der Zeile ab dem Kommentar grün einfärben (s. Bild 9).<\/p>\n Bild 9: Auch Kommentare hinter Anweisungen werden eingefärbt.<\/span><\/b><\/p>\n Als Erstes schauen wir uns eine Funktion an, welche die Position des Kommentarzeichens ermittelt – wenn denn eines vorliegt. Die Funktion heißt KommentarHinterBefehl <\/b>und befindet sich im Modul mdlGlobal <\/b>der Beispieldatenbank (s. Listing 4<\/a><\/span>).<\/p>\n Listing 4: Behandlung von Kommentaren hinter Anweisungen<\/p>\n Die Funktion liefert als Rückgabewert eine Boolean-Variable, die angibt, ob die Zeile einen Kommentar enthält. Außerdem enthält sie einen Rückgabeparameter, der die Position des relevanten Hochkommas festlegt. Diesen definieren Sie vor dem Aufruf etwa so:<\/p>\n Später arbeiten Sie diese Variable in den Aufruf mit ein:<\/p>\n Den kompletten neuen Block finden Sie in Bild 9. Dort erkennen Sie auch gleich ein Beispiel für das erfolgreiche Einfärben eines Kommentars hinter einer Anweisung.<\/p>\n Im Detail druckt der Bericht nach dem Ermitteln der Position des Hochkommas zunächst den Teil bis zum Hochkomma in Schwarz und dann den Rest in Grün.<\/p>\n Der Clou hierbei ist, dass hinter dem ersten Print<\/b>-Befehl ein Semikolon folgt (;). Dies signalisiert, dass die folgende Print<\/b>-Anweisung ihren Text gleich an den vorhergehenden anhängt. So müssen Sie zwischendurch nur die Farbe mit der Eigenschaft ForeColor<\/b> auf Grün umstellen.<\/p>\n Schlüsselwörter färben<\/b><\/p>\n Bislang haben wir etwa den Stand erreicht, den auch die Anzeige im VBA-Editor liefert. Es fehlt lediglich noch das Einfärben der VBA-Schlüsselwörter in Blau.<\/p>\n Der Code, der diese Farbgebung hervorruft, muss zunächst einmal alle VBA-Schlüsselwörter kennen. Zweitens muss er die Codezeilen noch genauer untersuchen als für die Färbung der Kommentarzeilen: Immerhin können Schlüsselwörter sowohl als VBA-Befehle als auch als Bestandteil anderer Texte auftreten – beispielsweise in Variablennamen oder in Zeichenketten.<\/p>\n Wie also unterscheiden wir die echten von den unechten Schlüsselwörtern Nun: Wir klammern gleich alle Bereiche aus, die sich innerhalb von Anführungszeichen befinden.<\/p>\n Für den Rest gilt: Keines der Schlüsselwörter darf ein führendes oder folgendes alphanumerisches Zeichen enthalten. Damit sind Ausnahmen wie etwa Klammern genehmigt.<\/p>\n Wie gehen wir vor, um die betroffenen Schlüsselwörter farbig zu markieren Als Erstes werden wir dort ein Sonderzeichen voranstellen, wo die Farbe für Schlüsselwörter eingesetzt werden soll, und ein weiteres Sonderzeichen für das Ende eines Schlüsselworts. Wir müssen vor dem Drucken also einfach alle Vorkommen von Schlüsselwörtern einer Zeile finden und diese durch entsprechende Sonderzeichen einrahmen. Aus der Zeile<\/p>\n soll dann beispielsweise folgende Zeile werden:<\/p>\n Mit diesen Sonderzeichen (\\@<\/b> für den Beginn, \\\\<\/b> für das Ende eines Schlüsselworts) können wir die Zeile dann wiederum aufteilen und mit mehreren Print<\/b>-Methoden, unterbrochen durch die entsprechenden änderungen der Eigenschaft ForeColor<\/b>, im Bericht ausgeben.<\/p>\n Die Anreicherung des Modulinhalts um die Sonderzeichen-Markierungen erfolgt in einer Funktion namens SchluesselwoerterErsetzen<\/b>, die reguläre Ausdrücke einsetzt und im Beitrag Suchen und Ersetzen mit regulären Ausdrücken <\/b>(www.access-im-unternehmen.de\/753<\/b>).<\/p>\n Gegenüber dem Bericht, der lediglich die Kommentarzeilen grün färbt, ergeben sich einige änderungen. Zunächst hinterlegen wir zwei Variablen, welche die Markierungen \\@ <\/b>und \\\\ <\/b>speichern:<\/p>\n Diese werden im Ereignis Report_Open <\/b>wie folgt gefüllt:<\/p>\n Warum schreiben wir diese Zeichen nicht einfach im Volltext in den Code Weil diese sonst beim Drucken genau dieses Moduls als Start- und Endzeichen für Schlüsselwörter erkannt würden statt als Elemente des Codes. Also verwenden wir in den Prozeduren, welche die Zeichenkombinationen \\@ <\/b>und \\\\ <\/b>erkennen sollen, nur die entsprechenden Variablen. Diese werden auch extra über die entsprechenden Chr<\/b>-Funktionen gefüllt.<\/p>\n Die Prozedur Report_Open <\/b>prüft desweiteren den Wert der OpenArgs<\/b>-Eigenschaft, mit welcher der Name des im Bericht zu druckenden Moduls übergeben werden soll.<\/p>\n Aus Schwarz-Grün wird bunt<\/b><\/p>\n Die Prozedur Detailbereich_Print <\/b>ist nach wie vor das Arbeitstier, was die Ausgabe der Codezeilen angeht, aber sie erhält Unterstützung von der Prozedur Codefaerber<\/b>.<\/p>\n Schauen wir uns zunächst Detailbereich_Print <\/b>an (s. Listing 5<\/a><\/span>). Diese druckt zunächst die Zeilennummer und prüft dann, ob die komplette Zeile eine Kommentarzeile ist.<\/p>\n Listing 5: Drucken und färben von Modulen mit VBA-Schlüsselwörtern<\/p>\n Falls ja, wird diese grün gedruckt und der Fall ist erledigt. Falls nein, geht es mit der Prüfung weiter, ob die Zeile zuerst Code und zum Schluss einen Kommentar enthält. Dann wird zunächst die Funktion Codefaerber <\/b>aufgerufen, die sich mit dem Färben der Schlüsselwörter beschäftigt – mehr dazu im Anschluss. Danach druckt die Prozedur den grün gefärbten Kommentar aus.<\/p>\n Der dritte Fall ist eine kommentarfreie Zeile: Diese wird kompett der Funktion Codefaerber <\/b>übergeben und von dieser in den entsprechenden Farben gedruckt.<\/p>\n Schlüsselwörter erkennen<\/b><\/p>\n![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2010_06\/BerichteOhneDatenherkunft-web-images\/pic002.png\")
<\/p>\n![\"pic009.png\"](\"..\/fileadmin\/_temp_\/2010_06\/BerichteOhneDatenherkunft-web-images\/pic009.png\")
<\/p>\nDim strTextdatei As String\r\nDim strTextzeile As String<\/pre>\n
Open strTextdatei For Input As #1\r\nDo While Not EOF(1)\r\n Line Input #1, strTextzeile\r\n ''was mit dem Text machen\r\nLoop\r\nClose #1<\/pre>\n
Private Sub Report_Open(Cancel As Integer)\r\n If Not IsNull(Me.OpenArgs) Then\r\n strTextdatei = Me.OpenArgs\r\n Else\r\n If IstFormularGeoeffnet("frmDateiDrucken") Then\r\n strTextdatei = Forms!frmDateidrucken!txtDatei\r\n Else\r\n MsgBox "Keine Datei!"\r\n Cancel = True\r\n End If\r\n End If\r\n Open strTextdatei For Input As #1\r\nEnd Sub<\/pre>\n\n
\n
Private Sub Detailbereich_Format(Cancel As _\r\n Integer, FormatCount As Integer)\r\n Line Input #1, strTextzeile\r\n Me.Detailbereich.Height = 200\r\n Me.MoveLayout = Not EOF(1)\r\n Me.NextRecord = Not Me.MoveLayout\r\nEnd Sub<\/pre>\n
Private Sub Detailbereich_Print(Cancel As Integer, PrintCount As Integer)\r\n Me.FontSize = 8\r\n Me.FontBold = False\r\n Me.FontName = "Courier New"\r\n Me.Print strTextzeile\r\nEnd Sub<\/pre>\n
Private Sub Seitenkopfbereich_Print(Cancel As Integer, PrintCount As Integer)\r\n Me.FontSize = 10\r\n Me.FontBold = True\r\n Me.Print strTextdatei\r\nEnd Sub<\/pre>\n
Private Sub Report_Close()\r\n Close #1\r\nEnd Sub<\/pre>\n
Private Sub Detailbereich_Format(Cancel As Integer, FormatCount As Integer)\r\n Dim intFontWeight As Integer\r\n Dim intZeilen As Integer\r\n Dim lngX As Long\r\n Dim lngY As Long\r\n Line Input #1, strTextzeile\r\n Me.FontSize = 8\r\n Me.FontBold = False\r\n Me.FontName = "Courier New"\r\n If Me.TextWidth(strTextzeile) > Me.Width Then\r\n strTextzeile = NarrowText(strTextzeile, 80, intZeilen)\r\n End If\r\n Me.Detailbereich.Height = Me.TextHeight(strTextzeile)\r\n Me.MoveLayout = Not EOF(1)\r\n Me.NextRecord = Not Me.MoveLayout\r\nEnd Sub\r\nDebug.Print NarrowText("bla bla bla bla bla", 12)<\/pre>\nbla bla bla\r\nbla bla<\/pre>\n
Private Sub Detailbereich_Print(Cancel As Integer, PrintCount As Integer)\r\n On Error Resume Next\r\n Me.Print strTextzeile\r\n If Not Err.Number = 0 Then\r\n MsgBox "Die folgende Zeile kann nicht gedruckt werden, da sie zu lang ist:" _\r\n & vbCrLf & vbCrLf & "''" & strTextzeile & "''"\r\n End If\r\nEnd Sub<\/pre>\n
![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2010_06\/BerichteOhneDatenherkunft-web-images\/pic003.png\")
<\/p>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2010_06\/BerichteOhneDatenherkunft-web-images\/pic004.png\")
<\/p>\n![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2010_06\/BerichteOhneDatenherkunft-web-images\/pic005.png\")
<\/p>\nPrivate Sub Detailbereich_Print(Cancel As Integer, PrintCount As Integer)\r\n If bolZeilennummern Then\r\n Me.Print Format(intLine * 10, "0000")\r\n Me.CurrentX = 600\r\n Else\r\n Me.CurrentX = 0\r\n End If\r\n Me.CurrentY = 0\r\n Me.Print strTextzeile\r\nEnd Sub<\/pre>\n
![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2010_06\/BerichteOhneDatenherkunft-web-images\/pic006.png\")
<\/p>\nIf intLine > 0 Then\r\n intLine = intLine - 1\r\nEnd If<\/pre>\n
intEinschub = Len(strTextzeile) - Len(LTrim(strTextzeile))<\/pre>\n
If Me.TextWidth(strTextzeile) > Me.Width Then\r\n strTextzeile = NarrowText(strTextzeile, 80)\r\n strTextzeile = Space(intEinschub) & strTextzeile\r\n strTextzeile = Replace(strTextzeile, vbCrLf, vbCrLf & Space(intEinschub))\r\nEnd If<\/pre>\n
![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2010_06\/BerichteOhneDatenherkunft-web-images\/pic007.png\")
<\/p>\n![\"pic008.png\"](\"..\/fileadmin\/_temp_\/2010_06\/BerichteOhneDatenherkunft-web-images\/pic008.png\")
<\/p>\nPublic Function KommentarHinterBefehl(strTextzeile As String, intPositionHochkomma As Integer) As Boolean\r\n Dim intPos As Integer\r\n Dim strTextzeileBisHochkomma As String\r\n intPos = InStr(1, strTextzeile, "''")\r\n Do While Not intPos = 0\r\n strTextzeileBisHochkomma = Left(strTextzeile, intPos)\r\n If (Len(strTextzeileBisHochkomma) - Len(Replace(strTextzeileBisHochkomma, """", ""))) _\r\n Mod 2 = 0 Then\r\n intPositionHochkomma = intPos\r\n KommentarHinterBefehl = True\r\n Exit Function\r\n End If\r\n intPos = InStr(intPos + 1, strTextzeile, "''")\r\n Loop\r\nEnd Function<\/pre>\n
Dim intPositionHochkomma As Integer<\/pre>\n
If KommentarHinterBefehl(strTextzeile, intPositionHochkomma) Then<\/pre>\n
Private Sub Report_Open(Cancel As Integer)<\/pre>\n
\\@Private\\\\ \\@Sub\\\\ Report_Open(Cancel \\@As Integer\\\\<\/pre>\n
Dim cStart As String\r\nDim cEnde As String<\/pre>\n
cStart = Chr(92) & Chr(64)\r\ncEnde = Chr(92) & Chr(92)<\/pre>\n
Private Sub Detailbereich_Print(Cancel As Integer, PrintCount As Integer)\r\n If bolZeilennummern Then\r\n Me.Print Format(intLine * 10, "0000")\r\n Me.CurrentX = 600\r\n Else\r\n Me.CurrentX = 0\r\n End If\r\n Me.CurrentY = 0\r\n ''Hier werden Kommentarzeilen grün eingefärbt:\r\n If Left(LTrim(strTextzeile), 1) = "''" Then\r\n ''Grün für Kommentare, ...\r\n Me.ForeColor = RGB(0, 128, 0)\r\n Me.Print strTextzeile ''Ausgabe mit Kommentar\r\n Me.ForeColor = RGB(0, 0, 0)\r\n Else\r\n ''... Schwarz für den Rest.\r\n Dim intPositionHochkomma As Integer ''lala\r\n If KommentarHinterBefehl(strTextzeile, intPositionHochkomma) Then\r\n Codefaerber Left(strTextzeile, intPositionHochkomma - 1)\r\n Me.ForeColor = RGB(0, 128, 0)\r\n Me.Print Mid(strTextzeile, intPositionHochkomma)\r\n Me.ForeColor = RGB(0, 0, 0)\r\n Else\r\n Me.ForeColor = RGB(0, 0, 0)\r\n Codefaerber strTextzeile\r\n Me.Print\r\n End If\r\n End If\r\nEnd Sub<\/pre>\n
![\"pic010.png\"](\"..\/fileadmin\/_temp_\/2010_06\/BerichteOhneDatenherkunft-web-images\/pic010.png\")
<\/p>\n