Class: EditTextView

• Inheritance
• Description
• Related information
• Class protocol
  • defaults
  • specs
• Instance protocol
  • Compatibility-ST80
  • accessing
  • accessing-behavior
  • accessing-contents
  • accessing-dimensions
  • accessing-look
  • accessing-replace
  • change & update
  • commenting
  • cursor handling
  • drag & drop
  • editing
  • editing-basic
  • event handling
  • focus handling
  • formatting
  • initialization
  • macros
  • menu & menu actions
  • private
  • queries
  • realization
  • redrawing
  • scrolling
  • searching
  • selections
  • undo & again
• Private classes
• Examples

Inheritance:

   Object
   |
   +--GraphicsMedium
      |
      +--DisplaySurface
         |
         +--SimpleView
            |
            +--View
               |
               +--ListView
                  |
                  +--TextView
                     |
                     +--EditTextView
                        |
                        +--ComposedTextView
                        |
                        +--EditField
                        |
                        +--RCSConflictEditTextView
                        |
                        +--TextCollector

Package:

stx:libwidg

Category:

Views-Text

Version:

rev: 1.774 date: 2019/08/16 20:45:13

user: cg

file: EditTextView.st directory: libwidg

module: stx stc-classLibrary: libwidg

Author:

Claus Gittinger

Description:

a view for editable text - adds editing functionality to TextView
Also, it adds accept functionality, and defines a new actionBlock:
acceptAction to be performed for accept

If used with a model, this is informed by sending it a changeMsg with
the current contents as argument.
(however, it is possible to define both changeMsg and acceptAction)

Please read the historic notice in the ListView class.

[Instance variables:]

    cursorLine              <Number>        line where cursor sits (1..)

    cursorVisibleLine       <Number>        visible line where cursor sits (1..nLinesShown)

    cursorCol               <Number>        col where cursor sits (1..)

    cursorShown             <Boolean>       true, if cursor is currently shown

    readOnly                <Boolean>       true, if text may not be edited

    modifiedChannel         <ValueHolder>   holding true, if text has been modified.
                                            cleared on accept.

    acceptChannel           <ValueHolder>   holding true, if text has been accepted.

    fixedSize               <Boolean>       true, if no lines may be added/removed

    exceptionBlock          <Block>         block to be evaluated when readonly text is about to be modified
                                            if it returns true, the modification will be done anyway.
                                            if it returns anything else, the modification is not done.

    cursorFgColor           <Color>         color used for cursor drawing
    cursorBgColor           <Color>         color used for cursor drawing

    cursorType              <Symbol>        how the cursor is drawn; currently implemented
                                            are #none, #block (solid-block cursor), #ibeam
                                            (vertical bar at insertion point)
                                            and #caret (caret below insertion-point).
                                            see cursorType: for an up-to-date list.

    cursorTypeNoFocus       <Symbol>        like above, if view has no focus
                                            nil means: hide the cursor.

    undoAction              <Block>         block which undoes last cut, paste or replace
                                            (not yet fully implemented)

    typeOfSelection         <Symbol>        #paste, if selection created by paste, nil otherwise
                                            this affects the next keyPress: if #paste it does not
                                            replace; otherwise it replaces the selection.

    lastCut                 <String>        last cut or replaced string

    lastReplacementInfo     <LastReplacementInfo>        holds the information about the last replace action
                                                         lastStringToReplace is the string to be replaced by lastReplacement
                                                         lastReplacement is the string to replace lastStringToReplace

    lastStringFromReplaceForNextSearch   <String>        string to be taken be the next search action
                                                         (cleared after a new selection)

    replacing               <Boolean>       true if entered characters replace last selection

    showMatchingParenthesis <Boolean>       if true, shows matching parenthesis
                                            when entering one; this is the default.

    hasKeyboardFocus        <Boolean>       true if this view has the focus

    acceptAction            <Block>         accept action - evaluated passing the contents as
                                            argument

    tabMeansNextField       <Boolean>       if true, Tab is ignored as input and shifts keyboard
                                            focus to the next field. For editTextViews, this is false
                                            by default (i.e. tabs can be entered into the text).
                                            For some subclasses (inputFields), this may be true.

    trimBlankLines          <Boolean>       if true, trailing blanks are
                                            removed when editing.
                                            Also, empty lines are represented as nil in the lines collection.
                                            Default is true.

    wordWrap                <Boolean>       Currently not used.

    lockUpdates             <Boolean>       internal, private

    prevCursorState         <Boolean>       temporary, private

    cursorMovementWhenUpdating
                            <Symbol>        defines where the cursor is to be positioned if the
                                            model changes its value by some outside activity
                                            (i.e. not by user input into the field).
                                            Can be one of:
                                                #keep / nil     -> stay where it was
                                                #endOfText      -> cursor to the end
                                                #endOfLine      -> stay in the line, but move to end
                                                #beginOfText    -> cursor to the beginning
                                                #beginOfLine    -> stay in the line, but move to begin
                                            The default is #beginOfText



    dropTarget              <DropTarget|nil> drop operation descriptor or nil (drop disabled)


userPreference values:
    userPreferences.st80EditMode
                            <Boolean>       if true, cursor positioning is
                                            done as in vi or ST80; i.e.
                                            wysiwyg mode is somewhat relaxed,
                                            in that the cursor cannot be
                                            positioned behind a lines end.
                                            This is not yet completely implemented.
used globals:

    DeleteHistory           <Text>          last 1000 lines of deleted text
                                            (but only if this variable exists already)

[styleSheet parameters:]

    textCursorForegroundColor <Color>          cursor fg color; default: text background
    textCursorBackgroundColor <Color>          cursor bg color; default: text foreground
    textCursorNoFocusForegroundColor
                              <Color>          cursor fg color if no focus; default: cursor fg color
    textCursorType            <Symbol>         cursor type; default:  #block

Related information:

    CodeView
    Workspace
    TextView
    ListView
    EditField

Class protocol:

 defaultCompletionSupportClass

 st80Mode

return true, if the st80 editing mode is turned on.
This setting affects the behavior of the cursor, when positioned
beyond the end of a line or the end of the text.
This method is here for backward compatibility, when this flag was stored
in a class var. It is now in the user's settings.
Please do not call it, but go to the prefs directly, to make it easier to find those getters.

usage example(s):

EditTextView st80Mode:true EditTextView st80Mode:false

 st80Mode: aBoolean

turns on/off st80 behavior, where the cursor cannot be positioned
beyond the end of a line or the last line.
This method is here for backward compatibility, when this flag was stored
in a class var. It is now in the user's settings.
Please do not call it, but go to the prefs directly, to make it easier to find those setters.

usage example(s):

EditTextView st80Mode:true EditTextView st80Mode:false

 updateStyleCache

extract values from the styleSheet and cache them in class variables

usage example(s):

self updateStyleCache

 searchReplaceDialogSpec

This resource specification was automatically generated
by the UIPainter of ST/X.

usage example(s):

UIPainter new openOnClass:DAPASX::ProjectEditorTextView andSelector:#searchReplaceDialogSpec

Instance protocol:

 autoAccept: aBoolean

ignored for now

 continuousAccept: aBoolean

ignored for now

 cutSelection

 deselect

remove the selection

 enabled: aBoolean

(comment from inherited method)
this is the basic machanism to enable/disable a view.
empty in this class; may be redefined by subclasses

 find: pattern

 insert: aString at: aCharacterPosition

insert a string at aCharacterPosition.

 insertAndSelect: aString at: aCharacterPosition

insert a selected string at aCharacterPosition.

 pasteSelection

 replaceSelectionWith: aString

 selectAt: pos

move the cursor before cursorPosition.

 textHasChanged

 textHasChanged: aBoolean

ST-80 compatibility: set/clear the modified flag.

 codeAspect

Applications should set it explictly, however, to make it behave like

 codeAspect: aSymbol

 completionSupport

 completionSupport: anEditTextViewCompletionSupport

 completionSupportClass

 editedClass

 editedLanguage

get the programming language (for comments, indentation etc.).
Here, in the generic editor, we don't know anything about languages

 editedLanguage: aProgrammingLanguage

Sets the edited language. Only defined here to make it polymorph with Workspace

 editedMethod

 editedMethodOrClass

 editedMethodOrClass: methodOrClass

Sets the edited method or class. Only defined here to make it polymorph with Workspace

 hasSelectionOrTextInCursorLine

 selectionOrTextOfCursorLine

 selectionOrTextOfCursorLine: doSelect

 acceptAction

return the action to be performed on accept (or nil)

 acceptAction: aBlock

set the action to be performed on accept

 acceptChannel

return the valueHolder holding true if text was accepted.
By placing a true into this channel, an accept can also be forced.

 acceptChannel: aValueHolder

set the valueHolder holding true if text was accepted.
By placing a true into this channel, an accept can also be forced.

 acceptEnabled: aBoolean

enable/disable accept. This greys the corresponding item in the menu

 accepted

return true if text was accepted

 accepted: aBoolean

set/clear the accepted flag.
This may force my current contents to be placed into my model.

 autoIndent

 autoIndent: aBoolean

 autoIndentHolder

 codeAspectHolder

 codeAspectHolder: something

 cursorMovementWhenUpdating

return what is be done with the cursor,
when I get a new text (via the model or the #contents/#list)
Allowed arguments are:
#keep / nil -> stay where it was
#endOfText -> position cursor to the end
#beginOfText -> position cursor to the beginning
#endOfLine -> position cursor to the current lines end
#beginOfLine -> position cursor to the current lines start
The default is #beginOfText.
This may be useful for fields which get new values assigned from
the program (i.e. not from the user)

 cursorMovementWhenUpdating: aSymbolOrNil

define what should be done with the cursor,
when I get a new text (via the model or the #contents/#list)
Allowed arguments are:
#keep / nil -> stay where it was
#endOfText -> position cursor to the end
#beginOfText -> position cursor to the beginning
#endOfLine -> position cursor to the current lines end
#beginOfLine -> position cursor to the current lines start
The default is #beginOfText.
This may be useful for fields which get new values assigned from
the program (i.e. not from the user)

 disableIfInvisible: aBoolean

 dontReplaceSelectionOnInput

remember that the current selection was created by a paste operation
(as opposed to an explicit selection by the user).
This selection will not be replaced by followup user input,
so multiple pastes will be possible.

 editModeHolder

 editModeInsert

 editModeInsertAndSelect

 editModeOverwrite

 exceptionBlock: aBlock

define the action to be triggered when user tries to modify
readonly text

 generateTextAfterEndHook: aBlock

some applications may want to dynamically generate lines below the bottom line,
when the cursor is moved there.
For example, disassembly views or memory dumps (hex-dumps),
which want to automatically generate additional lines lazily,
but which cannot afford to generate the whole text in advance
(eg: who wants to disassemble gigabytes?).
If set, this hook is called whenever the cursor is about to be moved below the
last line, getting the new lineNr (i.e > contents size) as argument.
It may generate more text (by setting my contents) and return a new cursor line
number, into which the cursor should be moved
(eg. if 10 additional lines are generated, it may want to return oldSize+1,
to make the cursor end in the last line which was inserted)

 generateTextBeforeStartHook: aBlock

some applications may want to dynamically generate lines above the top
line, when the cursor is moved there.
For example, disassembly views or memory dumps (hex-dumps),
which want to automatically generate additional lines lazily,
but which cannot afford to generate the whole text in advance
(eg: who wants to disassemble gigabytes?).
If set, this hook is called whenever the cursor is about to be moved above the
top, getting the new lineNr (i.e < 1) as argument.
It may generate more text (by setting my contents) and return a new cursor line
number, into which the cursor should be moved
(eg. if 10 additional lines are generated, it may want to return 10, to make the
cursor end in the last line which was inserted)

 insertMode: aBoolean

 insertModeHolder

 isInInsertMode

 isNotReadOnly

return true, if the text is not readonly.

 isReadOnly

return true, if the text is readonly.

 lineEndCRLF: aBoolean

If aBoolean is true, use CRLF (as in windows) for end of line.
Otherwise and default use Character cr (which in newline as in unix).

 modeLabelHolder

a valueHolder, which contains 'L' (learnMode), I (insertMode) or empty

 modified

return true if text was modified

 modified: aBoolean

set/clear the modified flag

 modifiedChannel

return the valueHolder holding true if text was modified

 modifiedChannel: aValueHolder

set the valueHolder holding true if text was modified

 readOnly

make the text readonly.
Obsolete because it is obfuscating (looks like a getter)
- use #readOnly:

** This is an obsolete interface - do not use it (it may vanish in future versions) **

 readOnly: aBooleanOrValueHolder

make the text readonly (aBoolean == true) or writable (aBoolean == false).
The argument may also be a valueHolder.

 reallyModifiedChannel

return the valueHolder holding true if text was really modified.
For compatibility with views which use the modified flag for syntax highlighting.

 st80EditMode

If on, the cursor wraps at the line end (like in vi or st80);
if off, we have the Rand-editor behavior (random access)

 st80EditMode: aBooleanOrNil

set/clear the st80Mode flag.
If on, the cursor wraps at the line end (like in vi or st80);
if off, we have the Rand-editor behavior (random access)
if nil, the setting follows the current userPref setting.

 st80Mode: aBooleanOrNil

** This is an obsolete interface - do not use it (it may vanish in future versions) **

 tabMeansNextField: aBoolean

set/clear tabbing to the next field.
If true, Tab is ignored and shifts the keyboard focus.
If false, tabs can be entered into the text.
The default is true for editTextView, false for single-line
input fields.

 tabRequiresControl

returns true, if a focus tabbing requires a control-key to be pressed.
The default is true for editTextView, false for other widgets,
to allow for easier text entry

 tabRequiresControl: aBoolean

controls if a focus tabbing requires a control-key to be pressed.
The default is true for editTextView, false for other widgets,
to allow for easier text entry

 trimBlankLines

If true, the blank lines are trimmed to zero size and trailing blank lines are removed;
if false, they are left as is;
if nil, the setting follows the current userPref setting.

 trimBlankLines: aBooleanOrNil

If true, the blank lines are trimmed to zero size and trailing blank lines are removed;
if false, they are left as is;
if nil, the setting follows the current userPref setting.

 trimLastCR

If true, the last line is returned without a trailing CR character;
The default is false; this is only used by very specialized editors.

 trimLastCR: aBooleanOrNil

If true, the last line is returned without a trailing CR character;
The default is false; this is only used by very specialized editors.

 at: lineNr basicPut: aLine

change a line without change notification.
this is not undoably, unless you care for yourself

 at: lineNr put: aLine

replace a line by something new.
this is not undoably, unless you care for yourself

 characterAfterCursor

return the character one after the cursor - space if beyond line.

 characterBeforeCursor

return the character to the left of cursor - space if beyond line, nil if at the beginning.

 characterUnderCursor

return the character under the cursor - space if beyond line.
For non-block cursors, this is the character immediately to the right
of the insertion-bar or caret.
For block cursors, this is the highlighted cursor-character

 contents

return the contents as a String or Text (i.e. with emphasis).
Cares for trimBlankLines and trimLastCR options.

 contents: aStringOrStringCollectionOrNil

replace the whole contents by something new.
this is not undoably, unless you care for yourself.
See replaceContentsWith:newContents for an undoable version of this

 contents: something keepUndoHistory: keepUndoHistory

set the contents and optionally clear the undo history.
The contents-change is not undoable.

 contentsAsString

return the contents as a String (i.e. without emphasis).
Trims always (i.e. ignores trimBlankLines and trimLastCR options)

 contentsAsStringWithTabs

return the contents as a String (i.e. without emphasis)
and with leading spaces replaced by tab characters
(i.e. as would be written to a file).
Trims always (i.e. ignores trimBlankLines and trimLastCR options)

 cursorCol

return the cursors col (1..).
This is the absolute col; NOT the visible col

 cursorColHolder

return a valueHolder for the cursors column (1..).

 cursorLine

return the cursors line (1..).
This is the absolute line; NOT the visible line

 cursorLineAndColumnHolder

return a valueHolder for the cursors line and column as an
array of the form { lineNr . col }
This can be used directly as a model to react on cursor movement

 cursorLineAndColumnLabelHolder

return a valueHolder for the cursors line and column as an info string
of the form 'line : col'.
This can be used directly as a model for a GUI label showing the cursor position (eg in the lower right)

 cursorLineHolder

return a valueHolder for the cursors line (1..).
This is the absolute line; NOT the visible line

 lineStringBeforeCursor

return the line's string before the cursor.
Pad with spaces up to the cursor position if beyond the end of line

 lineStringFromCursor

return the line's string beginning at the cursor position to the line's end.

 list: newCollectionOfLinesOrNil

replace the whole contents by something new.
this is not undoably, unless you care for yourself.
Positions the cursor as defined in cursorMovementWhenUpdating
(which defaults to: home)

 setContents: something

replace the whole contents by something new
AND clear the remembered undo actions

 wordBeforeCursor

return the word to the left of cursor - empty string if there is none

 wordBeforeCursorConsisitingOfCharactersMatching: characterMatchBlock

return the word to the left of cursor, where characters match the given condition;
empty string if there is none

 absoluteXOfPosition: positionInText
( an extension from the stx:libtool package )

 absoluteYOfCursor
( an extension from the stx:libtool package )

 xOfCursor

take the end of the selection, if any

 xOfPosition: positionInText
( an extension from the stx:libtool package )

 yOfCursor
( an extension from the stx:libtool package )

 yOfPosition: positionInText
( an extension from the stx:libtool package )

 cursorForegroundColor: color1 backgroundColor: color2

set both cursor foreground and cursor background colors

 cursorType

return the style of the text cursor.
Currently, supported are: #none
#block, #frame, #ibeam, #caret, #solidCaret
#bigCaret and #bigSolidCaret

 cursorType: aCursorTypeSymbol

set the style of the text cursor.
Currently, supported are: #none
#block, #frame, #ibeam, #caret, #solidCaret
#bigCaret and #bigSolidCaret

 cursorTypeNoFocus

return the style of the text cursor when the view has no focus.
If left unspecified, this is the same as the regular cursorType.

 cursorTypeNoFocus: aCursorTypeSymbol

set the style of the text cursor when the view has no focus.
If left unspecified, this is the same as the regular cursorType.

 lastReplacementInfo

 lastStringToReplace: aString

 previousReplacements

accessor for the code completion

 accept

accept the current contents by executing the accept-action and/or
changeMessage.
Historically, ST/X used a callBack (acceptAction);
and ST80/VW used the model, into which the text is stored.
We support both; if there is a mode, it gets a value: message,
If there is an acceptAction, it is called.

 argForChangeMessage

return the argument to be passed with the change notification.
Defined as separate method for easier subclassability.

 getListFromModel

get my contents from the model.
Redefined to ignore updates resulting from my own changes
(i.e. if lockUpdates is true).

 update: something with: aParameter from: changedObject

(comment from inherited method)
model changed (not more information)

 commentFrom: line1 to: line2 commentStrings: commentStrings

helper function to comment out a block.
All lines from line1 to line2 get an end-of-line comment
in the first col
(if no eol comment is available, a bracketing comment is used).

 commentSelection: commentStrings

convenient function to comment out a block.
All lines from line1 to line2 get an end-of-line comment
in the first col.

 uncommentFrom: line1 to: line2 commentStrings: commentStrings

helper function to comment out a block.
All lines from line1 to line2 get an end-of-line comment
in the first col.
(if no eol comment is available, a bracketing comment is removed).

 uncommentSelection: commentStrings

convenient function to comment out a block.
All lines from line1 to line2 get an end-of-line comment
in the first col.

 basicCursorReturn

move cursor to start of next line; scroll if at end of visible text

 characterPositionOfCursor

 cursorBacktab

move cursor to prev tabstop

 cursorCol: newCol

move cursor to some column in the current line

 cursorDown

move cursor down; scroll if at end of visible text;
beep if at end of physical text.

 cursorDown: n

move cursor down by n lines; scroll if at end of visible text

 cursorHome

scroll to top AND move cursor to first line of text.

 cursorLeft

move cursor to left

 cursorLeft: n

move cursor to left

 cursorLine: line col: col

this positions onto physical - not visible - line

 cursorLine: line col: col makeVisible: makeVisibleBoolean

this positions onto physical - not visible - line

 cursorMovementAllowed

return true, if the user may move the cursor around
(via button-click, or cursor-key with selection).
By default, true is returned, but this may be redefined
in special subclasses (such as a terminal view), where
this is not wanted

 cursorReturn

move cursor to start of next line; scroll if at end of visible text

 cursorReturn: withPossibleAutoIndent

move cursor to start of next line; scroll if at end of visible text

 cursorRight

move cursor to right

 cursorRight: n

move cursor to right

 cursorShown: aBoolean

change cursor visibility
return true if cursor was visible before.

 cursorTab

move cursor to next tabstop

 cursorToBeginOfLine

move cursor to the start of the current line

 cursorToBottom

move cursor to the last line of text (col 1)

 cursorToCharacterPosition: pos

compute line/col from character position (1..)
and move the cursor onto that char

 cursorToEnd

move cursor down below last line of text

 cursorToEndOfLine

move cursor to end of current line

 cursorToEndOfText

move cursor to the end of the text (behind the last character in last line)

 cursorToEndOfWord

move the cursor to the end of the word

 cursorToFirstVisibleLine

place cursor into the first visible line; do not scroll.

 cursorToLastVisibleLine

place cursor into the first visible line; do not scroll.

 cursorToNextWord

move the cursor to the beginning of the next word

 cursorToPreviousWord

move the cursor to the beginning of this or the previous word

 cursorToTop

move cursor to absolute home

 cursorUp

move cursor up; scroll if at start of visible text

 cursorUp: n

move cursor up n lines; scroll if at start of visible text

 cursorVisibleLine: visibleLineNr col: colNr

put cursor to visibleline/col

 cursorX: x y: y

put cursor to position next to x/y coordinate in view

 drawCursor

draw the cursor if shown and cursor is visible.
(but not, if there is a selection - to avoid confusion)

 drawCursor: cursorType with: fgColor and: bgColor

draw a cursor; the argument cursorType specifies what type
of cursor should be drawn.
Currently, supported are: #none,
#block, #frame, #ibeam, #caret, #solidCaret
#bigCaret and #bigSolidCaret

 drawCursorCharacter

draw the cursor.
(i.e. the cursor if no selection)
- helper for many cursor methods

 drawFocusCursor

draw the cursor when the focus is in the view.

 drawNoFocusCursor

draw the cursor for the case when the view has no keyboard focus

 gotoLine: aLineNumber

position cursor onto line, aLineNumber.
Make certain that this line is visible

 hideCursor

make cursor invisible if currently invisible

 makeCursorVisible

scroll text to make cursorline visible
(i.e. to have cursorLine in visible area)

 makeCursorVisibleAndShowCursor: flag

scroll to make cursorLine visible;
if flag is true, draw the cursor

 setCursorCol: colNr

strictly private: set the cursorCol

 setCursorLine: lineNr

strictly private: set the cursorLine

 setCursorLine: lineNr col: colNr

strictly private: set the cursorLine, col and update the visibleLine

 setValidatedCursorCol: colNr

strictly private: set the cursorCol

 setValidatedCursorLine: lineNr

strictly private: set the cursorLine and update the visibleLine

 setValidatedCursorLine: lineNr col: colNr

strictly private: set the cursorLine, col and update the visibleLine

 showCursor

make cursor visible if currently invisible

 singleQuoteSelection

place single quotes around the selected text

 undrawCursor

undraw the cursor (i.e. redraw the character(s) under the cursor)

 updateCursorVisibleLine

strictly private: set the visibleLine from the cursorLine.
notice: visibleLine will be set to nil if the cursor is not visible

 validateCursorCol: col inLine: line

check of col is a valid cursor position; return a new col-nr if not.
Here, no limits are enforced (and col is returned),
but it may be redefined in EditFields or views which don't like the
cursor to be positioned behind the end of a textLine (vi/st-80 behavior)

 validateCursorLine: line

check if line is a valid cursor line; return a fixed line-nr if not.
Here, no limits are enforced (and line is returned), but it may be
redefined in views which don't like the cursor to be positioned
behind the end of the text (vi/st-80 behavior), or want to
skip reserved regions

 withCursorOffDo: aBlock

evaluate aBlock with cursor off; turn it on afterwards.

 allowDrop: aBoolean

enable/disable drop support

 canDrop: aDropContext

public from d&d.
I accept textObjects and fileObjects only.

 canDropObjects: aCollectionOfDropObjects

public from d&d.
I accept textObjects and fileObjects only.

 drop: aDropContext

public from d&d.
drop objects (new API)

 dropFileObject: aDropObject

drop objects
For bw. compatibility, also collections of drop objects are handled (may vanish)

 dropObject: aDropObject

drop objects
For bw. compatibility, also collections of drop objects are handled (may vanish)

 dropObjects: aCollectionOfDropObjects

public from d&d.
drop objects (old API)

 applyConverterToSelection: converter

apply a converter to the selected text

 convertSelectionToLowercase

to-lower selected text

 convertSelectionToLowercaseOrUppercaseOrUppercaseFirst

toLower/toUppercaseFirst/toUpper selected text

 convertSelectionToUppercase

to-upper selected text

 convertSelectionToUppercaseFirst

to-upperFirst selected text

 copyAndDeleteSelection

copy the selection into the pastBuffer and delete it

 deleteCharAtCursor

delete single character under cursor; does not merge lines

 deleteCharAtLine: lineNr col: colNr

delete a single character at colNr in line lineNr

 deleteCharBeforeCursor

delete single character to the left of cursor and move cursor to left

 deleteCharsAtLine: lineNr fromCol: colNr

delete characters from colNr up to the end in line lineNr

 deleteCharsAtLine: lineNr fromCol: startCol toCol: endCol

delete characters from startCol to endCol in line lineNr

 deleteCharsAtLine: lineNr toCol: colNr

delete characters from start up to colNr in line lineNr

 deleteCursorLine

delete the line where the cursor sits

 deleteFromCharacterPosition: charPos1 to: charPos2

delete a substring at a character position

 deleteFromLine: startLine col: startCol toLine: endLine col: endCol

delete all text from startLine/startCol to endLine/endCol -
joining lines if necessary

 deleteFromLine: startLineNr toLine: endLineNr

delete some lines

 deleteLine: lineNr

delete line

 deleteLineWithoutRedraw: lineNr

delete line - no redraw;
return true, if something was really deleted

 deleteLinesWithoutRedrawFrom: startLine to: endLine

delete lines - no redraw;
return true, if something was really deleted

 deleteSelection

delete the selection

 deleteWordBeforeCursor

delete the word to the left of cursor and move cursor to left

 indentSelectionBy1

indent selected line-range
by 1 space (i.e. to the right)

 insert: aCharacter atLine: lineNr col: colNr

insert a single character at lineNr/colNr;
set emphasis to character at current position

 insertCharAtCursor: aCharacter

insert a single character at cursor-position - advance cursor.

 insertLine: aString before: lineNr

insert the line aString before line lineNr

 insertLines: aStringCollection before: lineNr

insert a bunch before line lineNr

 insertLines: someText from: start to: end before: lineNr

insert a bunch of lines before line lineNr.
The cursor position is left unchanged.

 insertLines: lines withCR: withCr

insert a bunch of lines at cursor position.
Cursor is moved behind insertion.
If withCr is true, append cr after last line

 insertLines: lines withCr: withCr

insert a bunch of lines at cursor position. Cursor
is moved behind insertion.
If withCr is true, append cr after last line

** This is an obsolete interface - do not use it (it may vanish in future versions) **

 insertSelectedStringAtCursor: aString

insert the argument, aString at cursor position and select it

 insertString: aString atCharacterPosition: charPos

insert the argument, aString at a character position

 insertString: aString atLine: lineNr col: colNr

insert the string, aString at line/col;
handle cr's correctly

 insertStringAtCursor: aString

insert the argument, aString at cursor position
handle cr's correctly. A nil argument is interpreted as an empty line.

 insertStringWithoutCRs: aString atLine: lineNr col: colNr

insert aString (which has no crs) at lineNr/colNr

 insertStringWithoutCRsAtCursor: aString

insert a string (which has no crs) at cursor position
- advance cursor

 insertTabAtCursor

insert spaces to next tab

 joinLines

join lines (remove line-break)

 mergeLine: lineNr

merge line lineNr with line lineNr+1

 mergeLine: lineNr removeBlanks: removeBlanks

merge line lineNr with line lineNr+1

 parenthizeSelection

place parentheses around the selected text.
if already parenthized, de-parenthize it

 parenthizeSelectionWith: openingCharacter and: closingCharacter

if already parenthized, de-parenthize it

 removeTrailingBlankLines

remove all blank lines at end of text

 replace: aCharacter atLine: lineNr col: colNr

replace a single character at lineNr/colNr

 replace: patternArg by: replacePatternArg all: all ignoreCase: ignoreCase

 replaceCharAtCursor: aCharacter

undoably replace a single character at cursor-position - advance cursor

 replaceContentsWith: newContents

undoably replace everything

 replaceFromCharacterPosition: charPos1 to: charPos2 with: newString

undoably replace a substring at a character position

 replaceLine: lineNr with: newText

undoably replace a line at lineNr

 replaceLines: lines withCR: withCr

undoably a bunch of lines at cursor position. Cursor
is moved behind replacement.
If withCr is true, move to the beginning of the next line
after the last line

 replaceSelectionBy: something

undoably delete the selection (if any) and insert something, a character or string;
leave cursor after insertion

 replaceSelectionBy: something keepCursor: keep

undoably delete the selection (if any) and insert something, a character or string;
leave cursor after insertion or leave it, depending on keep

 replaceSelectionBy: something keepCursor: keep select: selectNewText

undoably delete the selection (if any) and insert something, a character or string;
leave cursor after insertion or leave it, depending on keep.
If selectNewText is true, select the new text; otherwise deselect

 replaceString: aString atLine: lineNr col: colNr

undoably replace multiple characters starting at lineNr/colNr.
This is not prepared to encounter special chars (except TAB) in the string.

 replaceString: aString to: aNewString ignoreCase: ignoreCase

 replaceStringAtCursor: aString

replace multiple characters at cursor-position - advance cursor

 replaceTABAtCursor

replace a single character at cursor-position by a TAB character

 selectWordBeforeCursor

select the word to the left of cursor

 splitLine: lineNr before: colNr

split the line linNr before colNr; the right part (from colNr)
is cut off and inserted after lineNr; the view is redrawn

 toggleTabSetting

toggle between 4-col
and 8-col tabs

 undentSelectionBy1

undent selected line-range
by 1 space (i.e. to the left)

 withAutoIndent: aBoolean do: aBlock

 withoutRedrawAt: lineNr put: aString

replace a line at lineNr

 withoutRedrawInsertLine: aString before: lineNr

insert the argument, aString before line lineNr; the string
becomes line lineNr; everything else is moved down; the view
is not redrawn

 withoutRedrawInsertLines: lines from: start to: end before: lineNr

insert a bunch of lines before line lineNr; the view is not redrawn

 withoutRedrawInsertStringWithoutCRs: aString atLine: lineNr col: colNr

insert aString (which has no crs) at lineNr/colNr

 wrapLines

wrap lines (insert line-break)

 basicDeleteCharsAtLine: lineNr fromCol: startCol toCol: endCol

delete characters from startCol to endCol in line lineNr

 basicDeleteFromLine: startLineNr toLine: endLineNr

delete some lines

 basicDeleteLineWithoutRedraw: lineNr

delete line - no redraw;
return true, if something was really deleted

 basicInsert: aCharacter atLine: lineNr col: colNr

insert a single character at lineNr/colNr;
set emphasis to character at current position

 basicListAt: lineNr put: newLine

redefinable for special subclasses (with virtual list)

 basicListRemoveFromIndex: startLineNr toIndex: endLineNr

redefinable for special subclasses (with virtual list)

 basicMergeLine: lineNr removeBlanks: removeBlanks

merge line lineNr with line lineNr+1

 basicReplace: aCharacter atLine: lineNr col: colNr

replace a single character at lineNr/colNr

 basicReplaceString: aString atLine: lineNr col: colNr

replace multiple characters starting at lineNr/colNr.
This is not prepared to encounter special chars (except TAB)
in the string.

 basicSplitLine: lineNr before: colNr

split the line linNr before colNr; the right part (from colNr)
is cut off and inserted after lineNr; the view is redrawn

 basicWithoutRedrawInsertLines: lines from: start to: end before: lineNr

insert a bunch of lines before line lineNr; the view is not redrawn.
Tabs are expanded here with a tab=8 setting (independent of any editor-setting,
because the text might have been pasted from an alien view.

 basicWithoutRedrawInsertStringWithoutCRs: aString atLine: lineNr col: colNr

insert aString (which has no crs) at lineNr/colNr.
Tabs are expanded here with a tab=8 setting (independent of any editor-setting,
because the text might have been pasted from an alien view.

 buttonPress: button x: x y: y

hide the cursor when button is activated

 buttonRelease: button x: x y: y

move the cursor to the click-position of previous button press

 cursorKeyPress: key shifted: shifted

 doKeyPress: key x: x y: y

handle keyboard input

 executeKeyboardMacro: cmdMacro

 handleNonCommandKey: keyArg

pasted selection will NOT be replaced by keystroke

 handleReturnPressed

return key pressed - handle autoIndent

 handleReturnPressed: shiftPressed

return key pressed - handle autoIndent

 keyPress: key x: x y: y

handle keyboard input

 mapped

view was made visible

 maybeShowMatchingParenthesisFor: characterBeforeCursor

emacs style parenthesis shower

 requestAutoAccept

request to accept: this is invoked when a dialog closes via accept or cancel.
This forces my value to be accepted into my model.
Any widget may suppress the ok/cancel, by returning false.

 showMatchingParenthesisAtLine: line col: col

want to wait 240ms, but not if another keyPress

 sizeChanged: how

make certain, cursor is visible after the sizechange

 unmapped

    DeleteCharacters
    DeleteRange
    EditAction
    EditMode
    ExecutingMacroQuery
    LastReplacementInfo
    PasteString
    ReplaceCharacter
    ReplaceCharacters
    ReplaceContents
    ReplaceLine
    ReplaceLines
    RestoreSelectionAndCursor

      |top textView|

      top := StandardSystemView new.
      top extent:300@200.

      textView := EditTextView new.
      textView origin:0.0 @ 0.0 corner:1.0 @ 1.0.
      top addSubView:textView.

      textView contents:('/etc/hosts' asFilename contentsOfEntireFile).

      top open.

      |top scrollView textView|

      top := StandardSystemView new.
      top extent:300@200.

      scrollView := ScrollableView for:EditTextView.
      textView := scrollView scrolledView.
      scrollView origin:0.0 @ 0.0 corner:1.0 @ 1.0.
      top addSubView:scrollView.

      textView contents:('/etc/hosts' asFilename contentsOfEntireFile).

      top open.

      |top scrollView textView|

      top := StandardSystemView new.
      top extent:300@200.

      scrollView := HVScrollableView for:EditTextView.
      textView := scrollView scrolledView.
      scrollView origin:0.0 @ 0.0 corner:1.0 @ 1.0.
      top addSubView:scrollView.

      textView contents:('/etc/hosts' asFilename contentsOfEntireFile).

      top open.

      |top textView|

      top := StandardSystemView new.
      top extent:300@200.

      textView := EditTextView new.
      textView origin:0.0 @ 0.0 corner:1.0 @ 1.0.
      top addSubView:textView.

      textView contents:('/etc/hosts' asFilename contentsOfEntireFile).
      textView acceptAction:[:contents |
                              Transcript showCR:'will not overwrite the file with:'.
                              Transcript showCR:contents asString
                            ].
      top open.

      |top textView list|

      list := '/etc/hosts' asFilename contentsOfEntireFile asStringCollection.
      1 to:list size by:2 do:[:nr |
          list at:nr put:(Text string:(list at:nr)
                               emphasis:(Array with:#bold with:(#color->Color red)))
      ].

      top := StandardSystemView new.
      top extent:300@200.

      textView := EditTextView new.
      textView origin:0.0 @ 0.0 corner:1.0 @ 1.0.
      top addSubView:textView.

      textView contents:list.
      top open.

      |top textView model|

      model := Plug new.
      model respondTo:#accepted:
                 with:[:newContents |
                              Transcript showCR:'will not overwrite the file with:'.
                              Transcript showCR:newContents asString
                      ].
      model respondTo:#getList
                 with:['/etc/hosts' asFilename contentsOfEntireFile].


      top := StandardSystemView new.
      top extent:300@200.

      textView := EditTextView new.
      textView origin:0.0 @ 0.0 corner:1.0 @ 1.0.
      top addSubView:textView.

      textView listMessage:#getList;
               model:model;
               changeMessage:#accepted:;
               aspect:#list.
      top open.

      |top1 textView1 top2 textView2 model currentContents|

      model := Plug new.
      model respondTo:#accepted:
                 with:[:newContents |
                              Transcript showCR:'accepted:'.
                              Transcript showCR:newContents asString.
                              currentContents := newContents.
                              model changed:#contents
                      ].
      model respondTo:#getList
                 with:[Transcript showCR:'query'.
                       currentContents].


      top1 := StandardSystemView new.
      top1 extent:300@200.

      textView1 := EditTextView new.
      textView1 origin:0.0 @ 0.0 corner:1.0 @ 1.0.
      top1 addSubView:textView1.

      textView1 listMessage:#getList;
                model:model;
                aspect:#contents;
                changeMessage:#accepted:.
      top1 open.

      top2 := StandardSystemView new.
      top2 extent:300@200.

      textView2 := EditTextView new.
      textView2 origin:0.0 @ 0.0 corner:1.0 @ 1.0.
      top2 addSubView:textView2.

      textView2 listMessage:#getList;
                model:model;
                aspect:#contents;
                changeMessage:#accepted:.
      top2 open.