## handling events from the keyboard, mouse, touch screen, ...
# temporary main: interactive editor
# hit ctrl-c to exit
def! main text:text [
local-scope
load-inputs
open-console
clear-screen null/screen # non-scrolling app
editor:&:editor <- new-editor text, 5/left, 45/right
editor-render null/screen, editor
editor-event-loop null/screen, null/console, editor
close-console
]
def editor-event-loop screen:&:screen, console:&:console, editor:&:editor -> screen:&:screen, console:&:console, editor:&:editor [
local-scope
load-inputs
{
# looping over each (keyboard or touch) event as it occurs
+next-event
cursor-row:num <- get *editor, cursor-row:offset
cursor-column:num <- get *editor, cursor-column:offset
screen <- move-cursor screen, cursor-row, cursor-column
e:event, found?:bool, quit?:bool, console <- read-event console
loop-unless found?
break-if quit? # only in tests
trace 10, [app], [next-event]
# 'touch' event
t:touch-event, is-touch?:bool <- maybe-convert e, touch:variant
{
break-unless is-touch?
move-cursor editor, screen, t
loop +next-event
}
# keyboard events
{
break-if is-touch?
go-render?:bool <- handle-keyboard-event screen, editor, e
{
break-unless go-render?
screen <- editor-render screen, editor
}
}
loop
}
]
# process click, return if it was on current editor
def move-cursor editor:&:editor, screen:&:screen, t:touch-event -> in-focus?:bool, editor:&:editor [
local-scope
load-inputs
return-unless editor, false
click-row:num <- get t, row:offset
return-unless click-row, false # ignore clicks on 'menu'
click-column:num <- get t, column:offset
left:num <- get *editor, left:offset
too-far-left?:bool <- lesser-than click-column, left
return-if too-far-left?, false
right:num <- get *editor, right:offset
too-far-right?:bool <- greater-than click-column, right
return-if too-far-right?, false
# position cursor
<begin-move-cursor>
editor <- snap-cursor editor, screen, click-row, click-column
undo-coalesce-tag:num <- copy 0/never
<end-move-cursor>
# gain focus
return true
]
# Variant of 'render' that only moves the cursor (coordinates and
# before-cursor). If it's past the end of a line, it 'slides' it left. If it's
# past the last line it positions at end of last line.
def snap-cursor editor:&:editor, screen:&:screen, target-row:num, target-column:num -> editor:&:editor [
local-scope
load-inputs
return-unless editor
left:num <- get *editor, left:offset
right:num <- get *editor, right:offset
screen-height:num <- screen-height screen
# count newlines until screen row
curr:&:duplex-list:char <- get *editor, top-of-screen:offset
prev:&:duplex-list:char <- copy curr # just in case curr becomes null and we can't compute prev
curr <- next curr
row:num <- copy 1/top
column:num <- copy left
*editor <- put *editor, cursor-row:offset, target-row
cursor-row:num <- copy target-row
*editor <- put *editor, cursor-column:offset, target-column
cursor-column:num <- copy target-column
before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
{
+next-character
break-unless curr
off-screen?:bool <- greater-or-equal row, screen-height
break-if off-screen?
# update editor.before-cursor
# Doing so at the start of each iteration ensures it stays one step behind
# the current character.
{
at-cursor-row?:bool <- equal row, cursor-row
break-unless at-cursor-row?
at-cursor?:bool <- equal column, cursor-column
break-unless at-cursor?
before-cursor <- copy prev
*editor <- put *editor, before-cursor:offset, before-cursor
}
c:char <- get *curr, value:offset
{
# newline? move to left rather than 0
newline?:bool <- equal c, 10/newline
break-unless newline?
# adjust cursor if necessary
{
at-cursor-row?:bool <- equal row, cursor-row
break-unless at-cursor-row?
left-of-cursor?:bool <- lesser-than column, cursor-column
break-unless left-of-cursor?
cursor-column <- copy column
*editor <- put *editor, cursor-column:offset, cursor-column
before-cursor <- copy prev
*editor <- put *editor, before-cursor:offset, before-cursor
}
# skip to next line
row <- add row, 1
column <- copy left
curr <- next curr
prev <- next prev
loop +next-character
}
{
# at right? wrap. even if there's only one more letter left; we need
# room for clicking on the cursor after it.
at-right?:bool <- equal column, right
break-unless at-right?
column <- copy left
row <- add row, 1
# don't increment curr/prev
loop +next-character
}
curr <- next curr
prev <- next prev
column <- add column, 1
loop
}
# is cursor to the right of the last line? move to end
{
at-cursor-row?:bool <- equal row, cursor-row
cursor-outside-line?:bool <- lesser-or-equal column, cursor-column
before-cursor-on-same-line?:bool <- and at-cursor-row?, cursor-outside-line?
above-cursor-row?:bool <- lesser-than row, cursor-row
before-cursor?:bool <- or before-cursor-on-same-line?, above-cursor-row?
break-unless before-cursor?
cursor-row <- copy row
*editor <- put *editor, cursor-row:offset, cursor-row
cursor-column <- copy column
*editor <- put *editor, cursor-column:offset, cursor-column
before-cursor <- copy prev
*editor <- put *editor, before-cursor:offset, before-cursor
}
]
# Process an event 'e' and try to minimally update the screen.
# Set 'go-render?' to true to indicate the caller must perform a non-minimal update.
def handle-keyboard-event screen:&:screen, editor:&:editor, e:event -> go-render?:bool, screen:&:screen, editor:&:editor [
local-scope
load-inputs
return-unless editor, false/don't-render
screen-width:num <- screen-width screen
screen-height:num <- screen-height screen
left:num <- get *editor, left:offset
right:num <- get *editor, right:offset
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
save-row:num <- copy cursor-row
save-column:num <- copy cursor-column
# character
{
c:char, is-unicode?:bool <- maybe-convert e, text:variant
break-unless is-unicode?
trace 10, [app], [handle-keyboard-event: special character]
# exceptions for special characters go here
<handle-special-character>
# ignore any other special characters
regular-character?:bool <- greater-or-equal c, 32/space
return-unless regular-character?, false/don't-render
# otherwise type it in
<begin-insert-character>
go-render? <- insert-at-cursor editor, c, screen
<end-insert-character>
return
}
# special key to modify the text or move the cursor
k:num, is-keycode?:bool <- maybe-convert e:event, keycode:variant
assert is-keycode?, [event was of unknown type; neither keyboard nor mouse]
# handlers for each special key will go here
<handle-special-key>
return true/go-render
]
def insert-at-cursor editor:&:editor, c:char, screen:&:screen -> go-render?:bool, editor:&:editor, screen:&:screen [
local-scope
load-inputs
before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
insert c, before-cursor
before-cursor <- next before-cursor
*editor <- put *editor, before-cursor:offset, before-cursor
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
save-row:num <- copy cursor-row
save-column:num <- copy cursor-column
screen-width:num <- screen-width screen
screen-height:num <- screen-height screen
# occasionally we'll need to mess with the cursor
<insert-character-special-case>
# but mostly we'll just move the cursor right
cursor-column <- add cursor-column, 1
*editor <- put *editor, cursor-column:offset, cursor-column
next:&:duplex-list:char <- next before-cursor
{
# at end of all text? no need to scroll? just print the character and leave
at-end?:bool <- equal next, null
break-unless at-end?
bottom:num <- subtract screen-height, 1
at-bottom?:bool <- equal save-row, bottom
at-right?:bool <- equal save-column, right
overflow?:bool <- and at-bottom?, at-right?
break-if overflow?
move-cursor screen, save-row, save-column
print screen, c
return false/don't-render
}
{
# not at right margin? print the character and rest of line
break-unless next
at-right?:bool <- greater-or-equal cursor-column, screen-width
break-if at-right?
curr:&:duplex-list:char <- copy before-cursor
move-cursor screen, save-row, save-column
curr-column:num <- copy save-column
{
# hit right margin? give up and let caller render
at-right?:bool <- greater-than 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?
print screen, currc
curr-column <- add curr-column, 1
curr <- next curr
loop
}
return false/don't-render
}
return true/go-render
]
# helper for tests
def editor-render screen:&:screen, editor:&:editor -> screen:&:screen, editor:&:editor [
local-scope
load-inputs
old-top-idx:num <- save-top-idx screen
left:num <- get *editor, left:offset
right:num <- get *editor, right:offset
row:num, column:num <- render screen, editor
draw-horizontal screen, row, left, right, 9480/horizontal-dotted
row <- add row, 1
clear-screen-from screen, row, left, left, right
assert-no-scroll screen, old-top-idx
]
scenario editor-handles-empty-event-queue [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abc], 0/left, 10/right
editor-render screen, e
assume-console []
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.abc .
.┈┈┈┈┈┈┈┈┈┈.
. .
]
]
scenario editor-handles-mouse-clicks [
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 # on the 'b'
]
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 [
. .
.abc .
.┈┈┈┈┈┈┈┈┈┈.
. .
]
memory-should-contain [
3 <- 1 # cursor is at row 0..
4 <- 1 # ..and column 1
]
check-trace-count-for-label 0, [print-character]
]
scenario editor-handles-mouse-clicks-outside-text [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abc], 0/left, 10/right
$clear-trace
assume-console [
left-click 1, 7 # last line, to the right of text
]
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 # cursor row
4 <- 3 # cursor column
]
check-trace-count-for-label 0, [print-character]
]
scenario editor-handles-mouse-clicks-outside-text-2 [
local-scope
assume-screen 10/width, 5/height
s:text <- new [abc
def]
e:&:editor <- new-editor s, 0/left, 10/right
$clear-trace
assume-console [
left-click 1, 7 # interior line, to the right of text
]
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 # cursor row
4 <- 3 # cursor column
]
check-trace-count-for-label 0, [print-character]
]
scenario editor-handles-mouse-clicks-outside-text-3 [
local-scope
assume-screen 10/width, 5/height
s:text <- new [abc
def]
e:&:editor <- new-editor s, 0/left, 10/right
$clear-trace
assume-console [
left-click 3, 7 # below text
]
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 # cursor row
4 <- 3 # cursor column
]
check-trace-count-for-label 0, [print-character]
]
scenario editor-handles-mouse-clicks-outside-column [
local-scope
assume-screen 10/width, 5/height
# editor occupies only left half of screen
e:&:editor <- new-editor [abc], 0/left, 5/right
editor-render screen, e
$clear-trace
assume-console [
# click on right half of screen
left-click 3, 8
]
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 [
. .
.abc .
.┈┈┈┈┈ .
. .
]
memory-should-contain [
3 <- 1 # no change to cursor row
4 <- 0 # ..or column
]
check-trace-count-for-label 0, [print-character]
]
scenario editor-handles-mouse-clicks-in-menu-area [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abc], 0/left, 5/right
editor-render screen, e
$clear-trace
assume-console [
# click on first, 'menu' row
left-click 0, 3
]
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 to cursor
memory-should-contain [
3 <- 1
4 <- 0
]
]
scenario editor-inserts-characters-into-empty-editor [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [], 0/left, 5/right
editor-render screen, e
$clear-trace
assume-console [
type [abc]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.abc .
.┈┈┈┈┈ .
. .
]
check-trace-count-for-label 3, [print-character]
]
scenario editor-inserts-characters-at-cursor [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abc], 0/left, 10/right
editor-render screen, e
$clear-trace
# type two letters at different places
assume-console [
type [0]
left-click 1, 2
type [d]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.0adbc .
.┈┈┈┈┈┈┈┈┈┈.
. .
]
check-trace-count-for-label 7, [print-character] # 4 for first letter, 3 for second
]
scenario editor-inserts-characters-at-cursor-2 [
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, 5 # right of last line
type [d]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.abcd .
.┈┈┈┈┈┈┈┈┈┈.
. .
]
check-trace-count-for-label 1, [print-character]
]
scenario editor-inserts-characters-at-cursor-5 [
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
assume-console [
left-click 1, 5 # right of non-last line
type [e]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.abce .
.d .
.┈┈┈┈┈┈┈┈┈┈.
. .
]
check-trace-count-for-label 1, [print-character]
]
scenario editor-inserts-characters-at-cursor-3 [
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 3, 5 # below all text
type [d]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.abcd .
.┈┈┈┈┈┈┈┈┈┈.
. .
]
check-trace-count-for-label 1, [print-character]
]
scenario editor-inserts-characters-at-cursor-4 [
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
assume-console [
left-click 3, 5 # below all text
type [e]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.abc .
.de .
.┈┈┈┈┈┈┈┈┈┈.
. .
]
check-trace-count-for-label 1, [print-character]
]
scenario editor-inserts-characters-at-cursor-6 [
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
assume-console [
left-click 3, 5 # below all text
type [ef]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.abc .
.def .
.┈┈┈┈┈┈┈┈┈┈.
. .
]
check-trace-count-for-label 2, [print-character]
]
scenario editor-moves-cursor-after-inserting-characters [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [ab], 0/left, 5/right
editor-render screen, e
assume-console [
type [01]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.01ab .
.┈┈┈┈┈ .
. .
]
]
# if the cursor reaches the right margin, wrap the line
scenario editor-wraps-line-on-insert [
local-scope
assume-screen 5/width, 5/height
e:&:editor <- new-editor [abc], 0/left, 5/right
editor-render screen, e
# type a letter
assume-console [
type [e]
]
run [
editor-event-loop screen, console, e
]
# no wrap yet
screen-should-contain [
. .
.eabc .
.┈┈┈┈┈.
. .
. .
]
# type a second letter
assume-console [
type [f]
]
run [
editor-event-loop screen, console, e
]
# now wrap
screen-should-contain [
. .
.efab↩.
.c .
.┈┈┈┈┈.
. .
]
]
scenario editor-wraps-line-on-insert-2 [
local-scope
# create an editor with some text
assume-screen 10/width, 5/height
s:text <- new [abcdefg
defg]
e:&:editor <- new-editor s, 0/left, 5/right
editor-render screen, e
# type more text at the start
assume-console [
left-click 3, 0
type [abc]
]
run [
editor-event-loop screen, console, e
3:num/raw <- get *e, cursor-row:offset
4:num/raw <- get *e, cursor-column:offset
]
# cursor is not wrapped
memory-should-contain [
3 <- 3
4 <- 3
]
# but line is wrapped
screen-should-contain [
. .
.abcd↩ .
.efg .
.abcd↩ .
.efg .
]
]
after <insert-character-special-case> [
# if the line wraps at the cursor, move cursor to start of next row
{
# if either:
# a) we're at the end of the line and at the column of the wrap indicator, or
# b) we're not at end of line and just before the column of the wrap indicator
wrap-column:num <- copy right
before-wrap-column:num <- subtract wrap-column, 1
at-wrap?:bool <- greater-or-equal cursor-column, wrap-column
just-before-wrap?:bool <- greater-or-equal cursor-column, before-wrap-column
next:&:duplex-list:char <- next before-cursor
# at end of line? next == 0 || next.value == 10/newline
at-end-of-line?:bool <- equal next, null
{
break-if at-end-of-line?
next-character:char <- get *next, value:offset
at-end-of-line? <- equal next-character, 10/newline
}
# break unless ((eol? and at-wrap?) or (~eol? and just-before-wrap?))
move-cursor-to-next-line?:bool <- copy false
{
break-if at-end-of-line?
move-cursor-to-next-line? <- copy just-before-wrap?
# if we're moving the cursor because it's in the middle of a wrapping
# line, adjust it to left-most column
potential-new-cursor-column:num <- copy left
}
{
break-unless at-end-of-line?
move-cursor-to-next-line? <- copy at-wrap?
# if we're moving the cursor because it's at the end of a wrapping line,
# adjust it to one past the left-most column to make room for the
# newly-inserted wrap-indicator
potential-new-cursor-column:num <- add left, 1/make-room-for-wrap-indicator
}
break-unless move-cursor-to-next-line?
cursor-column <- copy potential-new-cursor-column
*editor <- put *editor, cursor-column:offset, cursor-column
cursor-row <- add cursor-row, 1
*editor <- put *editor, cursor-row:offset, cursor-row
# if we're out of the screen, scroll down
{
below-screen?:bool <- greater-or-equal cursor-row, screen-height
break-unless below-screen?
<scroll-down>
}
return true/go-render
}
]
scenario editor-wraps-cursor-after-inserting-characters-in-middle-of-line [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abcde], 0/left, 5/right
assume-console [
left-click 1, 3 # right before the wrap icon
type [f]
]
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 [
. .
.abcf↩ .
.de .
.┈┈┈┈┈ .
. .
]
memory-should-contain [
3 <- 2 # cursor row
4 <- 0 # cursor column
]
]
scenario editor-wraps-cursor-after-inserting-characters-at-end-of-line [
local-scope
assume-screen 10/width, 5/height
# create an editor containing two lines
s:text <- new [abc
xyz]
e:&:editor <- new-editor s, 0/left, 5/right
editor-render screen, e
screen-should-contain [
. .
.abc .
.xyz .
.┈┈┈┈┈ .
. .
]
assume-console [
left-click 1, 4 # at end of first line
type [de] # trigger wrap
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.abcd↩ .
.e .
.xyz .
.┈┈┈┈┈ .
]
]
scenario editor-wraps-cursor-to-left-margin [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abcde], 2/left, 7/right
assume-console [
left-click 1, 5 # line is full; no wrap icon yet
type [01]
]
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 [
. .
. abc0↩ .
. 1de .
. ┈┈┈┈┈ .
. .
]
memory-should-contain [
3 <- 2 # cursor row
4 <- 3 # cursor column
]
]
# if newline, move cursor to start of next line, and maybe align indent with previous line
container editor [
indent?:bool
]
after <editor-initialization> [
*result <- put *result, indent?:offset, true
]
scenario editor-moves-cursor-down-after-inserting-newline [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abc], 0/left, 10/right
assume-console [
type [0
1]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.0 .
.1abc .
.┈┈┈┈┈┈┈┈┈┈.
. .
]
]
after <handle-special-character> [
{
newline?:bool <- equal c, 10/newline
break-unless newline?
<begin-insert-enter>
insert-new-line-and-indent editor, screen
<end-insert-enter>
return true/go-render
}
]
def insert-new-line-and-indent editor:&:editor, screen:&:screen -> editor:&:editor, screen:&:screen [
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
screen-height:num <- screen-height screen
# update cursor coordinates
at-start-of-wrapped-line?:bool <- at-start-of-wrapped-line? editor
{
break-if at-start-of-wrapped-line?
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
# maybe scroll
{
below-screen?:bool <- greater-or-equal cursor-row, screen-height # must be equal, never greater
break-unless below-screen?
<scroll-down2>
cursor-row <- subtract cursor-row, 1 # bring back into screen range
*editor <- put *editor, cursor-row:offset, cursor-row
}
# insert newline
insert 10/newline, before-cursor
before-cursor <- next before-cursor
*editor <- put *editor, before-cursor:offset, before-cursor
# indent if necessary
indent?:bool <- get *editor, indent?:offset
return-unless indent?
d:&:duplex-list:char <- get *editor, data:offset
end-of-previous-line:&:duplex-list:char <- prev before-cursor
indent:num <- line-indent end-of-previous-line, d
i:num <- copy 0
{
indent-done?:bool <- greater-or-equal i, indent
break-if indent-done?
insert-at-cursor editor, 32/space, screen
i <- add i, 1
loop
}
]
def at-start-of-wrapped-line? editor:&:editor -> result:bool [
local-scope
load-inputs
left:num <- get *editor, left:offset
cursor-column:num <- get *editor, cursor-column:offset
cursor-at-left?:bool <- equal cursor-column, left
return-unless cursor-at-left?, false
before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
before-before-cursor:&:duplex-list:char <- prev before-cursor
return-unless before-before-cursor, false # cursor is at start of editor
char-before-cursor:char <- get *before-cursor, value:offset
cursor-after-newline?:bool <- equal char-before-cursor, 10/newline
return-if cursor-after-newline?, false
# if cursor is at left margin and not at start, but previous character is not a newline,
# then we're at start of a wrapped line
return true
]
# takes a pointer 'curr' into the doubly-linked list and its sentinel, counts
# the number of spaces at the start of the line containing 'curr'.
def line-indent 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?
# if c is a space, increment result
is-space?:bool <- equal c, 32/space
{
break-unless is-space?
result <- add result, 1
}
# if c is not a space, reset result
{
break-if is-space?
result <- copy 0
}
loop
}
]
scenario editor-moves-cursor-down-after-inserting-newline-2 [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abc], 1/left, 10/right
assume-console [
type [0
1]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
. 0 .
. 1abc .
. ┈┈┈┈┈┈┈┈┈.
. .
]
]
scenario editor-clears-previous-line-completely-after-inserting-newline [
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 .
.┈┈┈┈┈ .
. .
]
assume-console [
press enter
]
run [
editor-event-loop screen, console, e
]
# line should be fully cleared
screen-should-contain [
. .
. .
.abcd↩ .
.e .
.┈┈┈┈┈ .
]
]
scenario editor-splits-wrapped-line-after-inserting-newline [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abcdef], 0/left, 5/right
editor-render screen, e
screen-should-contain [
. .
.abcd↩ .
.ef .
.┈┈┈┈┈ .
. .
]
assume-console [
left-click 2, 0
press enter
]
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 [
. .
.abcd .
.ef .
.┈┈┈┈┈ .
]
memory-should-contain [
10 <- 2 # cursor-row
11 <- 0 # cursor-column
]
]
scenario editor-inserts-indent-after-newline [
local-scope
assume-screen 10/width, 10/height
s:text <- new [ab
cd
ef]
e:&:editor <- new-editor s, 0/left, 10/right
# position cursor after 'cd' and hit 'newline'
assume-console [
left-click 2, 8
type [
]
]
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 below start of previous line
memory-should-contain [
3 <- 3 # cursor row
4 <- 2 # cursor column (indented)
]
]
scenario editor-skips-indent-around-paste [
local-scope
assume-screen 10/width, 10/height
s:text <- new [ab
cd
ef]
e:&:editor <- new-editor s, 0/left, 10/right
# position cursor after 'cd' and hit 'newline' surrounded by paste markers
assume-console [
left-click 2, 8
press 65507 # start paste
press enter
press 65506 # end paste
]
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 below start of previous line
memory-should-contain [
3 <- 3 # cursor row
4 <- 0 # cursor column (not indented)
]
]
after <handle-special-key> [
{
paste-start?:bool <- equal k, 65507/paste-start
break-unless paste-start?
*editor <- put *editor, indent?:offset, false
return true/go-render
}
]
after <handle-special-key> [
{
paste-end?:bool <- equal k, 65506/paste-end
break-unless paste-end?
*editor <- put *editor, indent?:offset, true
return true/go-render
}
]
## helpers
def draw-horizontal screen:&:screen, row:num, x:num, right:num -> screen:&:screen [
local-scope
load-inputs
height:num <- screen-height screen
past-bottom?:bool <- greater-or-equal row, height
return-if past-bottom?
style:char, style-found?:bool <- next-input
{
break-if style-found?
style <- copy 9472/horizontal
}
color:num, color-found?:bool <- next-input
{
# default color to white
break-if color-found?
color <- copy 245/grey
}
bg-color:num, bg-color-found?:bool <- next-input
{
break-if bg-color-found?
bg-color <- copy 0/black
}
screen <- move-cursor screen, row, x
{
continue?:bool <- lesser-or-equal x, right # right is inclusive, to match editor semantics
break-unless continue?
print screen, style, color, bg-color
x <- add x, 1
loop
}
]