1145 lines
31 KiB
Plaintext
1145 lines
31 KiB
Plaintext
## 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
|
|
}
|
|
]
|