path: root/archive/1.vm/edit/003-shortcuts.mu

## special shortcuts for manipulating the editor
# Some keys on the keyboard generate unicode characters, others generate
# terminfo key codes. We need to modify different places in the two cases.

# tab - insert two spaces

scenario editor-inserts-two-spaces-on-tab [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [ab
cd]
  e:&:editor <- new-editor s, 0/left, 5/right
  editor-render screen, e
  $clear-trace
  assume-console [
    press tab
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .  ab      .
    .cd        .
  ]
  # we render at most two editor rows worth (one row for each space)
  check-trace-count-for-label-lesser-than 10, [print-character]
]

scenario editor-inserts-two-spaces-and-wraps-line-on-tab [
  local-scope
  assume-screen 10/width, 5/height
  e:&:editor <- new-editor [abcd], 0/left, 5/right
  editor-render screen, e
  $clear-trace
  assume-console [
    press tab
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .  ab↩     .
    .cd        .
  ]
  # we re-render the whole editor
  check-trace-count-for-label-greater-than 10, [print-character]
]

after <handle-special-character> [
  {
    tab?:bool <- equal c, 9/tab
    break-unless tab?
    <begin-insert-character>
    # todo: decompose insert-at-cursor into editor update and screen update,
    # so that 'tab' doesn't render the current line multiple times
    insert-at-cursor editor, 32/space, screen
    go-render? <- insert-at-cursor editor, 32/space, screen
    <end-insert-character>
    return
  }
]

# backspace - delete character before cursor

scenario editor-handles-backspace-key [
  local-scope
  assume-screen 10/width, 5/height
  e:&:editor <- new-editor [abc], 0/left, 10/right
  editor-render screen, e
  $clear-trace
  assume-console [
    left-click 1, 1
    press backspace
  ]
  run [
    editor-event-loop screen, console, e
    4:num/raw <- get *e, cursor-row:offset
    5:num/raw <- get *e, cursor-column:offset
  ]
  screen-should-contain [
    .          .
    .bc        .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  memory-should-contain [
    4 <- 1
    5 <- 0
  ]
  check-trace-count-for-label 3, [print-character]  # length of original line to overwrite
]

after <handle-special-character> [
  {
    delete-previous-character?:bool <- equal c, 8/backspace
    break-unless delete-previous-character?
    <begin-backspace-character>
    go-render?:bool, backspaced-cell:&:duplex-list:char <- delete-before-cursor editor, screen
    <end-backspace-character>
    return
  }
]

# return values:
#   go-render? - whether caller needs to update the screen
#   backspaced-cell - value deleted (or 0 if nothing was deleted) so we can save it for undo, etc.
def delete-before-cursor editor:&:editor, screen:&:screen -> go-render?:bool, backspaced-cell:&:duplex-list:char, editor:&:editor, screen:&:screen [
  local-scope
  load-inputs
  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
  data:&:duplex-list:char <- get *editor, data:offset
  # if at start of text (before-cursor at § sentinel), return
  prev:&:duplex-list:char <- prev before-cursor
  return-unless prev, false/no-more-render, null/nothing-deleted
  trace 10, [app], [delete-before-cursor]
  original-row:num <- get *editor, cursor-row:offset
  scroll?:bool <- move-cursor-coordinates-left editor
  backspaced-cell:&:duplex-list:char <- copy before-cursor
  data <- remove before-cursor, data  # will also neatly trim next/prev pointers in backspaced-cell/before-cursor
  before-cursor <- copy prev
  *editor <- put *editor, before-cursor:offset, before-cursor
  return-if scroll?, true/go-render
  screen-width:num <- screen-width screen
  cursor-row:num <- get *editor, cursor-row:offset
  cursor-column:num <- get *editor, cursor-column:offset
  # did we just backspace over a newline?
  same-row?:bool <- equal cursor-row, original-row
  return-unless same-row?, true/go-render
  left:num <- get *editor, left:offset
  right:num <- get *editor, right:offset
  curr:&:duplex-list:char <- next before-cursor
  screen <- move-cursor screen, cursor-row, cursor-column
  curr-column:num <- copy cursor-column
  {
    # hit right margin? give up and let caller render
    at-right?:bool <- greater-or-equal curr-column, right
    return-if at-right?, true/go-render
    break-unless curr
    # newline? done.
    currc:char <- get *curr, value:offset
    at-newline?:bool <- equal currc, 10/newline
    break-if at-newline?
    screen <- print screen, currc
    curr-column <- add curr-column, 1
    curr <- next curr
    loop
  }
  # we're guaranteed not to be at the right margin
  space:char <- copy 32/space
  screen <- print screen, space
  go-render? <- copy false
]

def move-cursor-coordinates-left editor:&:editor -> go-render?:bool, editor:&:editor [
  local-scope
  load-inputs
  go-render?:bool <- copy false
  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
  cursor-row:num <- get *editor, cursor-row:offset
  cursor-column:num <- get *editor, cursor-column:offset
  left:num <- get *editor, left:offset
  # if not at left margin, move one character left
  {
    at-left-margin?:bool <- equal cursor-column, left
    break-if at-left-margin?
    trace 10, [app], [decrementing cursor column]
    cursor-column <- subtract cursor-column, 1
    *editor <- put *editor, cursor-column:offset, cursor-column
    return
  }
  # if at left margin, we must move to previous row:
  top-of-screen?:bool <- equal cursor-row, 1  # exclude menu bar
  {
    break-if top-of-screen?
    cursor-row <- subtract cursor-row, 1
    *editor <- put *editor, cursor-row:offset, cursor-row
  }
  {
    break-unless top-of-screen?
    <scroll-up>
    go-render? <- copy true
  }
  {
    # case 1: if previous character was newline, figure out how long the previous line is
    previous-character:char <- get *before-cursor, value:offset
    previous-character-is-newline?:bool <- equal previous-character, 10/newline
    break-unless previous-character-is-newline?
    # compute length of previous line
    trace 10, [app], [switching to previous line]
    d:&:duplex-list:char <- get *editor, data:offset
    end-of-line:num <- previous-line-length before-cursor, d
    right:num <- get *editor, right:offset
    width:num <- subtract right, left
    wrap?:bool <- greater-than end-of-line, width
    {
      break-unless wrap?
      _, column-offset:num <- divide-with-remainder end-of-line, width
      cursor-column <- add left, column-offset
      *editor <- put *editor, cursor-column:offset, cursor-column
    }
    {
      break-if wrap?
      cursor-column <- add left, end-of-line
      *editor <- put *editor, cursor-column:offset, cursor-column
    }
    return
  }
  # case 2: if previous-character was not newline, we're just at a wrapped line
  trace 10, [app], [wrapping to previous line]
  right:num <- get *editor, right:offset
  cursor-column <- subtract right, 1  # leave room for wrap icon
  *editor <- put *editor, cursor-column:offset, cursor-column
]

# takes a pointer 'curr' into the doubly-linked list and its sentinel, counts
# the length of the previous line before the 'curr' pointer.
def previous-line-length curr:&:duplex-list:char, start:&:duplex-list:char -> result:num [
  local-scope
  load-inputs
  result:num <- copy 0
  return-unless curr
  at-start?:bool <- equal curr, start
  return-if at-start?
  {
    curr <- prev curr
    break-unless curr
    at-start?:bool <- equal curr, start
    break-if at-start?
    c:char <- get *curr, value:offset
    at-newline?:bool <- equal c, 10/newline
    break-if at-newline?
    result <- add result, 1
    loop
  }
]

scenario editor-clears-last-line-on-backspace [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [ab
cd]
  e:&:editor <- new-editor s, 0/left, 10/right
  assume-console [
    left-click 2, 0
    press backspace
  ]
  run [
    editor-event-loop screen, console, e
    4:num/raw <- get *e, cursor-row:offset
    5:num/raw <- get *e, cursor-column:offset
  ]
  screen-should-contain [
    .          .
    .abcd      .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  memory-should-contain [
    4 <- 1
    5 <- 2
  ]
]

scenario editor-joins-and-wraps-lines-on-backspace [
  local-scope
  assume-screen 10/width, 5/height
  # initialize editor with two long-ish but non-wrapping lines
  s:text <- new [abc def
ghi jkl]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # position the cursor at the start of the second and hit backspace
  assume-console [
    left-click 2, 0
    press backspace
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # resulting single line should wrap correctly
  screen-should-contain [
    .          .
    .abc defgh↩.
    .i jkl     .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
]

scenario editor-wraps-long-lines-on-backspace [
  local-scope
  assume-screen 10/width, 5/height
  # initialize editor in part of the screen with a long line
  e:&:editor <- new-editor [abc def ghij], 0/left, 8/right
  editor-render screen, e
  # confirm that it wraps
  screen-should-contain [
    .          .
    .abc def↩  .
    . ghij     .
    .┈┈┈┈┈┈┈┈  .
  ]
  $clear-trace
  # position the cursor somewhere in the middle of the top screen line and hit backspace
  assume-console [
    left-click 1, 4
    press backspace
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # resulting single line should wrap correctly and not overflow its bounds
  screen-should-contain [
    .          .
    .abcdef ↩  .
    .ghij      .
    .┈┈┈┈┈┈┈┈  .
    .          .
  ]
]

# delete - delete character at cursor

scenario editor-handles-delete-key [
  local-scope
  assume-screen 10/width, 5/height
  e:&:editor <- new-editor [abc], 0/left, 10/right
  editor-render screen, e
  $clear-trace
  assume-console [
    press delete
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .bc        .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 3, [print-character]  # length of original line to overwrite
  $clear-trace
  assume-console [
    press delete
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .c         .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 2, [print-character]  # new length to overwrite
]

after <handle-special-key> [
  {
    delete-next-character?:bool <- equal k, 65522/delete
    break-unless delete-next-character?
    <begin-delete-character>
    go-render?:bool, deleted-cell:&:duplex-list:char <- delete-at-cursor editor, screen
    <end-delete-character>
    return
  }
]

def delete-at-cursor editor:&:editor, screen:&:screen -> go-render?:bool, deleted-cell:&:duplex-list:char, editor:&:editor, screen:&:screen [
  local-scope
  load-inputs
  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
  data:&:duplex-list:char <- get *editor, data:offset
  deleted-cell:&:duplex-list:char <- next before-cursor
  return-unless deleted-cell, false/don't-render
  currc:char <- get *deleted-cell, value:offset
  data <- remove deleted-cell, data
  deleted-newline?:bool <- equal currc, 10/newline
  return-if deleted-newline?, true/go-render
  # wasn't a newline? render rest of line
  curr:&:duplex-list:char <- next before-cursor  # refresh after remove above
  cursor-row:num <- get *editor, cursor-row:offset
  cursor-column:num <- get *editor, cursor-column:offset
  screen <- move-cursor screen, cursor-row, cursor-column
  curr-column:num <- copy cursor-column
  screen-width:num <- screen-width screen
  {
    # hit right margin? give up and let caller render
    at-right?:bool <- greater-or-equal curr-column, screen-width
    return-if at-right?, true/go-render
    break-unless curr
    currc:char <- get *curr, value:offset
    at-newline?:bool <- equal currc, 10/newline
    break-if at-newline?
    screen <- print screen, currc
    curr-column <- add curr-column, 1
    curr <- next curr
    loop
  }
  # we're guaranteed not to be at the right margin
  space:char <- copy 32/space
  screen <- print screen, space
  go-render? <- copy false
]

# right arrow

scenario editor-moves-cursor-right-with-key [
  local-scope
  assume-screen 10/width, 5/height
  e:&:editor <- new-editor [abc], 0/left, 10/right
  editor-render screen, e
  $clear-trace
  assume-console [
    press right-arrow
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .a0bc      .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 3, [print-character]  # 0 and following characters
]

after <handle-special-key> [
  {
    move-to-next-character?:bool <- equal k, 65514/right-arrow
    break-unless move-to-next-character?
    # if not at end of text
    next-cursor:&:duplex-list:char <- next before-cursor
    break-unless next-cursor
    # scan to next character
    <begin-move-cursor>
    before-cursor <- copy next-cursor
    *editor <- put *editor, before-cursor:offset, before-cursor
    go-render?:bool <- move-cursor-coordinates-right editor, screen-height
    screen <- move-cursor screen, cursor-row, cursor-column
    undo-coalesce-tag:num <- copy 2/right-arrow
    <end-move-cursor>
    return
  }
]

def move-cursor-coordinates-right editor:&:editor, screen-height:num -> go-render?:bool, editor:&:editor [
  local-scope
  load-inputs
  before-cursor:&:duplex-list:char <- get *editor before-cursor:offset
  cursor-row:num <- get *editor, cursor-row:offset
  cursor-column:num <- get *editor, cursor-column:offset
  left:num <- get *editor, left:offset
  right:num <- get *editor, right:offset
  # if crossed a newline, move cursor to start of next row
  {
    old-cursor-character:char <- get *before-cursor, value:offset
    was-at-newline?:bool <- equal old-cursor-character, 10/newline
    break-unless was-at-newline?
    cursor-row <- add cursor-row, 1
    *editor <- put *editor, cursor-row:offset, cursor-row
    cursor-column <- copy left
    *editor <- put *editor, cursor-column:offset, cursor-column
    below-screen?:bool <- greater-or-equal cursor-row, screen-height  # must be equal
    return-unless below-screen?, false/don't-render
    <scroll-down>
    cursor-row <- subtract cursor-row, 1  # bring back into screen range
    *editor <- put *editor, cursor-row:offset, cursor-row
    return true/go-render
  }
  # if the line wraps, move cursor to start of next row
  {
    # if we're at the column just before the wrap indicator
    wrap-column:num <- subtract right, 1
    at-wrap?:bool <- equal cursor-column, wrap-column
    break-unless at-wrap?
    # and if next character isn't newline
    next:&:duplex-list:char <- next before-cursor
    break-unless next
    next-character:char <- get *next, value:offset
    newline?:bool <- equal next-character, 10/newline
    break-if newline?
    cursor-row <- add cursor-row, 1
    *editor <- put *editor, cursor-row:offset, cursor-row
    cursor-column <- copy left
    *editor <- put *editor, cursor-column:offset, cursor-column
    below-screen?:bool <- greater-or-equal cursor-row, screen-height  # must be equal
    return-unless below-screen?, false/no-more-render
    <scroll-down>
    cursor-row <- subtract cursor-row, 1  # bring back into screen range
    *editor <- put *editor, cursor-row:offset, cursor-row
    return true/go-render
  }
  # otherwise move cursor one character right
  cursor-column <- add cursor-column, 1
  *editor <- put *editor, cursor-column:offset, cursor-column
  go-render? <- copy false
]

scenario editor-moves-cursor-to-next-line-with-right-arrow [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [abc
d]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # type right-arrow a few times to get to start of second line
  assume-console [
    press right-arrow
    press right-arrow
    press right-arrow
    press right-arrow  # next line
  ]
  run [
    editor-event-loop screen, console, e
  ]
  check-trace-count-for-label 0, [print-character]
  # type something and ensure it goes where it should
  assume-console [
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .abc       .
    .0d        .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 2, [print-character]  # new length of second line
]

scenario editor-moves-cursor-to-next-line-with-right-arrow-2 [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [abc
d]
  e:&:editor <- new-editor s, 1/left, 10/right
  editor-render screen, e
  assume-console [
    press right-arrow
    press right-arrow
    press right-arrow
    press right-arrow  # next line
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    . abc      .
    . 0d       .
    . ┈┈┈┈┈┈┈┈┈.
    .          .
  ]
]

scenario editor-moves-cursor-to-next-wrapped-line-with-right-arrow [
  local-scope
  assume-screen 10/width, 5/height
  e:&:editor <- new-editor [abcdef], 0/left, 5/right
  editor-render screen, e
  $clear-trace
  assume-console [
    left-click 1, 3
    press right-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  screen-should-contain [
    .          .
    .abcd↩     .
    .ef        .
    .┈┈┈┈┈     .
    .          .
  ]
  memory-should-contain [
    3 <- 2
    4 <- 0
  ]
  check-trace-count-for-label 0, [print-character]
]

scenario editor-moves-cursor-to-next-wrapped-line-with-right-arrow-2 [
  local-scope
  assume-screen 10/width, 5/height
  # line just barely wrapping
  e:&:editor <- new-editor [abcde], 0/left, 5/right
  editor-render screen, e
  $clear-trace
  # position cursor at last character before wrap and hit right-arrow
  assume-console [
    left-click 1, 3
    press right-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  memory-should-contain [
    3 <- 2
    4 <- 0
  ]
  # now hit right arrow again
  assume-console [
    press right-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  memory-should-contain [
    3 <- 2
    4 <- 1
  ]
  check-trace-count-for-label 0, [print-character]
]

scenario editor-moves-cursor-to-next-wrapped-line-with-right-arrow-3 [
  local-scope
  assume-screen 10/width, 5/height
  e:&:editor <- new-editor [abcdef], 1/left, 6/right
  editor-render screen, e
  $clear-trace
  assume-console [
    left-click 1, 4
    press right-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  screen-should-contain [
    .          .
    . abcd↩    .
    . ef       .
    . ┈┈┈┈┈    .
    .          .
  ]
  memory-should-contain [
    3 <- 2
    4 <- 1
  ]
  check-trace-count-for-label 0, [print-character]
]

scenario editor-moves-cursor-to-next-line-with-right-arrow-at-end-of-line [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [abc
d]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # move to end of line, press right-arrow, type a character
  assume-console [
    left-click 1, 3
    press right-arrow
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # new character should be in next line
  screen-should-contain [
    .          .
    .abc       .
    .0d        .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 2, [print-character]
]

# todo: ctrl-right: next word-end

# left arrow

scenario editor-moves-cursor-left-with-key [
  local-scope
  assume-screen 10/width, 5/height
  e:&:editor <- new-editor [abc], 0/left, 10/right
  editor-render screen, e
  $clear-trace
  assume-console [
    left-click 1, 2
    press left-arrow
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .a0bc      .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 3, [print-character]
]

after <handle-special-key> [
  {
    move-to-previous-character?:bool <- equal k, 65515/left-arrow
    break-unless move-to-previous-character?
    trace 10, [app], [left arrow]
    # if not at start of text (before-cursor at § sentinel)
    prev:&:duplex-list:char <- prev before-cursor
    return-unless prev, false/don't-render
    <begin-move-cursor>
    go-render? <- move-cursor-coordinates-left editor
    before-cursor <- copy prev
    *editor <- put *editor, before-cursor:offset, before-cursor
    undo-coalesce-tag:num <- copy 1/left-arrow
    <end-move-cursor>
    return
  }
]

scenario editor-moves-cursor-to-previous-line-with-left-arrow-at-start-of-line [
  local-scope
  assume-screen 10/width, 5/height
  # initialize editor with two lines
  s:text <- new [abc
d]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # position cursor at start of second line (so there's no previous newline)
  assume-console [
    left-click 2, 0
    press left-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  memory-should-contain [
    3 <- 1
    4 <- 3
  ]
  check-trace-count-for-label 0, [print-character]
]

scenario editor-moves-cursor-to-previous-line-with-left-arrow-at-start-of-line-2 [
  local-scope
  assume-screen 10/width, 5/height
  # initialize editor with three lines
  s:text <- new [abc
def
g]
  e:&:editor <- new-editor s:text, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # position cursor further down (so there's a newline before the character at
  # the cursor)
  assume-console [
    left-click 3, 0
    press left-arrow
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .abc       .
    .def0      .
    .g         .
    .┈┈┈┈┈┈┈┈┈┈.
  ]
  check-trace-count-for-label 1, [print-character]  # just the '0'
]

scenario editor-moves-cursor-to-previous-line-with-left-arrow-at-start-of-line-3 [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [abc
def
g]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # position cursor at start of text, press left-arrow, then type a character
  assume-console [
    left-click 1, 0
    press left-arrow
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # left-arrow should have had no effect
  screen-should-contain [
    .          .
    .0abc      .
    .def       .
    .g         .
    .┈┈┈┈┈┈┈┈┈┈.
  ]
  check-trace-count-for-label 4, [print-character]  # length of first line
]

scenario editor-moves-cursor-to-previous-line-with-left-arrow-at-start-of-line-4 [
  local-scope
  assume-screen 10/width, 5/height
  # initialize editor with text containing an empty line
  s:text <- new [abc

d]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e:&:editor
  $clear-trace
  # position cursor right after empty line
  assume-console [
    left-click 3, 0
    press left-arrow
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .abc       .
    .0         .
    .d         .
    .┈┈┈┈┈┈┈┈┈┈.
  ]
  check-trace-count-for-label 1, [print-character]  # just the '0'
]

scenario editor-moves-across-screen-lines-across-wrap-with-left-arrow [
  local-scope
  assume-screen 10/width, 5/height
  # initialize editor with a wrapping line
  e:&:editor <- new-editor [abcdef], 0/left, 5/right
  editor-render screen, e
  $clear-trace
  screen-should-contain [
    .          .
    .abcd↩     .
    .ef        .
    .┈┈┈┈┈     .
    .          .
  ]
  # position cursor right after empty line
  assume-console [
    left-click 2, 0
    press left-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  memory-should-contain [
    3 <- 1  # previous row
    4 <- 3  # right margin except wrap icon
  ]
  check-trace-count-for-label 0, [print-character]
]

scenario editor-moves-across-screen-lines-to-wrapping-line-with-left-arrow [
  local-scope
  assume-screen 10/width, 5/height
  # initialize editor with a wrapping line followed by a second line
  s:text <- new [abcdef
g]
  e:&:editor <- new-editor s, 0/left, 5/right
  editor-render screen, e
  $clear-trace
  screen-should-contain [
    .          .
    .abcd↩     .
    .ef        .
    .g         .
    .┈┈┈┈┈     .
  ]
  # position cursor right after empty line
  assume-console [
    left-click 3, 0
    press left-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  memory-should-contain [
    3 <- 2  # previous row
    4 <- 2  # end of wrapped line
  ]
  check-trace-count-for-label 0, [print-character]
]

scenario editor-moves-across-screen-lines-to-non-wrapping-line-with-left-arrow [
  local-scope
  assume-screen 10/width, 5/height
  # initialize editor with a line on the verge of wrapping, followed by a second line
  s:text <- new [abcd
e]
  e:&:editor <- new-editor s, 0/left, 5/right
  editor-render screen, e
  $clear-trace
  screen-should-contain [
    .          .
    .abcd      .
    .e         .
    .┈┈┈┈┈     .
    .          .
  ]
  # position cursor right after empty line
  assume-console [
    left-click 2, 0
    press left-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  memory-should-contain [
    3 <- 1  # previous row
    4 <- 4  # end of wrapped line
  ]
  check-trace-count-for-label 0, [print-character]
]

# todo: ctrl-left: previous word-start

# up arrow

scenario editor-moves-to-previous-line-with-up-arrow [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [abc
def]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  assume-console [
    left-click 2, 1
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  memory-should-contain [
    3 <- 1
    4 <- 1
  ]
  check-trace-count-for-label 0, [print-character]
  assume-console [
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .a0bc      .
    .def       .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
]

after <handle-special-key> [
  {
    move-to-previous-line?:bool <- equal k, 65517/up-arrow
    break-unless move-to-previous-line?
    <begin-move-cursor>
    go-render? <- move-to-previous-line editor
    undo-coalesce-tag:num <- copy 3/up-arrow
    <end-move-cursor>
    return
  }
]

def move-to-previous-line editor:&:editor -> go-render?:bool, editor:&:editor [
  local-scope
  load-inputs
  go-render?:bool <- copy false
  cursor-row:num <- get *editor, cursor-row:offset
  cursor-column:num <- get *editor, cursor-column:offset
  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
  left:num <- get *editor, left:offset
  right:num <- get *editor, right:offset
  already-at-top?:bool <- lesser-or-equal cursor-row, 1/top
  {
    # if cursor not at top, move it
    break-if already-at-top?
    # if not at start of screen line, move to start of screen line (previous newline)
    # then scan back another line
    # if either step fails, give up without modifying cursor or coordinates
    curr:&:duplex-list:char <- copy before-cursor
    old:&:duplex-list:char <- copy curr
    {
      at-left?:bool <- equal cursor-column, left
      break-if at-left?
      curr <- before-previous-screen-line curr, editor
      no-motion?:bool <- equal curr, old
      return-if no-motion?
    }
    {
      curr <- before-previous-screen-line curr, editor
      no-motion?:bool <- equal curr, old
      return-if no-motion?
    }
    before-cursor <- copy curr
    *editor <- put *editor, before-cursor:offset, before-cursor
    cursor-row <- subtract cursor-row, 1
    *editor <- put *editor, cursor-row:offset, cursor-row
    # scan ahead to right column or until end of line
    target-column:num <- copy cursor-column
    cursor-column <- copy left
    *editor <- put *editor, cursor-column:offset, cursor-column
    {
      done?:bool <- greater-or-equal cursor-column, target-column
      break-if done?
      curr:&:duplex-list:char <- next before-cursor
      break-unless curr
      currc:char <- get *curr, value:offset
      at-newline?:bool <- equal currc, 10/newline
      break-if at-newline?
      #
      before-cursor <- copy curr
      *editor <- put *editor, before-cursor:offset, before-cursor
      cursor-column <- add cursor-column, 1
      *editor <- put *editor, cursor-column:offset, cursor-column
      loop
    }
    return
  }
  {
    # if cursor already at top, scroll up
    break-unless already-at-top?
    <scroll-up>
    return true/go-render
  }
]

# Takes a pointer into the doubly-linked list, scans back to before start of
# previous *wrapped* line.
# Returns original if no next newline.
# Beware: never return null pointer.
def before-previous-screen-line in:&:duplex-list:char, editor:&:editor -> out:&:duplex-list:char [
  local-scope
  load-inputs
  curr:&:duplex-list:char <- copy in
  c:char <- get *curr, value:offset
  # compute max, number of characters to skip
  #   1 + len%(width-1)
  #   except rotate second term to vary from 1 to width-1 rather than 0 to width-2
  left:num <- get *editor, left:offset
  right:num <- get *editor, right:offset
  max-line-length:num <- subtract right, left, -1/exclusive-right, 1/wrap-icon
  sentinel:&:duplex-list:char <- get *editor, data:offset
  len:num <- previous-line-length curr, sentinel
  {
    break-if len
    # empty line; just skip this newline
    prev:&:duplex-list:char <- prev curr
    return-unless prev, curr
    return prev
  }
  _, max:num <- divide-with-remainder len, max-line-length
  # remainder 0 => scan one width-worth
  {
    break-if max
    max <- copy max-line-length
  }
  max <- add max, 1
  count:num <- copy 0
  # skip 'max' characters
  {
    done?:bool <- greater-or-equal count, max
    break-if done?
    prev:&:duplex-list:char <- prev curr
    break-unless prev
    curr <- copy prev
    count <- add count, 1
    loop
  }
  return curr
]

scenario editor-adjusts-column-at-previous-line [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [ab
def]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  assume-console [
    left-click 2, 3
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  memory-should-contain [
    3 <- 1
    4 <- 2
  ]
  check-trace-count-for-label 0, [print-character]
  assume-console [
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .ab0       .
    .def       .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
]

scenario editor-adjusts-column-at-empty-line [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [
def]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  assume-console [
    left-click 2, 3
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  memory-should-contain [
    3 <- 1
    4 <- 0
  ]
  check-trace-count-for-label 0, [print-character]
  assume-console [
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .0         .
    .def       .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
]

scenario editor-moves-to-previous-line-from-zero-margin [
  local-scope
  assume-screen 10/width, 5/height
  # start out with three lines
  s:text <- new [abc
def
ghi]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # click on the third line and hit up-arrow, so you end up just after a newline
  assume-console [
    left-click 3, 0
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  memory-should-contain [
    3 <- 2
    4 <- 0
  ]
  check-trace-count-for-label 0, [print-character]
  assume-console [
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .abc       .
    .0def      .
    .ghi       .
    .┈┈┈┈┈┈┈┈┈┈.
  ]
]

scenario editor-moves-to-previous-line-from-left-margin [
  local-scope
  assume-screen 10/width, 5/height
  # start out with three lines
  s:text <- new [abc
def
ghi]
  e:&:editor <- new-editor s, 1/left, 10/right
  editor-render screen, e
  $clear-trace
  # click on the third line and hit up-arrow, so you end up just after a newline
  assume-console [
    left-click 3, 1
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  memory-should-contain [
    3 <- 2
    4 <- 1
  ]
  check-trace-count-for-label 0, [print-character]
  assume-console [
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    . abc      .
    . 0def     .
    . ghi      .
    . ┈┈┈┈┈┈┈┈┈.
  ]
]

scenario editor-moves-to-top-line-in-presence-of-wrapped-line [
  local-scope
  assume-screen 10/width, 5/height
  e:&:editor <- new-editor [abcde], 0/left, 5/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .abcd↩     .
    .e         .
    .┈┈┈┈┈     .
  ]
  $clear-trace
  assume-console [
    left-click 2, 0
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  memory-should-contain [
    3 <- 1
    4 <- 0
  ]
  check-trace-count-for-label 0, [print-character]
  assume-console [
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .0abc↩     .
    .de        .
    .┈┈┈┈┈     .
  ]
]

scenario editor-moves-to-top-line-in-presence-of-wrapped-line-2 [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [abc
defgh]
  e:&:editor <- new-editor s, 0/left, 5/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .abc       .
    .defg↩     .
    .h         .
    .┈┈┈┈┈     .
  ]
  $clear-trace
  assume-console [
    left-click 3, 0
    press up-arrow
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  memory-should-contain [
    3 <- 1
    4 <- 0
  ]
  check-trace-count-for-label 0, [print-character]
  assume-console [
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .0abc      .
    .defg↩     .
    .h         .
    .┈┈┈┈┈     .
  ]
]

# down arrow

scenario editor-moves-to-next-line-with-down-arrow [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [abc
def]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # cursor starts out at (1, 0)
  assume-console [
    press down-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  # ..and ends at (2, 0)
  memory-should-contain [
    3 <- 2
    4 <- 0
  ]
  check-trace-count-for-label 0, [print-character]
  assume-console [
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .abc       .
    .0def      .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
]

after <handle-special-key> [
  {
    move-to-next-line?:bool <- equal k, 65516/down-arrow
    break-unless move-to-next-line?
    <begin-move-cursor>
    go-render? <- move-to-next-line editor, screen-height
    undo-coalesce-tag:num <- copy 4/down-arrow
    <end-move-cursor>
    return
  }
]

def move-to-next-line editor:&:editor, screen-height:num -> go-render?:bool, editor:&:editor [
  local-scope
  load-inputs
  cursor-row:num <- get *editor, cursor-row:offset
  cursor-column:num <- get *editor, cursor-column:offset
  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
  left:num <- get *editor, left:offset
  right:num <- get *editor, right:offset
  last-line:num <- subtract screen-height, 1
  bottom:num <- get *editor, bottom:offset
  at-bottom-of-screen?:bool <- greater-or-equal bottom, last-line
  {
    break-if before-cursor
    {
      break-if at-bottom-of-screen?
      return false/don't-render
    }
    {
      break-unless at-bottom-of-screen?
      jump +try-to-scroll
    }
  }
  next:&:duplex-list:char <- next before-cursor
  {
    break-if next
    {
      break-if at-bottom-of-screen?
      return false/don't-render
    }
    {
      break-unless at-bottom-of-screen?
      jump +try-to-scroll
    }
  }
  already-at-bottom?:bool <- greater-or-equal cursor-row, last-line
  {
    # if cursor not at bottom, move it
    break-if already-at-bottom?
    target-column:num <- copy cursor-column
    # scan to start of next line
    {
      next:&:duplex-list:char <- next before-cursor
      break-unless next
      done?:bool <- greater-or-equal cursor-column, right
      break-if done?
      cursor-column <- add cursor-column, 1
      before-cursor <- copy next
      c:char <- get *next, value:offset
      at-newline?:bool <- equal c, 10/newline
      break-if at-newline?
      loop
    }
    {
      break-if next
      {
        break-if at-bottom-of-screen?
        return false/don't-render
      }
      {
        break-unless at-bottom-of-screen?
        jump +try-to-scroll
      }
    }
    cursor-row <- add cursor-row, 1
    cursor-column <- copy left
    {
      next:&:duplex-list:char <- next before-cursor
      break-unless next
      c:char <- get *next, value:offset
      at-newline?:bool <- equal c, 10/newline
      break-if at-newline?
      done?:bool <- greater-or-equal cursor-column, target-column
      break-if done?
      cursor-column <- add cursor-column, 1
      before-cursor <- copy next
      loop
    }
    *editor <- put *editor, before-cursor:offset, before-cursor
    *editor <- put *editor, cursor-column:offset, cursor-column
    *editor <- put *editor, cursor-row:offset, cursor-row
    return false/don't-render
  }
  +try-to-scroll
  <scroll-down>
  go-render? <- copy true
]

scenario editor-adjusts-column-at-next-line [
  local-scope
  assume-screen 10/width, 5/height
  # second line is shorter than first
  s:text <- new [abcde
fg
hi]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # move to end of first line, then press down
  assume-console [
    left-click 1, 8
    press down-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  # cursor doesn't go vertically down, it goes to end of shorter line
  memory-should-contain [
    3 <- 2
    4 <- 2
  ]
  check-trace-count-for-label 0, [print-character]
  assume-console [
    type [0]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .abcde     .
    .fg0       .
    .hi        .
    .┈┈┈┈┈┈┈┈┈┈.
  ]
]

scenario editor-moves-down-within-wrapped-line [
  local-scope
  assume-screen 10/width, 5/height
  e:&:editor <- new-editor [abcdefghijklmno], 0/left, 10/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .abcdefghi↩.
    .jklmno    .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  # position cursor on first screen line, but past end of second screen line
  assume-console [
    left-click 1, 8
    press down-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  # cursor should be at end of second screen line
  memory-should-contain [
    3 <- 2
    4 <- 6
  ]
]

# ctrl-a/home - move cursor to start of line

scenario editor-moves-to-start-of-line-with-ctrl-a [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start on second line, press ctrl-a
  assume-console [
    left-click 2, 3
    press ctrl-a
  ]
  run [
    editor-event-loop screen, console, e
    4:num/raw <- get *e, cursor-row:offset
    5:num/raw <- get *e, cursor-column:offset
  ]
  # cursor moves to start of line
  memory-should-contain [
    4 <- 2
    5 <- 0
  ]
  check-trace-count-for-label 0, [print-character]
]

after <handle-special-character> [
  {
    move-to-start-of-line?:bool <- equal c, 1/ctrl-a
    break-unless move-to-start-of-line?
    <begin-move-cursor>
    move-to-start-of-screen-line editor
    undo-coalesce-tag:num <- copy 0/never
    <end-move-cursor>
    return false/don't-render
  }
]

after <handle-special-key> [
  {
    move-to-start-of-line?:bool <- equal k, 65521/home
    break-unless move-to-start-of-line?
    <begin-move-cursor>
    move-to-start-of-screen-line editor
    undo-coalesce-tag:num <- copy 0/never
    <end-move-cursor>
    return false/don't-render
  }
]

# handles wrapped lines
# precondition: cursor-column should be in a consistent state
def move-to-start-of-screen-line editor:&:editor -> editor:&:editor [
  local-scope
  load-inputs
  # update cursor column
  left:num <- get *editor, left:offset
  col:num <- get *editor, cursor-column:offset
  # update before-cursor
  curr:&:duplex-list:char <- get *editor, before-cursor:offset
  # while not at start of line, move
  {
    done?:bool <- equal col, left
    break-if done?
    assert curr, [move-to-start-of-line tried to move before start of text]
    curr <- prev curr
    col <- subtract col, 1
    loop
  }
  *editor <- put *editor, cursor-column:offset, col
  *editor <- put *editor, before-cursor:offset, curr
]

scenario editor-moves-to-start-of-line-with-ctrl-a-2 [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start on first line (no newline before), press ctrl-a
  assume-console [
    left-click 1, 3
    press ctrl-a
  ]
  run [
    editor-event-loop screen, console, e
    4:num/raw <- get *e, cursor-row:offset
    5:num/raw <- get *e, cursor-column:offset
  ]
  # cursor moves to start of line
  memory-should-contain [
    4 <- 1
    5 <- 0
  ]
  check-trace-count-for-label 0, [print-character]
]

scenario editor-moves-to-start-of-line-with-home [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  $clear-trace
  # start on second line, press 'home'
  assume-console [
    left-click 2, 3
    press home
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  # cursor moves to start of line
  memory-should-contain [
    3 <- 2
    4 <- 0
  ]
  check-trace-count-for-label 0, [print-character]
]

scenario editor-moves-to-start-of-line-with-home-2 [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start on first line (no newline before), press 'home'
  assume-console [
    left-click 1, 3
    press home
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  # cursor moves to start of line
  memory-should-contain [
    3 <- 1
    4 <- 0
  ]
  check-trace-count-for-label 0, [print-character]
]

scenario editor-moves-to-start-of-screen-line-with-ctrl-a [
  local-scope
  assume-screen 10/width, 5/height
  e:&:editor <- new-editor [123456], 0/left, 5/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .1234↩     .
    .56        .
    .┈┈┈┈┈     .
    .          .
  ]
  $clear-trace
  # start on second line, press ctrl-a then up
  assume-console [
    left-click 2, 1
    press ctrl-a
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
    4:num/raw <- get *e, cursor-row:offset
    5:num/raw <- get *e, cursor-column:offset
  ]
  # cursor moves to start of first line
  memory-should-contain [
    4 <- 1  # cursor-row
    5 <- 0  # cursor-column
  ]
  check-trace-count-for-label 0, [print-character]
  # make sure before-cursor is in sync
  assume-console [
    type [a]
  ]
  run [
    editor-event-loop screen, console, e
    4:num/raw <- get *e, cursor-row:offset
    5:num/raw <- get *e, cursor-column:offset
  ]
  screen-should-contain [
    .          .
    .a123↩     .
    .456       .
    .┈┈┈┈┈     .
    .          .
  ]
  memory-should-contain [
    4 <- 1  # cursor-row
    5 <- 1  # cursor-column
  ]
]

# ctrl-e/end - move cursor to end of line

scenario editor-moves-to-end-of-line-with-ctrl-e [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start on first line, press ctrl-e
  assume-console [
    left-click 1, 1
    press ctrl-e
  ]
  run [
    editor-event-loop screen, console, e
    4:num/raw <- get *e, cursor-row:offset
    5:num/raw <- get *e, cursor-column:offset
  ]
  # cursor moves to end of line
  memory-should-contain [
    4 <- 1
    5 <- 3
  ]
  check-trace-count-for-label 0, [print-character]
  # editor inserts future characters at cursor
  assume-console [
    type [z]
  ]
  run [
    editor-event-loop screen, console, e
    4:num/raw <- get *e, cursor-row:offset
    5:num/raw <- get *e, cursor-column:offset
  ]
  memory-should-contain [
    4 <- 1
    5 <- 4
  ]
  screen-should-contain [
    .          .
    .123z      .
    .456       .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 1, [print-character]
]

after <handle-special-character> [
  {
    move-to-end-of-line?:bool <- equal c, 5/ctrl-e
    break-unless move-to-end-of-line?
    <begin-move-cursor>
    move-to-end-of-line editor
    undo-coalesce-tag:num <- copy 0/never
    <end-move-cursor>
    return false/don't-render
  }
]

after <handle-special-key> [
  {
    move-to-end-of-line?:bool <- equal k, 65520/end
    break-unless move-to-end-of-line?
    <begin-move-cursor>
    move-to-end-of-line editor
    undo-coalesce-tag:num <- copy 0/never
    <end-move-cursor>
    return false/don't-render
  }
]

def move-to-end-of-line editor:&:editor -> editor:&:editor [
  local-scope
  load-inputs
  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
  cursor-column:num <- get *editor, cursor-column:offset
  right:num <- get *editor, right:offset
  # while not at end of line, move
  {
    next:&:duplex-list:char <- next before-cursor
    break-unless next  # end of text
    nextc:char <- get *next, value:offset
    at-end-of-line?:bool <- equal nextc, 10/newline
    break-if at-end-of-line?
    cursor-column <- add cursor-column, 1
    at-right?:bool <- equal cursor-column, right
    break-if at-right?
    *editor <- put *editor, cursor-column:offset, cursor-column
    before-cursor <- copy next
    *editor <- put *editor, before-cursor:offset, before-cursor
    loop
  }
]

scenario editor-moves-to-end-of-line-with-ctrl-e-2 [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start on second line (no newline after), press ctrl-e
  assume-console [
    left-click 2, 1
    press ctrl-e
  ]
  run [
    editor-event-loop screen, console, e
    4:num/raw <- get *e, cursor-row:offset
    5:num/raw <- get *e, cursor-column:offset
  ]
  # cursor moves to end of line
  memory-should-contain [
    4 <- 2
    5 <- 3
  ]
  check-trace-count-for-label 0, [print-character]
]

scenario editor-moves-to-end-of-line-with-end [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start on first line, press 'end'
  assume-console [
    left-click 1, 1
    press end
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  # cursor moves to end of line
  memory-should-contain [
    3 <- 1
    4 <- 3
  ]
  check-trace-count-for-label 0, [print-character]
]

scenario editor-moves-to-end-of-line-with-end-2 [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start on second line (no newline after), press 'end'
  assume-console [
    left-click 2, 1
    press end
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  # cursor moves to end of line
  memory-should-contain [
    3 <- 2
    4 <- 3
  ]
  check-trace-count-for-label 0, [print-character]
]

scenario editor-moves-to-end-of-wrapped-line [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123456
789]
  e:&:editor <- new-editor s, 0/left, 5/right
  editor-render screen, e
  $clear-trace
  # start on first line, press 'end'
  assume-console [
    left-click 1, 1
    press end
  ]
  run [
    editor-event-loop screen, console, e
    10:num/raw <- get *e, cursor-row:offset
    11:num/raw <- get *e, cursor-column:offset
  ]
  # cursor moves to end of line
  memory-should-contain [
    10 <- 1
    11 <- 3
  ]
  # no prints
  check-trace-count-for-label 0, [print-character]
  # before-cursor is also consistent
  assume-console [
    type [a]
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .123a↩     .
    .456       .
    .789       .
    .┈┈┈┈┈     .
  ]
]

# ctrl-u - delete text from start of line until (but not at) cursor

scenario editor-deletes-to-start-of-line-with-ctrl-u [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start on second line, press ctrl-u
  assume-console [
    left-click 2, 2
    press ctrl-u
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # cursor deletes to start of line
  screen-should-contain [
    .          .
    .123       .
    .6         .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 10, [print-character]
]

after <handle-special-character> [
  {
    delete-to-start-of-line?:bool <- equal c, 21/ctrl-u
    break-unless delete-to-start-of-line?
    <begin-delete-to-start-of-line>
    deleted-cells:&:duplex-list:char <- delete-to-start-of-line editor
    <end-delete-to-start-of-line>
    go-render?:bool <- minimal-render-for-ctrl-u screen, editor, deleted-cells
    return
  }
]

def minimal-render-for-ctrl-u screen:&:screen, editor:&:editor, deleted-cells:&:duplex-list:char -> go-render?:bool, screen:&:screen [
  local-scope
  load-inputs
  curr-column:num <- get *editor, cursor-column:offset
  # accumulate the current line as text and render it
  buf:&:buffer:char <- new-buffer 30  # accumulator for the text we need to render
  curr:&:duplex-list:char <- get *editor, before-cursor:offset
  i:num <- copy curr-column
  right:num <- get *editor, right:offset
  {
    # if we have a wrapped line, give up and render the whole screen
    wrap?:bool <- greater-or-equal i, right
    return-if wrap?, true/go-render
    curr <- next curr
    break-unless curr
    c:char <- get *curr, value:offset
    b:bool <- equal c, 10
    break-if b
    buf <- append buf, c
    i <- add i, 1
    loop
  }
  # if the line used to be wrapped, give up and render the whole screen
  num-deleted-cells:num <- length deleted-cells
  old-row-len:num <- add i, num-deleted-cells
  left:num <- get *editor, left:offset
  end:num <- subtract right, left
  wrap?:bool <- greater-or-equal old-row-len, end
  return-if wrap?, true/go-render
  curr-line:text <- buffer-to-array buf
  curr-row:num <- get *editor, cursor-row:offset
  render-code screen, curr-line, curr-column, right, curr-row
  return false/dont-render
]

def delete-to-start-of-line editor:&:editor -> result:&:duplex-list:char, editor:&:editor [
  local-scope
  load-inputs
  # compute range to delete
  init:&:duplex-list:char <- get *editor, data:offset
  top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
  update-top-of-screen?:bool <- copy false
  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
  start:&:duplex-list:char <- copy before-cursor
  end:&:duplex-list:char <- next before-cursor
  {
    at-start-of-text?:bool <- equal start, init
    break-if at-start-of-text?
    curr:char <- get *start, value:offset
    at-start-of-line?:bool <- equal curr, 10/newline
    break-if at-start-of-line?
    # if we went past top-of-screen, make a note to update it as well
    at-top-of-screen?:bool <- equal start, top-of-screen
    update-top-of-screen?:bool <- or update-top-of-screen?, at-top-of-screen?
    start <- prev start
    assert start, [delete-to-start-of-line tried to move before start of text]
    loop
  }
  # snip it out
  result:&:duplex-list:char <- next start
  remove-between start, end
  # update top-of-screen if it's just been invalidated
  {
    break-unless update-top-of-screen?
    put *editor, top-of-screen:offset, start
  }
  # adjust cursor
  before-cursor <- copy start
  *editor <- put *editor, before-cursor:offset, before-cursor
  left:num <- get *editor, left:offset
  *editor <- put *editor, cursor-column:offset, left
  # if the line wrapped before, we may need to adjust cursor-row as well
  right:num <- get *editor, right:offset
  width:num <- subtract right, left
  num-deleted:num <- length result
  cursor-row-adjustment:num <- divide-with-remainder num-deleted, width
  return-unless cursor-row-adjustment
  cursor-row:num <- get *editor, cursor-row:offset
  cursor-row-in-editor:num <- subtract cursor-row, 1  # ignore menubar
  at-top?:bool <- lesser-or-equal cursor-row-in-editor, cursor-row-adjustment
  {
    break-unless at-top?
    cursor-row <- copy 1  # top of editor, below menubar
  }
  {
    break-if at-top?
    cursor-row <- subtract cursor-row, cursor-row-adjustment
  }
  put *editor, cursor-row:offset, cursor-row
]

def render-code screen:&:screen, s:text, left:num, right:num, row:num -> row:num, screen:&:screen [
  local-scope
  load-inputs
  return-unless s
  color:num <- copy 7/white
  column:num <- copy left
  screen <- move-cursor screen, row, column
  screen-height:num <- screen-height screen
  i:num <- copy 0
  len:num <- length *s
  {
    +next-character
    done?:bool <- greater-or-equal i, len
    break-if done?
    done? <- greater-or-equal row, screen-height
    break-if done?
    c:char <- index *s, i
    <character-c-received>
    {
      # newline? move to left rather than 0
      newline?:bool <- equal c, 10/newline
      break-unless newline?
      # clear rest of line in this window
      {
        done?:bool <- greater-than column, right
        break-if done?
        space:char <- copy 32/space
        print screen, space
        column <- add column, 1
        loop
      }
      row <- add row, 1
      column <- copy left
      screen <- move-cursor screen, row, column
      i <- add i, 1
      loop +next-character
    }
    {
      # at right? wrap.
      at-right?:bool <- equal column, right
      break-unless at-right?
      # print wrap icon
      wrap-icon:char <- copy 8617/loop-back-to-left
      print screen, wrap-icon, 245/grey
      column <- copy left
      row <- add row, 1
      screen <- move-cursor screen, row, column
      # don't increment i
      loop +next-character
    }
    i <- add i, 1
    print screen, c, color
    column <- add column, 1
    loop
  }
  was-at-left?:bool <- equal column, left
  clear-line-until screen, right
  {
    break-if was-at-left?
    row <- add row, 1
  }
  move-cursor screen, row, left
]

scenario editor-deletes-to-start-of-line-with-ctrl-u-2 [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start on first line (no newline before), press ctrl-u
  assume-console [
    left-click 1, 2
    press ctrl-u
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # cursor deletes to start of line
  screen-should-contain [
    .          .
    .3         .
    .456       .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 10, [print-character]
]

scenario editor-deletes-to-start-of-line-with-ctrl-u-3 [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start past end of line, press ctrl-u
  assume-console [
    left-click 1, 3
    press ctrl-u
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # cursor deletes to start of line
  screen-should-contain [
    .          .
    .          .
    .456       .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 10, [print-character]
]

scenario editor-deletes-to-start-of-final-line-with-ctrl-u [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start past end of final line, press ctrl-u
  assume-console [
    left-click 2, 3
    press ctrl-u
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # cursor deletes to start of line
  screen-should-contain [
    .          .
    .123       .
    .          .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 10, [print-character]
]

scenario editor-deletes-to-start-of-wrapped-line-with-ctrl-u [
  local-scope
  assume-screen 10/width, 10/height
  # first line starts out wrapping
  s:text <- new [123456
789]
  e:&:editor <- new-editor s, 0/left, 5/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .1234↩     .
    .56        .
    .789       .
    .┈┈┈┈┈     .
    .          .
  ]
  $clear-trace
  # ctrl-u enough of the first line that it's no longer wrapping
  assume-console [
    left-click 1, 3
    press ctrl-u
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # entire screen needs to be refreshed
  screen-should-contain [
    .          .
    .456       .
    .789       .
    .┈┈┈┈┈     .
    .          .
  ]
  check-trace-count-for-label 45, [print-character]
]

# sometimes hitting ctrl-u needs to adjust the cursor row
scenario editor-deletes-to-start-of-wrapped-line-with-ctrl-u-2 [
  local-scope
  assume-screen 10/width, 10/height
  # third line starts out wrapping
  s:text <- new [1
2
345678
9]
  e:&:editor <- new-editor s, 0/left, 5/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .1         .
    .2         .
    .3456↩     .
    .78        .
    .9         .
    .┈┈┈┈┈     .
    .          .
  ]
  # position cursor on screen line after the wrap and hit ctrl-u
  assume-console [
    left-click 4, 1  # on '8'
    press ctrl-u
  ]
  run [
    editor-event-loop screen, console, e
    10:num/raw <- get *e, cursor-row:offset
    11:num/raw <- get *e, cursor-column:offset
  ]
  screen-should-contain [
    .          .
    .1         .
    .2         .
    .8         .
    .9         .
    .┈┈┈┈┈     .
    .          .
  ]
  # cursor moves up one screen line
  memory-should-contain [
    10 <- 3  # cursor-row
    11 <- 0  # cursor-column
  ]
]

# line wrapping twice (taking up 3 screen lines)
scenario editor-deletes-to-start-of-wrapped-line-with-ctrl-u-3 [
  local-scope
  assume-screen 10/width, 10/height
  # third line starts out wrapping
  s:text <- new [1
2
3456789abcd
e]
  e:&:editor <- new-editor s, 0/left, 5/right
  editor-render screen, e
  assume-console [
    left-click 4, 1  # on '8'
  ]
  editor-event-loop screen, console, e
  screen-should-contain [
    .          .
    .1         .
    .2         .
    .3456↩     .
    .789a↩     .
    .bcd       .
    .e         .
    .┈┈┈┈┈     .
    .          .
  ]
  assume-console [
    left-click 5, 1
    press ctrl-u
  ]
  run [
    editor-event-loop screen, console, e
    10:num/raw <- get *e, cursor-row:offset
    11:num/raw <- get *e, cursor-column:offset
  ]
  screen-should-contain [
    .          .
    .1         .
    .2         .
    .cd        .
    .e         .
    .┈┈┈┈┈     .
    .          .
  ]
  # make sure we adjusted cursor-row
  memory-should-contain [
    10 <- 3  # cursor-row
    11 <- 0  # cursor-column
  ]
]

# adjusting cursor row at the top of the screen
scenario editor-deletes-to-start-of-wrapped-line-with-ctrl-u-4 [
  local-scope
  assume-screen 10/width, 10/height
  # first line starts out wrapping
  s:text <- new [1234567
89]
  e:&:editor <- new-editor s, 0/left, 5/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .1234↩     .
    .567       .
    .89        .
    .┈┈┈┈┈     .
    .          .
  ]
  # position cursor on second screen line (after the wrap) and hit ctrl-u
  assume-console [
    left-click 2, 1
    press ctrl-u
  ]
  run [
    editor-event-loop screen, console, e
    10:num/raw <- get *e, cursor-row:offset
    11:num/raw <- get *e, cursor-column:offset
  ]
  screen-should-contain [
    .          .
    .67        .
    .89        .
    .┈┈┈┈┈     .
    .          .
  ]
  # cursor moves up to screen line 1
  memory-should-contain [
    10 <- 1  # cursor-row
    11 <- 0  # cursor-column
  ]
]

# screen begins part-way through a wrapping line
scenario editor-deletes-to-start-of-wrapped-line-with-ctrl-u-5 [
  local-scope
  assume-screen 10/width, 10/height
  # third line starts out wrapping
  s:text <- new [1
2
345678
9]
  e:&:editor <- new-editor s, 0/left, 5/right
  editor-render screen, e
  # position the '78' line at the top of the screen
  assume-console [
    left-click 4, 1  # on '8'
    press ctrl-t
  ]
  editor-event-loop screen, console, e
  screen-should-contain [
    .          .
    .78        .
    .9         .
    .┈┈┈┈┈     .
    .          .
  ]
  assume-console [
    left-click 1, 1
    press ctrl-u
  ]
  run [
    editor-event-loop screen, console, e
    10:num/raw <- get *e, cursor-row:offset
    11:num/raw <- get *e, cursor-column:offset
  ]
  # make sure we updated top-of-screen correctly
  screen-should-contain [
    .          .
    .8         .
    .9         .
    .┈┈┈┈┈     .
    .          .
  ]
  memory-should-contain [
    10 <- 1  # cursor-row
    11 <- 0  # cursor-column
  ]
  # the entire line is deleted, even the part not shown on screen
  assume-console [
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .2         .
    .8         .
    .9         .
    .┈┈┈┈┈     .
    .          .
  ]
]

# screen begins part-way through a line wrapping twice (taking up 3 screen lines)
scenario editor-deletes-to-start-of-wrapped-line-with-ctrl-u-6 [
  local-scope
  assume-screen 10/width, 10/height
  # third line starts out wrapping
  s:text <- new [1
2
3456789abcd
e]
  e:&:editor <- new-editor s, 0/left, 5/right
  editor-render screen, e
  # position the 'bcd' line at the top of the screen
  assume-console [
    left-click 4, 1  # on '8'
    press ctrl-t
    press ctrl-s  # now on 'c'
  ]
  editor-event-loop screen, console, e
  screen-should-contain [
    .          .
    .bcd       .
    .e         .
    .┈┈┈┈┈     .
    .          .
  ]
  assume-console [
    left-click 1, 1
    press ctrl-u
  ]
  run [
    editor-event-loop screen, console, e
    10:num/raw <- get *e, cursor-row:offset
    11:num/raw <- get *e, cursor-column:offset
  ]
  # make sure we updated top-of-screen correctly
  screen-should-contain [
    .          .
    .cd        .
    .e         .
    .┈┈┈┈┈     .
    .          .
  ]
  memory-should-contain [
    10 <- 1  # cursor-row
    11 <- 0  # cursor-column
  ]
  # the entire line is deleted, even the part not shown on screen
  assume-console [
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .2         .
    .cd        .
    .e         .
    .┈┈┈┈┈     .
    .          .
  ]
]

# ctrl-k - delete text from cursor to end of line (but not the newline)

scenario editor-deletes-to-end-of-line-with-ctrl-k [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start on first line, press ctrl-k
  assume-console [
    left-click 1, 1
    press ctrl-k
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # cursor deletes to end of line
  screen-should-contain [
    .          .
    .1         .
    .456       .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 9, [print-character]
]

after <handle-special-character> [
  {
    delete-to-end-of-line?:bool <- equal c, 11/ctrl-k
    break-unless delete-to-end-of-line?
    <begin-delete-to-end-of-line>
    deleted-cells:&:duplex-list:char <- delete-to-end-of-line editor
    <end-delete-to-end-of-line>
    # checks if we can do a minimal render and if we can it will do a minimal render
    go-render?:bool <- minimal-render-for-ctrl-k screen, editor, deleted-cells
    return
  }
]

def minimal-render-for-ctrl-k screen:&:screen, editor:&:editor, deleted-cells:&:duplex-list:char -> go-render?:bool, screen:&:screen [
  local-scope
  load-inputs
  # if we deleted nothing, there's nothing to render
  return-unless deleted-cells, false/dont-render
  # if the line used to wrap before, give up and render the whole screen
  curr-column:num <- get *editor, cursor-column:offset
  num-deleted-cells:num <- length deleted-cells
  old-row-len:num <- add curr-column, num-deleted-cells
  left:num <- get *editor, left:offset
  right:num <- get *editor, right:offset
  end:num <- subtract right, left
  wrap?:bool <- greater-or-equal old-row-len, end
  return-if wrap?, true/go-render
  clear-line-until screen, right
  return false/dont-render
]

def delete-to-end-of-line editor:&:editor -> result:&:duplex-list:char, editor:&:editor [
  local-scope
  load-inputs
  # compute range to delete
  start:&:duplex-list:char <- get *editor, before-cursor:offset
  end:&:duplex-list:char <- next start
  {
    at-end-of-text?:bool <- equal end, null
    break-if at-end-of-text?
    curr:char <- get *end, value:offset
    at-end-of-line?:bool <- equal curr, 10/newline
    break-if at-end-of-line?
    end <- next end
    loop
  }
  # snip it out
  result <- next start
  remove-between start, end
]

scenario editor-deletes-to-end-of-line-with-ctrl-k-2 [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start on second line (no newline after), press ctrl-k
  assume-console [
    left-click 2, 1
    press ctrl-k
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # cursor deletes to end of line
  screen-should-contain [
    .          .
    .123       .
    .4         .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 9, [print-character]
]

scenario editor-deletes-to-end-of-line-with-ctrl-k-3 [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start at end of line
  assume-console [
    left-click 1, 2
    press ctrl-k
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # cursor deletes just last character
  screen-should-contain [
    .          .
    .12        .
    .456       .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 8, [print-character]
]

scenario editor-deletes-to-end-of-line-with-ctrl-k-4 [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start past end of line
  assume-console [
    left-click 1, 3
    press ctrl-k
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # cursor deletes nothing
  screen-should-contain [
    .          .
    .123       .
    .456       .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 7, [print-character]
]

scenario editor-deletes-to-end-of-line-with-ctrl-k-5 [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start at end of text
  assume-console [
    left-click 2, 2
    press ctrl-k
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # cursor deletes just the final character
  screen-should-contain [
    .          .
    .123       .
    .45        .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 8, [print-character]
]

scenario editor-deletes-to-end-of-line-with-ctrl-k-6 [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [123
456]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # start past end of text
  assume-console [
    left-click 2, 3
    press ctrl-k
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # cursor deletes nothing
  screen-should-contain [
    .          .
    .123       .
    .456       .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  # no prints necessary
  check-trace-count-for-label 0, [print-character]
]

scenario editor-deletes-to-end-of-wrapped-line-with-ctrl-k [
  local-scope
  assume-screen 10/width, 5/height
  # create an editor with the first line wrapping to a second screen row
  s:text <- new [1234
567]
  e:&:editor <- new-editor s, 0/left, 4/right
  editor-render screen, e
  $clear-trace
  # delete all of the first wrapped line
  assume-console [
    press ctrl-k
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows an empty unwrapped first line
  screen-should-contain [
    .          .
    .          .
    .567       .
    .┈┈┈┈      .
    .          .
  ]
  # entire screen is refreshed
  check-trace-count-for-label 16, [print-character]
]

# scroll down if necessary

scenario editor-can-scroll-down-using-arrow-keys [
  local-scope
  # screen has 1 line for menu + 3 lines
  assume-screen 10/width, 4/height
  # initialize editor with >3 lines
  s:text <- new [a
b
c
d]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .a         .
    .b         .
    .c         .
  ]
  # position cursor at last line, then try to move further down
  assume-console [
    left-click 3, 0
    press down-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen slides by one line
  screen-should-contain [
    .          .
    .b         .
    .c         .
    .d         .
  ]
]

after <scroll-down> [
  trace 10, [app], [scroll down]
  top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
  left:num <- get *editor, left:offset
  right:num <- get *editor, right:offset
  max:num <- subtract right, left
  old-top:&:duplex-list:char <- copy top-of-screen
  top-of-screen <- before-start-of-next-line top-of-screen, max
  *editor <- put *editor, top-of-screen:offset, top-of-screen
  no-movement?:bool <- equal old-top, top-of-screen
  return-if no-movement?, false/don't-render
]

after <scroll-down2> [
  trace 10, [app], [scroll down]
  top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
  left:num <- get *editor, left:offset
  right:num <- get *editor, right:offset
  max:num <- subtract right, left
  old-top:&:duplex-list:char <- copy top-of-screen
  top-of-screen <- before-start-of-next-line top-of-screen, max
  *editor <- put *editor, top-of-screen:offset, top-of-screen
  no-movement?:bool <- equal old-top, top-of-screen
  return-if no-movement?
]

# Takes a pointer into the doubly-linked list, scans ahead at most 'max'
# positions until the next newline.
# Returns original if no next newline.
# Beware: never return null pointer.
def before-start-of-next-line original:&:duplex-list:char, max:num -> curr:&:duplex-list:char [
  local-scope
  load-inputs
  count:num <- copy 0
  curr:&:duplex-list:char <- copy original
  # skip the initial newline if it exists
  {
    c:char <- get *curr, value:offset
    at-newline?:bool <- equal c, 10/newline
    break-unless at-newline?
    curr <- next curr
    count <- add count, 1
  }
  {
    return-unless curr, original
    done?:bool <- greater-or-equal count, max
    break-if done?
    c:char <- get *curr, value:offset
    at-newline?:bool <- equal c, 10/newline
    break-if at-newline?
    curr <- next curr
    count <- add count, 1
    loop
  }
  return-unless curr, original
  return curr
]

scenario editor-scrolls-down-past-wrapped-line-using-arrow-keys [
  local-scope
  # screen has 1 line for menu + 3 lines
  assume-screen 10/width, 4/height
  # initialize editor with a long, wrapped line and more than a screen of
  # other lines
  s:text <- new [abcdef
g
h
i]
  e:&:editor <- new-editor s, 0/left, 5/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .abcd↩     .
    .ef        .
    .g         .
  ]
  # position cursor at last line, then try to move further down
  assume-console [
    left-click 3, 0
    press down-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows partial wrapped line
  screen-should-contain [
    .          .
    .ef        .
    .g         .
    .h         .
  ]
]

scenario editor-scrolls-down-past-wrapped-line-using-arrow-keys-2 [
  local-scope
  # screen has 1 line for menu + 3 lines
  assume-screen 10/width, 4/height
  # editor starts with a long line wrapping twice
  s:text <- new [abcdefghij
k
l
m]
  e:&:editor <- new-editor s, 0/left, 5/right
  # position cursor at last line, then try to move further down
  assume-console [
    left-click 3, 0
    press down-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows partial wrapped line containing a wrap icon
  screen-should-contain [
    .          .
    .efgh↩     .
    .ij        .
    .k         .
  ]
  # scroll down again
  assume-console [
    press down-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows partial wrapped line
  screen-should-contain [
    .          .
    .ij        .
    .k         .
    .l         .
  ]
]

scenario editor-scrolls-down-when-line-wraps [
  local-scope
  # screen has 1 line for menu + 3 lines
  assume-screen 5/width, 4/height
  # editor contains a long line in the third line
  s:text <- new [a
b
cdef]
  e:&:editor <- new-editor s, 0/left, 5/right
  # position cursor at end, type a character
  assume-console [
    left-click 3, 4
    type [g]
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  # screen scrolls
  screen-should-contain [
    .     .
    .b    .
    .cdef↩.
    .g    .
  ]
  memory-should-contain [
    3 <- 3
    4 <- 1
  ]
]

scenario editor-stops-scrolling-once-bottom-is-visible [
  local-scope
  # screen has 1 line for menu + 3 lines
  assume-screen 10/width, 4/height
  # initialize editor with 2 lines
  s:text <- new [a
b]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .a         .
    .b         .
    .┈┈┈┈┈┈┈┈┈┈.
  ]
  # position cursor at last line, then try to move further down
  assume-console [
    left-click 3, 0
    press down-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # no change since the bottom border was already visible
  screen-should-contain [
    .          .
    .a         .
    .b         .
    .┈┈┈┈┈┈┈┈┈┈.
  ]
]

scenario editor-scrolls-down-on-newline [
  local-scope
  assume-screen 5/width, 4/height
  # position cursor after last line and type newline
  s:text <- new [a
b
c]
  e:&:editor <- new-editor s, 0/left, 5/right
  assume-console [
    left-click 3, 4
    type [
]
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  # screen scrolls
  screen-should-contain [
    .     .
    .b    .
    .c    .
    .     .
  ]
  memory-should-contain [
    3 <- 3
    4 <- 0
  ]
]

scenario editor-scrolls-down-on-right-arrow [
  local-scope
  # screen has 1 line for menu + 3 lines
  assume-screen 5/width, 4/height
  # editor contains a wrapped line
  s:text <- new [a
b
cdefgh]
  e:&:editor <- new-editor s, 0/left, 5/right
  # position cursor at end of screen and try to move right
  assume-console [
    left-click 3, 3
    press right-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  # screen scrolls
  screen-should-contain [
    .     .
    .b    .
    .cdef↩.
    .gh   .
  ]
  memory-should-contain [
    3 <- 3
    4 <- 0
  ]
]

scenario editor-scrolls-down-on-right-arrow-2 [
  local-scope
  # screen has 1 line for menu + 3 lines
  assume-screen 5/width, 4/height
  # editor contains more lines than can fit on screen
  s:text <- new [a
b
c
d]
  e:&:editor <- new-editor s, 0/left, 5/right
  # position cursor at end of screen and try to move right
  assume-console [
    left-click 3, 3
    press right-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  # screen scrolls
  screen-should-contain [
    .     .
    .b    .
    .c    .
    .d    .
  ]
  memory-should-contain [
    3 <- 3
    4 <- 0
  ]
]

scenario editor-scrolls-at-end-on-down-arrow [
  local-scope
  assume-screen 10/width, 5/height
  s:text <- new [abc
de]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  $clear-trace
  # try to move down past end of text
  assume-console [
    left-click 2, 0
    press down-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  # no change
  memory-should-contain [
    3 <- 2
    4 <- 0
  ]
]

scenario editor-combines-page-and-line-scroll [
  local-scope
  # screen has 1 line for menu + 3 lines
  assume-screen 10/width, 4/height
  # initialize editor with a few pages of lines
  s:text <- new [a
b
c
d
e
f
g]
  e:&:editor <- new-editor s, 0/left, 5/right
  editor-render screen, e
  # scroll down one page and one line
  assume-console [
    press page-down
    left-click 3, 0
    press down-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen scrolls down 3 lines
  screen-should-contain [
    .          .
    .d         .
    .e         .
    .f         .
  ]
]

# scroll up if necessary

scenario editor-can-scroll-up-using-arrow-keys [
  local-scope
  # screen has 1 line for menu + 3 lines
  assume-screen 10/width, 4/height
  # initialize editor with >3 lines
  s:text <- new [a
b
c
d]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .a         .
    .b         .
    .c         .
  ]
  # position cursor at top of second page, then try to move up
  assume-console [
    press page-down
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen slides by one line
  screen-should-contain [
    .          .
    .b         .
    .c         .
    .d         .
  ]
]

after <scroll-up> [
  trace 10, [app], [scroll up]
  top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
  old-top:&:duplex-list:char <- copy top-of-screen
  top-of-screen <- before-previous-screen-line top-of-screen, editor
  *editor <- put *editor, top-of-screen:offset, top-of-screen
  no-movement?:bool <- equal old-top, top-of-screen
  return-if no-movement?, false/don't-render
]

scenario editor-scrolls-up-past-wrapped-line-using-arrow-keys [
  local-scope
  # screen has 1 line for menu + 3 lines
  assume-screen 10/width, 4/height
  # initialize editor with a long, wrapped line and more than a screen of
  # other lines
  s:text <- new [abcdef
g
h
i]
  e:&:editor <- new-editor s, 0/left, 5/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .abcd↩     .
    .ef        .
    .g         .
  ]
  # position cursor at top of second page, just below wrapped line
  assume-console [
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .g         .
    .h         .
    .i         .
  ]
  # now move up one line
  assume-console [
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows partial wrapped line
  screen-should-contain [
    .          .
    .ef        .
    .g         .
    .h         .
  ]
]

scenario editor-scrolls-up-past-wrapped-line-using-arrow-keys-2 [
  local-scope
  # screen has 1 line for menu + 4 lines
  assume-screen 10/width, 5/height
  # editor starts with a long line wrapping twice, occupying 3 of the 4 lines
  s:text <- new [abcdefghij
k
l
m]
  e:&:editor <- new-editor s, 0/left, 5/right
  editor-render screen, e
  # position cursor at top of second page
  assume-console [
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .k         .
    .l         .
    .m         .
    .┈┈┈┈┈     .
  ]
  # move up one line
  assume-console [
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows partial wrapped line
  screen-should-contain [
    .          .
    .ij        .
    .k         .
    .l         .
    .m         .
  ]
  # move up a second line
  assume-console [
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows partial wrapped line
  screen-should-contain [
    .          .
    .efgh↩     .
    .ij        .
    .k         .
    .l         .
  ]
  # move up a third line
  assume-console [
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows partial wrapped line
  screen-should-contain [
    .          .
    .abcd↩     .
    .efgh↩     .
    .ij        .
    .k         .
  ]
]

# same as editor-scrolls-up-past-wrapped-line-using-arrow-keys but length
# slightly off, just to prevent over-training
scenario editor-scrolls-up-past-wrapped-line-using-arrow-keys-3 [
  local-scope
  # screen has 1 line for menu + 3 lines
  assume-screen 10/width, 4/height
  # initialize editor with a long, wrapped line and more than a screen of
  # other lines
  s:text <- new [abcdef
g
h
i]
  e:&:editor <- new-editor s, 0/left, 6/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .abcde↩    .
    .f         .
    .g         .
  ]
  # position cursor at top of second page, just below wrapped line
  assume-console [
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .g         .
    .h         .
    .i         .
  ]
  # now move up one line
  assume-console [
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows partial wrapped line
  screen-should-contain [
    .          .
    .f         .
    .g         .
    .h         .
  ]
]

# check empty lines
scenario editor-scrolls-up-past-wrapped-line-using-arrow-keys-4 [
  local-scope
  assume-screen 10/width, 4/height
  # initialize editor with some lines around an empty line
  s:text <- new [a
b

c
d
e]
  e:&:editor <- new-editor s, 0/left, 6/right
  editor-render screen, e
  assume-console [
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .          .
    .c         .
    .d         .
  ]
  assume-console [
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .d         .
    .e         .
    .┈┈┈┈┈┈    .
  ]
  assume-console [
    press page-up
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .          .
    .c         .
    .d         .
  ]
]

scenario editor-scrolls-up-on-left-arrow [
  local-scope
  # screen has 1 line for menu + 3 lines
  assume-screen 5/width, 4/height
  # editor contains >3 lines
  s:text <- new [a
b
c
d
e]
  e:&:editor <- new-editor s, 0/left, 5/right
  editor-render screen, e
  # position cursor at top of second page
  assume-console [
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .     .
    .c    .
    .d    .
    .e    .
  ]
  # now try to move left
  assume-console [
    press left-arrow
  ]
  run [
    editor-event-loop screen, console, e
    3:num/raw <- get *e, cursor-row:offset
    4:num/raw <- get *e, cursor-column:offset
  ]
  # screen scrolls
  screen-should-contain [
    .     .
    .b    .
    .c    .
    .d    .
  ]
  memory-should-contain [
    3 <- 1
    4 <- 1
  ]
]

scenario editor-can-scroll-up-to-start-of-file [
  local-scope
  # screen has 1 line for menu + 3 lines
  assume-screen 10/width, 4/height
  # initialize editor with >3 lines
  s:text <- new [a
b
c
d]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .a         .
    .b         .
    .c         .
  ]
  # position cursor at top of second page, then try to move up to start of
  # text
  assume-console [
    press page-down
    press up-arrow
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen slides by one line
  screen-should-contain [
    .          .
    .a         .
    .b         .
    .c         .
  ]
  # try to move up again
  assume-console [
    press up-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen remains unchanged
  screen-should-contain [
    .          .
    .a         .
    .b         .
    .c         .
  ]
]

# ctrl-f/page-down - render next page if it exists

scenario editor-can-scroll [
  local-scope
  assume-screen 10/width, 4/height
  s:text <- new [a
b
c
d]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .a         .
    .b         .
    .c         .
  ]
  # scroll down
  assume-console [
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows next page
  screen-should-contain [
    .          .
    .c         .
    .d         .
    .┈┈┈┈┈┈┈┈┈┈.
  ]
]

after <handle-special-character> [
  {
    page-down?:bool <- equal c, 6/ctrl-f
    break-unless page-down?
    old-top:&:duplex-list:char <- get *editor, top-of-screen:offset
    <begin-move-cursor>
    page-down editor
    undo-coalesce-tag:num <- copy 0/never
    <end-move-cursor>
    top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
    movement?:bool <- not-equal top-of-screen, old-top
    return movement?/go-render
  }
]

after <handle-special-key> [
  {
    page-down?:bool <- equal k, 65518/page-down
    break-unless page-down?
    old-top:&:duplex-list:char <- get *editor, top-of-screen:offset
    <begin-move-cursor>
    page-down editor
    undo-coalesce-tag:num <- copy 0/never
    <end-move-cursor>
    top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
    movement?:bool <- not-equal top-of-screen, old-top
    return movement?/go-render
  }
]

# page-down skips entire wrapped lines, so it can't scroll past lines
# taking up the entire screen
def page-down editor:&:editor -> editor:&:editor [
  local-scope
  load-inputs
  # if editor contents don't overflow screen, do nothing
  bottom-of-screen:&:duplex-list:char <- get *editor, bottom-of-screen:offset
  return-unless bottom-of-screen
  # if not, position cursor at final character
  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
  before-cursor:&:duplex-list:char <- prev bottom-of-screen
  *editor <- put *editor, before-cursor:offset, before-cursor
  # keep one line in common with previous page
  {
    last:char <- get *before-cursor, value:offset
    newline?:bool <- equal last, 10/newline
    break-unless newline?:bool
    before-cursor <- prev before-cursor
    *editor <- put *editor, before-cursor:offset, before-cursor
  }
  # move cursor and top-of-screen to start of that line
  move-to-start-of-line editor
  before-cursor <- get *editor, before-cursor:offset
  *editor <- put *editor, top-of-screen:offset, before-cursor
]

# jump to previous newline
def move-to-start-of-line editor:&:editor -> editor:&:editor [
  local-scope
  load-inputs
  # update cursor column
  left:num <- get *editor, left:offset
  cursor-column:num <- copy left
  *editor <- put *editor, cursor-column:offset, cursor-column
  # update before-cursor
  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
  init:&:duplex-list:char <- get *editor, data:offset
  # while not at start of line, move
  {
    at-start-of-text?:bool <- equal before-cursor, init
    break-if at-start-of-text?
    prev:char <- get *before-cursor, value:offset
    at-start-of-line?:bool <- equal prev, 10/newline
    break-if at-start-of-line?
    before-cursor <- prev before-cursor
    *editor <- put *editor, before-cursor:offset, before-cursor
    assert before-cursor, [move-to-start-of-line tried to move before start of text]
    loop
  }
]

scenario editor-does-not-scroll-past-end [
  local-scope
  assume-screen 10/width, 4/height
  s:text <- new [a
b]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .a         .
    .b         .
    .┈┈┈┈┈┈┈┈┈┈.
  ]
  # scroll down
  assume-console [
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen remains unmodified
  screen-should-contain [
    .          .
    .a         .
    .b         .
    .┈┈┈┈┈┈┈┈┈┈.
  ]
]

scenario editor-starts-next-page-at-start-of-wrapped-line [
  local-scope
  # screen has 1 line for menu + 3 lines for text
  assume-screen 10/width, 4/height
  # editor contains a long last line
  s:text <- new [a
b
cdefgh]
  # editor screen triggers wrap of last line
  e:&:editor <- new-editor s, 0/left, 4/right
  editor-render screen, e
  # some part of last line is not displayed
  screen-should-contain [
    .          .
    .a         .
    .b         .
    .cde↩      .
  ]
  # scroll down
  assume-console [
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows entire wrapped line
  screen-should-contain [
    .          .
    .cde↩      .
    .fgh       .
    .┈┈┈┈      .
  ]
]

scenario editor-starts-next-page-at-start-of-wrapped-line-2 [
  local-scope
  # screen has 1 line for menu + 3 lines for text
  assume-screen 10/width, 4/height
  # editor contains a very long line that occupies last two lines of screen
  # and still has something left over
  s:text <- new [a
bcdefgh]
  e:&:editor <- new-editor s, 0/left, 4/right
  editor-render screen, e
  # some part of last line is not displayed
  screen-should-contain [
    .          .
    .a         .
    .bcd↩      .
    .efg↩      .
  ]
  # scroll down
  assume-console [
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows entire wrapped line
  screen-should-contain [
    .          .
    .bcd↩      .
    .efg↩      .
    .h         .
  ]
]

# ctrl-b/page-up - render previous page if it exists

scenario editor-can-scroll-up [
  local-scope
  assume-screen 10/width, 4/height
  s:text <- new [a
b
c
d]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .a         .
    .b         .
    .c         .
  ]
  # scroll down
  assume-console [
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows next page
  screen-should-contain [
    .          .
    .c         .
    .d         .
    .┈┈┈┈┈┈┈┈┈┈.
  ]
  # scroll back up
  assume-console [
    press page-up
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows original page again
  screen-should-contain [
    .          .
    .a         .
    .b         .
    .c         .
  ]
]

after <handle-special-character> [
  {
    page-up?:bool <- equal c, 2/ctrl-b
    break-unless page-up?
    old-top:&:duplex-list:char <- get *editor, top-of-screen:offset
    <begin-move-cursor>
    editor <- page-up editor, screen-height
    undo-coalesce-tag:num <- copy 0/never
    <end-move-cursor>
    top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
    movement?:bool <- not-equal top-of-screen, old-top
    return movement?/go-render
  }
]

after <handle-special-key> [
  {
    page-up?:bool <- equal k, 65519/page-up
    break-unless page-up?
    old-top:&:duplex-list:char <- get *editor, top-of-screen:offset
    <begin-move-cursor>
    editor <- page-up editor, screen-height
    undo-coalesce-tag:num <- copy 0/never
    <end-move-cursor>
    top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
    movement?:bool <- not-equal top-of-screen, old-top
    # don't bother re-rendering if nothing changed. todo: test this
    return movement?/go-render
  }
]

def page-up editor:&:editor, screen-height:num -> editor:&:editor [
  local-scope
  load-inputs
  max:num <- subtract screen-height, 1/menu-bar, 1/overlapping-line
  count:num <- copy 0
  top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
  {
    done?:bool <- greater-or-equal count, max
    break-if done?
    prev:&:duplex-list:char <- before-previous-screen-line top-of-screen, editor
    break-unless prev
    top-of-screen <- copy prev
    *editor <- put *editor, top-of-screen:offset, top-of-screen
    count <- add count, 1
    loop
  }
]

scenario editor-can-scroll-up-multiple-pages [
  local-scope
  # screen has 1 line for menu + 3 lines
  assume-screen 10/width, 4/height
  # initialize editor with 8 lines
  s:text <- new [a
b
c
d
e
f
g
h]
  e:&:editor <- new-editor s, 0/left, 10/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .a         .
    .b         .
    .c         .
  ]
  # scroll down two pages
  assume-console [
    press page-down
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows third page
  screen-should-contain [
    .          .
    .e         .
    .f         .
    .g         .
  ]
  # scroll up
  assume-console [
    press page-up
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows second page
  screen-should-contain [
    .          .
    .c         .
    .d         .
    .e         .
  ]
  # scroll up again
  assume-console [
    press page-up
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows original page again
  screen-should-contain [
    .          .
    .a         .
    .b         .
    .c         .
  ]
]

scenario editor-can-scroll-up-wrapped-lines [
  local-scope
  # screen has 1 line for menu + 5 lines for text
  assume-screen 10/width, 6/height
  # editor contains a long line in the first page
  s:text <- new [a
b
cdefgh
i
j
k
l
m
n
o]
  # editor screen triggers wrap of last line
  e:&:editor <- new-editor s, 0/left, 4/right
  editor-render screen, e
  # some part of last line is not displayed
  screen-should-contain [
    .          .
    .a         .
    .b         .
    .cde↩      .
    .fgh       .
    .i         .
  ]
  # scroll down a page and a line
  assume-console [
    press page-down
    left-click 5, 0
    press down-arrow
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows entire wrapped line
  screen-should-contain [
    .          .
    .j         .
    .k         .
    .l         .
    .m         .
    .n         .
  ]
  # now scroll up one page
  assume-console [
    press page-up
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen resets
  screen-should-contain [
    .          .
    .b         .
    .cde↩      .
    .fgh       .
    .i         .
    .j         .
  ]
]

scenario editor-can-scroll-up-wrapped-lines-2 [
  local-scope
  # screen has 1 line for menu + 3 lines for text
  assume-screen 10/width, 4/height
  # editor contains a very long line that occupies last two lines of screen
  # and still has something left over
  s:text <- new [a
bcdefgh]
  e:&:editor <- new-editor s, 0/left, 4/right
  editor-render screen, e
  # some part of last line is not displayed
  screen-should-contain [
    .          .
    .a         .
    .bcd↩      .
    .efg↩      .
  ]
  # scroll down
  assume-console [
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen shows entire wrapped line
  screen-should-contain [
    .          .
    .bcd↩      .
    .efg↩      .
    .h         .
  ]
  # scroll back up
  assume-console [
    press page-up
  ]
  run [
    editor-event-loop screen, console, e
  ]
  # screen resets
  screen-should-contain [
    .          .
    .a         .
    .bcd↩      .
    .efg↩      .
  ]
]

scenario editor-can-scroll-up-past-nonempty-lines [
  local-scope
  assume-screen 10/width, 4/height
  # text with empty line in second screen
  s:text <- new [axx
bxx
cxx
dxx
exx
fxx
gxx
hxx
]
  e:&:editor <- new-editor s, 0/left, 4/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .axx       .
    .bxx       .
    .cxx       .
  ]
  assume-console [
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .cxx       .
    .dxx       .
    .exx       .
  ]
  assume-console [
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .exx       .
    .fxx       .
    .gxx       .
  ]
  # scroll back up past empty line
  assume-console [
    press page-up
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .cxx       .
    .dxx       .
    .exx       .
  ]
]

scenario editor-can-scroll-up-past-empty-lines [
  local-scope
  assume-screen 10/width, 4/height
  # text with empty line in second screen
  s:text <- new [axy
bxy
cxy

dxy
exy
fxy
gxy
]
  e:&:editor <- new-editor s, 0/left, 4/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .axy       .
    .bxy       .
    .cxy       .
  ]
  assume-console [
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .cxy       .
    .          .
    .dxy       .
  ]
  assume-console [
    press page-down
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .dxy       .
    .exy       .
    .fxy       .
  ]
  # scroll back up past empty line
  assume-console [
    press page-up
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .cxy       .
    .          .
    .dxy       .
  ]
]

# ctrl-s - scroll up by one line
# todo: scenarios

after <handle-special-character> [
  {
    scroll-up?:bool <- equal c, 19/ctrl-s
    break-unless scroll-up?
    <begin-move-cursor>
    go-render?:bool, editor <- line-up editor, screen-height
    undo-coalesce-tag:num <- copy 5/line-up
    <end-move-cursor>
    return go-render?
  }
]

def line-up editor:&:editor, screen-height:num -> go-render?:bool, editor:&:editor [
  local-scope
  load-inputs
  left:num <- get *editor, left:offset
  right:num <- get *editor, right:offset
  max:num <- subtract right, left
  old-top:&:duplex-list:char <- get *editor, top-of-screen:offset
  new-top:&:duplex-list:char <- before-start-of-next-line old-top, max
  movement?:bool <- not-equal old-top, new-top
  {
    break-unless movement?
    *editor <- put *editor, top-of-screen:offset, new-top
  }
  return movement?
]

# ctrl-x - scroll down by one line
# todo: scenarios

after <handle-special-character> [
  {
    scroll-down?:bool <- equal c, 24/ctrl-x
    break-unless scroll-down?
    <begin-move-cursor>
    go-render?:bool, editor <- line-down editor, screen-height
    undo-coalesce-tag:num <- copy 6/line-down
    <end-move-cursor>
    return go-render?
  }
]

def line-down editor:&:editor, screen-height:num -> go-render?:bool, editor:&:editor [
  local-scope
  load-inputs
  old-top:&:duplex-list:char <- get *editor, top-of-screen:offset
  new-top:&:duplex-list:char <- before-previous-screen-line old-top, editor
  movement?:bool <- not-equal old-top, new-top
  {
    break-unless movement?
    *editor <- put *editor, top-of-screen:offset, new-top
  }
  return movement?
]

# ctrl-t - move current line to top of screen
# todo: scenarios

after <handle-special-character> [
  {
    scroll-down?:bool <- equal c, 20/ctrl-t
    break-unless scroll-down?
    <begin-move-cursor>
    old-top:&:duplex-list:char <- get *editor, top-of-screen:offset
    cursor:&:duplex-list:char <- get *editor, before-cursor:offset
    cursor <- next cursor
    new-top:&:duplex-list:char <- before-previous-screen-line cursor, editor
    *editor <- put *editor, top-of-screen:offset, new-top
    *editor <- put *editor, cursor-row:offset, 1
    go-render?:bool <- not-equal new-top, old-top
    undo-coalesce-tag:num <- copy 0/never
    <end-move-cursor>
    return go-render?
  }
]

# ctrl-/ - comment/uncomment current line

after <handle-special-character> [
  {
    comment-toggle?:bool <- equal c, 31/ctrl-slash
    break-unless comment-toggle?
    cursor-column:num <- get *editor, cursor-column:offset
    data:&:duplex-list:char <- get *editor, data:offset
    <begin-insert-character>
    before-line-start:&:duplex-list:char <- before-start-of-screen-line editor
    line-start:&:duplex-list:char <- next before-line-start
    commented-out?:bool <- match line-start, [#? ]  # comment prefix
    {
      break-unless commented-out?
      # uncomment
      data <- remove line-start, 3/length-comment-prefix, data
      cursor-column <- subtract cursor-column, 3/length-comment-prefix
      *editor <- put *editor, cursor-column:offset, cursor-column
      go-render? <- render-line-from-start screen, editor, 3/size-of-comment-leader
    }
    {
      break-if commented-out?
      # comment
      insert before-line-start, [#? ]
      cursor-column <- add cursor-column, 3/length-comment-prefix
      *editor <- put *editor, cursor-column:offset, cursor-column
      go-render? <- render-line-from-start screen, editor, 0
    }
    <end-insert-character>
    return
  }
]

# Render just from the start of the current line, and only if it wasn't
# wrapping before (include margin) and isn't wrapping now. Otherwise just tell
# the caller to go-render? the entire screen.
def render-line-from-start screen:&:screen, editor:&:editor, right-margin:num -> go-render?:bool, screen:&:screen [
  local-scope
  load-inputs
  before-line-start:&:duplex-list:char <- before-start-of-screen-line editor
  line-start:&:duplex-list:char <- next before-line-start
  color:num <- copy 7/white
  left:num <- get *editor, left:offset
  cursor-row:num <- get *editor, cursor-row:offset
  screen <- move-cursor screen, cursor-row, left
  right:num <- get *editor, right:offset
  end:num <- subtract right, right-margin
  i:num <- copy 0
  curr:&:duplex-list:char <- copy line-start
  {
    render-all?:bool <- greater-or-equal i, end
    return-if render-all?, true/go-render
    break-unless curr
    c:char <- get *curr, value:offset
    newline?:bool <- equal c, 10/newline
    break-if newline?
    color <- get-color color, c
    print screen, c, color
    curr <- next curr
    i <- add i, 1
    loop
  }
  clear-line-until screen, right
  return false/dont-render
]

def before-start-of-screen-line editor:&:editor -> result:&:duplex-list:char [
  local-scope
  load-inputs
  cursor:&:duplex-list:char <- get *editor, before-cursor:offset
  {
    next:&:duplex-list:char <- next cursor
    break-unless next
    cursor <- copy next
  }
  result <- before-previous-screen-line cursor, editor
]

scenario editor-comments-empty-line [
  local-scope
  assume-screen 10/width, 5/height
  e:&:editor <- new-editor [], 0/left, 5/right
  editor-render screen, e
  $clear-trace
  assume-console [
    press ctrl-slash
  ]
  run [
    editor-event-loop screen, console, e
    4:num/raw <- get *e, cursor-row:offset
    5:num/raw <- get *e, cursor-column:offset
  ]
  screen-should-contain [
    .          .
    .#?        .
    .┈┈┈┈┈     .
    .          .
  ]
  memory-should-contain [
    4 <- 1
    5 <- 3
  ]
  check-trace-count-for-label 5, [print-character]
]

scenario editor-comments-at-start-of-contents [
  local-scope
  assume-screen 10/width, 5/height
  e:&:editor <- new-editor [ab], 0/left, 10/right
  editor-render screen, e
  $clear-trace
  assume-console [
    press ctrl-slash
  ]
  run [
    editor-event-loop screen, console, e
    4:num/raw <- get *e, cursor-row:offset
    5:num/raw <- get *e, cursor-column:offset
  ]
  screen-should-contain [
    .          .
    .#? ab     .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  memory-should-contain [
    4 <- 1
    5 <- 3
  ]
  check-trace-count-for-label 10, [print-character]
]

scenario editor-comments-at-end-of-contents [
  local-scope
  assume-screen 10/width, 5/height
  e:&:editor <- new-editor [ab], 0/left, 10/right
  editor-render screen, e
  $clear-trace
  assume-console [
    left-click 1, 7
    press ctrl-slash
  ]
  run [
    editor-event-loop screen, console, e
    4:num/raw <- get *e, cursor-row:offset
    5:num/raw <- get *e, cursor-column:offset
  ]
  screen-should-contain [
    .          .
    .#? ab     .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  memory-should-contain [
    4 <- 1
    5 <- 5
  ]
  check-trace-count-for-label 10, [print-character]
  # toggle to uncomment
  $clear-trace
  assume-console [
    press ctrl-slash
  ]
  run [
    editor-event-loop screen, console, e
    4:num/raw <- get *e, cursor-row:offset
    5:num/raw <- get *e, cursor-column:offset
  ]
  screen-should-contain [
    .          .
    .ab        .
    .┈┈┈┈┈┈┈┈┈┈.
    .          .
  ]
  check-trace-count-for-label 10, [print-character]
]

scenario editor-comments-almost-wrapping-line [
  local-scope
  assume-screen 10/width, 5/height
  # editor starts out with a non-wrapping line
  e:&:editor <- new-editor [abcd], 0/left, 5/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .abcd      .
    .┈┈┈┈┈     .
    .          .
  ]
  $clear-trace
  # on commenting the line is now wrapped
  assume-console [
    left-click 1, 7
    press ctrl-slash
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .#? a↩     .
    .bcd       .
    .┈┈┈┈┈     .
    .          .
  ]
]

scenario editor-uncomments-just-wrapping-line [
  local-scope
  assume-screen 10/width, 5/height
  # editor starts out with a comment that wraps the line
  e:&:editor <- new-editor [#? ab], 0/left, 5/right
  editor-render screen, e
  screen-should-contain [
    .          .
    .#? a↩     .
    .b         .
    .┈┈┈┈┈     .
    .          .
  ]
  $clear-trace
  # on uncommenting the line is no longer wrapped
  assume-console [
    left-click 1, 7
    press ctrl-slash
  ]
  run [
    editor-event-loop screen, console, e
  ]
  screen-should-contain [
    .          .
    .ab        .
    .┈┈┈┈┈     .
    .          .
  ]
]