Editor Toolbox

The editor toolbox provides a foundation for two common kinds of applications:

1. Programs that need a sophisticated text editor -- The simple text field control is inadequate for text-intensive applications. Many programs need editors that can handle multiple fonts and non-text items.
2. Programs that need a canvas with dragable objects -- The drawing toolbox provides a generic drawing surface for plotting lines and boxes, but many applications need an interactive canvas, where the user can drag and resize individual objects.

• text% -- in a text editor, items are automatically positioned in a paragraph flow.
• pasteboard% -- in a pasteboard editor, items are explicitly positioned and dragable.

MrEd's editor architecture addresses the full range of real-world issues for an editor--including cut-and-paste, extensible file formats, and layered text styles--while supporting a high level of extensibility. Unfortunately, the system is fairly complex as a result, and using the editor classes effectively requires a solid understanding of the structure and terminology of the editor toolbox. Nevertheless, enough applications fit one (or both) of the descriptions above to justify the depth and complexity of the toolbox and the learning investment required to use it.

A brief example illustrates how MrEd editors work. To start, an editor needs an editor-canvas% to display its contents. Then, we can create a text editor an install it into the canvas:

  (define f (make-object frame% "Simple Edit" #f 200 200)) 
  (define c (make-object editor-canvas% f)) 
  (define t (make-object text%)) 
  (send c set-editor t) 
  (send f show #t) 

  (define mb (make-object menu-bar% f)) 
  (define m-edit (make-object menu% "Edit" mb)) 
  (define m-font (make-object menu% "Font" mb)) 
  (append-editor-operation-menu-items m-edit) 
  (append-editor-font-menu-items m-font) 

The content of an editor is made up of snips. An embedded editor is a single snip from the embedding editor's point-of-view. To encode immediate text, a snip can be a single character, but more often a snip is a sequence of adjacent characters on the same line. The find-snip method extracts a snip from a text editor:

  (send t find-snip 0 'after) 

An editor is not permanently attached to any display. We can take the text editor out of our canvas and put a pastboard editor in the canvas, instead:

  (define pb (make-object pasteboard%)) 
  (send c set-editor pb) 

We can insert the old text editor (which we recently removed from the canvas) as an embedded editor in the pasteboard by explicitly creating an editor snip:

  (define s (make-object editor-snip% t)) ; t is the old text editor 
  (send pb insert s) 

  (send pb insert s) ; no effect 

  (send pb insert (send s copy)) 

Applications that use the editor classes typically derive new versions of the text% and pasteboard% classes. For example, to implement an append-only editor (which allows insertions only at the end and never allows deletions), derive a new class from text% and override the can-insert? and can-delete? methods:

  (define append-only-text% 
    (class text% args 
      (inherit last-position) 
      (override 
       [can-insert? (lambda (s l) (= s (last-position)))] 
       [can-delete? (lambda (s l) #f)])
      (sequence (apply super-init args)))) 

• Editor Structure and Terminology
  • Administrators
  • Styles
• File Format
  • Encoding Snips
    • Snip Classes
    • Editor Data
  • Global Data: Headers and Footers
• End of Line Ambiguity
• Flattened Text
• Caret Ownership
• Cut and Paste Time Stamps
• Clickbacks
• Internal Editor Locks