<\/p>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2019_02\/pic_1181_001.png\")
<\/p>\n
Bild 1: Hinzufügen eines Feldes mit dem Datentyp Langer Text und dem Textformat Rich-Text<\/span><\/b><\/p>\n Ein Kunde fragte, ob es möglich ist, im Text von Memofeldern im Rich-Text-Format auch das Tabulator-Zeichen einzugeben und damit eine strukturiertere Darstellung von Inhalten zu erreichen – vor allem für die Ausgabe in Berichten. Dazu sind mir einige Ideen gekommen, von denen sich aber nicht alle so einfach umsetzen ließen, wie es gedacht war. Schließlich hat sich aber doch noch eine sehr gut programmierbare Lösung herauskristallisiert.<\/b><\/p>\n In der Beispieldatenbank legen wir zunächst eine Tabelle an, die neben dem Primärschlüsselfeld TextID <\/b>noch die Felder Betreff <\/b>mit dem Datentyp Kurzer Text <\/b>und das Feld Inhalt <\/b>mit dem Datentyp Langer Text <\/b>enthält (siehe Bild 1). Für dieses Feld stellen wir außerdem die Eigenschaft Textformat <\/b>auf Rich-Text <\/b>ein.<\/p>\n Bild 1: Hinzufügen eines Feldes mit dem Datentyp Langer Text und dem Textformat Rich-Text<\/span><\/b><\/p>\n Danach erstellen wir ein Formular, das wir über die Eigenschaft Datensatzquelle <\/b>an die Tabelle tblTexte <\/b>binden. Danach ziehen wir alle Felder dieser Tabelle aus der Feldliste in den Detailbereich des Formularentwurfs. Das Feld Inhalt <\/b>gestalten wir etwas größer und stellen seine Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>auf Beide <\/b>ein, damit es seine Größe mit der des Formulars verändert (siehe Bild 2).<\/p>\n Bild 2: Formular zur Anzeige des Rich-Text-Feldes<\/span><\/b><\/p>\n Danach wird es interessant. Wir wechseln in die Formularansicht des Formulars und setzen den Fokus in das Textfeld, das an das Feld Inhalt <\/b>gebunden ist und dessen Namen wir zuvor noch auf txtInhalt <\/b>ändern.<\/p>\n Wenn wir nun ein paar Zeichen eingeben und dann die Tabulator-Taste drücken, erhalten wir das standardmäßige Verhalten: Access verschiebt schlicht den Fokus auf das nächste Steuer-element, in diesem Fall auf das Feld TextID<\/b>, und wechselt im gleichen Zuge den Datensatz, da unser Feld txtInhalt <\/b>das letzte Steuer-element in der Aktivierreihenfolge ist (siehe Bild 3).<\/p>\n Bild 3: Die Tabulator-Taste im letzten Feld der Aktivierreihenfolge wechselt zum nächsten Datensatz.<\/span><\/b><\/p>\n Wir müssen also eine Möglichkeit finden, die Tabulator-Taste abzufangen, wenn sich der Fokus gerade im Textfeld txtInhalt<\/b> befindet. Dann soll ein Tabulator-Zeichen in den Text eingefügt und die eigentliche Funktion der Tabulator-Taste unterbunden werden.<\/p>\n Dies erledigen wir mit einer passenden Ereignisprozedur. Wir müssen nur noch das passende Ereignis finden. Dabei handelt es sich vermutlich um das Ereignis Bei Taste auf <\/b>oder Bei Taste ab<\/b>. Um das Tabulator-Zeichen zum richtigen Zeitpunkt einzufügen, schauen wir uns an, wann eines der anderen Zeichen im Textfeld ausgegeben wird – beim Herabdrücken der Taste oder beim Loslassen.<\/p>\n Ein kurzes Experiment zeigt schnell, dass herkömmliche Zeichen immer direkt beim Herunterdrücken der Taste ausgegeben werden. Also verwenden wir das Ereignis Bei Taste ab<\/b>. Für dieses stellen wir den Wert auf [Ereignisprozedur] <\/b>ein und klicken dann auf die Schaltfläche mit den drei Punkten (…<\/b>) rechts von der Eigenschaft.<\/p>\n Die im nun erscheinenden VBA-Editor erscheinende Ereignisprozedur ergänzen wir um eine Anweisung, die den Wert des Parameters KeyCode <\/b>dieser Ereignisprozedur im Direktbereich des VBA-Editors ausgibt:<\/p>\n <\/p>\n Damit wechseln wir wieder in die Formularansicht und betätigen im Textfeld txtInhalt <\/b>die Tabulator-Taste, um den Wert für KeyCode <\/b>für diese Taste zu ermitteln. Das Ergebnis lautet 9<\/b>.<\/p>\n Wollen wir die eigentliche Funktion der Tabulator-Taste unterbinden, müssen wir also in der Prozedur prüfen, ob der Parameter KeyCode <\/b>dem Wert 9 <\/b>entspricht. Das erledigen wir in einer Select Case<\/b>-Bedingung. Damit die übliche Funktion der Tabulator-Taste nicht ausgeführt wird, stellen wir KeyCode <\/b>in diesem Fall auf den Wert 0 <\/b>fest. Dies sieht dann in der Ereignisprozedur txtInhalt_KeyDown <\/b>wie folgt aus:<\/p>\n Damit können Sie nun zumindest schon einmal die Tabulator-Taste im Textfeld txtInhalt <\/b>betätigen, ohne dass das Formular direkt zum nächsten Datensatz wechselt – auch wenn noch kein Tabulator-Zeichen erscheint.<\/p>\n Fehlt nur noch ein wenig Code, mit dem wir immer dann, wenn der Benutzer die Tabulator-Taste betätigt, ein Tabulator-Zeichen im Text des Textfeldes unterbringen.<\/p>\n Dazu müssen wir erst einmal herausfinden, wie wir dieses Zeichen kodieren müssen, damit es als Tabulator-Zeichen im Text angezeigt wird. Und wir müssen herausfinden, ob dies überhaupt im Rich-Text-Feld gelingt!<\/p>\n Vielleicht gelingt dies ja schon durch ein einfaches vbTab<\/b>, der Kodierung eines Tabulator-Zeichens unter VBA. Dazu fügen wir dem Textfeld txtInhalt <\/b>einen Beispieltext mit Tabulator-Zeichen hinzu, indem wir die folgende Anweisung im Direktbereich ausgeben:<\/p>\n Das Ergebnis ist ernüchternd: Statt eines Tabulator-Zeichens erscheint dort lediglich ein Leerzeichen. Wenn wir jedoch den ASCII-Code des Zeichens prüfen, stellen wir fest, dass das Zeichen zwar den ASCII-Code 9 <\/b>aufweist, aber dieses wohl dennoch nicht wie gewünscht codiert wird:<\/p>\n Also probieren wir es nun mit der entsprechenden HTML-Entität aus, die <\/b>lautet:<\/p>\n Dies fügt endlich das lang ersehnte Tabulator-Zeichen zum Textfeld hinzu (siehe Bild 4).<\/p>\n Bild 4: Ein per VBA hinzugefügtes Tab-Zeichen<\/span><\/b><\/p>\n Nun wollen wir das Tabulator-Zeichen durch das Betätigen der Tabulator-Taste einfügen. Zu Textzwecken fügen wir dem Textfeld den folgenden Text hinzu:<\/p>\n Wir wollen das Tabulator-Zeichen genau zwischen Tab <\/b>und Text<\/b> einfügen. Der Plan dazu ist, dass wir mit der SelStart<\/b>-Eigenschaft des Textfeldes ermitteln, an welcher Stelle sich die Einfügemarke beziehungsweise der Beginn der Markierung befindet und mit der SelStart<\/b>– und der SelLength<\/b>-Eigenschaft das Ende der Markierung. Damit wollen wir dann den Inhalt vor und nach der aktuellen Markierung ermitteln und diese beiden mit einem Tabulator-Zeichen in der Mitte wieder zusammensetzen. Also definieren wir in der Prozedur txtInhalt_KeyDown <\/b>zwei Variablen für den Teil vor und den Teil hinter der Markierung:<\/p>\n In der Select Case<\/b>-Bedingung ermitteln wir die beiden Teilzeichenketten wie geplant, nachdem wir die Einfügemarke an der gewünschten Stelle platziert haben (siehe Bild 5):<\/p>\n Bild 5: Hier soll das Tabulatur-Zeichen eingefügt werden<\/span><\/b><\/p>\n Die Ausgabe im Direktbereich sieht allerdings etwas überraschend aus:<\/p>\n Da hat sich offensichtlich noch ein <\/p>\n <\/b>-Element am Ende. Wir gingen davon aus, dass die SelStart<\/b>– und SelLength<\/b>-Eigenschaften diese berücksichtigen, was aber offensichtlich nicht der Fall ist. Hilft hier vielleicht die PlainText<\/b>-Funktion weiter, mit der wir den reinen Text ohne HTML-Auszeichnungen ermitteln können<\/p>\n Nein, auch das hilft nicht weiter. Wie aber können wir das Tabulator-Zeichen an der gewünschten Stelle einfügen Der Lösung ein Stückchen weiter bringt uns die Verwendung der Zwischenablage. Wenn wir die Position der Einfügemarke schon nicht eindeutig ermitteln können, verwenden wir einfach die Zwischenablage, um das Tabulator-Zeichen darin zu speichern und es einfach an der Stelle der Markierung einzufügen. Das sieht dann im ersten Versuch so aus:<\/p>\n Die Prozedur in Zwischenablage ist benutzerdefiniert und im Modul mdlZwischenablage<\/b> zu finden. Das Ergebnis aus Bild 6 sieht schon fast gut aus – jetzt müssen wir nur noch dafür sorgen, dass wir statt der HTML-Entität das richtige Tabulator-Zeichen einfügen. Und wenn wir mit der Zwischenablage arbeiten, brauchen wir – kaum zu glauben – nicht mehr die HTML-Entität <\/b>, sondern kommen mit der Konstanten vbTab <\/b>zum Erfolg. Die Prozedur txtInhalt_KeyDown <\/b>sieht nun also wie folgt aus:<\/p>\n<\/p>\n![\"Formular](\"..\/fileadmin\/_temp_\/2019_02\/pic_1181_002.png\")
<\/p>\nNormales Tabulatur-Verhalten<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2019_02\/pic_1181_003.png\")
<\/p>\nTabulator-Taste abfangen<\/h2>\n
Private Sub <\/span>Inhalt_KeyDown(KeyCode As Integer<\/span>, _\r\n Shift As Integer<\/span>)\r\n Debug.Print<\/span> KeyCode\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Inhalt_KeyDown(KeyCode As Integer<\/span>, _\r\n Shift As Integer<\/span>)\r\n Select Case KeyCode\r\n Case <\/span>9\r\n KeyCode = 0\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nTabulatur-Zeichen einfügen<\/h2>\n
Screen.ActiveControl = \"Text vor dem Tab\" & vbTab & \"Text nach dem Tab\"<\/pre>\n
Asc(Mid<\/span>(Screen.ActiveControl,17,1))<\/pre>\nScreen.ActiveControl = \"Text vor dem Tab Text nach dem Tab\"<\/pre>\n
![\"Ein](\"..\/fileadmin\/_temp_\/2019_02\/pic_1181_004.png\")
<\/p>\nTabulator nach Tabulator-Taste einfügen<\/h2>\n
Text<\/span> vor dem TabText nach dem Tab<\/pre>\nDim <\/span>strInhaltVor As String<\/span>\r\nDim <\/span>strInhaltNach As String<\/span><\/pre>\n![\"Hier](\"..\/fileadmin\/_temp_\/2019_02\/pic_1181_005.png\")
<\/p>\nSelect Case KeyCode\r\n Case <\/span>9\r\n KeyCode = 0\r\n strInhaltVor = Left<\/span>(Me!txtInhalt, _\r\n Me!txtInhalt.SelStart)\r\n strInhaltNach = Mid<\/span>(Me!txtInhalt, _\r\n Me!txtInhalt.SelStart + Me!txtInhalt.SelLength)\r\n Debug.Print<\/span> strInhaltVor\r\n Debug.Print<\/span> strInhaltNach\r\nEnd Select<\/span><\/pre>\n<div>Text vor de\r\nem TabText nach dem Tab<\/div><\/pre>\n
<\/b>-Element vor dem Text eingeschlichen – und ein schließendes <\/div>\n PlainText(Screen.ActiveControl)\r\nText<\/span> vor dem TabText nach dem Tab<\/pre>\nSelect Case KeyCode\r\n Case <\/span>9\r\n KeyCode = 0\r\n Inzwischenablage \" \"\r\n RunCommand acCmdPaste\r\nEnd Select<\/span><\/pre>\n![\"Das](\"..\/fileadmin\/_temp_\/2019_02\/pic_1181_006.png\")
<\/p>\n