[Pharo-project] [COTDC] 2 - SmalltalkEditingState

Alain Plantec alain.plantec at yahoo.com
Sat Feb 5 22:28:52 CET 2011


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
>





More information about the Pharo-project mailing list