# Mu - edit/012-editor-undo.mu

       1 ## undo/redo
       2
       3 # for every undoable event, create a type of *operation* that contains all the
       4 # information needed to reverse it
       5 exclusive-container operation [
       6   typing:insert-operation
       7   move:move-operation
       8   delete:delete-operation
       9 ]
      10
      11 container insert-operation [
      12   before-row:num
      13   before-column:num
      14   before-top-of-screen:&:duplex-list:char
      15   after-row:num
      16   after-column:num
      17   after-top-of-screen:&:duplex-list:char
      18   # inserted text is from 'insert-from' until 'insert-until'; list doesn't have to terminate
      19   insert-from:&:duplex-list:char
      20   insert-until:&:duplex-list:char
      21   tag:num  # event causing this operation; might be used to coalesce runs of similar events
      22     # 0: no coalesce (enter+indent)
      23     # 1: regular alphanumeric characters
      24 ]
      25
      26 container move-operation [
      27   before-row:num
      28   before-column:num
      29   before-top-of-screen:&:duplex-list:char
      30   after-row:num
      31   after-column:num
      32   after-top-of-screen:&:duplex-list:char
      33   tag:num  # event causing this operation; might be used to coalesce runs of similar events
      34     # 0: no coalesce (touch events, etc)
      35     # 1: left arrow
      36     # 2: right arrow
      37     # 3: up arrow
      38     # 4: down arrow
      39     # 5: line up
      40     # 6: line down
      41 ]
      42
      43 container delete-operation [
      44   before-row:num
      45   before-column:num
      46   before-top-of-screen:&:duplex-list:char
      47   after-row:num
      48   after-column:num
      49   after-top-of-screen:&:duplex-list:char
      50   deleted-text:&:duplex-list:char
      51   delete-from:&:duplex-list:char
      52   delete-until:&:duplex-list:char
      53   tag:num  # event causing this operation; might be used to coalesce runs of similar events
      54     # 0: no coalesce (ctrl-k, ctrl-u)
      55     # 1: backspace
      56     # 2: delete
      57 ]
      58
      59 # every editor accumulates a list of operations to undo/redo
      60 container editor [
      61   undo:&:list:&:operation
      62   redo:&:list:&:operation
      63 ]
      64
      65 # ctrl-z - undo operation
      66 after <handle-special-character> [
      67   {
      68     undo?:bool <- equal c, 26/ctrl-z
      69     break-unless undo?
      70     undo:&:list:&:operation <- get *editor, undo:offset
      71     break-unless undo
      72     op:&:operation <- first undo
      73     undo <- rest undo
      74     *editor <- put *editor, undo:offset, undo
      75     redo:&:list:&:operation <- get *editor, redo:offset
      76     redo <- push op, redo
      77     *editor <- put *editor, redo:offset, redo
      78     <handle-undo>
      79     return true/go-render
      80   }
      81 ]
      82
      83 # ctrl-y - redo operation
      84 after <handle-special-character> [
      85   {
      86     redo?:bool <- equal c, 25/ctrl-y
      87     break-unless redo?
      88     redo:&:list:&:operation <- get *editor, redo:offset
      89     break-unless redo
      90     op:&:operation <- first redo
      91     redo <- rest redo
      92     *editor <- put *editor, redo:offset, redo
      93     undo:&:list:&:operation <- get *editor, undo:offset
      94     undo <- push op, undo
      95     *editor <- put *editor, undo:offset, undo
      96     <handle-redo>
      97     return true/go-render
      98   }
      99 ]
     100
     101 # undo typing
     102
     103 scenario editor-can-undo-typing [
     104   local-scope
     105   # create an editor and type a character
     106   assume-screen 10/width, 5/height
     107   e:&:editor <- new-editor [], 0/left, 10/right
     108   editor-render screen, e
     109   assume-console [
     110     type [0]
     111   ]
     112   editor-event-loop screen, console, e
     113   # undo
     114   assume-console [
     115     press ctrl-z
     116   ]
     117   run [
     118     editor-event-loop screen, console, e
     119   ]
     120   # character should be gone
     121   screen-should-contain [
     122     .          .
     123     .          .
     124     .╌╌╌╌╌╌╌╌╌╌.
     125     .          .
     126   ]
     127   # cursor should be in the right place
     128   assume-console [
     129     type [1]
     130   ]
     131   run [
     132     editor-event-loop screen, console, e
     133   ]
     134   screen-should-contain [
     135     .          .
     136     .1         .
     137     .╌╌╌╌╌╌╌╌╌╌.
     138     .          .
     139   ]
     140 ]
     141
     142 # save operation to undo
     143 after <begin-insert-character> [
     144   top-before:&:duplex-list:char <- get *editor, top-of-screen:offset
     145   cursor-before:&:duplex-list:char <- get *editor, before-cursor:offset
     146 ]
     147 before <end-insert-character> [
     148   top-after:&:duplex-list:char <- get *editor, top-of-screen:offset
     149   cursor-row:num <- get *editor, cursor-row:offset
     150   cursor-column:num <- get *editor, cursor-column:offset
     151   undo:&:list:&:operation <- get *editor, undo:offset
     152   {
     153     # if previous operation was an insert, coalesce this operation with it
     154     break-unless undo
     155     op:&:operation <- first undo
     156     typing:insert-operation, is-insert?:bool <- maybe-convert *op, typing:variant
     157     break-unless is-insert?
     158     previous-coalesce-tag:num <- get typing, tag:offset
     159     break-unless previous-coalesce-tag
     160     before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
     161     insert-until:&:duplex-list:char <- next before-cursor
     162     typing <- put typing, insert-until:offset, insert-until
     163     typing <- put typing, after-row:offset, cursor-row
     164     typing <- put typing, after-column:offset, cursor-column
     165     typing <- put typing, after-top-of-screen:offset, top-after
     166     *op <- merge 0/insert-operation, typing
     167     break +done-adding-insert-operation
     168   }
     169   # if not, create a new operation
     170   insert-from:&:duplex-list:char <- next cursor-before
     171   insert-to:&:duplex-list:char <- next insert-from
     172   op:&:operation <- new operation:type
     173   *op <- merge 0/insert-operation, save-row/before, save-column/before, top-before, cursor-row/after, cursor-column/after, top-after, insert-from, insert-to, 1/coalesce
     174   editor <- add-operation editor, op
     175   +done-adding-insert-operation
     176 ]
     177
     178 # enter operations never coalesce with typing before or after
     179 after <begin-insert-enter> [
     180   cursor-row-before:num <- copy cursor-row
     181   cursor-column-before:num <- copy cursor-column
     182   top-before:&:duplex-list:char <- get *editor, top-of-screen:offset
     183   cursor-before:&:duplex-list:char <- get *editor, before-cursor:offset
     184 ]
     185 before <end-insert-enter> [
     186   top-after:&:duplex-list:char <- get *editor, top-of-screen:offset
     187   cursor-row:num <- get *editor, cursor-row:offset
     188   cursor-column:num <- get *editor, cursor-row:offset
     189   # never coalesce
     190   insert-from:&:duplex-list:char <- next cursor-before
     191   before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
     192   insert-to:&:duplex-list:char <- next before-cursor
     193   op:&:operation <- new operation:type
     194   *op <- merge 0/insert-operation, cursor-row-before, cursor-column-before, top-before, cursor-row/after, cursor-column/after, top-after, insert-from, insert-to, 0/never-coalesce
     195   editor <- add-operation editor, op
     196 ]
     197
     198 # Everytime you add a new operation to the undo stack, be sure to clear the
     199 # redo stack, because it's now obsolete.
     200 # Beware: since we're counting cursor moves as operations, this means just
     201 # moving the cursor can lose work on the undo stack.
     202 def add-operation editor:&:editor, op:&:operation -> editor:&:editor [
     203   local-scope
     204   load-inputs
     205   undo:&:list:&:operation <- get *editor, undo:offset
     206   undo <- push op undo
     207   *editor <- put *editor, undo:offset, undo
     208   redo:&:list:&:operation <- get *editor, redo:offset
     209   redo <- copy null
     210   *editor <- put *editor, redo:offset, redo
     211 ]
     212
     213 after <handle-undo> [
     214   {
     215     typing:insert-operation, is-insert?:bool <- maybe-convert *op, typing:variant
     216     break-unless is-insert?
     217     start:&:duplex-list:char <- get typing, insert-from:offset
     218     end:&:duplex-list:char <- get typing, insert-until:offset
     219     # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen
     220     before-cursor:&:duplex-list:char <- prev start
     221     *editor <- put *editor, before-cursor:offset, before-cursor
     222     remove-between before-cursor, end
     223     cursor-row <- get typing, before-row:offset
     224     *editor <- put *editor, cursor-row:offset, cursor-row
     225     cursor-column <- get typing, before-column:offset
     226     *editor <- put *editor, cursor-column:offset, cursor-column
     227     top:&:duplex-list:char <- get typing, before-top-of-screen:offset
     228     *editor <- put *editor, top-of-screen:offset, top
     229   }
     230 ]
     231
     232 scenario editor-can-undo-typing-multiple [
     233   local-scope
     234   # create an editor and type multiple characters
     235   assume-screen 10/width, 5/height
     236   e:&:editor <- new-editor [], 0/left, 10/right
     237   editor-render screen, e
     238   assume-console [
     239     type [012]
     240   ]
     241   editor-event-loop screen, console, e
     242   # undo
     243   assume-console [
     244     press ctrl-z
     245   ]
     246   run [
     247     editor-event-loop screen, console, e
     248   ]
     249   # all characters must be gone
     250   screen-should-contain [
     251     .          .
     252     .          .
     253     .╌╌╌╌╌╌╌╌╌╌.
     254     .          .
     255   ]
     256 ]
     257
     258 scenario editor-can-undo-typing-multiple-2 [
     259   local-scope
     260   # create an editor with some text
     261   assume-screen 10/width, 5/height
     262   e:&:editor <- new-editor [a], 0/left, 10/right
     263   editor-render screen, e
     264   # type some characters
     265   assume-console [
     266     type [012]
     267   ]
     268   editor-event-loop screen, console, e
     269   screen-should-contain [
     270     .          .
     271     .012a      .
     272     .╌╌╌╌╌╌╌╌╌╌.
     273     .          .
     274   ]
     275   # undo
     276   assume-console [
     277     press ctrl-z
     278   ]
     279   run [
     280     editor-event-loop screen, console, e
     281   ]
     282   # back to original text
     283   screen-should-contain [
     284     .          .
     285     .a         .
     286     .╌╌╌╌╌╌╌╌╌╌.
     287     .          .
     288   ]
     289   # cursor should be in the right place
     290   assume-console [
     291     type [3]
     292   ]
     293   run [
     294     editor-event-loop screen, console, e
     295   ]
     296   screen-should-contain [
     297     .          .
     298     .3a        .
     299     .╌╌╌╌╌╌╌╌╌╌.
     300     .          .
     301   ]
     302 ]
     303
     304 scenario editor-can-undo-typing-enter [
     305   local-scope
     306   # create an editor with some text
     307   assume-screen 10/width, 5/height
     308   e:&:editor <- new-editor [  abc], 0/left, 10/right
     309   editor-render screen, e
     310   # new line
     311   assume-console [
     312     left-click 1, 8
     313     press enter
     314   ]
     315   editor-event-loop screen, console, e
     316   screen-should-contain [
     317     .          .
     318     .  abc     .
     319     .          .
     320     .╌╌╌╌╌╌╌╌╌╌.
     321     .          .
     322   ]
     323   # line is indented
     324   3:num/raw <- get *e, cursor-row:offset
     325   4:num/raw <- get *e, cursor-column:offset
     326   memory-should-contain [
     327     3 <- 2
     328     4 <- 2
     329   ]
     330   # undo
     331   assume-console [
     332     press ctrl-z
     333   ]
     334   run [
     335     editor-event-loop screen, console, e
     336   ]
     337   3:num/raw <- get *e, cursor-row:offset
     338   4:num/raw <- get *e, cursor-column:offset
     339   memory-should-contain [
     340     3 <- 1
     341     4 <- 5
     342   ]
     343   # back to original text
     344   screen-should-contain [
     345     .          .
     346     .  abc     .
     347     .╌╌╌╌╌╌╌╌╌╌.
     348     .          .
     349   ]
     350   # cursor should be at end of line
     351   assume-console [
     352     type [1]
     353   ]
     354   run [
     355     editor-event-loop screen, console, e
     356   ]
     357   screen-should-contain [
     358     .          .
     359     .  abc1    .
     360     .╌╌╌╌╌╌╌╌╌╌.
     361     .          .
     362   ]
     363 ]
     364
     365 # redo typing
     366
     367 scenario editor-redo-typing [
     368   local-scope
     369   # create an editor, type something, undo
     370   assume-screen 10/width, 5/height
     371   e:&:editor <- new-editor [a], 0/left, 10/right
     372   editor-render screen, e
     373   assume-console [
     374     type [012]
     375     press ctrl-z
     376   ]
     377   editor-event-loop screen, console, e
     378   screen-should-contain [
     379     .          .
     380     .a         .
     381     .╌╌╌╌╌╌╌╌╌╌.
     382     .          .
     383   ]
     384   # redo
     385   assume-console [
     386     press ctrl-y
     387   ]
     388   run [
     389     editor-event-loop screen, console, e
     390   ]
     391   # all characters must be back
     392   screen-should-contain [
     393     .          .
     394     .012a      .
     395     .╌╌╌╌╌╌╌╌╌╌.
     396     .          .
     397   ]
     398   # cursor should be in the right place
     399   assume-console [
     400     type [3]
     401   ]
     402   run [
     403     editor-event-loop screen, console, e
     404   ]
     405   screen-should-contain [
     406     .          .
     407     .0123a     .
     408     .╌╌╌╌╌╌╌╌╌╌.
     409     .          .
     410   ]
     411 ]
     412
     413 after <handle-redo> [
     414   {
     415     typing:insert-operation, is-insert?:bool <- maybe-convert *op, typing:variant
     416     break-unless is-insert?
     417     before-cursor <- get *editor, before-cursor:offset
     418     insert-from:&:duplex-list:char <- get typing, insert-from:offset  # ignore insert-to because it's already been spliced away
     419     # assert insert-to matches next(before-cursor)
     420     splice before-cursor, insert-from
     421     # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen
     422     cursor-row <- get typing, after-row:offset
     423     *editor <- put *editor, cursor-row:offset, cursor-row
     424     cursor-column <- get typing, after-column:offset
     425     *editor <- put *editor, cursor-column:offset, cursor-column
     426     top:&:duplex-list:char <- get typing, after-top-of-screen:offset
     427     *editor <- put *editor, top-of-screen:offset, top
     428   }
     429 ]
     430
     431 scenario editor-redo-typing-empty [
     432   local-scope
     433   # create an editor, type something, undo
     434   assume-screen 10/width, 5/height
     435   e:&:editor <- new-editor [], 0/left, 10/right
     436   editor-render screen, e
     437   assume-console [
     438     type [012]
     439     press ctrl-z
     440   ]
     441   editor-event-loop screen, console, e
     442   screen-should-contain [
     443     .          .
     444     .          .
     445     .╌╌╌╌╌╌╌╌╌╌.
     446     .          .
     447   ]
     448   # redo
     449   assume-console [
     450     press ctrl-y
     451   ]
     452   run [
     453     editor-event-loop screen, console, e
     454   ]
     455   # all characters must be back
     456   screen-should-contain [
     457     .          .
     458     .012       .
     459     .╌╌╌╌╌╌╌╌╌╌.
     460     .          .
     461   ]
     462   # cursor should be in the right place
     463   assume-console [
     464     type [3]
     465   ]
     466   run [
     467     editor-event-loop screen, console, e
     468   ]
     469   screen-should-contain [
     470     .          .
     471     .0123      .
     472     .╌╌╌╌╌╌╌╌╌╌.
     473     .          .
     474   ]
     475 ]
     476
     477 scenario editor-work-clears-redo-stack [
     478   local-scope
     479   # create an editor with some text, do some work, undo
     480   assume-screen 10/width, 5/height
     481   contents:text <- new [abc
     482 def
     483 ghi]
     484   e:&:editor <- new-editor contents, 0/left, 10/right
     485   editor-render screen, e
     486   assume-console [
     487     type [1]
     488     press ctrl-z
     489   ]
     490   editor-event-loop screen, console, e
     491   # do some more work
     492   assume-console [
     493     type [0]
     494   ]
     495   editor-event-loop screen, console, e
     496   screen-should-contain [
     497     .          .
     498     .0abc      .
     499     .def       .
     500     .ghi       .
     501     .╌╌╌╌╌╌╌╌╌╌.
     502   ]
     503   # redo
     504   assume-console [
     505     press ctrl-y
     506   ]
     507   run [
     508     editor-event-loop screen, console, e
     509   ]
     510   # nothing should happen
     511   screen-should-contain [
     512     .          .
     513     .0abc      .
     514     .def       .
     515     .ghi       .
     516     .╌╌╌╌╌╌╌╌╌╌.
     517   ]
     518 ]
     519
     520 scenario editor-can-redo-typing-and-enter-and-tab [
     521   local-scope
     522   # create an editor
     523   assume-screen 10/width, 5/height
     524   e:&:editor <- new-editor [], 0/left, 10/right
     525   editor-render screen, e
     526   # insert some text and tabs, hit enter, some more text and tabs
     527   assume-console [
     528     press tab
     529     type [ab]
     530     press tab
     531     type [cd]
     532     press enter
     533     press tab
     534     type [efg]
     535   ]
     536   editor-event-loop screen, console, e
     537   screen-should-contain [
     538     .          .
     539     .  ab  cd  .
     540     .    efg   .
     541     .╌╌╌╌╌╌╌╌╌╌.
     542     .          .
     543   ]
     544   3:num/raw <- get *e, cursor-row:offset
     545   4:num/raw <- get *e, cursor-column:offset
     546   memory-should-contain [
     547     3 <- 2
     548     4 <- 7
     549   ]
     550   # undo
     551   assume-console [
     552     press ctrl-z
     553   ]
     554   run [
     555     editor-event-loop screen, console, e
     556   ]
     557   # typing in second line deleted, but not indent
     558   3:num/raw <- get *e, cursor-row:offset
     559   4:num/raw <- get *e, cursor-column:offset
     560   memory-should-contain [
     561     3 <- 2
     562     4 <- 2
     563   ]
     564   screen-should-contain [
     565     .          .
     566     .  ab  cd  .
     567     .          .
     568     .╌╌╌╌╌╌╌╌╌╌.
     569     .          .
     570   ]
     571   # undo again
     572   assume-console [
     573     press ctrl-z
     574   ]
     575   run [
     576     editor-event-loop screen, console, e
     577   ]
     578   # indent and newline deleted
     579   3:num/raw <- get *e, cursor-row:offset
     580   4:num/raw <- get *e, cursor-column:offset
     581   memory-should-contain [
     582     3 <- 1
     583     4 <- 8
     584   ]
     585   screen-should-contain [
     586     .          .
     587     .  ab  cd  .
     588     .╌╌╌╌╌╌╌╌╌╌.
     589     .          .
     590   ]
     591   # undo again
     592   assume-console [
     593     press ctrl-z
     594   ]
     595   run [
     596     editor-event-loop screen, console, e
     597   ]
     598   # empty screen
     599   3:num/raw <- get *e, cursor-row:offset
     600   4:num/raw <- get *e, cursor-column:offset
     601   memory-should-contain [
     602     3 <- 1
     603     4 <- 0
     604   ]
     605   screen-should-contain [
     606     .          .
     607     .          .
     608     .╌╌╌╌╌╌╌╌╌╌.
     609     .          .
     610   ]
     611   # redo
     612   assume-console [
     613     press ctrl-y
     614   ]
     615   run [
     616     editor-event-loop screen, console, e
     617   ]
     618   # first line inserted
     619   3:num/raw <- get *e, cursor-row:offset
     620   4:num/raw <- get *e, cursor-column:offset
     621   memory-should-contain [
     622     3 <- 1
     623     4 <- 8
     624   ]
     625   screen-should-contain [
     626     .          .
     627     .  ab  cd  .
     628     .╌╌╌╌╌╌╌╌╌╌.
     629     .          .
     630   ]
     631   # redo again
     632   assume-console [
     633     press ctrl-y
     634   ]
     635   run [
     636     editor-event-loop screen, console, e
     637   ]
     638   # newline and indent inserted
     639   3:num/raw <- get *e, cursor-row:offset
     640   4:num/raw <- get *e, cursor-column:offset
     641   memory-should-contain [
     642     3 <- 2
     643     4 <- 2
     644   ]
     645   screen-should-contain [
     646     .          .
     647     .  ab  cd  .
     648     .          .
     649     .╌╌╌╌╌╌╌╌╌╌.
     650     .          .
     651   ]
     652   # redo again
     653   assume-console [
     654     press ctrl-y
     655   ]
     656   run [
     657     editor-event-loop screen, console, e
     658   ]
     659   # indent and newline deleted
     660   3:num/raw <- get *e, cursor-row:offset
     661   4:num/raw <- get *e, cursor-column:offset
     662   memory-should-contain [
     663     3 <- 2
     664     4 <- 7
     665   ]
     666   screen-should-contain [
     667     .          .
     668     .  ab  cd  .
     669     .    efg   .
     670     .╌╌╌╌╌╌╌╌╌╌.
     671     .          .
     672   ]
     673 ]
     674
     675 # undo cursor movement and scroll
     676
     677 scenario editor-can-undo-touch [
     678   local-scope
     679   # create an editor with some text
     680   assume-screen 10/width, 5/height
     681   contents:text <- new [abc
     682 def
     683 ghi]
     684   e:&:editor <- new-editor contents, 0/left, 10/right
     685   editor-render screen, e
     686   # move the cursor
     687   assume-console [
     688     left-click 3, 1
     689   ]
     690   editor-event-loop screen, console, e
     691   # undo
     692   assume-console [
     693     press ctrl-z
     694   ]
     695   run [
     696     editor-event-loop screen, console, e
     697   ]
     698   # click undone
     699   3:num/raw <- get *e, cursor-row:offset
     700   4:num/raw <- get *e, cursor-column:offset
     701   memory-should-contain [
     702     3 <- 1
     703     4 <- 0
     704   ]
     705   # cursor should be in the right place
     706   assume-console [
     707     type [1]
     708   ]
     709   run [
     710     editor-event-loop screen, console, e
     711   ]
     712   screen-should-contain [
     713     .          .
     714     .1abc      .
     715     .def       .
     716     .ghi       .
     717     .╌╌╌╌╌╌╌╌╌╌.
     718   ]
     719 ]
     720
     721 after <begin-move-cursor> [
     722   cursor-row-before:num <- get *editor, cursor-row:offset
     723   cursor-column-before:num <- get *editor, cursor-column:offset
     724   top-before:&:duplex-list:char <- get *editor, top-of-screen:offset
     725 ]
     726 before <end-move-cursor> [
     727   top-after:&:duplex-list:char <- get *editor, top-of-screen:offset
     728   cursor-row:num <- get *editor, cursor-row:offset
     729   cursor-column:num <- get *editor, cursor-column:offset
     730   {
     731     break-unless undo-coalesce-tag
     732     # if previous operation was also a move, and also had the same coalesce
     733     # tag, coalesce with it
     734     undo:&:list:&:operation <- get *editor, undo:offset
     735     break-unless undo
     736     op:&:operation <- first undo
     737     move:move-operation, is-move?:bool <- maybe-convert *op, move:variant
     738     break-unless is-move?
     739     previous-coalesce-tag:num <- get move, tag:offset
     740     coalesce?:bool <- equal undo-coalesce-tag, previous-coalesce-tag
     741     break-unless coalesce?
     742     move <- put move, after-row:offset, cursor-row
     743     move <- put move, after-column:offset, cursor-column
     744     move <- put move, after-top-of-screen:offset, top-after
     745     *op <- merge 1/move-operation, move
     746     break +done-adding-move-operation
     747   }
     748   op:&:operation <- new operation:type
     749   *op <- merge 1/move-operation, cursor-row-before, cursor-column-before, top-before, cursor-row/after, cursor-column/after, top-after, undo-coalesce-tag
     750   editor <- add-operation editor, op
     751   +done-adding-move-operation
     752 ]
     753
     754 after <handle-undo> [
     755   {
     756     move:move-operation, is-move?:bool <- maybe-convert *op, move:variant
     757     break-unless is-move?
     758     # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen
     759     cursor-row <- get move, before-row:offset
     760     *editor <- put *editor, cursor-row:offset, cursor-row
     761     cursor-column <- get move, before-column:offset
     762     *editor <- put *editor, cursor-column:offset, cursor-column
     763     top:&:duplex-list:char <- get move, before-top-of-screen:offset
     764     *editor <- put *editor, top-of-screen:offset, top
     765   }
     766 ]
     767
     768 scenario editor-can-undo-scroll [
     769   local-scope
     770   # screen has 1 line for menu + 3 lines
     771   assume-screen 5/width, 4/height
     772   # editor contains a wrapped line
     773   contents:text <- new [a
     774 b
     775 cdefgh]
     776   e:&:editor <- new-editor contents, 0/left, 5/right
     777   # position cursor at end of screen and try to move right
     778   assume-console [
     779     left-click 3, 3
     780     press right-arrow
     781   ]
     782   editor-event-loop screen, console, e
     783   3:num/raw <- get *e, cursor-row:offset
     784   4:num/raw <- get *e, cursor-column:offset
     785   # screen scrolls
     786   screen-should-contain [
     787     .     .
     788     .b    .
     789     .cdef↩.
     790     .gh   .
     791   ]
     792   memory-should-contain [
     793     3 <- 3
     794     4 <- 0
     795   ]
     796   # undo
     797   assume-console [
     798     press ctrl-z
     799   ]
     800   run [
     801     editor-event-loop screen, console, e
     802   ]
     803   # cursor moved back
     804   3:num/raw <- get *e, cursor-row:offset
     805   4:num/raw <- get *e, cursor-column:offset
     806   memory-should-contain [
     807     3 <- 3
     808     4 <- 3
     809   ]
     810   # scroll undone
     811   screen-should-contain [
     812     .     .
     813     .a    .
     814     .b    .
     815     .cdef↩.
     816   ]
     817   # cursor should be in the right place
     818   assume-console [
     819     type [1]
     820   ]
     821   run [
     822     editor-event-loop screen, console, e
     823   ]
     824   screen-should-contain [
     825     .     .
     826     .b    .
     827     .cde1↩.
     828     .fgh  .
     829   ]
     830 ]
     831
     832 scenario editor-can-undo-left-arrow [
     833   local-scope
     834   # create an editor with some text
     835   assume-screen 10/width, 5/height
     836   contents:text <- new [abc
     837 def
     838 ghi]
     839   e:&:editor <- new-editor contents, 0/left, 10/right
     840   editor-render screen, e
     841   # move the cursor
     842   assume-console [
     843     left-click 3, 1
     844     press left-arrow
     845   ]
     846   editor-event-loop screen, console, e
     847   # undo
     848   assume-console [
     849     press ctrl-z
     850   ]
     851   run [
     852     editor-event-loop screen, console, e
     853   ]
     854   # cursor moves back
     855   3:num/raw <- get *e, cursor-row:offset
     856   4:num/raw <- get *e, cursor-column:offset
     857   memory-should-contain [
     858     3 <- 3
     859     4 <- 1
     860   ]
     861   # cursor should be in the right place
     862   assume-console [
     863     type [1]
     864   ]
     865   run [
     866     editor-event-loop screen, console, e
     867   ]
     868   screen-should-contain [
     869     .          .
     870     .abc       .
     871     .def       .
     872     .g1hi      .
     873     .╌╌╌╌╌╌╌╌╌╌.
     874   ]
     875 ]
     876
     877 scenario editor-can-undo-up-arrow [
     878   local-scope
     879   # create an editor with some text
     880   assume-screen 10/width, 5/height
     881   contents:text <- new [abc
     882 def
     883 ghi]
     884   e:&:editor <- new-editor contents, 0/left, 10/right
     885   editor-render screen, e
     886   # move the cursor
     887   assume-console [
     888     left-click 3, 1
     889     press up-arrow
     890   ]
     891   editor-event-loop screen, console, e
     892   3:num/raw <- get *e, cursor-row:offset
     893   4:num/raw <- get *e, cursor-column:offset
     894   memory-should-contain [
     895     3 <- 2
     896     4 <- 1
     897   ]
     898   # undo
     899   assume-console [
     900     press ctrl-z
     901   ]
     902   run [
     903     editor-event-loop screen, console, e
     904   ]
     905   # cursor moves back
     906   3:num/raw <- get *e, cursor-row:offset
     907   4:num/raw <- get *e, cursor-column:offset
     908   memory-should-contain [
     909     3 <- 3
     910     4 <- 1
     911   ]
     912   # cursor should be in the right place
     913   assume-console [
     914     type [1]
     915   ]
     916   run [
     917     editor-event-loop screen, console, e
     918   ]
     919   screen-should-contain [
     920     .          .
     921     .abc       .
     922     .def       .
     923     .g1hi      .
     924     .╌╌╌╌╌╌╌╌╌╌.
     925   ]
     926 ]
     927
     928 scenario editor-can-undo-down-arrow [
     929   local-scope
     930   # create an editor with some text
     931   assume-screen 10/width, 5/height
     932   contents:text <- new [abc
     933 def
     934 ghi]
     935   e:&:editor <- new-editor contents, 0/left, 10/right
     936   editor-render screen, e
     937   # move the cursor
     938   assume-console [
     939     left-click 2, 1
     940     press down-arrow
     941   ]
     942   editor-event-loop screen, console, e
     943   # undo
     944   assume-console [
     945     press ctrl-z
     946   ]
     947   run [
     948     editor-event-loop screen, console, e
     949   ]
     950   # cursor moves back
     951   3:num/raw <- get *e, cursor-row:offset
     952   4:num/raw <- get *e, cursor-column:offset
     953   memory-should-contain [
     954     3 <- 2
     955     4 <- 1
     956   ]
     957   # cursor should be in the right place
     958   assume-console [
     959     type [1]
     960   ]
     961   run [
     962     editor-event-loop screen, console, e
     963   ]
     964   screen-should-contain [
     965     .          .
     966     .abc       .
     967     .d1ef      .
     968     .ghi       .
     969     .╌╌╌╌╌╌╌╌╌╌.
     970   ]
     971 ]
     972
     973 scenario editor-can-undo-ctrl-f [
     974   local-scope
     975   # create an editor with multiple pages of text
     976   assume-screen 10/width, 5/height
     977   contents:text <- new [a
     978 b
     979 c
     980 d
     981 e
     982 f]
     983   e:&:editor <- new-editor contents, 0/left, 10/right
     984   editor-render screen, e
     985   # scroll the page
     986   assume-console [
     987     press ctrl-f
     988   ]
     989   editor-event-loop screen, console, e
     990   # undo
     991   assume-console [
     992     press ctrl-z
     993   ]
     994   run [
     995     editor-event-loop screen, console, e
     996   ]
     997   # screen should again show page 1
     998   screen-should-contain [
     999     .          .
    1000     .a         .
    1001     .b         .
    1002     .c         .
    1003     .d         .
    1004   ]
    1005 ]
    1006
    1007 scenario editor-can-undo-page-down [
    1008   local-scope
    1009   # create an editor with multiple pages of text
    1010   assume-screen 10/width, 5/height
    1011   contents:text <- new [a
    1012 b
    1013 c
    1014 d
    1015 e
    1016 f]
    1017   e:&:editor <- new-editor contents, 0/left, 10/right
    1018   editor-render screen, e
    1019   # scroll the page
    1020   assume-console [
    1021     press page-down
    1022   ]
    1023   editor-event-loop screen, console, e
    1024   # undo
    1025   assume-console [
    1026     press ctrl-z
    1027   ]
    1028   run [
    1029     editor-event-loop screen, console, e
    1030   ]
    1031   # screen should again show page 1
    1032   screen-should-contain [
    1033     .          .
    1034     .a         .
    1035     .b         .
    1036     .c         .
    1037     .d         .
    1038   ]
    1039 ]
    1040
    1041 scenario editor-can-undo-ctrl-b [
    1042   local-scope
    1043   # create an editor with multiple pages of text
    1044   assume-screen 10/width, 5/height
    1045   contents:text <- new [a
    1046 b
    1047 c
    1048 d
    1049 e
    1050 f]
    1051   e:&:editor <- new-editor contents, 0/left, 10/right
    1052   editor-render screen, e
    1053   # scroll the page down and up
    1054   assume-console [
    1055     press page-down
    1056     press ctrl-b
    1057   ]
    1058   editor-event-loop screen, console, e
    1059   # undo
    1060   assume-console [
    1061     press ctrl-z
    1062   ]
    1063   run [
    1064     editor-event-loop screen, console, e
    1065   ]
    1066   # screen should again show page 2
    1067   screen-should-contain [
    1068     .          .
    1069     .d         .
    1070     .e         .
    1071     .f         .
    1072     .╌╌╌╌╌╌╌╌╌╌.
    1073   ]
    1074 ]
    1075
    1076 scenario editor-can-undo-page-up [
    1077   local-scope
    1078   # create an editor with multiple pages of text
    1079   assume-screen 10/width, 5/height
    1080   contents:text <- new [a
    1081 b
    1082 c
    1083 d
    1084 e
    1085 f]
    1086   e:&:editor <- new-editor contents, 0/left, 10/right
    1087   editor-render screen, e
    1088   # scroll the page down and up
    1089   assume-console [
    1090     press page-down
    1091     press page-up
    1092   ]
    1093   editor-event-loop screen, console, e
    1094   # undo
    1095   assume-console [
    1096     press ctrl-z
    1097   ]
    1098   run [
    1099     editor-event-loop screen, console, e
    1100   ]
    1101   # screen should again show page 2
    1102   screen-should-contain [
    1103     .          .
    1104     .d         .
    1105     .e         .
    1106     .f         .
    1107     .╌╌╌╌╌╌╌╌╌╌.
    1108   ]
    1109 ]
    1110
    1111 scenario editor-can-undo-ctrl-a [
    1112   local-scope
    1113   # create an editor with some text
    1114   assume-screen 10/width, 5/height
    1115   contents:text <- new [abc
    1116 def
    1117 ghi]
    1118   e:&:editor <- new-editor contents, 0/left, 10/right
    1119   editor-render screen, e
    1120   # move the cursor, then to start of line
    1121   assume-console [
    1122     left-click 2, 1
    1123     press ctrl-a
    1124   ]
    1125   editor-event-loop screen, console, e
    1126   # undo
    1127   assume-console [
    1128     press ctrl-z
    1129   ]
    1130   run [
    1131     editor-event-loop screen, console, e
    1132   ]
    1133   # cursor moves back
    1134   3:num/raw <- get *e, cursor-row:offset
    1135   4:num/raw <- get *e, cursor-column:offset
    1136   memory-should-contain [
    1137     3 <- 2
    1138     4 <- 1
    1139   ]
    1140   # cursor should be in the right place
    1141   assume-console [
    1142     type [1]
    1143   ]
    1144   run [
    1145     editor-event-loop screen, console, e
    1146   ]
    1147   screen-should-contain [
    1148     .          .
    1149     .abc       .
    1150     .d1ef      .
    1151     .ghi       .
    1152     .╌╌╌╌╌╌╌╌╌╌.
    1153   ]
    1154 ]
    1155
    1156 scenario editor-can-undo-home [
    1157   local-scope
    1158   # create an editor with some text
    1159   assume-screen 10/width, 5/height
    1160   contents:text <- new [abc
    1161 def
    1162 ghi]
    1163   e:&:editor <- new-editor contents, 0/left, 10/right
    1164   editor-render screen, e
    1165   # move the cursor, then to start of line
    1166   assume-console [
    1167     left-click 2, 1
    1168     press home
    1169   ]
    1170   editor-event-loop screen, console, e
    1171   # undo
    1172   assume-console [
    1173     press ctrl-z
    1174   ]
    1175   run [
    1176     editor-event-loop screen, console, e
    1177   ]
    1178   # cursor moves back
    1179   3:num/raw <- get *e, cursor-row:offset
    1180   4:num/raw <- get *e, cursor-column:offset
    1181   memory-should-contain [
    1182     3 <- 2
    1183     4 <- 1
    1184   ]
    1185   # cursor should be in the right place
    1186   assume-console [
    1187     type [1]
    1188   ]
    1189   run [
    1190     editor-event-loop screen, console, e
    1191   ]
    1192   screen-should-contain [
    1193     .          .
    1194     .abc       .
    1195     .d1ef      .
    1196     .ghi       .
    1197     .╌╌╌╌╌╌╌╌╌╌.
    1198   ]
    1199 ]
    1200
    1201 scenario editor-can-undo-ctrl-e [
    1202   local-scope
    1203   # create an editor with some text
    1204   assume-screen 10/width, 5/height
    1205   contents:text <- new [abc
    1206 def
    1207 ghi]
    1208   e:&:editor <- new-editor contents, 0/left, 10/right
    1209   editor-render screen, e
    1210   # move the cursor, then to start of line
    1211   assume-console [
    1212     left-click 2, 1
    1213     press ctrl-e
    1214   ]
    1215   editor-event-loop screen, console, e
    1216   # undo
    1217   assume-console [
    1218     press ctrl-z
    1219   ]
    1220   run [
    1221     editor-event-loop screen, console, e
    1222   ]
    1223   # cursor moves back
    1224   3:num/raw <- get *e, cursor-row:offset
    1225   4:num/raw <- get *e, cursor-column:offset
    1226   memory-should-contain [
    1227     3 <- 2
    1228     4 <- 1
    1229   ]
    1230   # cursor should be in the right place
    1231   assume-console [
    1232     type [1]
    1233   ]
    1234   run [
    1235     editor-event-loop screen, console, e
    1236   ]
    1237   screen-should-contain [
    1238     .          .
    1239     .abc       .
    1240     .d1ef      .
    1241     .ghi       .
    1242     .╌╌╌╌╌╌╌╌╌╌.
    1243   ]
    1244 ]
    1245
    1246 scenario editor-can-undo-end [
    1247   local-scope
    1248   # create an editor with some text
    1249   assume-screen 10/width, 5/height
    1250   contents:text <- new [abc
    1251 def
    1252 ghi]
    1253   e:&:editor <- new-editor contents, 0/left, 10/right
    1254   editor-render screen, e
    1255   # move the cursor, then to start of line
    1256   assume-console [
    1257     left-click 2, 1
    1258     press end
    1259   ]
    1260   editor-event-loop screen, console, e
    1261   # undo
    1262   assume-console [
    1263     press ctrl-z
    1264   ]
    1265   run [
    1266     editor-event-loop screen, console, e
    1267   ]
    1268   # cursor moves back
    1269   3:num/raw <- get *e, cursor-row:offset
    1270   4:num/raw <- get *e, cursor-column:offset
    1271   memory-should-contain [
    1272     3 <- 2
    1273     4 <- 1
    1274   ]
    1275   # cursor should be in the right place
    1276   assume-console [
    1277     type [1]
    1278   ]
    1279   run [
    1280     editor-event-loop screen, console, e
    1281   ]
    1282   screen-should-contain [
    1283     .          .
    1284     .abc       .
    1285     .d1ef      .
    1286     .ghi       .
    1287     .╌╌╌╌╌╌╌╌╌╌.
    1288   ]
    1289 ]
    1290
    1291 scenario editor-can-undo-multiple-arrows-in-the-same-direction [
    1292   local-scope
    1293   # create an editor with some text
    1294   assume-screen 10/width, 5/height
    1295   contents:text <- new [abc
    1296 def
    1297 ghi]
    1298   e:&:editor <- new-editor contents, 0/left, 10/right
    1299   editor-render screen, e
    1300   # move the cursor
    1301   assume-console [
    1302     left-click 2, 1
    1303     press right-arrow
    1304     press right-arrow
    1305     press up-arrow
    1306   ]
    1307   editor-event-loop screen, console, e
    1308   3:num/raw <- get *e, cursor-row:offset
    1309   4:num/raw <- get *e, cursor-column:offset
    1310   memory-should-contain [
    1311     3 <- 1
    1312     4 <- 3
    1313   ]
    1314   # undo
    1315   assume-console [
    1316     press ctrl-z
    1317   ]
    1318   run [
    1319     editor-event-loop screen, console, e
    1320   ]
    1321   # up-arrow is undone
    1322   3:num/raw <- get *e, cursor-row:offset
    1323   4:num/raw <- get *e, cursor-column:offset
    1324   memory-should-contain [
    1325     3 <- 2
    1326     4 <- 3
    1327   ]
    1328   # undo again
    1329   assume-console [
    1330     press ctrl-z
    1331   ]
    1332   run [
    1333     editor-event-loop screen, console, e
    1334   ]
    1335   # both right-arrows are undone
    1336   3:num/raw <- get *e, cursor-row:offset
    1337   4:num/raw <- get *e, cursor-column:offset
    1338   memory-should-contain [
    1339     3 <- 2
    1340     4 <- 1
    1341   ]
    1342 ]
    1343
    1344 # redo cursor movement and scroll
    1345
    1346 scenario editor-redo-touch [
    1347   local-scope
    1348   # create an editor with some text, click on a character, undo
    1349   assume-screen 10/width, 5/height
    1350   contents:text <- new [abc
    1351 def
    1352 ghi]
    1353   e:&:editor <- new-editor contents, 0/left, 10/right
    1354   editor-render screen, e
    1355   assume-console [
    1356     left-click 3, 1
    1357     press ctrl-z
    1358   ]
    1359   editor-event-loop screen, console, e
    1360   # redo
    1361   assume-console [
    1362     press ctrl-y
    1363   ]
    1364   run [
    1365     editor-event-loop screen, console, e
    1366   ]
    1367   # cursor moves to left-click
    1368   3:num/raw <- get *e, cursor-row:offset
    1369   4:num/raw <- get *e, cursor-column:offset
    1370   memory-should-contain [
    1371     3 <- 3
    1372     4 <- 1
    1373   ]
    1374   # cursor should be in the right place
    1375   assume-console [
    1376     type [1]
    1377   ]
    1378   run [
    1379     editor-event-loop screen, console, e
    1380   ]
    1381   screen-should-contain [
    1382     .          .
    1383     .abc       .
    1384     .def       .
    1385     .g1hi      .
    1386     .╌╌╌╌╌╌╌╌╌╌.
    1387   ]
    1388 ]
    1389
    1390 after <handle-redo> [
    1391   {
    1392     move:move-operation, is-move?:bool <- maybe-convert *op, move:variant
    1393     break-unless is-move?
    1394     # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen
    1395     cursor-row <- get move, after-row:offset
    1396     *editor <- put *editor, cursor-row:offset, cursor-row
    1397     cursor-column <- get move, after-column:offset
    1398     *editor <- put *editor, cursor-column:offset, cursor-column
    1399     top:&:duplex-list:char <- get move, after-top-of-screen:offset
    1400     *editor <- put *editor, top-of-screen:offset, top
    1401   }
    1402 ]
    1403
    1404 scenario editor-separates-undo-insert-from-undo-cursor-move [
    1405   local-scope
    1406   # create an editor, type some text, move the cursor, type some more text
    1407   assume-screen 10/width, 5/height
    1408   e:&:editor <- new-editor [], 0/left, 10/right
    1409   editor-render screen, e
    1410   assume-console [
    1411     type [abc]
    1412     left-click 1, 1
    1413     type [d]
    1414   ]
    1415   editor-event-loop screen, console, e
    1416   3:num/raw <- get *e, cursor-row:offset
    1417   4:num/raw <- get *e, cursor-column:offset
    1418   screen-should-contain [
    1419     .          .
    1420     .adbc      .
    1421     .╌╌╌╌╌╌╌╌╌╌.
    1422     .          .
    1423   ]
    1424   memory-should-contain [
    1425     3 <- 1
    1426     4 <- 2
    1427   ]
    1428   # undo
    1429   assume-console [
    1430     press ctrl-z
    1431   ]
    1432   run [
    1433     editor-event-loop screen, console, e
    1434     3:num/raw <- get *e, cursor-row:offset
    1435     4:num/raw <- get *e, cursor-column:offset
    1436   ]
    1437   # last letter typed is deleted
    1438   screen-should-contain [
    1439     .          .
    1440     .abc       .
    1441     .╌╌╌╌╌╌╌╌╌╌.
    1442     .          .
    1443   ]
    1444   memory-should-contain [
    1445     3 <- 1
    1446     4 <- 1
    1447   ]
    1448   # undo again
    1449   assume-console [
    1450     press ctrl-z
    1451   ]
    1452   run [
    1453     editor-event-loop screen, console, e
    1454     3:num/raw <- get *e, cursor-row:offset
    1455     4:num/raw <- get *e, cursor-column:offset
    1456   ]
    1457   # no change to screen; cursor moves
    1458   screen-should-contain [
    1459     .          .
    1460     .abc       .
    1461     .╌╌╌╌╌╌╌╌╌╌.
    1462     .          .
    1463   ]
    1464   memory-should-contain [
    1465     3 <- 1
    1466     4 <- 3
    1467   ]
    1468   # undo again
    1469   assume-console [
    1470     press ctrl-z
    1471   ]
    1472   run [
    1473     editor-event-loop screen, console, e
    1474     3:num/raw <- get *e, cursor-row:offset
    1475     4:num/raw <- get *e, cursor-column:offset
    1476   ]
    1477   # screen empty
    1478   screen-should-contain [
    1479     .          .
    1480     .          .
    1481     .╌╌╌╌╌╌╌╌╌╌.
    1482     .          .
    1483   ]
    1484   memory-should-contain [
    1485     3 <- 1
    1486     4 <- 0
    1487   ]
    1488   # redo
    1489   assume-console [
    1490     press ctrl-y
    1491   ]
    1492   run [
    1493     editor-event-loop screen, console, e
    1494     3:num/raw <- get *e, cursor-row:offset
    1495     4:num/raw <- get *e, cursor-column:offset
    1496   ]
    1497   # first insert
    1498   screen-should-contain [
    1499     .          .
    1500     .abc       .
    1501     .╌╌╌╌╌╌╌╌╌╌.
    1502     .          .
    1503   ]
    1504   memory-should-contain [
    1505     3 <- 1
    1506     4 <- 3
    1507   ]
    1508   # redo again
    1509   assume-console [
    1510     press ctrl-y
    1511   ]
    1512   run [
    1513     editor-event-loop screen, console, e
    1514     3:num/raw <- get *e, cursor-row:offset
    1515     4:num/raw <- get *e, cursor-column:offset
    1516   ]
    1517   # cursor moves
    1518   screen-should-contain [
    1519     .          .
    1520     .abc       .
    1521     .╌╌╌╌╌╌╌╌╌╌.
    1522     .          .
    1523   ]
    1524   # cursor moves
    1525   memory-should-contain [
    1526     3 <- 1
    1527     4 <- 1
    1528   ]
    1529   # redo again
    1530   assume-console [
    1531     press ctrl-y
    1532   ]
    1533   run [
    1534     editor-event-loop screen, console, e
    1535     3:num/raw <- get *e, cursor-row:offset
    1536     4:num/raw <- get *e, cursor-column:offset
    1537   ]
    1538   # second insert
    1539   screen-should-contain [
    1540     .          .
    1541     .adbc      .
    1542     .╌╌╌╌╌╌╌╌╌╌.
    1543     .          .
    1544   ]
    1545   memory-should-contain [
    1546     3 <- 1
    1547     4 <- 2
    1548   ]
    1549 ]
    1550
    1551 # undo backspace
    1552
    1553 scenario editor-can-undo-and-redo-backspace [
    1554   local-scope
    1555   # create an editor
    1556   assume-screen 10/width, 5/height
    1557   e:&:editor <- new-editor [], 0/left, 10/right
    1558   editor-render screen, e
    1559   # insert some text and hit backspace
    1560   assume-console [
    1561     type [abc]
    1562     press backspace
    1563     press backspace
    1564   ]
    1565   editor-event-loop screen, console, e
    1566   screen-should-contain [
    1567     .          .
    1568     .a         .
    1569     .╌╌╌╌╌╌╌╌╌╌.
    1570     .          .
    1571   ]
    1572   3:num/raw <- get *e, cursor-row:offset
    1573   4:num/raw <- get *e, cursor-column:offset
    1574   memory-should-contain [
    1575     3 <- 1
    1576     4 <- 1
    1577   ]
    1578   # undo
    1579   assume-console [
    1580     press ctrl-z
    1581   ]
    1582   run [
    1583     editor-event-loop screen, console, e
    1584   ]
    1585   3:num/raw <- get *e, cursor-row:offset
    1586   4:num/raw <- get *e, cursor-column:offset
    1587   memory-should-contain [
    1588     3 <- 1
    1589     4 <- 3
    1590   ]
    1591   screen-should-contain [
    1592     .          .
    1593     .abc       .
    1594     .╌╌╌╌╌╌╌╌╌╌.
    1595     .          .
    1596   ]
    1597   # redo
    1598   assume-console [
    1599     press ctrl-y
    1600   ]
    1601   run [
    1602     editor-event-loop screen, console, e
    1603   ]
    1604   3:num/raw <- get *e, cursor-row:offset
    1605   4:num/raw <- get *e, cursor-column:offset
    1606   memory-should-contain [
    1607     3 <- 1
    1608     4 <- 1
    1609   ]
    1610   screen-should-contain [
    1611     .          .
    1612     .a         .
    1613     .╌╌╌╌╌╌╌╌╌╌.
    1614     .          .
    1615   ]
    1616 ]
    1617
    1618 # save operation to undo
    1619 after <begin-backspace-character> [
    1620   top-before:&:duplex-list:char <- get *editor, top-of-screen:offset
    1621 ]
    1622 before <end-backspace-character> [
    1623   {
    1624     break-unless backspaced-cell  # backspace failed; don't add an undo operation
    1625     top-after:&:duplex-list:char <- get *editor, top-of-screen:offset
    1626     cursor-row:num <- get *editor, cursor-row:offset
    1627     cursor-column:num <- get *editor, cursor-row:offset
    1628     before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
    1629     undo:&:list:&:operation <- get *editor, undo:offset
    1630     {
    1631       # if previous operation was an insert, coalesce this operation with it
    1632       break-unless undo
    1633       op:&:operation <- first undo
    1634       deletion:delete-operation, is-delete?:bool <- maybe-convert *op, delete:variant
    1635       break-unless is-delete?
    1636       previous-coalesce-tag:num <- get deletion, tag:offset
    1637       coalesce?:bool <- equal previous-coalesce-tag, 1/coalesce-backspace
    1638       break-unless coalesce?
    1639       deletion <- put deletion, delete-from:offset, before-cursor
    1640       backspaced-so-far:&:duplex-list:char <- get deletion, deleted-text:offset
    1641       splice backspaced-cell, backspaced-so-far
    1642       deletion <- put deletion, deleted-text:offset, backspaced-cell
    1643       deletion <- put deletion, after-row:offset, cursor-row
    1644       deletion <- put deletion, after-column:offset, cursor-column
    1645       deletion <- put deletion, after-top-of-screen:offset, top-after
    1646       *op <- merge 2/delete-operation, deletion
    1647       break +done-adding-backspace-operation
    1648     }
    1649     # if not, create a new operation
    1650     op:&:operation <- new operation:type
    1651     deleted-until:&:duplex-list:char <- next before-cursor
    1652     *op <- merge 2/delete-operation, save-row/before, save-column/before, top-before, cursor-row/after, cursor-column/after, top-after, backspaced-cell/deleted, before-cursor/delete-from, deleted-until, 1/coalesce-backspace
    1653     editor <- add-operation editor, op
    1654     +done-adding-backspace-operation
    1655   }
    1656 ]
    1657
    1658 after <handle-undo> [
    1659   {
    1660     deletion:delete-operation, is-delete?:bool <- maybe-convert *op, delete:variant
    1661     break-unless is-delete?
    1662     anchor:&:duplex-list:char <- get deletion, delete-from:offset
    1663     break-unless anchor
    1664     deleted:&:duplex-list:char <- get deletion, deleted-text:offset
    1665     old-cursor:&:duplex-list:char <- last deleted
    1666     splice anchor, deleted
    1667     # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen
    1668     before-cursor <- copy old-cursor
    1669     cursor-row <- get deletion, before-row:offset
    1670     *editor <- put *editor, cursor-row:offset, cursor-row
    1671     cursor-column <- get deletion, before-column:offset
    1672     *editor <- put *editor, cursor-column:offset, cursor-column
    1673     top:&:duplex-list:char <- get deletion, before-top-of-screen:offset
    1674     *editor <- put *editor, top-of-screen:offset, top
    1675   }
    1676 ]
    1677
    1678 after <handle-redo> [
    1679   {
    1680     deletion:delete-operation, is-delete?:bool <- maybe-convert *op, delete:variant
    1681     break-unless is-delete?
    1682     start:&:duplex-list:char <- get deletion, delete-from:offset
    1683     end:&:duplex-list:char <- get deletion, delete-until:offset
    1684     data:&:duplex-list:char <- get *editor, data:offset
    1685     remove-between start, end
    1686     # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen
    1687     cursor-row <- get deletion, after-row:offset
    1688     *editor <- put *editor, cursor-row:offset, cursor-row
    1689     cursor-column <- get deletion, after-column:offset
    1690     *editor <- put *editor, cursor-column:offset, cursor-column
    1691     top:&:duplex-list:char <- get deletion, before-top-of-screen:offset
    1692     *editor <- put *editor, top-of-screen:offset, top
    1693   }
    1694 ]
    1695
    1696 # undo delete
    1697
    1698 scenario editor-can-undo-and-redo-delete [
    1699   local-scope
    1700   # create an editor
    1701   assume-screen 10/width, 5/height
    1702   e:&:editor <- new-editor [], 0/left, 10/right
    1703   editor-render screen, e
    1704   # insert some text and hit delete and backspace a few times
    1705   assume-console [
    1706     type [abcdef]
    1707     left-click 1, 2
    1708     press delete
    1709     press backspace
    1710     press delete
    1711     press delete
    1712   ]
    1713   editor-event-loop screen, console, e
    1714   screen-should-contain [
    1715     .          .
    1716     .af        .
    1717     .╌╌╌╌╌╌╌╌╌╌.
    1718     .          .
    1719   ]
    1720   3:num/raw <- get *e, cursor-row:offset
    1721   4:num/raw <- get *e, cursor-column:offset
    1722   memory-should-contain [
    1723     3 <- 1
    1724     4 <- 1
    1725   ]
    1726   # undo deletes
    1727   assume-console [
    1728     press ctrl-z
    1729   ]
    1730   run [
    1731     editor-event-loop screen, console, e
    1732   ]
    1733   3:num/raw <- get *e, cursor-row:offset
    1734   4:num/raw <- get *e, cursor-column:offset
    1735   memory-should-contain [
    1736     3 <- 1
    1737     4 <- 1
    1738   ]
    1739   screen-should-contain [
    1740     .          .
    1741     .adef      .
    1742     .╌╌╌╌╌╌╌╌╌╌.
    1743     .          .
    1744   ]
    1745   # undo backspace
    1746   assume-console [
    1747     press ctrl-z
    1748   ]
    1749   run [
    1750     editor-event-loop screen, console, e
    1751   ]
    1752   3:num/raw <- get *e, cursor-row:offset
    1753   4:num/raw <- get *e, cursor-column:offset
    1754   memory-should-contain [
    1755     3 <- 1
    1756     4 <- 2
    1757   ]
    1758   screen-should-contain [
    1759     .          .
    1760     .abdef     .
    1761     .╌╌╌╌╌╌╌╌╌╌.
    1762     .          .
    1763   ]
    1764   # undo first delete
    1765   assume-console [
    1766     press ctrl-z
    1767   ]
    1768   run [
    1769     editor-event-loop screen, console, e
    1770   ]
    1771   3:num/raw <- get *e, cursor-row:offset
    1772   4:num/raw <- get *e, cursor-column:offset
    1773   memory-should-contain [
    1774     3 <- 1
    1775     4 <- 2
    1776   ]
    1777   screen-should-contain [
    1778     .          .
    1779     .abcdef    .
    1780     .╌╌╌╌╌╌╌╌╌╌.
    1781     .          .
    1782   ]
    1783   # redo first delete
    1784   assume-console [
    1785     press ctrl-y
    1786   ]
    1787   run [
    1788     editor-event-loop screen, console, e
    1789   ]
    1790   # first line inserted
    1791   3:num/raw <- get *e, cursor-row:offset
    1792   4:num/raw <- get *e, cursor-column:offset
    1793   memory-should-contain [
    1794     3 <- 1
    1795     4 <- 2
    1796   ]
    1797   screen-should-contain [
    1798     .          .
    1799     .abdef     .
    1800     .╌╌╌╌╌╌╌╌╌╌.
    1801     .          .
    1802   ]
    1803   # redo backspace
    1804   assume-console [
    1805     press ctrl-y
    1806   ]
    1807   run [
    1808     editor-event-loop screen, console, e
    1809   ]
    1810   # first line inserted
    1811   3:num/raw <- get *e, cursor-row:offset
    1812   4:num/raw <- get *e, cursor-column:offset
    1813   memory-should-contain [
    1814     3 <- 1
    1815     4 <- 1
    1816   ]
    1817   screen-should-contain [
    1818     .          .
    1819     .adef      .
    1820     .╌╌╌╌╌╌╌╌╌╌.
    1821     .          .
    1822   ]
    1823   # redo deletes
    1824   assume-console [
    1825     press ctrl-y
    1826   ]
    1827   run [
    1828     editor-event-loop screen, console, e
    1829   ]
    1830   # first line inserted
    1831   3:num/raw <- get *e, cursor-row:offset
    1832   4:num/raw <- get *e, cursor-column:offset
    1833   memory-should-contain [
    1834     3 <- 1
    1835     4 <- 1
    1836   ]
    1837   screen-should-contain [
    1838     .          .
    1839     .af        .
    1840     .╌╌╌╌╌╌╌╌╌╌.
    1841     .          .
    1842   ]
    1843 ]
    1844
    1845 after <begin-delete-character> [
    1846   top-before:&:duplex-list:char <- get *editor, top-of-screen:offset
    1847 ]
    1848 before <end-delete-character> [
    1849   {
    1850     break-unless deleted-cell  # delete failed; don't add an undo operation
    1851     top-after:&:duplex-list:char <- get *editor, top-of-screen:offset
    1852     cursor-row:num <- get *editor, cursor-row:offset
    1853     cursor-column:num <- get *editor, cursor-column:offset
    1854     before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
    1855     undo:&:list:&:operation <- get *editor, undo:offset
    1856     {
    1857       # if previous operation was an insert, coalesce this operation with it
    1858       break-unless undo
    1859       op:&:operation <- first undo
    1860       deletion:delete-operation, is-delete?:bool <- maybe-convert *op, delete:variant
    1861       break-unless is-delete?
    1862       previous-coalesce-tag:num <- get deletion, tag:offset
    1863       coalesce?:bool <- equal previous-coalesce-tag, 2/coalesce-delete
    1864       break-unless coalesce?
    1865       delete-until:&:duplex-list:char <- next before-cursor
    1866       deletion <- put deletion, delete-until:offset, delete-until
    1867       deleted-so-far:&:duplex-list:char <- get deletion, deleted-text:offset
    1868       deleted-so-far <- append deleted-so-far, deleted-cell
    1869       deletion <- put deletion, deleted-text:offset, deleted-so-far
    1870       deletion <- put deletion, after-row:offset, cursor-row
    1871       deletion <- put deletion, after-column:offset, cursor-column
    1872       deletion <- put deletion, after-top-of-screen:offset, top-after
    1873       *op <- merge 2/delete-operation, deletion
    1874       break +done-adding-delete-operation
    1875     }
    1876     # if not, create a new operation
    1877     op:&:operation <- new operation:type
    1878     deleted-until:&:duplex-list:char <- next before-cursor
    1879     *op <- merge 2/delete-operation, save-row/before, save-column/before, top-before, cursor-row/after, cursor-column/after, top-after, deleted-cell/deleted, before-cursor/delete-from, deleted-until, 2/coalesce-delete
    1880     editor <- add-operation editor, op
    1881     +done-adding-delete-operation
    1882   }
    1883 ]
    1884
    1885 # undo ctrl-k
    1886
    1887 scenario editor-can-undo-and-redo-ctrl-k [
    1888   local-scope
    1889   # create an editor
    1890   assume-screen 10/width, 5/height
    1891   contents:text <- new [abc
    1892 def]
    1893   e:&:editor <- new-editor contents, 0/left, 10/right
    1894   editor-render screen, e
    1895   # insert some text and hit delete and backspace a few times
    1896   assume-console [
    1897     left-click 1, 1
    1898     press ctrl-k
    1899   ]
    1900   editor-event-loop screen, console, e
    1901   screen-should-contain [
    1902     .          .
    1903     .a         .
    1904     .def       .
    1905     .╌╌╌╌╌╌╌╌╌╌.
    1906     .          .
    1907   ]
    1908   3:num/raw <- get *e, cursor-row:offset
    1909   4:num/raw <- get *e, cursor-column:offset
    1910   memory-should-contain [
    1911     3 <- 1
    1912     4 <- 1
    1913   ]
    1914   # undo
    1915   assume-console [
    1916     press ctrl-z
    1917   ]
    1918   run [
    1919     editor-event-loop screen, console, e
    1920   ]
    1921   screen-should-contain [
    1922     .          .
    1923     .abc       .
    1924     .def       .
    1925     .╌╌╌╌╌╌╌╌╌╌.
    1926     .          .
    1927   ]
    1928   3:num/raw <- get *e, cursor-row:offset
    1929   4:num/raw <- get *e, cursor-column:offset
    1930   memory-should-contain [
    1931     3 <- 1
    1932     4 <- 1
    1933   ]
    1934   # redo
    1935   assume-console [
    1936     press ctrl-y
    1937   ]
    1938   run [
    1939     editor-event-loop screen, console, e
    1940   ]
    1941   # first line inserted
    1942   screen-should-contain [
    1943     .          .
    1944     .a         .
    1945     .def       .
    1946     .╌╌╌╌╌╌╌╌╌╌.
    1947     .          .
    1948   ]
    1949   3:num/raw <- get *e, cursor-row:offset
    1950   4:num/raw <- get *e, cursor-column:offset
    1951   memory-should-contain [
    1952     3 <- 1
    1953     4 <- 1
    1954   ]
    1955   # cursor should be in the right place
    1956   assume-console [
    1957     type [1]
    1958   ]
    1959   run [
    1960     editor-event-loop screen, console, e
    1961   ]
    1962   screen-should-contain [
    1963     .          .
    1964     .a1        .
    1965     .def       .
    1966     .╌╌╌╌╌╌╌╌╌╌.
    1967     .          .
    1968   ]
    1969 ]
    1970
    1971 after <begin-delete-to-end-of-line> [
    1972   top-before:&:duplex-list:char <- get *editor, top-of-screen:offset
    1973 ]
    1974 before <end-delete-to-end-of-line> [
    1975   {
    1976     break-unless deleted-cells  # delete failed; don't add an undo operation
    1977     top-after:&:duplex-list:char <- get *editor, top-of-screen:offset
    1978     cursor-row:num <- get *editor, cursor-row:offset
    1979     cursor-column:num <- get *editor, cursor-column:offset
    1980     deleted-until:&:duplex-list:char <- next before-cursor
    1981     op:&:operation <- new operation:type
    1982     *op <- merge 2/delete-operation, save-row/before, save-column/before, top-before, cursor-row/after, cursor-column/after, top-after, deleted-cells/deleted, before-cursor/delete-from, deleted-until, 0/never-coalesce
    1983     editor <- add-operation editor, op
    1984     +done-adding-delete-operation
    1985   }
    1986 ]
    1987
    1988 # undo ctrl-u
    1989
    1990 scenario editor-can-undo-and-redo-ctrl-u [
    1991   local-scope
    1992   # create an editor
    1993   assume-screen 10/width, 5/height
    1994   contents:text <- new [abc
    1995 def]
    1996   e:&:editor <- new-editor contents, 0/left, 10/right
    1997   editor-render screen, e
    1998   # insert some text and hit delete and backspace a few times
    1999   assume-console [
    2000     left-click 1, 2
    2001     press ctrl-u
    2002   ]
    2003   editor-event-loop screen, console, e
    2004   screen-should-contain [
    2005     .          .
    2006     .c         .
    2007     .def       .
    2008     .╌╌╌╌╌╌╌╌╌╌.
    2009     .          .
    2010   ]
    2011   3:num/raw <- get *e, cursor-row:offset
    2012   4:num/raw <- get *e, cursor-column:offset
    2013   memory-should-contain [
    2014     3 <- 1
    2015     4 <- 0
    2016   ]
    2017   # undo
    2018   assume-console [
    2019     press ctrl-z
    2020   ]
    2021   run [
    2022     editor-event-loop screen, console, e
    2023   ]
    2024   screen-should-contain [
    2025     .          .
    2026     .abc       .
    2027     .def       .
    2028     .╌╌╌╌╌╌╌╌╌╌.
    2029     .          .
    2030   ]
    2031   3:num/raw <- get *e, cursor-row:offset
    2032   4:num/raw <- get *e, cursor-column:offset
    2033   memory-should-contain [
    2034     3 <- 1
    2035     4 <- 2
    2036   ]
    2037   # redo
    2038   assume-console [
    2039     press ctrl-y
    2040   ]
    2041   run [
    2042     editor-event-loop screen, console, e
    2043   ]
    2044   # first line inserted
    2045   screen-should-contain [
    2046     .          .
    2047     .c         .
    2048     .def       .
    2049     .╌╌╌╌╌╌╌╌╌╌.
    2050     .          .
    2051   ]
    2052   3:num/raw <- get *e, cursor-row:offset
    2053   4:num/raw <- get *e, cursor-column:offset
    2054   memory-should-contain [
    2055     3 <- 1
    2056     4 <- 0
    2057   ]
    2058   # cursor should be in the right place
    2059   assume-console [
    2060     type [1]
    2061   ]
    2062   run [
    2063     editor-event-loop screen, console, e
    2064   ]
    2065   screen-should-contain [
    2066     .          .
    2067     .1c        .
    2068     .def       .
    2069     .╌╌╌╌╌╌╌╌╌╌.
    2070     .          .
    2071   ]
    2072 ]
    2073
    2074 after <begin-delete-to-start-of-line> [
    2075   top-before:&:duplex-list:char <- get *editor, top-of-screen:offset
    2076 ]
    2077 before <end-delete-to-start-of-line> [
    2078   {
    2079     break-unless deleted-cells  # delete failed; don't add an undo operation
    2080     top-after:&:duplex-list:char <- get *editor, top-of-screen:offset
    2081     op:&:operation <- new operation:type
    2082     before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
    2083     deleted-until:&:duplex-list:char <- next before-cursor
    2084     cursor-row:num <- get *editor, cursor-row:offset
    2085     cursor-column:num <- get *editor, cursor-column:offset
    2086     *op <- merge 2/delete-operation, save-row/before, save-column/before, top-before, cursor-row/after, cursor-column/after, top-after, deleted-cells/deleted, before-cursor/delete-from, deleted-until, 0/never-coalesce
    2087     editor <- add-operation editor, op
    2088     +done-adding-delete-operation
    2089   }
    2090 ]
    2091
    2092 scenario editor-can-undo-and-redo-ctrl-u-2 [
    2093   local-scope
    2094   # create an editor
    2095   assume-screen 10/width, 5/height
    2096   e:&:editor <- new-editor [], 0/left, 10/right
    2097   editor-render screen, e
    2098   # insert some text and hit delete and backspace a few times
    2099   assume-console [
    2100     type [abc]
    2101     press ctrl-u
    2102     press ctrl-z
    2103   ]
    2104   editor-event-loop screen, console, e
    2105   screen-should-contain [
    2106     .          .
    2107     .abc       .
    2108     .╌╌╌╌╌╌╌╌╌╌.
    2109     .          .
    2110   ]
    2111 ]