4.10 Text-Objekte

4.10.1 Überblick
4.10.2 Arbeit mit dem Text
4.10.3 Zeichenattribute
4.10.4 Absatzattribute
4.10.5 Textfilter
4.10.6 Textobjekt Actions
4.10.7 Verhalten und Aussehen
4.10.8 Text-Objekte im Delayed Mode

^

4.10.1 Überblick

Die R-BASIC Textobjekte erlauben das einfache Eingeben von Text, ohne dass Sie als Programmierer sich um irgendwelche Details kümmern müssen. Die Textobjekte behandeln Tastatur- und Mausereignisse selbständig. Sie registrieren, ob der Text vom Nutzer verändert wurde und können bei Bedarf Messages aussenden, um den Rest des Programms über bestimmten Ereignissen zu informieren.

In R-BASIC stehen vier Textobjekt Klassen zur Verfügung. Die Klasse Memo und InputLine sind GenericClass Objekte und sehr einfach zu benutzen. VisText und LargeText sind VisualClass Objekte. Sie müssen mit einem VisContent in einem View verwendet werden. Diesen Klassen ist ein eigenes Kapitel (4.10.9) gewidmet.

Memo Die Memo-Klasse stellt einen einfachen Texteditor bereit. Sie unterstützt einen automatischen Zeilenumbruch und die Entertaste beginnt einen neuen Absatz. Bei Bedarf wird ein vertikaler Rollbalken erzeugt.
InputLine Die Klasse InputLine ist für die Eingabe einzeiliger Texte, z.B. von Dateinamen, gedacht. Die Entertaste löst bei InputLine-Objekten den Apply-Handler des Objekts aus.
VisText Objekte der Klasse VisText müssen wie ein VisObj-Objekt in einem visual Tree verwendet werden. Details zu diesem Thema finden Sie im Kapitel 5.5. des Objekthandbuchs.
LargeText Der Vorteil der LargeText Objekte ist, dass sie beliebig viel Text speichern können (theoretisch bis zu 2 GByte), während die anderen Textobjekte auf 4 kByte begrenzt sind.

Die meisten Instancevariablen und Methoden sind für alle Textobjektklassen identisch, Ausnahmen sind unten erwähnt. Keins der R-BASIC Text-Objekte unterstützt die Formatierung einzelner Buchstaben, Worte oder Absätze. Alle Formatinformationen (z.B. Font, Textgröße, Textstil, Ausrichtung usw.) gelten immer für den gesamten Text des Objekts.

Da die Textobjekte Memo und InputLine von der GenericClass abstammen erben sie alle Eigenschaften, Hints und Fähigkeiten dieser Klasse. Für diese Textobjekte sind besonders die Fähigkeiten zum Geometrie-Management (Kapitel 3.3) von Bedeutung.

Die Geometrie von VisText- und LargeText-Objekten wird vom VisContent bzw. dem dazugehörigen View bestimmt, in dem sie sich befinden.

Arbeit mit dem Clipboard

Alle Textobjekte können mit der Zwischenablage (Clipboard) kommunizieren. Die Methoden (Objektanweisungen) ClpTestCopy, ClpTestPaste, ClpCopy und ClpPaste werden unterstützt. Eine detaillierte Beschreibung dieser Methoden finden Sie im Kapitel "Arbeit mit der Zwischenablage" (Kapitel 5 im Handbuch "Spezielle Themen"). Die Textobjekte verhalten sich dabei genauso wie Sie es von Textobjekten in anderen Programmen gewohnt sind.

Die wichtigsten Punkte sind:

ClpTestCopy liefert TRUE, wenn Text selektiert ist. Ist nichts selektiert liefert es FALSE.
Die Methode ClpCopy kopiert den aktuell selektierten Text in die Zwischenablage. Ist nichts selektiert wird auch nichts in die Zwischenablage kopiert. Die globale Variable clipboardError wird gesetzt (TRUE: Text wurde ins Clipboard kopiert, FALSE: kein Text wurde ins Clipboard kopiert).
Die Methode ClpPaste ersetzt den aktuell selektierten Text. Ist nichts selektiert wird der Text an der Cursorposition eingefügt. Achtung! ClpPaste setzt die globale Variable clipboardError immer auf FALSE. PC/GEOS liefert für Textobjekte keine Rückmeldung, ob die Operation erfolgreich war oder nicht.
ClpPaste akzeptiert nur "reine" Texte. Eventuelle Formatierungen gehen verloren. Enthält der Text zu viele Zeichen oder Grafiken, so erzeugt das Objekt eine Fehlermeldung. Ist kein Text in der Zwischenablage wird die Operation ignoriert.

Keyboard-Handler

Sie können in die Behandlung von Tastaturereignissen eingreifen indem Sie einen Tastaturhandler für das Textobjekt schreiben. Dazu werden die folgenden Instancevariablen unterstützt:

Actionhandler Instancevariablen Methoden

OnKeyPressed inputFlags --

Der OnKeyPressed-Handler wird gerufen, wenn das Textobjekt den Focus hat und der Nutzer drückt eine Taste oder lässt sie los. Er muss als KeyboardAction deklariert sein. Dabei steuert inputFlags, ob das Objekt selbst oder der entsprechende BASIC Handler das Ereignis bearbeitet. Eine ausführliche Beschreibung der Zusammenhänge finden Sie im Kapitel 14 (Arbeit mit der Tastatur) im Handbuch "Spezielle Themen".

Insbesondere ist es wichtig zu wissen, dass das Textobjekt zunächst jedes Tastaturereignis selbst behandelt, bevor es den entsprechenden BASIC Handler aufruft. Im Kapitel 14.4 (Filtern von Tastaturereignissen) des Handbuchs "Spezielle Themen" ist beschrieben, wie man das umgehen kann.

Focus und Target

Textobjekte interagieren mit der Focus- und Target-Hierarchie. Es ist möglich zu überwachen, ob ein Text-Objekt den Focus oder das Target hat, indem man einen Focus- bzw. Target-Handler schreibt. Dazu werden die folgenden Actionhandler, Instance- und Systemvariablen unterstützt.

Actionhandler Instancevariablen
(nur Memo und InputLine) Systemvariable

OnFocusChanged
OnTargetChanged defaultFocus
targetable
defaultTarget Focus
Target

Die notwendigen Details zur Arbeit mit Focus und Target finden Sie im Kapitel 12 (Focus und Target) des Handbuchs "Spezielle Themen". Das Arbeiten mit Focus und Target ist etwas für erfahrene Programmierer und nur in wenigen Fällen notwendig. Eine Ausnahme bildet die Implementation von speziellen Menüs wie dem "Bearbeiten" Menü. Diesem Thema ist deswegen ein eigenes Kapitel ("Spezielle Themen", Kapitel 13) gewidmet.

Hinweise zu Focus und Target bei Text-Objekten:

Die Verwendung des OnFocusChanged Handler ist nur sehr selten nötig. In den meisten Fällen, in denen man zunächst an den Focus-Handler denkt, ist es sinnvoller den OnTargetChanged Handler zu verwenden.
Wenn Sie zum Beispiel mehr als ein Textobjekt haben wird der OnTargetChanged Handler oft benutzt um die UI entsprechend den Attributen (Font, Textgröße, Farben usw.) anzupassen, die im Textobjekt dargestellt werden, mit dem der Nutzer gerade interagiert.
Ein entsprechendes Beispiel finden Sie im Kapitel 4.10.6 (Text-Objekt Actions).

Die folgenden Kapitel verwenden meist Memo oder InputLine Objekte als Beispiele. Die Aussagen gelten aber immer für alle Textobjekte. Ausnahmen sind explizit erwähnt.

Außerdem wird davon ausgegangen, dass die Textobjekte im normalen Modus (nicht im sogenannten "Delayed Mode") arbeiten. Der Delayed Mode ist nur für GenericClass Objekte (Memo und InputLine) verfügbar und ausführlich im Kapitel 3.4.2 (Delayed Mode und Statusmessage) beschrieben.

Abstammung Memo und InputLine:

Abstammung VisText und LargeText:

Spezielle Instance-Variablen für alle (*) Textobjekt Klassen:

Variable Syntax im UI-Code Im BASIC-Code
maxLen (*) maxLen = numWert lesen, schreiben
textLen -- nur lesen
text$ text$ = "text" lesen, schreiben
cursorPos -- lesen, schreiben
selectionEnd -- lesen, schreiben
selectionLen -- lesen, schreiben
fontID fontID = numWert lesen, schreiben
fontSize fontSize = numWert lesen, schreiben
textStyle textStyle = numWert lesen, schreiben
textColor textColor = numWert lesen, schreiben
backColor backColor = numWert lesen, schreiben
justifyText justifyText = numWert lesen, schreiben
lineSpacing lineSpacing = numWert lesen, schreiben
margins margins = left, right [ , first ] lesen, schreiben
topSpace topSpace = numWert lesen, schreiben
textFilter textFilter = numWert lesen, schreiben
textAttrs textAttrs = numWert lesen, schreiben
modified modified = numWert lesen, schreiben
OnModified OnModified = <Handler> nur schreiben
OnSelectionChanged OnSelectionChanged = <Handler> nur schreiben

(*) maxLen wird von LargeText Objekten nicht unterstützt. Die Textgröße von LargeText Objekten ist prinzipiell unbegrenzt.

Spezielle Instance-Variablen nur für GenericClass Objekte Memo und InputLine:

Variable Syntax im UI-Code Im BASIC-Code
TextFrame TextFrame --
TextNoFrame TextNoFrame --
SelectableIfRO SelectableIfRO --
ApplyHandler ApplyHandler = <Handler> nur schreiben
StatusHandler StatusHandler = <Handler> nur schreiben

Spezielle Instance-Variablen nur für LargeText:

Variable Syntax im UI-Code Im BASIC-Code
approxSize approxSize = numWert lesen, schreiben

Methoden für alle Textobjekt Klassen:

Methode Aufgabe
SelectedText$ Liefert den aktuell selektierten Text
TextRange$ Liefert einen bestimmten Textbereich
Append Text anhängen
Insert Text einfügen
ReplaceSelection Selektierten Text ersetzen
DeleteSelection Selektierten Text löschen
DeleteRange Textbereich löschen
ShowCursor Zur Cursorposition scrollen
Suspend Verhindert die Neudarstellung des Objekts
EndSuspend Erlaubt die Neudarstellung des Objekts wieder

Methoden nur für Memo und InputLine:

Methode Aufgabe
ScrollUp Hoch scrollen
ScrollDown Herunter scrollen
SendStatus Status-Handler aufrufen

Action-Handler-Typen:

Handler-Typ Parameter
TextAction (sender as object, isModified as integer, textLen as word, selectionLen as word)

Beispiel: Ein typisches Memo Text Objekt

Memo Memo1 
  Caption$ = "Note:"
  justifyCaption = J_TOP
  text$ ="Enter some text here ..."  
  maxlen = 100  
  fixedSize = 30 + ST_AVG_CHAR_WIDTH, 5 + ST_LINES_OF_TEXT
  END Object

Beispiel: Ein typisches InputLine Text Objekt

InputLine NameText 
  Caption$ = "Name:"
  text$ ="Setag, Llib" 
  maxLen = 100  
  ExpandWidth
  ApplyHandler = ApplyNameText
  END Object

^

4.10.2 Arbeit mit dem Text

Hinweis: Stringvariablen nehmen standardmäßig nur bis zu 128 Zeichen auf, mit String(n) vereinbarte Stringvariablen können bis zu 1024 Zeichen speichern. Achten Sie beim Lesen von Text aus einem Textobjekt darauf, dass Textobjekte bis zu 4096 Zeichen enthalten können, LargeText Objekte sogar noch wesentlich mehr. Verwenden Sie die Instancevariable maxLen, um sicher zu sein, bzw. fragen Sie die Instancevariable textLen ab, wenn sie unsicher sind.

Instancevariable Syntax im UI-Code Im BASIC-Code
maxLen (*) maxLen = numWert lesen, schreiben
textLen -- nur lesen
text$ text$ = "text" lesen, schreiben
cursorPos -- lesen, schreiben

selectionEnd -- lesen, schreiben
selectionLen -- lesen, schreiben

(*) maxLen wird von LargeText Objekten nicht unterstützt.

Methoden:

Methode Aufgabe
SelectedText$ Liefert des aktuell selektierten Text
TextRange$ Liefert einen bestimmten Textbereich
Append Text anhängen
Insert Text einfügen
ReplaceSelection Selektierten Text ersetzen
DeleteSelection Selektierten Text löschen
DeleteRange Textbereich löschen
ShowCursor Zur Cursorposition scrollen
ScrollUp Hoch scrollen
ScrollDown Herunter scrollen
Suspend Verhindert die Neudarstellung des Objekts
EndSuspend Erlaubt die Neudarstellung des Objekts wieder

text$

Die Instance-Variable text$ enthält den eigentlichen Text des Objekts. Sie kann gelesen und geschrieben werden. Das Textobjekt stellt den neuen Text automatisch dar, wenn sie der Instance-Variable text$ einen Wert zuweisen.

Syntax UI-Code: text$ = "text" 
         Lesen: <stringVar> = <obj>.text$ 
     Schreiben: <obj>.text$ = "text"
Kompatibilität: alle Textobjekte

maxLen

Die Instance-Variable maxLen enthält die maximale Länge des Textes, den das Objekt verwalten kann. Der Default-Wert liegt bei 1024, das ist die maximale Größe, die eine String-Variable in R-BASIC speichern kann. Erlaubt sind Werte von 1 bis 4096. Für LargeText Objekte kann die Textlänge nicht begrenzt werden, maxLen wird nicht unterstützt.

Syntax UI-Code: maxLen = numWert 
         Lesen: <numVar> = <obj>.maxLen 
     Schreiben: <obj>.maxLen = numWert
Kompatibilität: Memo, InputLine, VisText (nicht LargeText)

Setzen Sie maxLen auf einen Wert, der kleiner als die aktuelle Textlänge ist, so wird der Text abgeschnitten.
Der Nutzer kann nicht mehr Text eingeben, als durch maxLen festgelegt ist.
Es ist immer eine gute Idee maxLen so klein wie nur möglich zu wählen. Beispielsweise ist zur Eingabe von GEOS-Dateinamen ein Wert von 32 für maxLen vernünftig, da GEOS-Dateinamen nicht länger als 32 Zeichen werden können.
Der Text wird immer gemeinsam mit dem Textobjekt in den Speicher geladen wird. Wenn Sie maxLen zur Laufzeit (!) drastisch vergrößern und auch entsprechend viel Text abspeichern kann es in sehr ungünstigen Fällen zur Meldung "Hauptspeicher voll" kommen. Das Problem kann nicht auftreten, wenn Sie maxLen im UI-Code auf einen großen Wert setzen. Der Compiler verteilt die Textobjekte dann auf mehrere Objektblöcke. Im Kapitel 2.1.4 finden Sie Details zu diesem Problem.

textLen

Die Instance-Variable textLen enthält die Länge des aktuellen Textes.

  Syntax Lesen: <numVar> = <obj>.textLen 
Kompatibilität: Memo, InputLine, VisText (nicht LargeText)

CursorPos

Die Instancevariable cursorPos enthält die aktuelle Position der Schreibmarke (Cursor). Sie entspricht er Zeichenposition, hinter dem sich der Cursor befindet. Die Position Null entspricht dem Textanfang. CursorPos kann gelesen und geschrieben, aber nicht im UI-Code verwendet werden. Wenn Text selektiert ist enthält cursorPos die Anfangsposition des selektierten Texts. Schreiben der Cursorposition hebt eine vorhandene Textselektion auf.

  Syntax Lesen: <numVar> = <obj>.cursorPos
     Schreiben: <obj>.cursorPos = wert
          wert: Neue Cursorposition. Null entspricht dem Textanfang.
Kompatibilität: Alle Textobjekte

SelectionEnd

Die Instancevariable selectionEnd enthält die Endposition des aktuell selektierten Texts. SelectionEnd ist immer größer oder gleich cursorPos. Ist kein Text selektiert enthält selectionEnd den gleichen Wert wie cursorPos. SelectionEnd kann gelesen und geschrieben, aber nicht im UI-Code verwendet werden.

   Syntax Lesen: <numVar> = <obj>.selectionEnd
      Schreiben: <obj>.selectionEnd = wert
           wert: Neue Endposition der Textselektion.
 Kompatibilität: alle Textobjekte

SelectionLen

Die Instancevariable selectionLen enthält die Länge des aktuell selektierten Texts. SelectionEnd ist immer größer oder gleich Null. Ist kein Text selektiert enthält selectionLen den Wert Null. SelectionLen kann gelesen und geschrieben, aber nicht im UI-Code verwendet werden.

  Syntax Lesen: <numVar> = <obj>.selectionLen
     Schreiben: <obj>.selectionLen = wert
          wert: Neue Länge der Textselektion.
                Negative Werte selektieren den Text links vom Cursor.
Kompatibilität: alle Textobjekte

SelectedText$

Die Methode SelectedText$ liefert den aktuell selektierten Text. Ist nichts selektiert liefert sie einen leeren String. SelectedText$ kann nur gelesen werden. Um den selektierten Text zu ersetzen verwenden Sie die Methode ReplaceSelection.

  Syntax Lesen: <stringVar> = <obj>.SelectedText$
Kompatibilität: alle Textobjekte

TextRange$

Die Methode TextRange$ liefert einen bestimmten Textbereich. Der Bereich wird dabei durch die Cursorpositionen links vom zu lesenden Bereich (pos1) und die Cursorpositionen rechts vom zu lesenden Bereich. Dadurch ergeben sich die folgenden Zusammenhänge:

Pos1 entspricht der Anzahl der zu übergehenden Zeichen links vom zu lesenden Bereich.
Pos1 = 0 entspricht dem Lesen ab dem Textanfang, pos1 = N bedeutet: Lesen ab dem N+1. Zeichen.
Die Anzahl der gelesenen Zeichen ergibt sich zu pos2 - pos 1.

Außerdem gilt folgendes:

Ist pos2 größer als die Textlänge so liefert TextRange$ entsprechend weniger Zeichen.
Sollte pos1 > pos2 sein so vertauscht R-BASIC die Werte automatisch.

  Syntax Lesen: <stringVar> = <obj>.TextRange$ (pos1, pos2)
    pos1, pos2: Textbereich der gelesen werden soll.
Kompatibilität: alle Textobjekte

Beispiele. Beachten Sie die Werte in der zweiten Zeile!

 a$ = TextObj.TextRange$ ( 0, 10)    ' die ersten 10 Zeichen
 a$ = TextObj.TextRange$ (10, 20)    ' die nächsten 10 Zeichen
 a$ = TextObj.TextRange$ (100, 5000) ' alles ab Zeichen 101

Append

Die Methode Append hängt Text an den vorhandenen Text an.

Syntax Schreiben: <TextObj>.Append  <StringExpression> 
StringExpression: ein beliebiger Stringausdruck
  Kompatibilität: alle Textobjekte

Insert

Die Methode Insert fügt Text an der aktuellen Cursorposition ein. Ist Text selektiert wird am Anfang des selektierten Bereichs eingefügt. Die Selektion wird dabei aufgehoben.

Syntax Schreiben: <TextObj>.Insert <StringExpression> 
StringExpression: ein beliebiger Stringausdruck
  Kompatibilität: alle Textobjekte

ReplaceSelection

Die Methode ReplaceSelection ersetzt den aktuell selektierten Text. Ist nichts selektiert wird der Text an der Cursorposition eingefügt.

Syntax Schreiben: <TextObj>.ReplaceSelection <StringExpression> 
StringExpression: ein beliebiger Stringausdruck
  Kompatibilität: alle Textobjekte

DeleteSelection

Die Methode DeleteSelection löscht den aktuell selektierten Text. Ist nichts selektiert passiert nichts.

Syntax Schreiben: <TextObj>.DeleteSelection 
  Kompatibilität: alle Textobjekte

DeleteRange

Die Methode DeleteRange löscht einen bestimmten Textbereich. Der Bereich wird dabei durch die Cursorpositionen vor (pos1) und nach dem gewünschten Bereich (pos2) bestimmt. Weitere Hinweise dazu finden Sie bei der Methode TextRange$.

  Syntax Lesen: <stringVar> = <obj>.DeleteRange (pos1, pos2)
    pos1, pos2: Textbereich der gelöscht werden soll.
Kompatibilität: alle Textobjekte

Beispiele:

 TextObj.DeleteRange 0, 10      ' die ersten 10 Zeichen
 TextObj.DeleteRange 100, 5000  ' alles ab Zeichen 101

ShowCursor

Die Methode ShowCursor scrollt den Text so, dass die aktuelle Cursorposition für den Nutzer sichtbar ist.

        Syntax: <TextObj>.ShowCursor
Kompatibilität: alle Textobjekte

ScrollDown

Die Methode ScrollDown scrollt den Text nach unten.

        Syntax: <TextObj>.ScrollDown
Kompatibilität: GenericClass Text-Objekte: Memo, InputLine

ScrollUp

Die Methode ScrollUp scrollt den Text nach oben.

        Syntax: <TextObj>.ScrollUp
Kompatibilität: GenericClass Text-Objekte: Memo, InputLine

Hinweis: VisText Objekte sind nicht scrollbar. Für LargeText-Objekte können Sie die Methode ScrollCmd des zugehörigen Views benutzen.

Suspend

Die Methode Suspend verhindert eine Neudarstellung, solange bis die Methode EndSuspend aufgerufen wurde. Das ist sinnvoll, wenn man mehrere Änderungen (Font, Größe usw.) vornehmen will, bzw. Text Stück für Stück hinzufügt. Dadurch wird ein Flackern verhindert.

Syntax BASIC-Code: <obj>.Suspend 
   Kompatibilität: alle Textobjekte

EndSuspend

EndSuspend hebt den mit Suspend gesetzten Zustand wieder auf.

Syntax BASIC-Code: <obj>.EndSuspend Kompatibilität: alle Textobjekte

^

4.10.3 Zeichenattribute

Instancevariable Syntax im UI-Code Im BASIC-Code
fontID fontID = numWert lesen, schreiben
fontSize fontSize = numWert lesen, schreiben
textStyle textStyle = numWert lesen, schreiben
textColor textColor = numWert lesen, schreiben

Per Default lesen die Textobjekte Font und Größe des darzustellenden Textes aus der GEOS.INI (Kategorie [ui], Einträge "editableTextFontID" und "editableTextFontsize"). Damit passen sie sich der GEOS-Installation des Nutzers an.

Es ist jedoch möglich, den Texten eine bestimmte Schriftart, Größe, Farbe und Stil (sogenannte Zeichenattribute) zuzuweisen. Damit werden die INI-Einträge vom Textobjekt ignoriert und der Text wird bei allen Nutzern auf die geforderte Weise dargestellt.

Dabei ist es nötig, folgendes zu wissen:

Sie können immer nur dem ganzen Text bestimmte Zeichenattribute zuweisen. Alle Zeichen werden dann auf diese Weise dargestellt. Die Zuweisung verschiedener Schriftarten oder Schriftgrößen zu einzelnen Teilen des Textes ist also nicht möglich.
Textobjekte speichern die Zeichenattribute nicht einzeln, sondern in einer gemeinsamen Datenstruktur. Weisen Sie auch nur ein einziges Zeichenattribut zu (z.B. die Textfarbe) so wird die Datenstruktur mit allen Zeichenattributen angelegt. Dabei gelten die folgenden Standardwerte für die nicht explizit zugewiesenen Attribute:
Font: URW Sans
Größe: 12
Stil: normal
Farbe: schwarz

Beispiel:

Memo NotesText
  text$ = "Noch keine Notizen eingetragen."
  fontID = FID_MONO
  ' fontSize nicht gesetzt --> 12 pt wird verwendet,
  ' egal was in der INI steht
  textStyle = TS_BOLD + TS_ITALIC
  textColor = BLUE
  END OBJECT

fontID

Syntax UI-Code: fontID = idCode
         Lesen: <numVar> = <obj>.fontID 
     Schreiben: <obj>.fontID = idCode
        idCode: Numerischer Wert, der den Textfont bestimmt
Kompatibilität:  alle Textobjekte

PC/GEOS identifiziert Schriften (Fonts) über eine sogenannte Font-ID-Nummer. Details dazu finden Sie im Kapitel 2, insbesondere Kapitel 2.2, des Handbuchs "Spezielle Themen".

Bitte beachten Sie, dass fontID, fontSize, textStyle und textColor vom Textobjekt in einer gemeinsamen Datenstruktur gespeichert werden. Für nicht explizit belegte Zeichenattribute wird ein Standardwert verwendet.

Namentlich verfügbare Font-ID's in R-BASIC

Name der Konstante Wert GEOS-Name
FID_BISON 2560 Bison ^{( 1 )}
FID_UNIVERSITY 513 University ^{( 1 )}
FID_BERKELEY 514 Berkeley ^{( 1 )}
FID_MONO 6656 URW Mono
FID_SANS 4608 URW Sans
FID_ROMAN 4096 URW Roman
FID_CRANBROOK 4097 Cranbrook
FID_SYMBOLPS 6144 URW SymbolPS

^{( 1 )}Hinweis: Die Fonts mit den ID's FID_BISON, FID_UNIVERSITY und FID_BERKELEY sind Bitmap-Fonts, die sich nicht zur Ausgabe auf den Drucker eignen.

Achtung! Die Kombination von Bitmap-Fonts mit bestimmten, nicht von diesem Font unterstützten Stilkombinationen kann zum Systemabsturz führen.

Einige weitere Font-ID's ohne vordefinierten Namen in R-BASIC:

1563 LED (Bitmap-Font)
53006 Fat Fracture
5632 Superb
4612 Sather Gothic
5123 Shattuck Avenue

textStyle

TextStyle stellt den Textstil ein.

Syntax UI-Code: textStyle = style
         Lesen: <numVar> = <obj>.textStyle 
     Schreiben: <obj>.textStyle = style
          size: Numerischer Wert, Textstil
                Kombination von TS_ Konstanten, siehe Tabelle
Kompatibilität: alle Textobjekte

Textstile zur Benutzung mit textStyle

Textstil Wert Bedeutung
TS_UNDERLINE 1 unterstrichene Schrift
TS_STRIKE_THRU 2 ~~durchgestrichene Schrift~~
TS_SUBSCRIPT 4 tiefgestellte Schrift _Schrift
TS_SUPERSCRIPT 8 hochgestellte Schrift ^Schrift
TS_ITALIC 16 kursive Schrift
TS_BOLD 32 fette Schrift
TS_OUTLINE 64 Wenn der Font sowohl Bitmap- und als auch Outline-Schrift enthält: Verwendung der Outline Schrift erzwingen

textColor

TextColor stellt die Textfarbe ein. Zulässig sind nur Indexfarben (0 bis 255).

Syntax UI-Code: textColor = farbwert
         Lesen: <numVar> = <obj>.textColor 
     Schreiben: <obj>.textColor = farbwert
      farbwert: Numerischer Wert, Textfarbe (0 ... 255)
Kompatibilität: alle Textobjekte

^

4.10.4 Absatzattribute

Unter Absatzattributen versteht man die Merkmale Texthintergrundfarbe, Textausrichtung, Zeilenabstand, Ränder und Absatzzwischenräume. Sie können immer nur dem ganzen Text bestimmte Absatzattribute zuweisen. Alle Absätze werden immer auf diese Weise dargestellt.

Folgende Instancevariablen stehen für die Absatzattribute zur Verfügung:

Instancevariable Syntax im UI-Code Im BASIC-Code
backColor backColor = numWert lesen, schreiben
justifyText justifyText = numWert lesen, schreiben
lineSpacing lineSpacing = numWert lesen, schreiben
margins margins = left, right [ , first ] lesen, schreiben
topSpace topSpace = numWert lesen, schreiben

Beispiel:

Memo NotesText
  text$ = "Noch keine Notizen eingetragen."
  backColor = WITHE
  justifyText = J_CENTER
  topSpace = 10
  END OBJECT

backColor

BackColor stellt die Hintergrundfarbe des Textobjekts ein. Zulässig sind nur Indexfarben (0 bis 255).
Ist kein Wert für backColor gesetzt so wird die System-Hintergrundfarbe (z.B. Grau) verwendet. <obj>.backColor liefert dann -1.

Syntax UI-Code: backColor = farbwert
         Lesen: <numVar> = <obj>.backColor 
     Schreiben: <obj>.backColor = farbwert
      farbwert: Numerischer Wert, Hintergrundfarbe (0 ... 255)
Kompatibilität: alle Textobjekte

justifyText

JustifyText stellt die Textausrichtung ein. Der Defaultwert ist J_LEFT.

Syntax UI-Code: justifyText = jText
         Lesen: <numVar> = <obj>.justifyText 
     Schreiben: <obj>.justifyText = jText
         jText: Numerischer Wert, Ausrichtung
                Zulässige Wert: Siehe Tabelle
Kompatibilität: alle Textobjekte

Zulässige Werte für justifyText:

Konstante Wert Bedeutung
J_CENTER 1 Text zentrieren
J_LEFT 2 Text linksbündig
J_RIGHT 4 Text rechtsbündig
J_FULL 32 Blocksatz

lineSpacing

LineSpacing stellt den Zeilenabstand ein. Der Defaultwert (kein Wert für lineSpacing gesetzt) ist 1.

Syntax UI-Code: lineSpacing = abstand
         Lesen: <numVar> = <obj>.lineSpacing 
     Schreiben: <obj>.lineSpacing = abstand
       abstand: Numerischer Wert vom Typ Real
                z.B. 1 (einzeilig), 1.5 oder 2 (zweizeilig)
Kompatibilität: alle Textobjekte

Hinweis: Wenn Sie "krumme" Werte (z.B. 1.15) für lineSpacing verwenden, kann es passieren, dass ein falscher Bereich selektiert wird, wenn Sie eine Textzeile mit einem Dreifachklick selektieren. Das liegt nicht an R-BASIC. Selektieren Sie dann den gewünschten Text durch Ziehen mit der Maus. Wenn die Funktion für Sie wichtig ist, müssen Sie probieren, ob der eingestellte Wert funktioniert. Für read-only Texte gibt es keine Einschränkungen.

margins

Margins stellt die Ränder für den Text ein. Dabei kann der linke Einzug für die erste Zeile unabhängig vom linken Rand gewählt werden. Lassen Sie den Parameter first weg, gilt first=left, d.h. die erste Zeile beginnt dort, wo auch alle anderen Zeilen beginnen.

Die Maßeinheit für die Ränder ist 1/12 Punkt, also sehr klein. Um einen linken Rand von 12 Punkt Breite zu erzeugen müssen Sie also einen Wert von 144 angeben.

Syntax UI-Code: margins = left, right [, first ]
         Lesen: <numVar> = <obj>.margins (n)
                n = 0: linker Rand
                n = 1: rechter Rand
                n = 2: Einzug erste Zeile
     Schreiben: <obj>.margins = left, right [, first ]
                 left: linker Rand
                right: rechter Rand
                first: Einzug 1. Zeile (Default: wie left)
Kompatibilität: alle Textobjekte

Beispiel:

Memo NotesText
  text$ = "Noch keine Notizen eingetragen."
  margins = 144, 144   ' je 12 Punkt
  END OBJECT

topSpace

TopSpace (engl.: Oberer Abstand, hier Abstand über dem Absatz) stellt den zusätzlichen Platz zwischen zwei durch einen Zeilenumbruch (Entertaste) getrennten Absätzen ein.

Die Maßeinheit hierfür ist 1/12 Punkt, also sehr klein. Um einen Abstand von 12 Punkt zu erzeugen müssen Sie also einen Wert von 144 angeben.

Syntax UI-Code: topSpace = anstand
         Lesen: <numVar> = <obj>.topSpace
     Schreiben: <obj>.topSpace = abstand
       abstand: Numerischer Wert, Absatzabstand.
Kompatibilität: alle Textobjekte

^

4.10.5 Textfilter

Mit Hilfe der Textfilter können Sie festlegen, dass der Nutzer nur Zeichen eingeben kann, die bestimmten Kriterien genügen. Das ist z.B. sinnvoll, wenn der Nutzer einen Dateinamen eingeben soll. Der entsprechende Textfilter stellt sicher, dass nur Zeichen eingegeben werden können, die in Dateinamen auch erlaubt sind.

Instancevariable Syntax im UI-Code Im BASIC-Code
textFilter textFilter = numWert lesen, schreiben

Wichtig! Textfilter wirken nur auf Zeichen, die über die Tastatur eingegeben werden. Weder der bereits vorhandene Text noch Änderungen der Instancevariable text$ werden beeinflusst!

Syntax UI-Code: textFilter = wert
         Lesen: <numVar> = <obj>.textFilter
     Schreiben: <obj>.textFilter = wert
          wert: Einer der Filterwerte entsprechend der Tabelle,
                gegebenenfalls kombiniert mit einem der Modifier-Bits
                entsprechend der zweiten Tabelle.
Kompatibilität: alle Textobjekte

Die folgenden Textfilter stehen zur Verfügung:

Konstante Wert
TF_NONE 0
TF_NORMAL_ASCII 1
TF_DOS_CHARACTER_SET 2
TF_ALPHA 3
TF_ALPHA_NUMERIC 4
TF_DASHED_ALPHA_NUMERIC 5
TF_NUMERIC 6
TF_SIGNED_NUMERIC 7
TF_SIGNED_DECIMAL 8
TF_FLOAT_DECIMAL 9
TF_LEGAL_FILENAMES 10
TF_LEGAL_DOS_FILENAMES 11
TF_LEGAL_DOS_PATH 12
TF_LEGAL_DOS_VOLUME_NAMES 13
TF_DATE 14
TF_TIME 15

Zusätzlich gibt es Filter-Modifier Bits. Diese können gemeinsam mit den anderen Textfiltern verwendet werden um deren Eigenschaften zu modifizieren.

Konstante Wert (hex) Wert (dez)
TF_MAKE_UPPERCASE h100& 512
TF_ALLOW_SPACES &h200 1024
TF_NO_SPACES &h400 2048

Beispiel:

InputLine NameText
  textFilter = TF_ALPHA + TF_MAKE_UPPERCASE + TF_NO_SPACES
  End Object

Wirkung der einzelnen Filter

TF_NONE: Das ist der Default Wert. Es ist kein spezieller Filter gesetzt.
TF_NORMAL_ASCII: Dieser Filter erlaubt nur normale ASCII-Zeichen. Erweiterte ASCII-Zeichen, also auch Umlaute, sind nicht erlaubt.
TF_DOS_CHARACTER_SET: Dieser Filter erlaubt nur Zeichen aus dem Standard-DOS-Zeichensatz.
TF_ALPHA: Dieser Filter erlaubt nur Buchstaben und Leerzeichen.
TF_ALPHA_NUMERIC: Dieser Filter erlaubt nur Buchstaben, Zahlen und Leerzeichen.
TF_DASHED_ALPHA_NUMERIC: Dieser Filter erlaubt nur Buchstaben, Zahlen und Leerzeichen sowie den Bindestrich.
TF_NUMERIC, TF_SIGNED_NUMERIC: Diese Filter erlauben nur Zeichen, die in den entsprechenden numerischen Werten vorkommen können. Leerzeichen sind erlaubt.
TF_SIGNED_DECIMAL, TF_FLOAT_DECIMAL: Diese Filter erlauben nur Zeichen, die in den entsprechenden numerischen Werten vorkommen können. Leerzeichen sind nicht erlaubt. Der Dezimaltrenner hängt von den Einstellungen des Systems ab, in Deutschland ist es üblicher Weise das Komma. Das weicht von R-BASIC Konventionen ab, hier ist der Dezimaltrenner immer ein Punkt.
TF_LEGAL_FILENAMES: Dieser Filter erlaubt nur Zeichen, die in GEOS Dateinamen vorkommen können.
TF_LEGAL_DOS_FILENAMES: Dieser Filter erlaubt nur Zeichen, die in DOS Dateinamen vorkommen können.
TF_LEGAL_DOS_PATH: Dieser Filter erlaubt nur Zeichen, die in DOS Pfaden vorkommen können. Er kann mit TF_ALLOW_SPACES kombiniert werden.
TF_LEGAL_DOS_VOLUME_NAMES: Dieser Filter erlaubt nur Zeichen, die in DOS Volumenamen vorkommen können.
TF_DATE, TF_TIME: Dieser Filter erlaubt nur Zeichen, die in Datum und Uhrzeit vorkommen können sowie Leerzeichen. Wichtig! Welche Zeichen das sind, hängt von den lokalen Einstellungen ab.

Bedeutung der Filter-Modifier Bits

TF_MAKE_UPPERCASE: Dieser Filter bewirkt, wenn er gemeinsam mit einem der anderen Filter angewendet wird, dass alle Buchstaben in Großbuchstaben umgewandelt werden. Er wirkt nicht auf Umlaute und Sonderzeichen.
TF_ALLOW_SPACES, TF_NO_SPACES: Diese Filter bestimmen, ob Leerzeichen erlaubt sind oder nicht. TF_ALLOW_SPACES wird von VisText und LargeText nicht unterstützt.

^

4.10.6 Textobjekt Actions

Instancevariable Syntax im UI-Code Im BASIC-Code
modified modified = numWert lesen, schreiben
ApplyHandler (*) ApplyHandler = <Handler> nur schreiben
OnModified OnModified = <Handler> nur schreiben
OnSelectionChanged OnSelectionChanged = <Handler> nur schreiben

(*) ActionHandler stehen nur für die GenericClass Objekte Memo und InputLine zur Verfügung.

Action-Handler-Typen:

Handler-Typ Parameter
TextAction (sender as object, isModified as integer, textLen as word, selectionLen as word)

Anmerkungen zu TextAction

Die Parameter isModified, textLen und selectionLen sind normalerweise eine Kopie der entsprechenden Instancevariablen des Objekts. Der Zugriff auf die Parameter ist wesentlich schneller als der direkte Zugriff auf die zugehörigen Instancevariablen.

Die Ausnahme sind LargeText Objekte. Weil textLen und selectionLen vom Typ word sind, können sie in vielen Fällen die korrekten Werte für ein LargeText-Objekt nicht aufnehmen. Deswegen sind diese beiden Parameter immer Null, wenn der Handler von einem LargeText-Objekt gerufen wurde.

Anmerkung zu Focus und Target

Textobjekte gehören zu den seltenen Fällen, in denen der Programmierer die Focus- und Targethierarchie benutzt. Deswegen wegen finden Sie am Ende des Kapitels ein entsprechendes Beispiel.

Beschreibung der Instancevariablen

modified

Die Instance-Variable modified enthält die Information, ob der Text seit dem letzten Aussenden der Apply-Message (Aufruf des Apply-Handlers) vom Nutzer modifiziert wurde (modified=TRUE) oder nicht (modified=FALSE). Textobjekte eines neu gestarteten Programms sind zunächst ebenfalls "nicht modified".

Syntax UI-Code: modified = TRUE | FALSE
         Lesen: <numVar> = <obj>.modified 
     Schreiben: <obj>.modified = TRUE | FALSE 
Kompatibilität: alle Textobjekte

Beachten Sie, dass ein Verändern des Textes vom BASIC-Code aus (z.B. Belegen der Instance-Variable text$), den Text nicht als "modified" markiert, d.h. der Wert der Instance-Variablen modified wird nicht verändert. Sie können dies bei Bedarf selbst machen, indem Sie die Anweisung "<obj>.modified = TRUE" verwenden.

Das Aussenden der Apply-Message setzt den Modified-Status zurück (modified = FALSE).

ApplyHandler

Die Instance-Variable ApplyHandler enthält den Namen des Action-Handlers, der aufgerufen wird, wenn der Text sein Änderungen anwenden will (engl. to apply: Anwenden). Apply-Handler müssen als TextAction deklariert sein.

Syntax UI- Code: ApplyHandler = <Handler> 
      Schreiben: <obj>.ApplyHandler = <Handler> 
 Kompatibilität: Nur GenericClass Textobjekte Memo und InputLine

Beachten Sie: Der Apply-Handler wird nur aufgerufen, wenn der Text "modified", d.h. vom Nutzer verändert ist. Dies passiert automatisch, wenn der Nutzer den Text ändert, Sie können es aber auch vom BASIC Code aus machen, indem Sie die Instance-Variable modified mit TRUE belegen.

InputLine-Objekte haben im Allgemeinen einen Apply-Handler. Er wird aufgerufen, wenn der Nutzer nach Eingabe eines Textes im Eingabefeld auf die Entertaste drückt.
Memo-Objekte haben häufig keinen Apply-Handler.
VisText und LargeText-Objekte können keinen Apply-Handler haben.
Sie können ein GenericClass Textobjekt (Memo und InputLine) veranlassen, seinen Apply-Handler aufzurufen, indem Sie die von der GenericClass geerbte Methode Apply verwenden. Das Objekt muss aber als "modified" markiert (siehe oben). Alternativ könnte man dem Objekt auch den Hint ApplyEvenIfNotModified geben. Eine ausführliche Beschreibung dazu finden Sie im Kapitel 3.4 (Die "Apply"-Message) dieses Handbuchs.

SUB ForceApply ( obj as OBJECT )
  obj.modified = TRUE   ' zu Sicherheit!
  obj.Apply
  END SUB

OnModified

Gelegentlich benötigt man eine Information, wenn ein Textobjekt durch eine Nutzereingabe vom "nicht modified" in den "modified" Zustand übergeht. Die Instance-Variable OnModified enthält den Namen des Action-Handlers, der aufgerufen wird, wenn das Textobjekt erstmalig nach Aussenden der letzten Apply-Message vom Nutzer verändert wird. OnModified-Handler müssen als TextAction deklariert sein.

Syntax UI-Code: OnModified = <Handler> 
     Schreiben: <obj>.OnModified = <Handler> 
Kompatibilität: alle Textobjekte

Das Aussenden der Apply-Message setzt den "modified" Zustand des Textobjekt zurück. Gibt der Nutzer nun Text ein, so wird der OnModified-Handler aufgerufen. Das heißt im Umkehrschluss, dass der OnModified-Handler in folgenden Fällen nicht gerufen wird:

Setzen der modified Instance-Variable vom BASIC Code aus.
Verändern des Textes vom BASIC-Code aus (z.B. Belegen der Instance-Variable text$).
Die Instance-Variable modified steht bereits auf TRUE, z.B. weil sie vom BASIC-Code aus gesetzt wurde, bevor der Nutzer etwas eingegeben hat.

Beispiel: Textobjekt mit Apply- und OnModified-Handler. Der Nutzer soll einen Dateinamen eingeben und ihn durch Drücken der Entertaste im Textobjekt "anwenden" können. Oder er soll einen extra Button dazu verwenden. Dieser soll aber erst aktiv sein, nachdem der Nutzer etwas eingegeben hat. Die SUB "DoSaveFile" muss natürlich irgendwo definiert sein und wird hier nicht mit aufgeführt.

UI-Code

Button SaveFileButton
  Caption$ = "Save File"
  ActionHandler = ButtonSaveFile
  enabled = FALSE   ' Zunächst inaktiv
  END Object

InputLine FileNameText
  maxLen = 32   ' max. 32 Zeichen sinnvoll
  textFilter = TF_LEGAL_FILENAMES ' ungültige Zeichen blocken
  ApplyHandler = TextSaveFile
  OnModified = TextIsModified
  END Object

BASIC-Code

ButtonAction ButtonSaveFile
  DoSaveFile   ' macht die Arbeit
  END Action

TextAction TextSaveFile
  DoSaveFile   ' macht die Arbeit
  END Action

TextAction TextIsModified
  SaveFileButton.enabled = TRUE   ' Button freischalten
  END Action

OnSelectionChanged

Wenn man ein "Edit" Menü implementieren will benötigt man die Information, ob der Nutzer Text selektiert hat oder nicht und ob er den Selektionsstatus verändert. Die Instancevariable OnSelectionChanged enthält den Namen des Actionhandlers, der aufgerufen wird, wenn der Nutzer zwischen "nichts selektiert" und "etwas selektiert" wechselt. OnSelectionChanged Handler müssen als TextAction deklariert sein. Um herauszufinden, ob Text selektiert ist oder nicht sollten Sie den Parameter "selectionLen" abfragen. Bei LargeText Objekten müssen Sie die Instancevariable selectionLen direkt abfragen, weil der an den Handler übergebene Parameter selectionLen hier immer Null ist.

Syntax UI-Code: OnSelectionChanged = <Handler> 
     Schreiben: <obj>.OnSelectionChanged = <Handler> 
Kompatibilität: alle Textobjekte

Beispiel: Einen "Kopieren" Button im Edit Menü verwalten.

UI-Code

Button CopyButton
  Caption$ = "Kopieren"
  ActionHandler = DoCopyText ' woanders implementiert
  enabled = FALSE ' Anfangs inaktiv
  END Object

Memo InfoText
  OnSelectionChanged = HandleSelection
  END Object

BASIC-Code

TextAction HandleSelection
    IF selectionLen THEN     ' d.h. selectionLen <> 0
    CopyButton.enabled = TRUE
  ELSE
    CopyButton.enabled = FALSE
  END IF
END Action

Beispiel für die Verwendung des OnTargetChanged-Handlers

Wenn das Programm wissen muss, welches Text-Objekt gerade aktiv ist, bietet sich der OnTargetChanged-Handler an. Im Beispiel wird ein Number-Objekt verwendet, um die Größe des Fonts im aktiven Text-Objekt anzuzeigen.

UI-Code:

Memo Text1
  fontSize = 14 : fontID = FID_MONO
  defaultFocus    ' ja, Focus
  OnTargetChanged = HandleTarget
End Object

Memo Text2
  fontSize = 24 : fontID = FID_SANS
  OnTargetChanged = HandleTarget
End Object

Number PointInfoNumber
  Caption$ = "Aktuelle Font Größe:"
End Object

BASIC-Code

TargetAction HandleTarget
  if state = FALSE THEN RETURN   ' Target verloren? Ignorieren.
  PointInfoNumber.value = sender.fontSize   ' UI updaten
End Action

^

4.10.7 Verhalten und Aussehen von Textobjekten

Um das Aussehen und das Verhalten der GenericClass Textobjekte Memo und InputLine in bestimmten Situationen zu steuern, stehen die folgenden Instancevariablen zur Verfügung.

VisText und LargeText Objekte werden in einem visual Tree verwaltet. Für diese Objekte steht nur textAttrs mit genau einem Attribut zur Verfügung.

Instancevariable Memo, InputLine Syntax im UI-Code Im BASIC-Code
TextFrame TextFrame --
TextNoFrame TextNoFrame --
SelectableIfRO SelectableIfRO --
textAttrs (*) textAttrs = numWert lesen, schreiben

(*) textAttrs steht mit Einschränkungen auch für VisText und LargeText-Objekte zur Verfügung.

TextFrame

Der Hint TextFrame bewirkt, dass das Textobjekt immer mit einem Rahmen gezeichnet wird. Read-Only Textobjekte haben normalerweise keinen Rahmen.

Syntax UI-Code: TextFrame
Kompatibilität: Nur GenericClass Textobjekte Memo und InputLine

TextNoFrame

Der Hint TextNoFrame bewirkt, dass das Textobjekt immer ohne Rahmen gezeichnet wird. Editierbare Texte haben normalerweise einen Rahmen.

Syntax UI-Code: TextNoFrame
Kompatibilität: Nur GenericClass Textobjekte Memo und InputLine

SelectableIfRO

Der Hint SelectableIfRO (selektierbar, auch wenn Read-Only) bewirkt, dass der Nutzer read-only Texte mit der Maus selektieren kann. Drag und Drop ist dann möglich.

Syntax UI-Code: SelectableIfRO
Kompatibilität: Nur GenericClass Textobjekte Memo und InputLine

textAttrs

Die Instancevariable textAttrs enthält eine Reihe von Flagbits, die das Verhalten und die Eigenschaften des Textobjekts in bestimmten Situationen bestimmen. Jedes Bit hat eine eigene Bedeutung. Die verschiedenen Werte können mit + oder OR verknüpft werden. Die folgende Tabelle enthält die für textAttrs definierten Bitwerte. Hier nicht angegebene Werte sind intern reserviert und sollten nicht benutzt werden. Per Default ist das Bit TA_USE_TAB_FOR_NAVIGATION für Memo und InputLine gesetzt.

VisText und LargeText unterstützen nur genau ein Attribut, nämlich TA_USE_ TAB_FOR_NAVIGATION. Dieses Bit ist für VisText und LargeText per Default aber nicht gesetzt.

Hinweis: R-BASIC unterstützt die im PC/GEOS-SDK definierten Attribute. Ob ein bestimmtes Attribut oder eine Attributkombination im konkreten Fall wirkt hängt manchmal von den konkreten Umständen ab. Beispielsweise setzen einige Flags (z.B. TA_SELECT_TEXT) setzen voraus, dass der Hint defaultFocus gesetzt ist. Oder der Hint fixedSize verhindert trotz gesetzten TA_NEVER_SCOLLABLE, dass das Textobjekt seine Größe an den aktuellen Text anpasst.

Konstante Wert (hex) Wert (dez)
TA_DONT_SCROLL_TO_CHANGES &h02 2
TA_TAIL_ORIENTED &h04 4
TA_ALLOW_TEXT_OFF_END &h08 8
TA_NO_WORD_WRAPPING &h10 16
TA_INIT_SCROLLING &h20 32
TA_USE_TAB_FOR_NAVIGATION &h40 64
TA_NEVER_SCROLLABLE &h100 256
TA_SELECT_TEXT &h200 512
TA_CURSOR_AT_START &h400 1024
TA_CURSOR_AT_END &h800 2048

Syntax UI-Code: textAttrs = wert
         Lesen: <numVar> = <obj>.textAttrs
     Schreiben: <obj>.textAttrs = wert
          wert: Kombination aus den Bitwerten entsprechend der Tabelle.
                Für VisText und LargeText wird nur das Bit 
                TA_USE_TAB_FOR_NAVIGATION unterstützt.
                Alle anderen Werte werden ignoriert.
Kompatibilität: alle Textobjekte

Beispiele:

Memo InfoText
  textAttrs = TA_INIT_SCROLLING OR TA_USE_TAB_FOR_NAVIGATION
  ' Statt + kann man auch die logische Operation OR
  ' verwenden
  End Object

InputLine OtherText 
  defaultFocus
  textAttrs = TA_SELECT_TEXT
  ' Weil TA_USE_TAB_FOR_NAVIGATION nicht angegeben ist 
  ' wird die Tabulatortaste nicht zum Anspringen des 
  ' nächsten UI-Objekts verwendet.
  End Object

Bedeutung der einzelnen Flagbits:

TA_DONT_SCROLL_TO_CHANGES: Per Default scrollen Textobjekte automatisch zu der Position, an der Änderungen am Text, z.B. Einfügen oder Löschen, vorgenommen werden. Dieses Flag schaltet dieses Verhalten aus.
TA_TAIL_ORIENTED: Dieses Flag sollte gesetzt sein, wenn Sie möchten, dass das Objekt das Textende anzeigt (engl. tail: Schwanz), statt den Beginn des Textes. In einer scrollbaren Textbox bewirkt es, dass Text, der am Ende angefügt wird, immer angezeigt wird.
TA_ALLOW_TEXT_OFF_END: Dieses Flag ermöglicht es, dass der Text größer ist, als von der Textbox dargestellt werden kann, ohne dass die Textbox vertikale oder horizontale Rollbalken erzeugt.
TA_NO_WORD_WRAPPING: Dieses Flag schaltet den Wortweisen Zeilenumbruch (Word wrapping) aus. Stattdessen erfolgt ein Zeilenumbruch auch mitten im Wort.
TA_INIT_SCROLLING: Dieses Flag bewirkt, dass der Text immer Rollbalken hat, auch wenn dies nicht erforderlich ist.
TA_USE_TAB_FOR_NAVIGATION: Dieses Flag zeigt an, dass die Tabulatortaste zum Anspringen des nächsten UI-Objekts benutzt werden soll, statt ein Tabulatorzeichen im Text zu speichern. Für Memo und InputLine ist es das einzige Flag, dass per Default gesetzt ist.
Für VisText und LargeText ist es das einzige unterstütze Flag und es ist per Default nicht gesetzt.
TA_NEVER_SCROLLABLE: Dieses Flag bewirkt, dass das Textobjekt bei länger werdendem Text seine Größe ändern soll, statt Rollbalken zu erzeugen.
TA_SELECT_TEXT: Dieses Flag bewirkt, dass Textobjekte, die den Hint defaultFocus gesetzt haben, ihren Text zum Programmstart komplett selektieren sollen. Das erleichtert es dem Nutzer, ihn komplett zu ersetzen.
TA_CURSOR_AT_START: Dieses Flag bewirkt, dass Textobjekte, die den Hint defaultFocus gesetzt haben, den Cursor am Textanfang positionieren.
TA_CURSOR_AT_END: Dieses Flag bewirkt, dass Textobjekte, die den Hint defaultFocus gesetzt haben, den Cursor am Textende positionieren.

^

4.10.8 Textobjekte im Delayed Mode

Die Textobjekte Memo und InputLine können im "Delayed Mode" (engl.: verzögerter Modus) arbeiten. Dazu muss man dem Objekt selbst bzw. einem seiner Parents im UI-Code den Hint MakeDelayedApply geben oder man bindet das Objekt als Child in einem Dialog ein, dessen dialogType Instance Variable auf DT_DELAYED_APPLY gesetzt ist. Dieser "Delayed Mode" ist ausführlich im Kapitel 3.4.2 (Delayed Mode und Status-Message) dieses Handbuchs beschrieben, eine Beschreibung des Dialog-Objekts im Delayed Mode finden Sie im Kapitel 4.6.6.5.

Instance Variable Syntax im UI-Code Im BASIC-Code
StatusHandler StatusHandler = <Handler> nur schreiben

Syntax UI-Code: StatusHandler = <Handler> 
     Schreiben: <obj>.StatusHandler = <Handler> 
Kompatibilität: Nur GenericClass Textobjekte Memo und InputLine

Der StatusHandler wird im Delayed Mode statt des ApplyHandlers gerufen, wenn der Nutzer z.B. nach Eingabe eines Textes in einem InputLine-Objekt auf die Entertaste drückt. Der ApplyHandler hingegen wird erst auf Anforderung gerufen (siehe Kapitel 3.4.2). Die Instance-Variable modified kann einen Wert ungleich Null enthalten, nämlich dann, wenn der Text vom User modifiziert wurde, der ApplyHandler aber noch nicht gerufen wurde. Der Aufruf des ApplyHandlers setzt auch im Delayed Mode den modified-Status zurück.

Methode	Aufgabe
SendStatus	Status-Handler aufrufen

Syntax BASIC-Code: <obj>.SendStatus 
   Kompatibilität: Nur GenericClass Textobjekte Memo und InputLine

Die Methode SendStatus fordert das Objekt auf, seinen StatusHandler aufzurufen (d.h. seine Status-Message zu senden).

^

Weiter...