specifying a layered presentation-oriented editor martijn schrage utrecht university 26-1-2005

Specifying a layered presentation-oriented editor

Martijn Schrage

Utrecht University

26-1-2005

Overview Proxima

Introduction to architecture Extra state Demo

Specification Chapter 5 of

Martijn M. Schrage. Proxima - A presentation-oriented editor for structured

documents. PhD thesis, Utrecht University, 2004. Joint work with Lambert Meertens Stepwise

1. Proxima

Edit model

Document(internal)

Presentation sheet

Presentation(visible)

present

".."3

Edit model

-Keep track of cursor/selection

-Catch edit events

Update document

Document(internal)

Presentation sheet

Presentation(visible)

present

interpret

Interpretation sheet

".."3

Document

edit

view

present interpret

Rendering

Proxima architectureInternal document tree

Image

Enriched Document

Rendering

Presentation

Layout

Arrangement

Document Internal document tree

Document + derived values

Logical presentation: rows, columns, tokens, etc.

Presentation + explicit whitespace

Presentation with exact positions & sizes

Image

edit

view

Level:

Level:

...

Proxima architecture: Levels

Presentation processDocument:Root [ Comment ["This", "is", "a", "simple", "expression"] , Decl "simple1" (IfExp (BoolExp True) (IntExp 1) (IntExp 0)) ]

This is a simpleexpression

simple1 :: Intsimple1 = if True then 1 else 0

Rendering:

ArrangementLayoutPresentation

Enriched Document RenderingPresentation Layout ArrangementDocument

RenderingEvaluation

Evaluation

Document:Root [ Comment ["This", "is", "a", "simple", "expression"] , Decl "simple1" (IfExp (BoolExp True) (IntExp 1) (IntExp 0)) ]

Enriched Document:Root [ Comment ["This", "is", "a", "simple", "expression"] , TypeDecl "simple1" IntType , Decl "simple1" (IfExp (BoolExp True) (IntExp 1) (IntExp 0)) ]


Evaluation

PresentationEnriched Document:Root [ Comment ["This", "is", "a", "simple", "expression"] , TypeDecl "simple1" IntType , Decl "simple1" (IfExp (BoolExp True) (IntExp 1) (IntExp 0)) ]

Presentation:Col [ With {font} (Formatter [ "This", "is", "a", "simple", "expression" ]) , With {font} (Tokens [ Token (1,0) "simple1", Token (0,1) "::" , Token (0,1) "Int" ]) , With {font} (Tokens [ Token (1,0) "simple1", Token (0,1) "=" , Token (1,2) "if", ... ]) ]

font

font

font

Presentation


Layout

Layout:Col [ ... , With {font} (Col [ "" , Row [ "simple1", " ", "::", " ", "Int" ] ]) , With {font} (Col [ Row [ "simple1", " ", "=" ] , Row [ " ", "if", " ", "True", " ", "then" ] , Row [ " ", "else", ... ] ) ]

font

font

Presentation:Col [ ... , With {font} (Tokens [ Token (1,0) "simple1", Token (0,1) "::" , Token (0,1) "Int" ]) , With {font} (Tokens [ Token (1,0) "simple1", Token (0,1) "=" , Token (1,2) "if", ... ]) ]

font

font

Layout


ArrangementLayout:Col [ With {font} (Formatter [ "This", "is", "a", "simple", "expression" ]) , With {font} (Col [ "" , Row [ "simple1", " ", "::", " ", "Int" ] ]) , With {font} (Col [ Row [ "simple1", " ", "=" ], ... ]) ]

font

font

font

Arrangement:Col(0,0)(80×84)

[ Col(0,0)(80×24) [ Row(0,0)(80×12) [ "This"(0,0)(17×12), "is"(25,0)(6×12), ... ] , Row(0,12)(80×12)[ "expression"(53,0)(27×12) ] , Col(0,24)(75×24) [ ""(0,0)(0×12)

, Row{..} [ "simple1"{..}, " "{..}, "::"{..}, ... ] ] , Col(0,48)(80×36) [ Row{..} [ "simple1"{..}, " "{..}, "="{..} ] , ... ] ]

This isexpression

simple1 ::simple1 =

Arrangement


Arrangement:Col(0,0)(80×84)

[ Col(0,0)(80×24) [ Row(0,0)(80×12) [ "This"(0,0)(17×12), "is"(25,0)(6×12), ... ] , Row(0,12)(80×12)[ "expression"(53,0)(27×12) ] , Col(0,24)(75×24) [ Row{..} [] , Row{..} [ "simple1"{..}, " "{..}, "::"{..}, ... ] ] , Col(0,48)(80×36) [ Row{..} [ "simple1"{..}, " "{..}, "="{..} ] , ... ] ]

This isexpression

simple1 ::simple1

Rendering

This is a simpleexpression

simple1 :: Intsimple1 = if True then 1 else 0

Rendering:

=


Rendering

Enriched Document

Rendering

Presentation

Layout

Arrangement

Document Internal document tree





Image

edit

view

Level:

Level:

...

Proxima architecture: levels

Arranger/Unarranger

Evaluator/Reducer

Enriched Document

Rendering

Presentation

Layout

Arrangement

Document

Renderer/Gesture Interpreter

Internal document tree





Image

edit

view

Layer:

Presenter/ParserLayer:

Layout/Scanner...

Proxima architecture: layers

Arranger/Unarranger

Layout/Scanner

Presenter/Parser

Evaluator/Reducer

Rendering

Presentation

Layout

Arrangement

Document







Image

reduction sheet

parsing sheet(combinator parser)

scanner sheet

Enriched Document

evaluation sheet

presentation sheet(AG)

edit

view

Proxima architecture: sheets

Arranger/Unarranger

Scanner

Parser

Reducer

Rendering

Presentation

Layout

Arrangement

Document







Image

reduction sheet

parsing sheet(combinator parser)

scanner sheet

Enriched Document

'textual' editing

tree editing

tree editing

edit

view

Interpretation process

Presentation:

Extra state (simplified)Decl

"f" +

1 *

f = ...

2 3

Document:interpretation

extra state

presentationextra state

Extra state (actual)Decl

"f" +

1 *

f = ...

2 3

Enriched document:

Layout:

Tk

"f"(1,0)

Tk

"="(0,2)

Tk

"..."(0,1)

interpretationextra state

presentationextra state

Presentation:

Extra state, other examples Tree view

fruit vegetablescabbage

Savoycabbage

redcabbage

food

citruslemon

snack

peachorange

spinach

Document:

Presentation:

present

List orderDocument:

Presentation:

present

[ "Sun King", "Mean Mr. Mustard", "Polythene Pam", "The End", "Her Majesty"] extra state: list order

extra state

Demo Research prototype

Implemented in Haskell (with GUI in wxHaskell) Attribute grammar for presentation Parser combinators for interpretation

Four editors instantiated Program source (Helium) Slide presentations (a la PowerPoint) Chess board Editor for reversible language Inv

No optimisations yet On each key press, every pixel is recomputed

DTD - Helium (partial)data Document = RootDoc decls:[Decl]

data Decl = Decl Ident Exp -- <ident> = <exp>; | BoardDecl Board -- Chess: <board> | SlidesDecl Slides -- Slides: <slides>

data Ident = Ident String

data Exp = PlusExp exp1:Exp exp2:Exp -- <exp> + <exp> | TimesExp exp1:Exp exp2:Exp -- <exp> * <exp> | DivExp exp1:Exp exp2:Exp -- <exp> / <exp> | AppExp exp1:Exp exp2:Exp -- <exp> <exp> | LamExp Ident Exp -- \<ident> <exp> | LetExp [Decl] Exp -- let <decls> in <exp> | BoolExp Bool -- True | IntExp Int -- 173 | IdentExp Ident -- X | ...

concrete

syntax

+ ~1500 lines of sheet code

DTD - Slide editordata Slides = Slides viewType:Bool [Slide]

data Slide = Slide title:String ItemList

data ItemList = ItemList ListType items:[Item]

data ListType = Bullet | Number | Alpha data Item = StringItem string:String | HeliumItem Exp | ListItem ItemList

+ ~200 lines of sheet code

DTD - Chessdata Board = Board r1:Row r2:Row r3:Row r4:Row r5:Row r6:Row r7:Row r8:Row

data Row = Row ca:Square cb:Square cc:Square cd:Square ce:Square cf:Square cg:Square ch:Square

data BoardSquare = Queen color:Bool | King color:Bool | Bishop color:Bool | Knight color:Bool | Rook color:Bool | Pawn color:Bool | Empty

+ ~130 lines of sheet code (without move generator)

2. Specification

Step 1: Single layer Two levels:

LevelH (Document) and LevelL (Presentation)

Given present LevelH LevelL (Total & injective)

we specify interpret LevelL LevelH

PSD analogy: (present, interpret) is (get, put) (LevelH, LevelL) is (Source, View) However, we give only a specification, no language No assumptions on level types or formalism for functions

Data flow

|x + 1

Plus "x" 1

\x->|x + 1

levelH:

levelL':levelL:

x |x + 1

levelL'':

Lam "x" (Plus "x" 1)

levelH'':

user enters:"\x->"

present interpret present

Requirements Precondition: levelL present levelH Edit operation: levelL level'L

Requirements: {true} Comp {levelL'' present levelH''}

(Postcondition) {levelL' present h} Comp {levelL'' levelL'} (Pres-

Inert) {true} Comp {levell' “close to” levelL''} (Intended)

Computation Comp levelH'' : interpret levelL'

levelL'' : present levelH''

l present h h interpret l (InterPresent) Interpresent implies all requirements

Step 2: Extra state Extra state in both directions

Whitespace, expansion state, hidden data, etc. Relations instead of functions Present LevelL ~ LevelH

Interpret LevelH ~ LevelL Equivalence relations L and H for extra state

L LevelL ~ LevelL and H LevelH ~ LevelH "x + 1") L " x + 1") Decl "f" 1) H (Decl "f" (Sum 1 2))

Wildcards: data Decl = Decl String *Exp

Functions instead of relations [x]R y | x R y } Equivalence class

TR [x]R | x T } Factor set: all eq. classes

Functions between equivalence classes

present LevelHH LevelLL

interpret LevelLL LevelHH

l Present h [l]L present [h]H (present-Char)

l Interpret h [h]L interpret [l]L (interpret-Char)

{true} Comp {[levelL'']L present [levelH'']H}

(Postcondition) {[levelL']L present [h]H} Comp {levelL'' levelL'}

(Pres-Inert) {true} Comp {levell' “close to” levelL''} (Intended)

{[levelL']L present [levelH]H} Comp {levelH'' levelH}

(Doc-Inert)

{true} Comp {levelH “close to” levelH''} (Doc-Preserve)

Requirements

Computation Select a value from eq. class, reusing extra state :: LevelR Level Level

E.g. Decl "g" *) Decl "f" 1) Decl "g" 1)

[ [x]R y ]R [x]R (-Valid) [x]R [y]R [x]R y y (-Idem) [x]R y “close to” y (-Close)

Comp levelH'' : interpret [levelL']L H levelH ; levelL'' : present [levelH'']H L levelL'

[l]L present [h]H [h]H interpret [l]L (InterPresent) InterPresent implies all requirements

Step 3: Composite layer Not discussed in detail because of complexity Problem when composing:

Composition of mappings between equivalence classes is not necessarily a mapping between equivalence classes again

Components [l]LL presentL [m]LHand[m]HL presentH [h]HH

Composition is not always [l]CL presentC [h]CH

For present, we may assume a valid decomposition,

but interpret may fail Other problems occur as well Solution: strong restrictions on composition,

explained in thesis

Step 4: Duplicates Example: present x (x, x, x) Hard to define without assumptions on types and mappings When a duplicate is modified, the modified value is used for

the document update Updated title in contents leads to update on chapter title

Problem with Intended requirement Intended: {true} Comp {levell' “close to” levelL''} Result of (1,1,1) (1,2,1) should be (2,2,2) However, (1,2,1) is closer to (1,1,1) than (2,2,2)

Solution: block out interfering duplicates with operator

Requirements: Intended Level Level Level

depends on present, usage: levell levell' Duplicates of edited parts become wildcards, which do not affect

“close to” and equality. For present x (x, x, x) For present (x,y) (x, y, x+y)

Not possible to give formal definition

New requirement: {true} Comp {levell levell' “close to” levelL''} (Intended)

Because presentation extra state is now no longer reused for duplicates, we need the (weaker) requirement:

{true} Comp {levelL' “close to” levelL''} (Pres-Preserve)

Only require updated parts to be inert and not their duplicates + fix precondition to handle interfering duplicates in presentation

{[levell levell']L present [h]H} Comp {levell levell' levelL''}

(Pres-Inert)

Other requirements remain unchanged

Requirements: Pres-Inert Also a problem with Pres-Inert Old Pres-Inert: {[levelL']L present [h]H} Comp {levelL'' levelL'}

Simple source editor with document [ f = a + 2, a = 1]and presentation with type check "f = ...; a = 1 OK"

User update "1" "True" should yield "f = ...; a = True ERROR" But since "f = ...; a = True OK" is the presentation of some h,

Pres-Inert specifies update on hidden body of f (e.g. a+2 undefined)

Conclusions / future work Given present, specification of interpret plus computation When simple requirements are met, more complex

requirements can be proven Specification helps to clarify concept of extra state

Specification Find workable restrictions for composite layer Maybe formalize closeness

Simple fixes on prototype Incrementality (10x faster), focus, edit model

Add evaluation layer Automatically construct interpret that meets the specification

Typed Inv + presentation extra state + AG Inversion is fragile, must be easy to specify non-automatic parts

Questions?

For thesis & more information:

http://www.cs.uu.nl/research/projects/proxima/

specifying a layered presentation-oriented editor martijn schrage utrecht university 26-1-2005

Documents

typedecl simple1 inttype

root comment

courier new

times new roman

joint work

track of cursorselection

structured documents

phd thesis