<\/p>\n
Die MSForms-Bibliothek beherbergt einige Steuer-elemente, die unter Access ein stiefmütterliches Dasein erleben. Es gibt jedoch Einsatzzwecke, welche die dort enthaltenen Steuer-elemente ans Tageslicht kommen lassen. Eines dieser Steuer-elemente ist die MSForms-Textbox. Sie bietet gegenüber dem eingebauten TextBox-Steuerelement unter anderem den Vorteil, dass auch Texte mit mehr als 64.000 Zeichen angezeigt werden können. Die übrigen Vor- und Nachteile liefert der vorliegende Beitrag.<\/b><\/p>\nProblem Bearbeitung langer Texte<\/h2>\n
Ein Problem herkömmlicher Textfelder ist, dass Sie damit keine Texte bearbeiten können, die länger als 64.000 Zeichen sind. Dies können Sie reproduzieren, indem Sie eine Tabelle namens tblTexte <\/b>mit den beiden Feldern Text-ID <\/b>und Inhalt <\/b>(Datentyp: Langer Text<\/b>\/Memo<\/b>) anlegen.<\/p>\n
Erstellen Sie dann ein Formular mit der Tabelle tblTexte <\/b>als Datenherkunft und fügen Sie die beiden Felder aus der Feldliste zum Formularentwurf hinzu. Nun legen wir einen Text von knapp 64.000 Zeichen im ersten Datensatz der Tabelle an:<\/p>\n Wechseln Sie dann zum Formular in der Formularansicht und fügen Sie noch ein paar Zeichen zum Text hinzu. Nach dem Hinzufügen von fünf Zeichen werden Sie keine neuen Zeichen mehr hinzufügen können – das Limit von 64.000 ist dann erreicht. Sie können auch nicht mehr als 64.000 Zeichen über eine INSERT INTO<\/b>-Anweisung hinzufügen. Die einzige Möglichkeit ist der Einsatz der oben verwendeten Prozedur mit den DAO-Methoden AddNew <\/b>und Update <\/b>des Recordset<\/b>-Objekts.<\/p>\n Das ändern des Textes ist weder in der Datenblattansicht der Tabelle noch im Formular möglich.<\/p>\n Damit kommt der Einsatz der MSForms-TextBox. Diese fügen Sie hinzu, indem Sie im Ribbon zum Tab Entwurf <\/b>wechseln und das Menü unter Steuer-elemente aufklappen und den Eintrag ActiveX-Steuerelemente auswählen (s. Bild 1).<\/p>\n Bild 1: öffnen des Dialogs zum Hinzufügen von ActiveX-Steuerelementen<\/span><\/b><\/p>\n Daraufhin erscheint der Dialog aus Bild 2, mit dem Sie den Eintrag Microsoft Forms 2.0 TextBox <\/b>selektieren und dieses per Mausklick auf die OK<\/b>-Schaltfläche zum Formularentwurf hinzufügen können. Das neue Steuer-element wird dann relativ klein in der linken, oberen Ecke des Formulars angelegt – Sie dürften das vom TreeView<\/b>-Steuerelement her kennen.<\/p>\n Bild 2: Der Dialog zur Auswahl von ActiveX-Steuerelementen<\/span><\/b><\/p>\n Die weiteren offensichtlichen Unterschiede zwischen diesem Steuer-element und dem eingebauten TextBox<\/b>-Element sind das fehlende Bezeichnungsfeld sowie der 3D-Effekt für den Rahmen (s. Bild 3).<\/p>\n Bild 3: Das herkömmliche Textfeld und sein MSForms-Bruder<\/span><\/b><\/p>\n Wenn wir uns die Eigenschaften dieses Steuerelements ansehen, finden wir auf den meisten Registerseiten eine vergleichsweise geringe Menge an Eigenschaften vor. Die spezifischen Eigenschaften des Steuerelements finden wir in englischer Sprache auf der Registerseite Andere <\/b>(s. Bild 4). Bevor wir uns die Eigenschaften unter VBA ansehen, benennen wir das Steuer-element noch schnell in txtMSForms <\/b>um.<\/p>\n Bild 4: Eigenschaften der MSForms-TextBox<\/span><\/b><\/p>\n Danach können wir zum VBA-Editor wechseln, mit dem Menübefehl Ansicht|Objektkatalog <\/b>(oder F2<\/b>) den Objektkatalog öffnen und uns die Eigenschaften des TextBox<\/b>-Objekts der Bibliothek MSForms <\/b>ansehen (s. Bild 5). Hier finden Sie noch einige weitere Einträge gegenüber denen im Eigenschaftsfenster.<\/p>\n Bild 5: Eigenschaften unter VBA<\/span><\/b><\/p>\n Das ActiveX-Steuerelement besteht aus einem Container des Typs CustomControl <\/b>sowie dem darin enthaltenen Steuer-element TextBox<\/b>. Den Container referenzieren wir direkt über den Namen des Elements, das enthaltene Steuer-element über die Eigenschaft Object<\/b>.<\/p>\n Dies verdeutlichen die folgenden beiden Codezeilen, mit denen wir den Typ der beiden Elemente im Direktbereich ausgeben:<\/p>\n Diese liefern nämlich:<\/p>\n Wenn Sie einfach Me!txtMSForms.Object <\/b>und den Punkt im VBA-Editor eingeben, würden Sie vermutlich gern eine Liste der Eigenschaften und Methoden präsentiert bekommen.<\/p>\n Das ist aber nicht der Fall. Eine Alternative wäre es, eine Objektvariable für das TextBox-Element zu deklarieren und diese im Form_Load<\/b>-Ereignis des Formulars zu füllen. Hier ist die Deklaration:<\/p>\n Und so stellen Sie die Objektvariable ein:<\/p>\n Die Menge der über das Eigenschaftsfenster verfügbaren Ereigniseigenschaften ist mit Bei OLE Aktualisierung<\/b>, Beim Hingehen<\/b>, Beim Verlassen<\/b>, Bei Fokuserhalt <\/b>und Bei Fokusverlust <\/b>überschaubar. Der Grund für diese wenigen Ereignisse ist, dass dies die Ereignisse des CustomControl<\/b>-Elements sind, das als Container für das eigentliche Steuer-element dient – diese Ereignisse finden Sie also auch bei den übrigen Steuerelementen der MSForms-Sammlung.<\/p>\n Wenn Sie die Ereignisse des eigentlichen Steuerelements nutzen wollen, müssen Sie den VBA-Editor zum Anlegen bemühen. Hier wählen Sie aus dem linken Kombinationsfeld den Namen des Steuerelements aus, hier txtMSForms<\/b>. Im rechten Kombinationsfeld erscheinen dann die verfügbaren Ereignisse (s. Bild 6). Das Ereignis txtMSForms_Change <\/b>wird hier automatisch bei Auswahl des Eintrags im linken Kombinationsfeld angelegt. Erfreut stellen wir hier fest, dass das TextBox-Element der MSForms-Bibliothek offensichtlich über Drag and Drop-Funktionalität verfügt, was wir uns weiter unten noch ansehen werden.<\/p>\n Bild 6: Anlegen von Ereignisprozeduren für MSForms-Steuerelemente<\/span><\/b><\/p>\n Ein wesentlicher Unterschied zum herkömmlichen TextBox-Element ist, dass es kein Before-Update <\/b>und AfterUpdate<\/b>-Ereignis gibt, sondern nur ein Updated<\/b>-Ereignis.<\/p>\n Beim Eingeben eines Zeichens werden beispielsweise die folgenden Ereignisse in dieser Reihenfolge ausgelöst:<\/p>\n Eine der wichtigeren Fragen für uns als Access-Benutzer ist natürlich: Können wir das Steuer-element an ein Feld der an das Formular gebundenen Datenherkunft binden Die Antwort lautet ja – das TextBox-Element der MSForms-Bibliothek liefert mit Steuerelementinhalt <\/b>genau die gleiche Eigenschaft für diesen Zweck wie das eingebaute TextBox<\/b>-Element. Also binden wir das Steuer-element doch gleich einmal an das Feld Inhalt, an das wir auch das Textfeld im gleichen Formular gebunden haben.<\/p>\n Nun können wir uns auch direkt davon überzeugen, was geschieht, wenn wir versuchen, einen Text mit mehr als 64.000 Zeichen zu bearbeiten. Das Erste, was uns auffällt, ist die unterschiedliche Darstellung des Textes. Das eingebaute TextBox-Element bricht die Zeilen des anzuzeigenden Textes um, die MSForms-TextBox zeigt nur eine Zeile an.<\/p>\n Auch das Einfügen von Zeilenumbrüchen macht es nicht besser – diese werden im Standardzustand in Form eines entsprechenden Symbols angezeigt (s. Bild 7).<\/p>\n Bild 7: Anzeige des gleichen Textes in den beiden TextBox-Elementen<\/span><\/b><\/p>\n Wir können aber durch Einstellen der Eigenschaft MultiLine <\/b>auf den Wert Ja <\/b>(im Eigenschaftsfenster) oder True <\/b>(per VBA) dafür sorgen, dass die Inhalte in der MSForms-TextBox mit Zeilenumbruch ausgegeben werden. Wenn MultiLine <\/b>auf Ja <\/b>eingestellt ist, werden die Zeilenumbrüche ausgeführt und nicht als Icon dargestellt.<\/p>\n Nun kommt noch die Eigenschaft WordWrap <\/b>ins Spiel: Stellen Sie diese auf Nein ein, werden Zeilen nur umbrochen, wenn Sie einen Zeilenumbruch eingefügt haben. Anderenfalls reichen die Zeilen über den rechten Rand des Steuerelements hinaus. Dies können Sie ändern, indem Sie WordWrap <\/b>auf Ja <\/b>einstellen. Dann werden die Zeilen an Leerzeichen umbrochen oder, wenn eine Zeile kein Leerzeichen aufweist, an der Stelle vor dem Erreichen des rechten Randes des Steuerelements.<\/p>\n Wenn Sie mit der Eingabetaste neue Zeilenumbrüche hinzufügen wollen, können Sie dies immer bei gedrückter Strg<\/b>-Taste erledigen – das allerdings nur, wenn die Eigenschaft Multiline <\/b>auf den Wert True <\/b>eingestellt ist. Erst wenn Sie die Eigenschaft EnterKeyBehavior <\/b>auf den Wert True <\/b>einstellen, erzeugt auch das reine Drücken der Eingabetaste (ohne Strg<\/b>) einen Zeilenumbruch.<\/p>\n Damit wir das gleiche Look and Feel wie mit dem eingebauten TextBox-Steuerelement erhalten, legen wir als Erstes die Schriftart fest. Das können wir nicht im Eigenschaftsfenster erledigen, da die entsprechende Eigenschaft dort nicht aufgeführt wird.<\/p>\n Stattdessen legen wir die notwendigen Codezeilen in der Form_Load<\/b>-Ereignisprozedur des Formulars an:<\/p>\n Hier stellen wir auch gleich die Bildlaufleiste am rechten Rand ein. Es gibt übrigens vier Werte für die Eigenschaft ScrollBars<\/b>: <\/p>\n Die Ausrichtung des Textes legen Sie mit der Eigenschaft TextAlign<\/b> ein. Diese erwartet einen der folgenden Werte:<\/p>\n Eine interessante Eigenschaft heißt AutoSize<\/b>. Wenn Sie diese auf Ja <\/b>einstellen, erhalten Sie ein Textfeld, das beim öffnen des Formulars auf die Länge der längsten Zeile des Inhalts eingestellt wird und das beim Eingeben von Text nach unten wächst (aber nicht in die Breite). Ich konnte noch keinen Sinn ausmachen, aber wer weiß …<\/p>\n <\/p>\n Diese beiden Eigenschaften MaxLength <\/b>und AutoTab <\/b>hören sich interessant an, wenn man ihre Beschreibung in der Onlinehilfe liest. Bei MaxLength = 4 <\/b>und AutoTab = True <\/b>etwa soll der Fokus nach der Eingabe auf das nächste Steuer-element verschoben werden, was etwa für die Eingabe von Registrierungsdaten aus mehreren Zeichenketten wie 1234-2345-3456-4567<\/b> interessant wäre. Leider klappt dies nicht wie in der Dokumentation beschrieben.<\/p>\n Für die folgenden Beispiele erstellen wir ein neues Formular, das wir auch an die Tabelle tblTexte <\/b>binden. Es enthält ein MSForms-Textfeld namens txtMarkierungen<\/b>, das wir an das Feld Inhalt des Formulars binden.<\/p>\n Wenn der Benutzer eine Markierung mit der Maus durchgeführt hat, soll der markierte Text in einem weiteren Textfeld namens txtMarkierterText <\/b>angezeigt werden. Dazu legen wir die folgenden Codezeilen im Klassenmodul des Formulars an:<\/p>\n Die Form_Load<\/b>-Prozedur füllt die Objektvariable mit einem Verweis auf die MSForms-TextBox. Dann nutzen wir MouseUp<\/b>-Ereignisprozedur, um den markierten Text mit der SelText<\/b>-Eigenschaft auszulesen und im Textfeld txtMarkierterText <\/b>auszugeben (s. Bild 8).<\/p>\n Bild 8: Erfassen einer Markierung<\/span><\/b><\/p>\n Analog können wir mit den Eigenschaften SelStart <\/b>und SelLength <\/b>herausfinden, welcher Bereich markiert ist. Das ist an sich kein Vorteil gegenüber dem normalen Textfeld, aber da dort die SelStart<\/b>– und die SelLength<\/b>-Eigenschaft als Integer definiert sind, können Sie dort nur Positionen bis zum 65.535ten Zeichen bestimmen. In der MSForms-TextBox hingegen gibt es diese Beschränkung nicht.<\/p>\n Die Eigenschaft CurLine <\/b>liefert die Nummer der Zeile, in der sich aktuell die Einfügemarke beziehungsweise das erste Zeichen der aktuellen Markierung befindet. Diese Eigenschaft ist 0-basiert.<\/p>\n Die Eigenschaft CurX<\/b> liefert die horizontale Position der Einfügemarke in der Einheit HIMETRIC<\/b>. CurTargetX <\/b>liefert laut Dokumentation die „bevorzugte“ Position der Einfügemarke. Aus unseren Experimenten ergab sich kein sinnvoller Einsatzzweck für diese Eigenschaften.<\/p>\n Die Eigenschaft AutoWordSelect <\/b>legt fest, wie die Markierung erfolgt, wenn Sie diese über ein Wort hinaus erstrecken:<\/p>\n Das bedeutet: Wenn Sie beispielsweise die Einfügemarke in der Mitte eines Wortes platzieren und die Markierung dann etwa bei gedrückter Umschalttaste so erweitern, dass Sie auch noch mindestens einen Buchstaben des benachbarten Wortes markieren, dann werden automatisch beide Wörter komplett markiert (Einstellung: True<\/b>).<\/p>\n Sehr wichtig ist die Eigenschaft HideSelection<\/b>. Wenn diese, wie standardmäßig vorgesehen, den Wert True <\/b>aufweise, wird die aktuelle Markierung im TextBox<\/b>-Element nicht mehr angezeigt, wenn das Steuer-element den Fokus verliert. Stellen Sie HideSelection <\/b>hingegen auf False <\/b>ein, bleibt die Markierung auch bei Fokusverlust erhalten.<\/p>\n LineCount <\/b>liefert die Gesamtanzahl der Zeilen, wie Sie im TextBox<\/b>-Steuerelement angezeigt werden.<\/p>\n TextLength <\/b>liefert die Anzahl der im TextBox<\/b>-Element enthaltenen Zeichen.<\/p>\n Wenn ein Text im TextBox<\/b>-Element markiert war, das Feld dann den Fokus verliert und der Benutzer dann mit der Tabulator-Taste zurück auf dieses Feld geht, sollen Sie mit der Eigenschaft EnterFieldBehavior <\/b>einstellen können, wie mit der vorhandenen Markierung verfahren werden soll:<\/p>\n Dies konnten wir nicht bestätigen – wenn wir das Textfeld per Tabulator-Taste aktiviert haben, wurde bei beiden Einstellungen die vorherige Markierung angezeigt.<\/p>\n Wenn Sie wie in einem herkömmlichen TextBox<\/b>-Steuerelement Kennwörter in maskierter Form eingeben möchten, also so, dass bei der Eingabe etwa für jedes Zeichen ein Sternchen (*<\/b>) erscheint, stellen Sie dies mit der Eigenschaft PasswordChar <\/b>ein:<\/p>\n Soll der Text wieder auf herkömmliche Art und Weise ausgegeben werden, stellen Sie PasswordChar <\/b>wieder auf eine leere Zeichenkette ein („“<\/b>).<\/p>\n In der Einstellung MultiLine = True <\/b>und TabKeyBehavior = False <\/b>wird die Eingabe mit der Tabulator-Taste gar nicht berücksichtigt. Erst in Kombination mit der Strg<\/b>-Taste wird der Fokus zum nächsten Steuer-element in der Tab<\/b>-Reihenfolge weitergereicht.<\/p>\n Erhält dann TabKeyBehavior <\/b>den Wert True<\/b>, können Sie den Fokus durch einfache Betätigung der Tabulator-Taste verschieben. Strg+Tabulator <\/b>fügt dann tatsächlich einen Tabulator-Vorschub in den Text ein.<\/p>\n Wenn Sie eine komplette Zeile selektieren wollen, können Sie dies standardmäßig durch einen Klick auf den schmalen Bereich links von der Zeile erledigen (s. Bild 9). Um dieses Verhalten zu deaktivieren, stellen Sie die Eigenschaft SelectionMargin <\/b>auf False <\/b>ein. Auf diese Weise wird der Text auch direkt am linken Rand angezeigt und nicht mehr mit der Einrückung.<\/p>\n Bild 9: Selektieren der kompletten Zeile<\/span><\/b><\/p>\n Während diese beiden Eigenschaften sich beim eingebauten TextBox<\/b>-Steuerelement insofern unterscheiden, als dass Value <\/b>immer den gespeicherten Wert liefert und Text <\/b>den aktuell sichtbaren Wert, ist das beim MSForms-TextBox-Element anders. Hier liefern beiden Eigenschaften immer den gleichen Wert.<\/p>\n In der Datei FM20.CHM <\/b>(unter Windows 10 und Office 2016, 32bit im Verzeichnis C:\\Program Files (x86)\\Common Files\\Microsoft Shared\\VBA\\VBA6\\1031 <\/b>zu finden) finden Sie eine Onlinehilfe mit weiteren Informationen zu den Steuer-elemente der MSForms-Bibliothek (s. Bild 10).<\/p>\n Bild 10: Hilfe-Datei<\/span><\/b><\/p>\n Sie können auch im Objektkatalog den Eintrag markieren, zu dem Sie Informationen benötigen, und dann die Taste F1 <\/b>betätigen. Dies öffnet die entsprechende Internetseite mit dem Hilfetext.<\/p>\n Die TextBox bietet Methoden, mit denen Sie den aktuell markierten Text unkompliziert in die Zwischenablage übertragen können – entweder zum Kopieren (Copy<\/b>) oder zum Ausschneiden (Cut<\/b>). Die folgenden beiden Methoden haben wir für zwei Schaltflächen hinterlegt, welche den markierten Text entweder kopieren oder ausschneiden:<\/p>\n Die Eigenschaft CanPaste <\/b>gibt an, ob der aktuelle Inhalt der Zwischenablage in das TextBox<\/b>-Element eingefügt werden kann. Damit können wir dem Formular, in dem sich das TextBox<\/b>-Element befindet, eine Schaltfläche hinzufügen, welche in Abhängigkeit vom möglichen Einfügen des Inhalts der Zwischenablage aktiviert oder deaktiviert wird.<\/p>\n Wir haben eine solche Ereignisprozedur beispielhaft für das MouseDown<\/b>-Ereignis der TextBox angelegt:<\/p>\n Wenn die Schaltfläche aktiviert ist, kann sie den Inhalt der Zwischenablage mit der folgenden Ereignisprozedur einfügen:<\/p>\n Drag and Drop ist natürlich ein sehr interessantes Feature – beispielsweise wäre es in vielen Fällen praktisch, wenn man etwa einen Dateinamen aus dem Explorer einfach in ein Textfeld ziehen und diesen so in einer Tabelle speichern oder die Datei zur weiteren Verarbeitung öffnen könnte. Für das Drag and Drop-Beispiel erstellen wir ein neues Formular namens frmDragAndDrop <\/b>und fügen diesem eine MSForms-TextBox namens txtDateipfad <\/b>hinzu (s. Bild 11).<\/p>\n Bild 11: Beispielformular für Drag and Drop<\/span><\/b><\/p>\n Für das Steuer-element legen wir eine Variable im Klassenmodul des Formulars an:<\/p>\n Außerdem füllen wir diese in der Form_Load<\/b>-Methode:<\/p>\n Damit wir Drag and Drop überhaupt mit der TextBox nutzen können, stellen wir außerdem die Eigenschaft DragBehavior <\/b>auf den Wert fmDragBehaviorEnabled <\/b>(1<\/b>) ein.<\/p>\n Ziehen wir nun einen Dateinamen aus dem Windows Explorer auf das Textfeld, erhalten wir allerdings noch nicht die gewünschte Resonanz (s. Bild 12).<\/p>\n Bild 12: Drag and Drop funktioniert nicht einfach so.<\/span><\/b><\/p>\n Um herauszufinden, wie wir die vorhandenen Ereignisse für die Implementierung der Drag and Drop-Funktion nutzen können, legen wir diese einfach erstmal alle an und tragen jeweils eine Debug.Print<\/b>-Anweisung ein, um zu erfahren, welches Ereignis wann ausgelöst wird (s. Listing 1).<\/p>\n Listing 1: Test der drei Ereignisse, die mit dem Drag and Drop zusammenhängen<\/span><\/b><\/p>\n Ein erster Test zeigt, dass beim überfahren des Textfeldes mit einem Eintrag des Windows Explorers lediglich das Ereignis BeforeDragOver <\/b>ausgelöst wird.<\/p>\n Vermutlich müssen wir hier die Weichen stellen, damit die übrigen Ereignisse auch feuern. Die Ereignisprozedur liefert die folgenden Parameter:<\/p>\n Wir wissen also nun, dass wir Cancel <\/b>auf True <\/b>einstellen müssen, wenn wir selbst den Drag and Drop-Vorgang ausprogrammieren wollen. In diesem Fall wird dann auch noch die BeforeDropOrPaste<\/b>-Ereignisprozedur ausgelöst, welche die gleichen Parameter wie das BeforeDragOver<\/b>-Ereignis bietet.<\/p>\n Nach dem Testen der Drag and Drop-Funktion kommt die Ernüchterung: Drag and Drop mit Daten vom Windows Explorer gelingt nicht – wir kommen nicht an den Dateinamen heran. Das hält uns allerdings nicht auf – wir gehen einen kleinen Umweg. Dabei nutzen wir die Möglichkeit, den Inhalt der Drag and Drop-Operation in die Zwischenablage zu kopieren.<\/p>\n Von dort können wir wiederum den Dateinamen auslesen, und zwar mithilfe einiger API-Funktionen, die wir in fertig zusammengestellter Form im Internet finden. Listing 2 zeigt, wie wir in der Ereignisprozedur BeforeDropOrPaste <\/b>den Inhalt des Parameters Data <\/b>mit der Methode PutInClipboard <\/b>in die Zwischenablage kopieren.<\/p>\n Listing 2: Ereignisprozedur, die vor dem Fallenlassen ausgelöst wird<\/span><\/b><\/p>\n Die Funktion GetClipboardFiles <\/b>ermittelt daraus ein Array aller enthaltenen Dateinamen, die wir dann nur noch auslesen und in das TextBox<\/b>-Element eintragen müssen.<\/p>\n Weiter oben haben Sie bereits die grundlegenden Techniken kennengelernt, wie Sie Texte in einer MSForms-TextBox markieren können und wie Sie auf die Markierungen zugreifen.<\/p>\n Nun haben Sie auch mittlerweile erfahren, dass die MSForms-TextBox größere Mengen von Text verarbeiten kann als das eingebaute TextBox-Element – und dass auch die Eigenschaften SelStart <\/b>und SelLength <\/b>hier als Long <\/b>deklariert sind und nicht als Integer <\/b>und somit auch größere Werte annehmen können.<\/p>\n Wenn Sie nun in diesem Steuer-element mit einem langen Text eine Textpassage markieren wollen, die sich weit hinter dem zu Beginn sichtbaren Bereich befindet, können Sie das ganz einfach tun, indem Sie die entsprechenden Werte für die Eigenschaften SelStart <\/b>und SelLength <\/b>einstellen. Das einzige Problem, das wir beim herkömmlichen TextBox<\/b>-Element haben, lautet: Wir bekommen wir den markierten Bereich in den sichtbaren Bereich<\/p>\n Hier bietet das MSForms-TextBox-Element noch die Eigenschaft CurLine <\/b>an, mit der wir nicht nur ermitteln können, in welcher Zeile sich die Einfügemarke aktuell befindet, sondern mit der wir auch die aktuelle Zeile einstellen können – und diese somit in den sichtbaren Bereich holen.<\/p>\n Wenn wir nun einen fest definierten Bereich annehmen – beispielsweise vom 3.000ten Zeichen mit einer Länge von 20 Zeichen – können wir diesen über eine Schaltfläche mit der folgenden Ereignisprozedur einblenden:<\/p>\n In Bild 13 sehen Sie das Ergebnis dieser Prozedur. Diese setzt zunächst die Markierung und ermittelt dann die Zeile, in der die Markierung beginnt. Dann stellt sie über die Eigenschaft CurLine <\/b>die aktuelle Zeile neu ein, die dann auch in den sichtbaren Bereich gerückt wird.<\/p>\n Bild 13: Markieren und Anzeigen eines weit hinten liegenden Bereichs<\/span><\/b><\/p>\n Damit die Zeile nicht ganz unten erscheint, sondern in der Mitte, fügen wir zur zuvor gespeicherten Zeilenangabe noch fünf Zeilen hinzu. Dann erhält das Textfeld den Fokus und wir stellen die durch das Setzen der aktuellen Zeile mit CurLine <\/b>verloren gegangene Markierung wieder neu.<\/p>\n In neueren Access-Versionen gibt es die beiden Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker<\/b>. Damit können Sie dafür sorgen, dass ein Steuer-element mit entsprechenden Einstellungen beim ändern der Formulargröße ebenfalls seine Höhe und\/oder Breite ändert. <\/p>\n Diese beiden Eigenschaften gibt es auch für die MSForms-TextBox. Leider funktioniert dies aber nicht wie erwartet. Wenn Sie nur die Breite des Formulars verändern und somit auch die Breite des TextBox-Elements, sieht alles noch recht gut aus – mit Ausnahme einer eventuell eingeblendeten vertikalen Bildlaufleiste, die dann ebenfalls verbreitert wird (s. Bild 14).<\/p>\n Bild 14: Das Verbreitern des horizontal verankerten Steuerelements gelingt noch recht gut …<\/span><\/b><\/p>\n Wenn wir allerdings die Höhe des Formulars ändern, wächst auch die Schriftgröße des enthaltenen Textes (s. Bild 15).<\/p>\nPublic Sub <\/span>EinLangerText()\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 Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblTexte\", _\r\n dbOpenDynaset)\r\n rst.AddNew<\/span>\r\n strText = String(63995, \"A\")\r\n rst!Inhalt = strText\r\n rst.Update\r\nEnd Sub<\/span><\/pre>\nLange Texte in der MSForms-TextBox<\/h2>\n
![\"öffnen](\"..\/fileadmin\/_temp_\/2018_01\/pic_1114_001.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2018_01\/pic_1114_002.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2018_01\/pic_1114_003.png\")
<\/p>\n![\"Eigenschaften](\"..\/fileadmin\/_temp_\/2018_01\/pic_1114_004.png\")
<\/p>\n![\"Eigenschaften](\"..\/fileadmin\/_temp_\/2018_01\/pic_1114_005.png\")
<\/p>\nAus eins mach zwei<\/h2>\n
Debug.Print<\/span> TypeName(Me!txtMSForms)\r\nDebug.Print<\/span> TypeName(Me!txtMSForms.Object)<\/pre>\nCustomControl\r\nText<\/span>Box<\/pre>\nEigenschaften per IntelliSense<\/h2>\n
Dim <\/span>objMSForms As <\/span>MSForms.TextBox<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objMSForms = Me!txtMSForms.Object\r\n With<\/span> objMSForms\r\n ''''... \r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nEreignisse<\/h2>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2018_01\/pic_1114_006.png\")
<\/p>\nKeyDown\r\nKeyPress\r\nUpdated\r\nUpdated\r\nChange\r\nKeyUp<\/pre>\n
Datenbindung<\/h2>\n
![\"Anzeige](\"..\/fileadmin\/_temp_\/2018_01\/pic_1114_007.png\")
<\/p>\nZeilenumbruch<\/h2>\n
Neue Zeilen<\/h2>\n
Anpassen an das Layout der eingebauten TextBox<\/h2>\n
Set<\/span> objMSForms = Me!txtMSForms.Object\r\nWith<\/span> objMSForms\r\n .Font.Name = \"Calibri\"\r\n .Font.Size = 11\r\n .ScrollBars = fmScrollBarsHorizontal\r\nEnd With<\/span><\/pre>\n\n
Ausrichtung einstellen<\/h2>\n
\n
Automatische Größe <\/h2>\n
MaxLength und AutoTab<\/h2>\n
Markierten Text auslesen<\/h2>\n
Dim <\/span>objMarkierungen As <\/span>MSForms.TextBox\r\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objMarkierungen = Me.txtMarkierungen.Object\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>txtMarkierungen_MouseUp(...)\r\n Me!txtMarkierterText = objMarkierungen.SelText\r\nEnd Sub<\/span><\/pre>\n![\"Erfassen](\"..\/fileadmin\/_temp_\/2018_01\/pic_1114_011.png\")
<\/p>\nWeitere Eigenschaften zur aktuellen Markierung: CurLine, CurTargetX, CurX<\/h2>\n
Markierung erweitern<\/h2>\n
\n
Markierung auch bei Fokusverlust beibehalten<\/h2>\n
Allgemeine Eigenschaften: LineCount und TextLength<\/h2>\n
Beim Aktivieren per Tabulatur-Taste<\/h2>\n
\n
Eingabe von Kennwörtern<\/h2>\n
Me!txtMarkierungen.Object.PasswordChar = \"*\"<\/pre>\n
Eingabe von Tabulator-Zeichen<\/h2>\n
Komplette Zeile selektieren<\/h2>\n
![\"Selektieren](\"..\/fileadmin\/_temp_\/2018_01\/pic_1114_010.png\")
<\/p>\nText und Value<\/h2>\n
Onlinehilfe<\/h2>\n
![\"Hilfe-Datei\"](\"..\/fileadmin\/_temp_\/2018_01\/pic_1114_008.png\")
<\/p>\nZwischenablage-Funktionen<\/h2>\n
Private Sub <\/span>cmdCopy_Click()\r\n Me!txtMarkierungen.Object.Copy\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cmdCut_Click()\r\n Me!txtMarkierungen.Object.Cut\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>txtMarkierungen_MouseDown(ByVal Button As Integer<\/span>, ByVal Shift As Integer<\/span>, ByVal X As Single<\/span>, ByVal Y As Single<\/span>)\r\n If <\/span>objMarkierungen.CanPaste Then<\/span>\r\n Me!cmdPaste.Enabled = True<\/span>\r\n Else<\/span>\r\n Me!cmdPaste.Enabled = False<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdPaste_Click()\r\n Me!txtMarkierungen.Object.Paste\r\nEnd Sub<\/span><\/pre>\nDrag and Drop<\/h2>\n
![\"Beispielformular](\"..\/fileadmin\/_temp_\/2018_01\/pic_1114_012.png\")
<\/p>\nDim <\/span>WithEvents objDateipfad As <\/span>MSForms.TextBox<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objDateipfad = Me!txtDateipfad.Object\r\n objDateipfad.DragBehavior = fmDragBehaviorEnabled\r\nEnd Sub<\/span><\/pre>\n![\"Drag](\"..\/fileadmin\/_temp_\/2018_01\/pic_1114_013.png\")
<\/p>\nPrivate Sub <\/span>objDateipfad_BeforeDragOver(ByVal Cancel As <\/span>MSForms.ReturnBoolean, ByVal Data As <\/span>MSForms.DataObject, _\r\n ByVal X As Single<\/span>, ByVal Y As Single<\/span>, ByVal DragState As <\/span>MSForms.fmDragState, ByVal Effect As <\/span>MSForms._\r\n ReturnEffect, ByVal Shift As Integer<\/span>)\r\n Debug.Print<\/span> \"BeforeDragOver\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>objDateipfad_BeforeDropOrPaste(ByVal Cancel As <\/span>MSForms.ReturnBoolean, ByVal Action As <\/span>MSForms.fmAction, _\r\n ByVal Data As <\/span>MSForms.DataObject, ByVal X As Single<\/span>, ByVal Y As Single<\/span>, ByVal Effect As <\/span>MSForms.ReturnEffect, _\r\n ByVal Shift As Integer<\/span>)\r\n Debug.Print<\/span> \"BeforeDropOrPaste\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>objDateipfad_DropButtonClick()\r\n Debug.Print<\/span> \"DropButtonClick\"\r\nEnd Sub<\/span><\/pre>\n\n
Private Sub <\/span>objDateipfad_BeforeDropOrPaste(ByVal Cancel As <\/span>MSForms.ReturnBoolean, ByVal Action As <\/span>MSForms.fmAction, _\r\n ByVal Data As <\/span>MSForms.DataObject, ByVal X As Single<\/span>, ByVal Y As Single<\/span>, ByVal Effect As <\/span>MSForms.ReturnEffect, _\r\n ByVal Shift As Integer<\/span>)\r\n Dim <\/span>intAnzahl As Integer<\/span>\r\n Dim <\/span>strDateipfade() As String<\/span>\r\n Data.PutInClipboard\r\n intAnzahl = GetClipboardFiles(strDateipfade())\r\n If <\/span>intAnzahl > 0 Then<\/span>\r\n Cancel = True<\/span>\r\n objDateipfad.Text = strDateipfade(0)\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nTexte markieren für Fortgeschrittene<\/h2>\n
Private Sub <\/span>cmdMarkieren_Click()\r\n Dim <\/span>lngCurLine As Long<\/span>\r\n objMarkierungen.SelStart = 3000\r\n objMarkierungen.SelLength = 20\r\n lngCurLine = objMarkierungen.CurLine\r\n objMarkierungen.CurLine = lngCurLine + 5\r\n Me!txtMarkierungen.SetFocus\r\n objMarkierungen.SelStart = 3000\r\n objMarkierungen.SelLength = 20\r\nEnd Sub<\/span><\/pre>\n![\"Markieren](\"..\/fileadmin\/_temp_\/2018_01\/pic_1114_014.png\")
<\/p>\nVerankern des Steuerelements<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2018_01\/pic_1114_015.png\")
<\/p>\n![\"...](\"..\/fileadmin\/_temp_\/2018_01\/pic_1114_016.png\")
<\/p>\n