yep, me! me!, I want to play :)
--------------
The uncommented class selection algorithm should take undocumented
parent classes before. Thus, it is difficult to document
SmalltalkEditingState before EditingState is itself documented. So, I
first give a documentation for EditingState and then a small additional
comment for SmalltalkEditingState.
Maybe the comments about editing session is misplaced (better in
TextMorph, in TextEditor ?)
with my bad English:
EditingState comments:
I store the current state of an editing session. An instance of mine is
shared by all TextEditor instances that are created during an editing
session managed by a TextMorph (see below for more explanations about
editing session). The state data are basically made of an undo/redo
manager and of all data needed in order to manage text editing undo and
redo (mainly all informations for the current and previous selection
intervals).
I'm created by a TextEditor at the beginning of an editing session (see
TextEditor>>editingStateClass and TextEditor>>editingState).
Specializations can be introduced to fit a particular TextEditor
subclass need.
Editing session:
An editing session starts when a TextMorph is created (precisely, when
a TextEditor instance is first assigned to a TextMorph editor instance
variable). An editing session ends when a TextMorph is deleted. During
an editing session, a TextMorph can make use of a lot of TextEditor
instances, one at a time. As an example, each time a TextMorph is
resized, its editor is released and a new one that fit the TextMorph
physical properties is created. Another example, when a TextMorph loses
the keyboard focus, then its editor could be fully released; it is
created again when the TextMorph retrieves the focus.
When an editor is created by a TextMorph, the state of the previous
TextEditor, stored in its associated EditingState instance, is got and
passed to the newly created editor. Thus the editing session remains
stable (see TextEditor >> #stateArray and TextMorph >>
#installEditorToReplace:). So TextEditor instances are extremely
volatile whereas its associated EditingState instance remains during the
whole editing session.
Instance Variables:
emphasisHere <Array of TextAttribute>
pointBlock <CharacterBlock>
markBlock <CharacterBlock>
startOfTyping <Integer>
previousInterval <Interval>
previousSelection <Text>
undoManager <HistoryIterator>
lastParenLocation <Integer>
mouseDownInterval <Interval>
secondarySelectionToken ** obsolete ** should be removed **
- emphasisHere:
The TextAttributes that are used for the newly entered text
- pointBlock:
The CharacterBlock where a selection begins (where the mouse has
first pointed)
- markBlock:
The CharacterBlock where a selection ends
- startOfTyping:
The index of the first character which has been entered during the
currently undoable/redoable portion of text (see TextEditor>>#openTypeIn
and TextEditor>>#doneTyping)
- previousInterval:
Previous interval used for undo/redo actions
- previousSelection:
The previously selected text for undo/redo actions
- undoManager:
The undo/redo manager
- lastParenLocation:
Keep the position of the open parenthesis which corresponds to the
last entered close parenthesis
- mouseDownInterval:
The position of the first mouse down in the editor
-----------------------------------
SmalltalkEditingState comments:
See EditingState comments.
SmalltalkEditingState is made to manage data for Smalltalk code editing
sessions (such as a selector chooser).
Instance Variables:
selectorChooser <SelectorChooserMorph>
- selectorChooser
The basic selector chooser which is popup to fetch available selectors
or class names begining with a prefix. The prefix is token from the
current caret location (see SelectorChooserMorph comments)
Le 05/02/2011 18:08, Stéphane Ducasse a écrit :
I'm the logic behind a texteditor. I'm a kind of strategy object responsible of
handling edit operations of an editor such as undo, text emphasis, mouse handle
actions.
On Feb 5, 2011, at 5:40 PM, laurent laffont wrote:
SmalltalkEditingState
