{"id":55001115,"date":"2018-02-01T00:00:00","date_gmt":"2020-05-13T21:17:58","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1115"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Selektieren_in_langen_Texten","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Selektieren_in_langen_Texten\/","title":{"rendered":"Selektieren in langen Texten"},"content":{"rendered":"

\"\"<\/p>\n

Wenn Sie einen Text in einem Textfeld selektieren wollen, erledigen Sie das in der Regel per Maus oder Tastatur. Das geht jedoch auch per Code – in der Regel durch das Setzen der Eigenschaften SelStart und SelLength. Damit lässt sich auch die Position der Markierung auslesen, wenn diese von Hand gesetzt wurde. Die genannten Eigenschaften haben jedoch einen Haken: Sie können damit nur in Texten mit bis zu 32.767 Zeichen arbeiten, da die Eigenschaften als Integer definiert sind. Abhilfe schafft die Windows API – alle notwendigen Informationen dazu finden Sie in diesem Beitrag.<\/b><\/p>\n

Anlass für die Untersuchung dieses Problems ist die Lösung aus dem Beitrag Volltextsuche mit Fundstellen <\/b>(www.access-im-unternehmen.de\/1119<\/b>), wo wir einen Suchbegriff an der entsprechenden Stelle im Text durch eine Markierung hervorheben wollen.<\/p>\n

Die dort verwendeten Texte sind jedoch mitunter länger als 32.767 Zeichen, enthalten also mehr Zeichen, als durch den Datentyp Integer <\/b>erfasst werden können.<\/p>\n

Zum Setzen der Markierung wollten wir aber gern die beiden Eigenschaften SelStart <\/b>und SelLength <\/b>verwenden. Wenn wir in einem Textfeld mit einem langen Text eine Markierung setzen wollen, die hinter dem 32.767ten Zeichen liegt, lösen wir damit einen überlauf-Fehler aus.<\/p>\n

Als Spielwiese für die nachfolgend entwickelte Lösung erstellen wir eine Tabelle namens tblTexte <\/b>mit dem Primärschlüsselfeld TextID <\/b>und dem Feld Inhalt <\/b>mit dem Datentyp Langer Text <\/b>beziehungsweise Memo<\/b> (s. Bild 1).<\/p>\n

\"Tabelle<\/p>\n

Bild 1: Tabelle zum Speichern langer Texte<\/span><\/b><\/p>\n

Das Formular, mit dem wir das Selektieren ausprobieren wollen, sieht im Entwurf wie in Bild 2 aus. Es ist an die Tabelle tblTexte <\/b>gebunden. Damit wir möglichst viel Text sehen, haben wir die Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>für das Textfeld, das an das Feld Inhalt <\/b>gebunden ist, auf Beide <\/b>eingestellt. Das Textfeld haben wir außerdem txtInhalte <\/b>benannt.<\/p>\n

\"Entwurf<\/p>\n

Bild 2: Entwurf des Testformulars<\/span><\/b><\/p>\n

Oben finden Sie noch zwei Textfelder, in die wir die gewünschten Werte für SelStart <\/b>und SelLength <\/b>eintragen können und eine Schaltfläche namens cmdGo<\/b>, welche die Markierung anwenden soll. Die Schaltfläche cmdGo <\/b>soll die folgende Ereignisprozedur auslösen:<\/p>\n

Private Sub <\/span>cmdGo_Click()\r\n     With<\/span> Me!txtInhalt\r\n         .SetFocus\r\n         .SelStart = Me!txtSelStart\r\n         .SelLength = Me!txtSelLength\r\n     End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
Wenn wir nun etwa die Werte 10 <\/b>für SelStart <\/b>und 20 <\/b>für SelLength<\/b> eingeben, erhalten wir im Textfeld eine Markierung wie in Bild 3.<\/p>\n
\"Setzen<\/p>\n
Bild 3: Setzen einer Markierung am Anfang des Textes<\/span><\/b><\/p>\n
Nun geben wir einmal einen Wert größer als 32.767 für die Eigenschaft SelStart <\/b>ein und klicken auf die Schaltfläche cmdGo<\/b>. Dies löst nun den Fehler aus Bild 4 aus. Die Ursache für das Problem können wir uns gleich im Direktbereich nochmal bestätigen lassen.<\/p>\n
\"Fehler<\/p>\n
Bild 4: Fehler beim Einsatz von Werten größer als 32.767<\/span><\/b><\/p>\n
Dort geben wir eine Debug.Print<\/b>-Anweisung ein, die mit der Funktion TypeName <\/b>den Datentyp der SelStart<\/b>-Eigenschaft liefert:<\/p>\n
Debug.Print<\/span> TypeName( Me!txtInhalt.SelStart)\r\n     Integer<\/pre>\n
Alternative: API-Funktionen<\/h2>\n
An dieser Stelle können wir also wohl nicht ändern und müssen uns eine Alternative überlegen.<\/p>\n
Diese finden wir in den API-Funktionen von Windows.<\/p>\n
Damit lassen sich die meisten Dinge bezüglich Benutzeroberfläche und Steuer-elemente erledigen, die Sie auch über den Befehlssatz von Access\/VBA einstellen können – allerdings sieht das auf diesem Wege immer ein wenig komplizierter aus.<\/p>\n
Für unsere Anforderung nutzen wir den Code aus Listing 1. Hier definieren wir zunächst zwei API-Funktionen, um diese innerhalb des VBA-Codes zu nutzen. Die erste API-Funktion heißt SendMessage <\/b>und wird für das Senden aller möglichen Nachrichten verwendet.<\/p>\n
Private <\/span>Declare Function SendMessage Lib \"user32\" Alias \"SendMessageA\" (ByVal hwnd As Long<\/span>, ByVal wMsg As Long<\/span>, _\r\n     ByVal wParam As Long<\/span>, lParam As <\/span>Any) As Long<\/span>\r\nPrivate <\/span>Declare Function GetFocus Lib \"user32\" () As Long<\/span>\r\nPrivate <\/span>Const EM_SETSEL  As Long<\/span> = &HB1\r\nPrivate Sub <\/span>cmdGo_Click()\r\n     Dim <\/span>lngHandle As Long<\/span>\r\n     Dim <\/span>lngSelStart As Long<\/span>\r\n     Dim <\/span>lngSelLength As Long<\/span>\r\n     With<\/span> Me!txtInhalt\r\n         .SetFocus\r\n         lngHandle = GetFocus\r\n         lngSelStart = Me!txtSelStart\r\n         lngSelLength = Me!txtSelLength\r\n       SendMessage lngHandle, EM_SETSEL, lngSelStart, ByVal lngSelStart + lngSelLength\r\n     End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
<\/p>\n
Listing 1: API-Code zum Markieren eines Textabschnitts<\/span><\/b><\/p>\n
Um anzugeben, um welche Art Nachricht es sich handelt, übergibt man mit dem zweiten Parameter eine Konstante für den Typ der Nachricht.<\/p>\n
Der erste Parameter erwartet ein Handle auf das anzusprechende Element der Benutzeroberfläche, also eine Zahl, mit welcher das entsprechende Element referenziert wird. Die beiden folgenden Parameter nehmen je nach Aufgabe verschiedene Werte entgegen.<\/p>\n
Die zweite API-Funktion, die wir nutzen wollen, heißt GetFocus <\/b>und soll uns dabei unterstützen, das Handle für das anzusprechende Textfeld im Access-Formular zu ermitteln. Normalerweise haben Elemente wie Schaltflächen, Textfelder et cetera eine Eigenschaft namens Handle <\/b>oder hWnd<\/b>, um diesen Wert direkt zu ermitteln, aber unter Access läuft dies etwas anders.<\/p>\n
Hier erhält nur das Steuer-element ein Handle, das aktuell den Fokus besitzt. Deshalb müssen wir erst den Fokus auf das Steuer-element einstellen und dann mit der API-Funktion GetFocus <\/b>das entsprechende Handle ermitteln.<\/p>\n
In der Prozedur cmdGo <\/b>definieren wir nun zunächst entsprechende Variablen für das Handle und für die beiden zu übergebenen Parameter, also lngSelStart <\/b>und lngSelLength<\/b>. Dann setzen wir wie bereits im vorherigen Beispiel den Fokus auf das Textfeld und ermitteln mit der GetFocus<\/b>-Funktion das Handle des Textfeldes, welches dann in der Variablen lngHandle <\/b>landet.<\/p>\n
Dann schreiben wir die Werte der beiden Textfelder txtSelStart <\/b>und txtSelLength <\/b>in die Variablen lngSelStart <\/b>und lngSelLength<\/b>.<\/p>\n
Für den ersten Parameter der gleich aufzurufenden SendMessage<\/b>-Funktion nutzen wir die Konstante EM_SETSEL<\/b>. Damit haben wir nun alle Parameter für den Aufruf der API-Funktion SendMessage <\/b>zusammen und können diese aufrufen.<\/p>\n
Zu beachten ist hier noch, dass wir nicht die Länge der zu setzenden Markierung angeben, sondern die Position des ersten und des letzten Zeichens. Daher verwenden wir als vierten Parameter lngSelStart + lngSelLength<\/b>. Das Ergebnis überzeugt – wir können damit auch Bereiche markieren, die sich jenseits des 32.767ten Zeichens befinden. Der Nachteil ist: Wir sehen die Markierung nicht, da das Textfeld nach dem Setzen des Fokus immer den Bereich vom ersten Zeichen an liefert.<\/p>\n
Zur Markierung scrollen<\/h2>\n
Damit liefert die Anforderung dieses Beitrags noch eine zweite Aufgabe, nämlich das Scrollen innerhalb eines Textfeldes zu einer bestimmten Position – in diesem Fall zur Position des Starts der Markierung. Wer glaubt, man braucht dazu weitere API-Funktionen, irrt sich – wir müssen einfach nur die gleiche API-Funktion mit den gleichen Parametern zwei Mal aufrufen:<\/p>\n
Private Sub <\/span>cmdGo_Click()\r\n     Dim <\/span>lngHandle As Long<\/span>\r\n     Dim <\/span>lngSelStart As Long<\/span>\r\n     Dim <\/span>lngSelLength As Long<\/span>\r\n     With<\/span> Me!txtInhalt\r\n         .SetFocus\r\n         lngHandle = GetFocus\r\n         lngSelStart = Me!txtSelStart\r\n         lngSelLength = Me!txtSelLength\r\n         SendMessage lngHandle, EM_SETSEL,  lngSelStart, ByVal lngSelStart + lngSelLength\r\n         SendMessage lngHandle, EM_SETSEL,  lngSelStart, ByVal lngSelStart + lngSelLength\r\n     End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
Das Ergebnis sehen Sie in Bild 5. Noch schöner wäre es natürlich, wenn man den selektierten Text in der Mitte des Textfeldes anzeigen könnte. Dies würde weitere aufwendige API-Programmierung erfordern.<\/p>\n
\"Erster<\/p>\n
Bild 5: Erster Ansatz zum Hervorheben von markierten Texten<\/span><\/b><\/p>\n
Allerdings gibt es noch einen alternativen Weg, den wir uns nun ansehen. Dabei nutzen wir schlicht ein anderes TextBox<\/b>-Steuerelement, nämlich das aus der MSForms-Bibliothek. Ausführlich stellen wir dieses Steuer-element im Beitrag Die MSForms-TextBox <\/b>vor (www.access-im-unternehmen.de\/1114<\/b>) vor.<\/p>\n
Die MSForms-TextBox hat ein paar Vorteile, die bei diesem Einsatzzweck zum Tragen kommen: Erstens sind die beiden Eigenschaften SelStart <\/b>und SelLength <\/b>hier als Long ausgelegt, sodass wir viel größere Texte damit untersuchen und markieren können.<\/p>\n
Außerdem bietet es mit der Eigenschaft CurLine<\/b> die Möglichkeit, nicht nur die Nummer der Zeile mit der Einfügemarke zu ermitteln, sondern diese auch zu setzen und damit die Einfügemarke in den Fokus zu holen – auch wenn diese sich im Text weiter unterhalb des aktuell angezeigten Ausschnitts befindet.<\/p>\n
Formular mit MSForms-TextBox<\/h2>\n
Also erstellen wir unter dem Namen frmTexte_MSForms <\/b>eine Kopie des bisher programmierten Formulars und fügen statt des bisher verwendeten eingebauten TextBox<\/b>-Elements eine MSForms-TextBox zum Formular hinzu, das wir ebenfalls txtInhalt<\/b> nennen.<\/p>\n
Dazu wählen Sie auf dem Ribbon-Tab Entwurf den Eintrag Steuerelemente|ActiveX-Steuerelemente <\/b>aus und selektieren im nun erscheinenden Dialog den Eintrag Microsoft Forms 2.0 TextBox<\/b>. Nach dem Bestätigen über die Schaltfläche OK <\/b>erscheint das neue TextBox<\/b>-Steuerelement im Formular, von wo sie es an die gewünschte Stelle verschieben und die Größe anpassen.<\/p>\n
Nun passen wir die Optik und das Verhalten bezüglich der angezeigten Daten der MSForms-TextBox an die herkömmliche TextBox an. Dazu legen wir im Eigenschaftsfenster den Wert Steuerelementinhalt <\/b>auf das Feld Inhalt <\/b>fest (s. Bild 6).<\/p>\n
\"Einstellen<\/p>\n
Bild 6: Einstellen des Steuerelementinhalts<\/span><\/b><\/p>\n
Die übrigen Eigenschaften wollen wir per Code einstellen. Dazu legen wir zunächst eine Objektvariable an, welche einen Verweis auf die MSForms-TextBox aufnimmt:<\/p>\n
Dim <\/span>WithEvents objInhalt As <\/span>MSForms.TextBox<\/pre>\n
Diese füllen wir dann in der Ereignisprozedur Form_Load<\/b>, wo wir auch die fehlenden Eigenschaften einstellen:<\/p>\n
Private Sub <\/span>Form_Load()\r\n     Set<\/span> objInhalt = Me!txtInhalt.Object\r\n     objInhalt.SelectionMargin = False<\/span>\r\n     objInhalt.Font = \"Calibri\"\r\n     objInhalt.Font.Size = \"9\"\r\n     objInhalt.MultiLine = True<\/span>\r\n     objInhalt.BorderStyle = fmBorderStyleSingle\r\n     objInhalt.SpecialEffect = fmSpecialEffectFlat\r\n     objInhalt.BorderColor = Me!txtSelStart.BorderColor\r\nEnd Sub<\/span><\/pre>\n
SelectionMargin <\/b>blendet den Rand links in der TextBox aus, der zum Markieren vollständiger Zeilen notwendig ist. MultiLine <\/b>aktiviert die Anzeige von Absätzen über mehrere Zeilen. Die übrigen Einstellungen sind selbsterklärend.<\/p>\n
Da die MSForms-TextBox bei Verwendung des vertikalen Ankers automatisch die Schrift vergrößert, sollten Sie diese Eigenschaft nicht verändern. Wenn Sie möchten, können Sie aber den horizontalen Anker einstellen – dies behält beim Verbreitern des Textfeldes die Schriftgröße bei und ändert nur die Breite der Bildlaufleiste.<\/p>\n
Damit kommen wir zur Abbildung der bereits vorgestellten Funktionen zum Einstellen einer Markierung und zum Fokussieren auf diese Markierung, wenn sich diese nicht im Sichtfeld befindet.<\/p>\n
Die Ereignisprozedur, die durch den Mausklick auf die Schaltfläche cmdGo <\/b>ausgelöst wird, sieht wie folgt aus:<\/p>\n
Private Sub <\/span>cmdGo_Click()\r\n     Dim <\/span>lngSelStart As Long<\/span>\r\n     Dim <\/span>lngSelLength As Long<\/span>\r\n     Dim <\/span>lngCurLine As Long<\/span>\r\n     lngSelStart = Me!txtSelStart\r\n     lngSelLength = Me!txtSelLength\r\n     With<\/span> objInhalt\r\n         .SelStart = lngSelStart\r\n         .SelLength = lngSelLength\r\n         lngCurLine = .CurLine\r\n         .CurLine = lngCurLine + 5\r\n         Me!txtInhalt.SetFocus\r\n         .SelStart = lngSelStart\r\n         .SelLength = lngSelLength\r\n         .HideSelection = False<\/span>\r\n     End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
Hier geschehen nun folgende Schritte:<\/p>\n