1777 lines
69 KiB
Forth
1777 lines
69 KiB
Forth
type environment {
|
|
search-terms: (handle gap-buffer)
|
|
tabs: (handle array tab)
|
|
current-tab-index: int # index into tabs
|
|
dirty?: boolean
|
|
# search mode
|
|
cursor-in-search?: boolean
|
|
# channel mode
|
|
cursor-in-channels?: boolean
|
|
channel-cursor-index: int
|
|
}
|
|
|
|
type tab {
|
|
type: int
|
|
# type 0: all items
|
|
# type 1: items in a channel
|
|
# type 2: search for a term
|
|
# type 3: comments in a single thread
|
|
item-index: int # what item in the corresponding list we start rendering
|
|
# the current page at
|
|
# only for type 0, 1
|
|
hidden-items: (handle stream int)
|
|
# only for type 1
|
|
channel-index: int
|
|
# only for type 2
|
|
search-terms: (handle gap-buffer)
|
|
search-items: (handle array int)
|
|
search-items-first-free: int
|
|
# only for type 3
|
|
root-index: int
|
|
}
|
|
|
|
# static buffer sizes in this file:
|
|
# main-panel-hor # in characters
|
|
# item-padding-hor # in pixels
|
|
# item-padding-ver # in characters
|
|
# avatar-side # in pixels
|
|
# avatar-space-hor # in characters
|
|
# avatar-space-ver # in characters
|
|
# search-position-x # in characters
|
|
# search-space-ver # in characters
|
|
# author-name-padding-ver # in characters
|
|
# post-right-coord # in characters
|
|
# channel-offset-x # in characters
|
|
# menu-space-ver # in characters
|
|
# max-search-results
|
|
|
|
fn initialize-environment _self: (addr environment), _items: (addr item-list) {
|
|
var self/esi: (addr environment) <- copy _self
|
|
var search-terms-ah/eax: (addr handle gap-buffer) <- get self, search-terms
|
|
allocate search-terms-ah
|
|
var search-terms/eax: (addr gap-buffer) <- lookup *search-terms-ah
|
|
initialize-gap-buffer search-terms, 0x30/search-capacity
|
|
var items/eax: (addr item-list) <- copy _items
|
|
var items-data-first-free-a/eax: (addr int) <- get items, data-first-free
|
|
var final-item/edx: int <- copy *items-data-first-free-a
|
|
final-item <- decrement
|
|
var tabs-ah/ecx: (addr handle array tab) <- get self, tabs
|
|
populate tabs-ah, 0x10/max-history
|
|
# current-tab-index implicitly set to 0
|
|
var tabs/eax: (addr array tab) <- lookup *tabs-ah
|
|
var first-tab/eax: (addr tab) <- index tabs, 0/current-tab-index
|
|
var dest/edi: (addr int) <- get first-tab, item-index
|
|
copy-to *dest, final-item
|
|
}
|
|
|
|
### Render
|
|
|
|
fn render-environment screen: (addr screen), _env: (addr environment), users: (addr array user), channels: (addr array channel), items: (addr item-list) {
|
|
var env/esi: (addr environment) <- copy _env
|
|
{
|
|
var dirty?/eax: (addr boolean) <- get env, dirty?
|
|
compare *dirty?, 0/false
|
|
break-if-!=
|
|
# minimize repaints when typing into the search bar
|
|
{
|
|
var cursor-in-search?/eax: (addr boolean) <- get env, cursor-in-search?
|
|
compare *cursor-in-search?, 0/false
|
|
break-if-=
|
|
render-search-input screen, env
|
|
clear-rect screen, 0/x 0x2f/y, 0x80/x 0x30/y, 0/bg
|
|
render-search-menu screen, env
|
|
return
|
|
}
|
|
# minimize repaints when focus in channel nav
|
|
{
|
|
var cursor-in-channels?/eax: (addr boolean) <- get env, cursor-in-channels?
|
|
compare *cursor-in-channels?, 0/false
|
|
break-if-=
|
|
render-channels screen, env, channels
|
|
clear-rect screen, 0/x 0x2f/y, 0x80/x 0x30/y, 0/bg
|
|
render-channels-menu screen, env
|
|
return
|
|
}
|
|
}
|
|
# full repaint
|
|
clear-screen screen
|
|
render-search-input screen, env
|
|
render-channels screen, env, channels
|
|
render-item-list screen, env, users, channels, items
|
|
render-menu screen, env
|
|
var dirty?/eax: (addr boolean) <- get env, dirty?
|
|
copy-to *dirty?, 0/false
|
|
}
|
|
|
|
fn render-channels screen: (addr screen), _env: (addr environment), _channels: (addr array channel) {
|
|
var env/esi: (addr environment) <- copy _env
|
|
var cursor-index/edi: int <- copy -1
|
|
{
|
|
var cursor-in-search?/eax: (addr boolean) <- get env, cursor-in-search?
|
|
compare *cursor-in-search?, 0/false
|
|
break-if-!=
|
|
var cursor-in-channels?/eax: (addr boolean) <- get env, cursor-in-channels?
|
|
compare *cursor-in-channels?, 0/false
|
|
break-if-=
|
|
var cursor-index-addr/eax: (addr int) <- get env, channel-cursor-index
|
|
cursor-index <- copy *cursor-index-addr
|
|
}
|
|
var channels/esi: (addr array channel) <- copy _channels
|
|
var y/ebx: int <- copy 2/search-space-ver
|
|
y <- add 1/item-padding-ver
|
|
var i/ecx: int <- copy 0
|
|
var max/edx: int <- length channels
|
|
{
|
|
compare i, max
|
|
break-if->=
|
|
var offset/eax: (offset channel) <- compute-offset channels, i
|
|
var curr/eax: (addr channel) <- index channels, offset
|
|
var name-ah/eax: (addr handle array byte) <- get curr, name
|
|
var name/eax: (addr array byte) <- lookup *name-ah
|
|
compare name, 0
|
|
break-if-=
|
|
set-cursor-position screen, 2/x y
|
|
{
|
|
compare cursor-index, i
|
|
break-if-=
|
|
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "#", 7/grey 0/black
|
|
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, name, 7/grey 0/black
|
|
}
|
|
{
|
|
compare cursor-index, i
|
|
break-if-!=
|
|
# cursor; reverse video
|
|
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "#", 0/black 0xf/white
|
|
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, name, 0/black 0xf/white
|
|
}
|
|
y <- add 2/channel-padding
|
|
i <- increment
|
|
loop
|
|
}
|
|
}
|
|
|
|
fn render-item-list screen: (addr screen), _env: (addr environment), users: (addr array user), channels: (addr array channel), items: (addr item-list) {
|
|
var env/esi: (addr environment) <- copy _env
|
|
var tmp-width/eax: int <- copy 0
|
|
var tmp-height/ecx: int <- copy 0
|
|
tmp-width, tmp-height <- screen-size screen
|
|
var screen-width: int
|
|
copy-to screen-width, tmp-width
|
|
var screen-height: int
|
|
copy-to screen-height, tmp-height
|
|
#
|
|
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
|
|
var _tabs/eax: (addr array tab) <- lookup *tabs-ah
|
|
var tabs/edx: (addr array tab) <- copy _tabs
|
|
var current-tab-index-a/eax: (addr int) <- get env, current-tab-index
|
|
var current-tab-index/eax: int <- copy *current-tab-index-a
|
|
var current-tab-offset/eax: (offset tab) <- compute-offset tabs, current-tab-index
|
|
var current-tab/edx: (addr tab) <- index tabs, current-tab-offset
|
|
var show-cursor?: boolean
|
|
{
|
|
var cursor-in-search?/eax: (addr boolean) <- get env, cursor-in-search?
|
|
compare *cursor-in-search?, 0/false
|
|
break-if-!=
|
|
var cursor-in-channels?/eax: (addr boolean) <- get env, cursor-in-channels?
|
|
compare *cursor-in-channels?, 0/false
|
|
break-if-!=
|
|
copy-to show-cursor?, 1/true
|
|
}
|
|
render-tab screen, current-tab, show-cursor?, users, channels, items, screen-height
|
|
var top/eax: int <- copy screen-height
|
|
top <- subtract 2/menu-space-ver
|
|
clear-rect screen, 0 top, screen-width screen-height, 0/bg
|
|
}
|
|
|
|
fn render-tab screen: (addr screen), _current-tab: (addr tab), show-cursor?: boolean, users: (addr array user), channels: (addr array channel), items: (addr item-list), screen-height: int {
|
|
var current-tab/esi: (addr tab) <- copy _current-tab
|
|
var current-tab-type/eax: (addr int) <- get current-tab, type
|
|
compare *current-tab-type, 0/all-items
|
|
{
|
|
break-if-!=
|
|
render-all-items screen, current-tab, show-cursor?, items, users, screen-height
|
|
return
|
|
}
|
|
compare *current-tab-type, 1/channel
|
|
{
|
|
break-if-!=
|
|
render-channel-tab screen, current-tab, show-cursor?, users, channels, items, screen-height
|
|
return
|
|
}
|
|
compare *current-tab-type, 2/search
|
|
{
|
|
break-if-!=
|
|
render-search-tab screen, current-tab, show-cursor?, users, channels, items, screen-height
|
|
return
|
|
}
|
|
compare *current-tab-type, 3/thread
|
|
{
|
|
break-if-!=
|
|
render-thread-tab screen, current-tab, show-cursor?, users, channels, items, screen-height
|
|
return
|
|
}
|
|
}
|
|
|
|
fn render-all-items screen: (addr screen), _current-tab: (addr tab), show-cursor?: boolean, _items: (addr item-list), users: (addr array user), screen-height: int {
|
|
var current-tab/esi: (addr tab) <- copy _current-tab
|
|
var items/edi: (addr item-list) <- copy _items
|
|
var newest-item/eax: (addr int) <- get current-tab, item-index
|
|
var i/ebx: int <- copy *newest-item
|
|
var items-data-first-free-addr/eax: (addr int) <- get items, data-first-free
|
|
render-progress screen, i, *items-data-first-free-addr
|
|
var items-data-ah/eax: (addr handle array item) <- get items, data
|
|
var _items-data/eax: (addr array item) <- lookup *items-data-ah
|
|
var items-data/edi: (addr array item) <- copy _items-data
|
|
var y/ecx: int <- copy 2/search-space-ver
|
|
y <- add 1/item-padding-ver
|
|
$render-all-items:loop: {
|
|
compare i, 0
|
|
break-if-<
|
|
{
|
|
var hide?/eax: boolean <- should-hide? current-tab, i, _items
|
|
compare hide?, 0/false
|
|
break-if-=
|
|
i <- decrement
|
|
loop $render-all-items:loop
|
|
}
|
|
compare y, screen-height
|
|
break-if->=
|
|
var offset/eax: (offset item) <- compute-offset items-data, i
|
|
var curr-item/eax: (addr item) <- index items-data, offset
|
|
y <- render-item screen, curr-item, users, show-cursor?, y, screen-height
|
|
# cursor always at top item
|
|
copy-to show-cursor?, 0/false
|
|
i <- decrement
|
|
loop
|
|
}
|
|
}
|
|
|
|
fn render-channel-tab screen: (addr screen), _current-tab: (addr tab), show-cursor?: boolean, users: (addr array user), _channels: (addr array channel), _items: (addr item-list), screen-height: int {
|
|
var current-tab/esi: (addr tab) <- copy _current-tab
|
|
var items/edi: (addr item-list) <- copy _items
|
|
var channels/ebx: (addr array channel) <- copy _channels
|
|
var channel-index-addr/eax: (addr int) <- get current-tab, channel-index
|
|
var channel-index/eax: int <- copy *channel-index-addr
|
|
var channel-offset/eax: (offset channel) <- compute-offset channels, channel-index
|
|
var current-channel/ecx: (addr channel) <- index channels, channel-offset
|
|
var current-channel-posts-ah/eax: (addr handle array int) <- get current-channel, posts
|
|
var _current-channel-posts/eax: (addr array int) <- lookup *current-channel-posts-ah
|
|
var current-channel-posts/edx: (addr array int) <- copy _current-channel-posts
|
|
var current-channel-first-channel-item-addr/eax: (addr int) <- get current-tab, item-index
|
|
var i/ebx: int <- copy *current-channel-first-channel-item-addr
|
|
var current-channel-posts-first-free-addr/eax: (addr int) <- get current-channel, posts-first-free
|
|
set-cursor-position 0/screen, 0x68/x 0/y
|
|
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "channel", 7/fg 0/bg
|
|
render-progress screen, i, *current-channel-posts-first-free-addr
|
|
var items-data-ah/eax: (addr handle array item) <- get items, data
|
|
var _items-data/eax: (addr array item) <- lookup *items-data-ah
|
|
var items-data/edi: (addr array item) <- copy _items-data
|
|
var y/ecx: int <- copy 2/search-space-ver
|
|
y <- add 1/item-padding-ver
|
|
{
|
|
compare i, 0
|
|
break-if-<
|
|
compare y, screen-height
|
|
break-if->=
|
|
var item-index-addr/eax: (addr int) <- index current-channel-posts, i
|
|
var item-index/eax: int <- copy *item-index-addr
|
|
var item-offset/eax: (offset item) <- compute-offset items-data, item-index
|
|
var curr-item/eax: (addr item) <- index items-data, item-offset
|
|
y <- render-item screen, curr-item, users, show-cursor?, y, screen-height
|
|
# cursor always at top item
|
|
copy-to show-cursor?, 0/false
|
|
i <- decrement
|
|
loop
|
|
}
|
|
}
|
|
|
|
fn render-search-tab screen: (addr screen), _current-tab: (addr tab), show-cursor?: boolean, users: (addr array user), channels: (addr array channel), _items: (addr item-list), screen-height: int {
|
|
var current-tab/esi: (addr tab) <- copy _current-tab
|
|
var items/edi: (addr item-list) <- copy _items
|
|
var current-tab-search-items-ah/eax: (addr handle array int) <- get current-tab, search-items
|
|
var _current-tab-search-items/eax: (addr array int) <- lookup *current-tab-search-items-ah
|
|
var current-tab-search-items/ebx: (addr array int) <- copy _current-tab-search-items
|
|
var current-tab-top-item-addr/eax: (addr int) <- get current-tab, item-index
|
|
var i/edx: int <- copy *current-tab-top-item-addr
|
|
var current-tab-search-items-first-free-addr/eax: (addr int) <- get current-tab, search-items-first-free
|
|
set-cursor-position 0/screen, 0x68/x 0/y
|
|
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "search", 7/fg 0/bg
|
|
render-progress screen, i, *current-tab-search-items-first-free-addr
|
|
{
|
|
compare *current-tab-search-items-first-free-addr, 0x100/max-search-results
|
|
break-if-<
|
|
set-cursor-position 0/screen, 0x68/x 1/y
|
|
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "too many results", 4/fg 0/bg
|
|
}
|
|
var items-data-ah/eax: (addr handle array item) <- get items, data
|
|
var _items-data/eax: (addr array item) <- lookup *items-data-ah
|
|
var items-data/edi: (addr array item) <- copy _items-data
|
|
var y/ecx: int <- copy 2/search-space-ver
|
|
y <- add 1/item-padding-ver
|
|
{
|
|
compare i, 0
|
|
break-if-<
|
|
compare y, screen-height
|
|
break-if->=
|
|
var item-index-addr/eax: (addr int) <- index current-tab-search-items, i
|
|
var item-index/eax: int <- copy *item-index-addr
|
|
var item-offset/eax: (offset item) <- compute-offset items-data, item-index
|
|
var curr-item/eax: (addr item) <- index items-data, item-offset
|
|
y <- render-item screen, curr-item, users, show-cursor?, y, screen-height
|
|
# cursor always at top item
|
|
copy-to show-cursor?, 0/false
|
|
i <- decrement
|
|
loop
|
|
}
|
|
}
|
|
|
|
fn render-thread-tab screen: (addr screen), _current-tab: (addr tab), show-cursor?: boolean, users: (addr array user), channels: (addr array channel), _items: (addr item-list), screen-height: int {
|
|
var current-tab/esi: (addr tab) <- copy _current-tab
|
|
var items/eax: (addr item-list) <- copy _items
|
|
var items-data-ah/eax: (addr handle array item) <- get items, data
|
|
var _items-data/eax: (addr array item) <- lookup *items-data-ah
|
|
var items-data/edi: (addr array item) <- copy _items-data
|
|
var post-index-addr/eax: (addr int) <- get current-tab, root-index
|
|
var post-index/eax: int <- copy *post-index-addr
|
|
var post-offset/eax: (offset item) <- compute-offset items-data, post-index
|
|
var post/ebx: (addr item) <- index items-data, post-offset
|
|
var current-tab-top-item-addr/eax: (addr int) <- get current-tab, item-index
|
|
var i/edx: int <- copy *current-tab-top-item-addr
|
|
var post-comments-first-free-addr/eax: (addr int) <- get post, comments-first-free
|
|
set-cursor-position 0/screen, 0x68/x 0/y
|
|
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "thread", 7/fg 0/bg
|
|
render-progress screen, i, *post-comments-first-free-addr
|
|
var post-comments-ah/eax: (addr handle array int) <- get post, comments
|
|
var post-comments/eax: (addr array int) <- lookup *post-comments-ah
|
|
var y/ecx: int <- copy 2/search-space-ver
|
|
y <- add 1/item-padding-ver
|
|
{
|
|
compare i, 0
|
|
break-if-<
|
|
compare y, screen-height
|
|
break-if->=
|
|
var item-index-addr/eax: (addr int) <- index post-comments, i
|
|
var item-index/eax: int <- copy *item-index-addr
|
|
var item-offset/eax: (offset item) <- compute-offset items-data, item-index
|
|
var curr-item/eax: (addr item) <- index items-data, item-offset
|
|
y <- render-item screen, curr-item, users, show-cursor?, y, screen-height
|
|
# cursor always at top item
|
|
copy-to show-cursor?, 0/false
|
|
i <- decrement
|
|
loop
|
|
}
|
|
# finally render the parent -- though we'll never focus on it
|
|
y <- render-item screen, post, users, 0/no-cursor, y, screen-height
|
|
}
|
|
|
|
# side-effect: mutates cursor position
|
|
fn render-progress screen: (addr screen), curr: int, max: int {
|
|
set-cursor-position 0/screen, 0x70/x 0/y
|
|
var top-index/eax: int <- copy max
|
|
top-index <- subtract curr # happy accident: 1-based
|
|
draw-int32-decimal-wrapping-right-then-down-from-cursor-over-full-screen screen, top-index, 7/fg 0/bg
|
|
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "/", 7/fg 0/bg
|
|
draw-int32-decimal-wrapping-right-then-down-from-cursor-over-full-screen screen, max, 7/fg 0/bg
|
|
}
|
|
|
|
fn render-search-input screen: (addr screen), _env: (addr environment) {
|
|
var env/esi: (addr environment) <- copy _env
|
|
var cursor-in-search?/ecx: (addr boolean) <- get env, cursor-in-search?
|
|
set-cursor-position 0/screen, 0x22/x=search-position-x 1/y
|
|
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "search ", 7/fg 0/bg
|
|
var search-terms-ah/eax: (addr handle gap-buffer) <- get env, search-terms
|
|
var search-terms/eax: (addr gap-buffer) <- lookup *search-terms-ah
|
|
rewind-gap-buffer search-terms
|
|
var x/eax: int <- render-gap-buffer screen, search-terms, 0x2a/x 1/y, *cursor-in-search?, 0xf/fg 0/bg
|
|
{
|
|
compare x, 0x4a/end-search
|
|
break-if->
|
|
var y/ecx: int <- copy 0
|
|
x, y <- render-code-point screen, 0x5f/underscore, 0/xmin 1/ymin, 0x80/xmax, 1/ymax, x, 1/y, 0xf/fg 0/bg
|
|
loop
|
|
}
|
|
}
|
|
|
|
# not used in search mode
|
|
fn render-menu screen: (addr screen), _env: (addr environment) {
|
|
var env/edi: (addr environment) <- copy _env
|
|
{
|
|
var cursor-in-search?/eax: (addr boolean) <- get env, cursor-in-search?
|
|
compare *cursor-in-search?, 0/false
|
|
break-if-=
|
|
render-search-menu screen, env
|
|
return
|
|
}
|
|
var cursor-in-channels?/eax: (addr boolean) <- get env, cursor-in-channels?
|
|
compare *cursor-in-channels?, 0/false
|
|
{
|
|
break-if-=
|
|
render-channels-menu screen, env
|
|
return
|
|
}
|
|
render-main-menu screen, env
|
|
}
|
|
|
|
fn render-main-menu screen: (addr screen), _env: (addr environment) {
|
|
var width/eax: int <- copy 0
|
|
var y/ecx: int <- copy 0
|
|
width, y <- screen-size screen
|
|
y <- decrement
|
|
set-cursor-position screen, 2/x, y
|
|
{
|
|
var env/edi: (addr environment) <- copy _env
|
|
var num-tabs/edi: (addr int) <- get env, current-tab-index
|
|
compare *num-tabs, 0
|
|
break-if-<=
|
|
draw-text-rightward-from-cursor screen, " Esc ", width, 0/fg 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " go back ", width, 0xf/fg, 0/bg
|
|
}
|
|
draw-text-rightward-from-cursor screen, " / ", width, 0/fg 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " search ", width, 0xf/fg, 0/bg
|
|
draw-text-rightward-from-cursor screen, " Tab ", width, 0/fg 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " go to channels ", width, 0xf/fg, 0/bg
|
|
draw-text-rightward-from-cursor screen, " Enter ", width, 0/fg 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " go to thread ", width, 0xf/fg, 0/bg
|
|
{
|
|
{
|
|
var is-all-items-or-channel?/eax: boolean <- current-tab-is-all-items-or-channel? _env
|
|
compare is-all-items-or-channel?, 0/false
|
|
}
|
|
break-if-=
|
|
draw-text-rightward-from-cursor screen, " ^h ", width, 0/fg 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " hide thread ", width, 0xf/fg, 0/bg
|
|
draw-text-rightward-from-cursor screen, " ^u ", width, 0/fg 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " unhide all ", width, 0xf/fg, 0/bg
|
|
}
|
|
draw-text-rightward-from-cursor screen, " ^b ", width, 0/fg 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " << page ", width, 0xf/fg, 0/bg
|
|
draw-text-rightward-from-cursor screen, " ^f ", width, 0/fg 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " page >> ", width, 0xf/fg, 0/bg
|
|
}
|
|
|
|
fn render-channels-menu screen: (addr screen), _env: (addr environment) {
|
|
var width/eax: int <- copy 0
|
|
var y/ecx: int <- copy 0
|
|
width, y <- screen-size screen
|
|
y <- decrement
|
|
set-cursor-position screen, 2/x, y
|
|
{
|
|
var env/edi: (addr environment) <- copy _env
|
|
var num-tabs/edi: (addr int) <- get env, current-tab-index
|
|
compare *num-tabs, 0
|
|
break-if-<=
|
|
draw-text-rightward-from-cursor screen, " Esc ", width, 0/fg 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " go back ", width, 0xf/fg, 0/bg
|
|
}
|
|
draw-text-rightward-from-cursor screen, " / ", width, 0/fg 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " search ", width, 0xf/fg, 0/bg
|
|
draw-text-rightward-from-cursor screen, " Tab ", width, 0/fg 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " go to items ", width, 0xf/fg, 0/bg
|
|
draw-text-rightward-from-cursor screen, " Enter ", width, 0/fg 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " select ", width, 0xf/fg, 0/bg
|
|
}
|
|
|
|
fn render-search-menu screen: (addr screen), _env: (addr environment) {
|
|
var width/eax: int <- copy 0
|
|
var y/ecx: int <- copy 0
|
|
width, y <- screen-size screen
|
|
y <- decrement
|
|
set-cursor-position screen, 2/x, y
|
|
draw-text-rightward-from-cursor screen, " Esc ", width, 0/fg 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " cancel ", width, 0xf/fg, 0/bg
|
|
draw-text-rightward-from-cursor screen, " Enter ", width, 0/fg 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " select ", width, 0xf/fg, 0/bg
|
|
draw-text-rightward-from-cursor screen, " ^a ", width, 0/fg, 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " << ", width, 0xf/fg, 0/bg
|
|
draw-text-rightward-from-cursor screen, " ^b ", width, 0/fg, 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " <word ", width, 0xf/fg, 0/bg
|
|
draw-text-rightward-from-cursor screen, " ^f ", width, 0/fg, 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " word> ", width, 0xf/fg, 0/bg
|
|
draw-text-rightward-from-cursor screen, " ^e ", width, 0/fg, 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " >> ", width, 0xf/fg, 0/bg
|
|
draw-text-rightward-from-cursor screen, " ^u ", width, 0/fg, 0xf/bg
|
|
draw-text-rightward-from-cursor screen, " clear ", width, 0xf/fg, 0/bg
|
|
}
|
|
|
|
fn render-item screen: (addr screen), _item: (addr item), _users: (addr array user), show-cursor?: boolean, y: int, screen-height: int -> _/ecx: int {
|
|
var item/esi: (addr item) <- copy _item
|
|
var users/edi: (addr array user) <- copy _users
|
|
var author-index-addr/ecx: (addr int) <- get item, by
|
|
var author-index/ecx: int <- copy *author-index-addr
|
|
var author-offset/ecx: (offset user) <- compute-offset users, author-index
|
|
var author/ecx: (addr user) <- index users, author-offset
|
|
# author avatar
|
|
var author-avatar-ah/eax: (addr handle image) <- get author, avatar
|
|
var _author-avatar/eax: (addr image) <- lookup *author-avatar-ah
|
|
var author-avatar/ebx: (addr image) <- copy _author-avatar
|
|
{
|
|
compare author-avatar, 0
|
|
break-if-=
|
|
var y/edx: int <- copy y
|
|
y <- shift-left 4/log2font-height
|
|
var x/eax: int <- copy 0x20/main-panel-hor
|
|
x <- shift-left 3/log2font-width
|
|
x <- add 0x18/item-padding-hor
|
|
render-image screen, author-avatar, x, y, 0x50/avatar-side, 0x50/avatar-side
|
|
}
|
|
# channel
|
|
var channel-name-ah/eax: (addr handle array byte) <- get item, channel
|
|
var channel-name/eax: (addr array byte) <- lookup *channel-name-ah
|
|
{
|
|
var x/eax: int <- copy 0x20/main-panel-hor
|
|
x <- add 0x40/channel-offset-x
|
|
set-cursor-position screen, x y
|
|
}
|
|
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "#", 7/grey 0/black
|
|
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, channel-name, 7/grey 0/black
|
|
# author name
|
|
{
|
|
var author-real-name-ah/eax: (addr handle array byte) <- get author, real-name
|
|
var author-real-name/eax: (addr array byte) <- lookup *author-real-name-ah
|
|
var x/ecx: int <- copy 0x20/main-panel-hor
|
|
x <- add 0x10/avatar-space-hor
|
|
set-cursor-position screen, x y
|
|
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, author-real-name, 0xf/white 0/black
|
|
}
|
|
increment y
|
|
# text
|
|
var text-ah/eax: (addr handle array byte) <- get item, text
|
|
var _text/eax: (addr array byte) <- lookup *text-ah
|
|
var text/edx: (addr array byte) <- copy _text
|
|
var text-y/eax: int <- render-slack-message screen, text, show-cursor?, y, screen-height
|
|
# flush
|
|
add-to y, 6/avatar-space-ver
|
|
compare y, text-y
|
|
{
|
|
break-if-<
|
|
return y
|
|
}
|
|
return text-y
|
|
}
|
|
|
|
fn render-slack-message screen: (addr screen), text: (addr array byte), highlight?: boolean, ymin: int, ymax: int -> _/eax: int {
|
|
var x/eax: int <- copy 0x20/main-panel-hor
|
|
x <- add 0x10/avatar-space-hor
|
|
var y/ecx: int <- copy ymin
|
|
y <- add 1/author-name-padding-ver
|
|
$render-slack-message:draw: {
|
|
compare highlight?, 0/false
|
|
{
|
|
break-if-=
|
|
x, y <- draw-json-text-wrapping-right-then-down screen, text, x y, 0x70/xmax=post-right-coord ymax, x y, 0/fg 7/bg
|
|
break $render-slack-message:draw
|
|
}
|
|
x, y <- draw-json-text-wrapping-right-then-down screen, text, x y, 0x70/xmax=post-right-coord ymax, x y, 7/fg 0/bg
|
|
}
|
|
y <- add 2/item-padding-ver
|
|
return y
|
|
}
|
|
|
|
# draw text in the rectangle from (xmin, ymin) to (xmax, ymax), starting from (x, y), wrapping as necessary
|
|
# return the next (x, y) coordinate in raster order where drawing stopped
|
|
# that way the caller can draw more if given the same min and max bounding-box.
|
|
# if there isn't enough space, truncate
|
|
fn draw-json-text-wrapping-right-then-down screen: (addr screen), _text: (addr array byte), xmin: int, ymin: int, xmax: int, ymax: int, _x: int, _y: int, color: int, background-color: int -> _/eax: int, _/ecx: int {
|
|
var stream-storage: (stream byte 0x4000/print-buffer-size)
|
|
var stream/edi: (addr stream byte) <- address stream-storage
|
|
var text/esi: (addr array byte) <- copy _text
|
|
var len/eax: int <- length text
|
|
compare len, 0x4000/print-buffer-size
|
|
{
|
|
break-if-<
|
|
write stream, "ERROR: stream too small in draw-text-wrapping-right-then-down"
|
|
}
|
|
compare len, 0x4000/print-buffer-size
|
|
{
|
|
break-if->=
|
|
write stream, text
|
|
}
|
|
var x/eax: int <- copy _x
|
|
var y/ecx: int <- copy _y
|
|
x, y <- draw-json-stream-wrapping-right-then-down screen, stream, xmin, ymin, xmax, ymax, x, y, color, background-color
|
|
return x, y
|
|
}
|
|
|
|
# draw a stream in the rectangle from (xmin, ymin) to (xmax, ymax), starting from (x, y), wrapping as necessary
|
|
# return the next (x, y) coordinate in raster order where drawing stopped
|
|
# that way the caller can draw more if given the same min and max bounding-box.
|
|
# if there isn't enough space, truncate
|
|
fn draw-json-stream-wrapping-right-then-down screen: (addr screen), stream: (addr stream byte), xmin: int, ymin: int, xmax: int, ymax: int, x: int, y: int, color: int, background-color: int -> _/eax: int, _/ecx: int {
|
|
var xcurr/ecx: int <- copy x
|
|
var ycurr/edx: int <- copy y
|
|
var c/ebx: code-point <- copy 0
|
|
var next-c/esi: code-point <- copy 0
|
|
{
|
|
# read c from either next-c or stream
|
|
$draw-json-stream-wrapping-right-then-down:read-base: {
|
|
compare next-c, 0
|
|
{
|
|
break-if-=
|
|
c <- copy next-c
|
|
next-c <- copy 0
|
|
break $draw-json-stream-wrapping-right-then-down:read-base
|
|
}
|
|
c <- read-json-code-point stream
|
|
}
|
|
compare c, 0xffffffff/end-of-file
|
|
break-if-=
|
|
$draw-json-stream-wrapping-right-then-down:render-code-point-utf8: {
|
|
compare c, 0x5c/backslash
|
|
{
|
|
break-if-!=
|
|
xcurr, ycurr <- render-json-escaped-code-point screen, stream, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
|
|
break $draw-json-stream-wrapping-right-then-down:render-code-point-utf8
|
|
}
|
|
compare c, 0xa/newline
|
|
{
|
|
break-if-!=
|
|
# minimum effort to clear cursor
|
|
var dummy/eax: int <- draw-code-point screen, 0x20/space, xcurr, ycurr, color, background-color
|
|
xcurr <- copy xmin
|
|
ycurr <- increment
|
|
break $draw-json-stream-wrapping-right-then-down:render-code-point-utf8
|
|
}
|
|
var offset/eax: int <- draw-code-point screen, c, xcurr, ycurr, color, background-color
|
|
# overlay a combining character if necessary
|
|
$draw-json-stream-wrapping-right-then-down:read-combiner: {
|
|
var done?/eax: boolean <- stream-empty? stream
|
|
compare done?, 0/false
|
|
break-if-!=
|
|
# read a character
|
|
# no combining character allowed here
|
|
var g/eax: code-point-utf8 <- read-code-point-utf8 stream
|
|
var c/eax: code-point <- to-code-point g
|
|
# if not a combining character, save for next iteration and loop
|
|
{
|
|
var combining-code-point?/eax: boolean <- combining-code-point? c
|
|
compare combining-code-point?, 0/false
|
|
}
|
|
{
|
|
break-if-!=
|
|
next-c <- copy c
|
|
break $draw-json-stream-wrapping-right-then-down:read-combiner
|
|
}
|
|
# otherwise overlay it without saving its width
|
|
# This means strange results if a base and its combiner have different
|
|
# widths. We'll always follow the base width.
|
|
var dummy/eax: int <- overlay-code-point screen, c, xcurr, ycurr, color, background-color
|
|
}
|
|
xcurr <- add offset
|
|
compare xcurr, xmax
|
|
{
|
|
break-if-<
|
|
xcurr <- copy xmin
|
|
ycurr <- increment
|
|
}
|
|
}
|
|
loop
|
|
}
|
|
set-cursor-position screen, xcurr, ycurr
|
|
return xcurr, ycurr
|
|
}
|
|
|
|
# just return a different register
|
|
fn read-json-code-point stream: (addr stream byte) -> _/ebx: code-point {
|
|
var g/eax: code-point-utf8 <- read-code-point-utf8 stream
|
|
var result/eax: code-point <- to-code-point g
|
|
return result
|
|
}
|
|
|
|
# '\' encountered
|
|
# https://www.json.org/json-en.html
|
|
fn render-json-escaped-code-point screen: (addr screen), stream: (addr stream byte), xmin: int, ymin: int, xmax: int, ymax: int, xcurr: int, ycurr: int, color: int, background-color: int -> _/ecx: int, _/edx: int {
|
|
var g/ebx: code-point <- read-json-code-point stream
|
|
compare g, 0xffffffff/end-of-file
|
|
{
|
|
break-if-!=
|
|
return xcurr, ycurr
|
|
}
|
|
# \n = newline
|
|
compare g, 0x6e/n
|
|
var x/eax: int <- copy xcurr
|
|
{
|
|
break-if-!=
|
|
increment ycurr
|
|
return xmin, ycurr
|
|
}
|
|
# ignore \t \r \f \b
|
|
{
|
|
compare g, 0x74/t
|
|
break-if-!=
|
|
return xcurr, ycurr
|
|
}
|
|
{
|
|
compare g, 0x72/r
|
|
break-if-!=
|
|
return xcurr, ycurr
|
|
}
|
|
{
|
|
compare g, 0x66/f
|
|
break-if-!=
|
|
return xcurr, ycurr
|
|
}
|
|
{
|
|
compare g, 0x62/b
|
|
break-if-!=
|
|
return xcurr, ycurr
|
|
}
|
|
var y/ecx: int <- copy 0
|
|
# \u = Unicode
|
|
{
|
|
compare g, 0x75/u
|
|
break-if-!=
|
|
x, y <- render-json-escaped-unicode-code-point screen, stream, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
|
|
var y/edx: int <- copy y
|
|
return x, y
|
|
}
|
|
# most characters escape to themselves
|
|
# combining characters not supported after backslash
|
|
x, y <- render-code-point screen, g, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
|
|
var y/edx: int <- copy y
|
|
return x, y
|
|
}
|
|
|
|
# '\u' encountered
|
|
fn render-json-escaped-unicode-code-point screen: (addr screen), stream: (addr stream byte), xmin: int, ymin: int, xmax: int, ymax: int, xcurr: int, ycurr: int, color: int, background-color: int -> _/eax: int, _/ecx: int {
|
|
var hex-digits-storage: (array byte 4)
|
|
var hex-digits/esi: (addr array byte) <- address hex-digits-storage
|
|
# slurp 4 bytes exactly
|
|
var src/eax: byte <- read-byte stream
|
|
var dest/ecx: (addr byte) <- index hex-digits, 0
|
|
copy-byte-to *dest, src
|
|
src <- read-byte stream
|
|
dest <- index hex-digits, 1
|
|
copy-byte-to *dest, src
|
|
src <- read-byte stream
|
|
dest <- index hex-digits, 2
|
|
copy-byte-to *dest, src
|
|
src <- read-byte stream
|
|
dest <- index hex-digits, 3
|
|
copy-byte-to *dest, src
|
|
# \u2013 = -
|
|
{
|
|
var endash?/eax: boolean <- string-equal? hex-digits, "2013"
|
|
compare endash?, 0/false
|
|
break-if-=
|
|
var x/eax: int <- copy 0
|
|
var y/ecx: int <- copy 0
|
|
x, y <- render-code-point screen, 0x2d/dash, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
|
|
return x, y
|
|
}
|
|
# \u2014 = -
|
|
{
|
|
var emdash?/eax: boolean <- string-equal? hex-digits, "2014"
|
|
compare emdash?, 0/false
|
|
break-if-=
|
|
var x/eax: int <- copy 0
|
|
var y/ecx: int <- copy 0
|
|
x, y <- render-code-point screen, 0x2d/dash, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
|
|
return x, y
|
|
}
|
|
# \u2018 = '
|
|
{
|
|
var left-quote?/eax: boolean <- string-equal? hex-digits, "2018"
|
|
compare left-quote?, 0/false
|
|
break-if-=
|
|
var x/eax: int <- copy 0
|
|
var y/ecx: int <- copy 0
|
|
x, y <- render-code-point screen, 0x27/quote, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
|
|
return x, y
|
|
}
|
|
# \u2019 = '
|
|
{
|
|
var right-quote?/eax: boolean <- string-equal? hex-digits, "2019"
|
|
compare right-quote?, 0/false
|
|
break-if-=
|
|
var x/eax: int <- copy 0
|
|
var y/ecx: int <- copy 0
|
|
x, y <- render-code-point screen, 0x27/quote, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
|
|
return x, y
|
|
}
|
|
# \u201c = "
|
|
{
|
|
var left-dquote?/eax: boolean <- string-equal? hex-digits, "201c"
|
|
compare left-dquote?, 0/false
|
|
break-if-=
|
|
var x/eax: int <- copy 0
|
|
var y/ecx: int <- copy 0
|
|
x, y <- render-code-point screen, 0x22/dquote, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
|
|
return x, y
|
|
}
|
|
# \u201d = "
|
|
{
|
|
var right-dquote?/eax: boolean <- string-equal? hex-digits, "201d"
|
|
compare right-dquote?, 0/false
|
|
break-if-=
|
|
var x/eax: int <- copy 0
|
|
var y/ecx: int <- copy 0
|
|
x, y <- render-code-point screen, 0x22/dquote, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
|
|
return x, y
|
|
}
|
|
# \u2022 = *
|
|
{
|
|
var bullet?/eax: boolean <- string-equal? hex-digits, "2022"
|
|
compare bullet?, 0/false
|
|
break-if-=
|
|
var x/eax: int <- copy 0
|
|
var y/ecx: int <- copy 0
|
|
x, y <- render-code-point screen, 0x2a/asterisk, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
|
|
return x, y
|
|
}
|
|
# \u2026 = ...
|
|
{
|
|
var ellipses?/eax: boolean <- string-equal? hex-digits, "2026"
|
|
compare ellipses?, 0/false
|
|
break-if-=
|
|
var x/eax: int <- copy 0
|
|
var y/ecx: int <- copy 0
|
|
x, y <- draw-text-wrapping-right-then-down screen, "...", xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
|
|
return x, y
|
|
}
|
|
var n/eax: int <- parse-hex-int hex-digits
|
|
var c/edx: code-point <- copy n
|
|
var x/eax: int <- copy 0
|
|
var y/ecx: int <- copy 0
|
|
x, y <- render-code-point screen, c, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
|
|
return x, y
|
|
}
|
|
|
|
### Edit
|
|
|
|
fn update-environment _env: (addr environment), key: byte, users: (addr array user), channels: (addr array channel), items: (addr item-list) {
|
|
var env/edi: (addr environment) <- copy _env
|
|
# first dispatch to search mode if necessary
|
|
{
|
|
var cursor-in-search?/eax: (addr boolean) <- get env, cursor-in-search?
|
|
compare *cursor-in-search?, 0/false
|
|
break-if-=
|
|
update-search env, key, users, channels, items
|
|
return
|
|
}
|
|
{
|
|
compare key, 0x2f/slash
|
|
break-if-!=
|
|
# enter search mode
|
|
var cursor-in-search?/eax: (addr boolean) <- get env, cursor-in-search?
|
|
copy-to *cursor-in-search?, 1/true
|
|
# do one more repaint
|
|
var dirty?/eax: (addr boolean) <- get env, dirty?
|
|
copy-to *dirty?, 1/true
|
|
return
|
|
}
|
|
{
|
|
compare key, 0x1b/esc
|
|
break-if-!=
|
|
# back in history
|
|
previous-tab env
|
|
return
|
|
}
|
|
var cursor-in-channels?/eax: (addr boolean) <- get env, cursor-in-channels?
|
|
{
|
|
compare key, 9/tab
|
|
break-if-!=
|
|
# toggle cursor between main panel and channels nav
|
|
not *cursor-in-channels? # bitwise NOT; only works if you never assign 1/true to this variable
|
|
# do one more repaint
|
|
var dirty?/eax: (addr boolean) <- get env, dirty?
|
|
copy-to *dirty?, 1/true
|
|
return
|
|
}
|
|
{
|
|
compare *cursor-in-channels?, 0/false
|
|
break-if-!=
|
|
update-main-panel env, key, users, channels, items
|
|
return
|
|
}
|
|
{
|
|
compare *cursor-in-channels?, 0/false
|
|
break-if-=
|
|
update-channels-nav env, key, users, channels, items
|
|
return
|
|
}
|
|
}
|
|
|
|
fn update-main-panel env: (addr environment), key: byte, users: (addr array user), channels: (addr array channel), items: (addr item-list) {
|
|
{
|
|
compare key, 0xa/newline
|
|
break-if-!=
|
|
new-thread-tab-from-cursor env, users, channels, items
|
|
return
|
|
}
|
|
{
|
|
compare key, 8/ctrl-h
|
|
break-if-!=
|
|
var is-all-items-or-channel?/eax: boolean <- current-tab-is-all-items-or-channel? env
|
|
compare is-all-items-or-channel?, 0/false
|
|
break-if-=
|
|
hide-thread env, users, channels, items
|
|
return
|
|
}
|
|
{
|
|
compare key, 0x15/ctrl-u
|
|
break-if-!=
|
|
var is-all-items-or-channel?/eax: boolean <- current-tab-is-all-items-or-channel? env
|
|
compare is-all-items-or-channel?, 0/false
|
|
break-if-=
|
|
new-all-items-tab env, users, channels, items
|
|
return
|
|
}
|
|
{
|
|
compare key, 0x81/down-arrow
|
|
break-if-!=
|
|
next-item env, users, channels, items
|
|
return
|
|
}
|
|
{
|
|
compare key, 0x82/up-arrow
|
|
break-if-!=
|
|
previous-item env, users, channels, items
|
|
return
|
|
}
|
|
{
|
|
compare key, 6/ctrl-f
|
|
break-if-!=
|
|
page-down env, users, channels, items
|
|
return
|
|
}
|
|
{
|
|
compare key, 2/ctrl-b
|
|
break-if-!=
|
|
page-up env, users, channels, items
|
|
return
|
|
}
|
|
}
|
|
|
|
fn current-tab-is-all-items-or-channel? _env: (addr environment) -> _/eax: boolean {
|
|
var env/esi: (addr environment) <- copy _env
|
|
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
|
|
var _tabs/eax: (addr array tab) <- lookup *tabs-ah
|
|
var tabs/edx: (addr array tab) <- copy _tabs
|
|
var current-tab-index-a/eax: (addr int) <- get env, current-tab-index
|
|
var current-tab-index/eax: int <- copy *current-tab-index-a
|
|
var current-tab-offset/eax: (offset tab) <- compute-offset tabs, current-tab-index
|
|
var current-tab/edx: (addr tab) <- index tabs, current-tab-offset
|
|
var current-tab-type/eax: (addr int) <- get current-tab, type
|
|
{
|
|
compare *current-tab-type, 0/all-items
|
|
break-if-!=
|
|
return 1/true
|
|
}
|
|
{
|
|
compare *current-tab-type, 1/channel
|
|
break-if-!=
|
|
return 1/true
|
|
}
|
|
return 0/false
|
|
}
|
|
|
|
# TODO: clamp cursor within bounds
|
|
fn update-channels-nav _env: (addr environment), key: byte, users: (addr array user), channels: (addr array channel), items: (addr item-list) {
|
|
var env/edi: (addr environment) <- copy _env
|
|
var channel-cursor-index/eax: (addr int) <- get env, channel-cursor-index
|
|
{
|
|
compare key, 0x81/down-arrow
|
|
break-if-!=
|
|
increment *channel-cursor-index
|
|
return
|
|
}
|
|
{
|
|
compare key, 0x82/up-arrow
|
|
break-if-!=
|
|
decrement *channel-cursor-index
|
|
return
|
|
}
|
|
{
|
|
compare key, 0xa/newline
|
|
break-if-!=
|
|
new-channel-tab env, *channel-cursor-index, channels
|
|
var cursor-in-channels?/eax: (addr boolean) <- get env, cursor-in-channels?
|
|
copy-to *cursor-in-channels?, 0/false
|
|
return
|
|
}
|
|
}
|
|
|
|
fn update-search _env: (addr environment), key: byte, users: (addr array user), channels: (addr array channel), items: (addr item-list) {
|
|
var env/edi: (addr environment) <- copy _env
|
|
var cursor-in-search?/eax: (addr boolean) <- get env, cursor-in-search?
|
|
{
|
|
compare key 0x1b/esc
|
|
break-if-!=
|
|
# get out of search mode
|
|
copy-to *cursor-in-search?, 0/false
|
|
return
|
|
}
|
|
{
|
|
compare key, 0xa/newline
|
|
break-if-!=
|
|
# perform a search, then get out of search mode
|
|
new-search-tab env, items
|
|
copy-to *cursor-in-search?, 0/false
|
|
return
|
|
}
|
|
# otherwise delegate
|
|
var search-terms-ah/eax: (addr handle gap-buffer) <- get env, search-terms
|
|
var search-terms/eax: (addr gap-buffer) <- lookup *search-terms-ah
|
|
var g/ecx: code-point-utf8 <- copy key
|
|
edit-gap-buffer search-terms, g
|
|
}
|
|
|
|
fn new-all-items-tab _env: (addr environment), users: (addr array user), channels: (addr array channel), _items: (addr item-list) {
|
|
var env/edi: (addr environment) <- copy _env
|
|
var current-tab-index-addr/ecx: (addr int) <- get env, current-tab-index
|
|
increment *current-tab-index-addr
|
|
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
|
|
var tabs/eax: (addr array tab) <- lookup *tabs-ah
|
|
var max-tabs/ebx: int <- length tabs
|
|
{
|
|
compare *current-tab-index-addr, max-tabs
|
|
break-if-<
|
|
abort "history overflow; grow max-history (we should probably improve this)"
|
|
}
|
|
var current-tab-index/ecx: int <- copy *current-tab-index-addr
|
|
var current-tab-offset/ecx: (offset tab) <- compute-offset tabs, current-tab-index
|
|
var current-tab/ecx: (addr tab) <- index tabs, current-tab-offset
|
|
clear-object current-tab
|
|
var items/eax: (addr item-list) <- copy _items
|
|
var items-data-first-free-a/eax: (addr int) <- get items, data-first-free
|
|
var final-item/edx: int <- copy *items-data-first-free-a
|
|
final-item <- decrement
|
|
var dest/edi: (addr int) <- get current-tab, item-index
|
|
copy-to *dest, final-item
|
|
}
|
|
|
|
fn new-thread-tab-from-cursor _env: (addr environment), users: (addr array user), channels: (addr array channel), _items: (addr item-list) {
|
|
var env/edi: (addr environment) <- copy _env
|
|
var current-tab-index-addr/ecx: (addr int) <- get env, current-tab-index
|
|
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
|
|
var tabs/eax: (addr array tab) <- lookup *tabs-ah
|
|
var current-tab-index/ecx: int <- copy *current-tab-index-addr
|
|
var item-index/esi: int <- item-index env, _items, channels
|
|
var post-index/ecx: int <- post-index _items, item-index
|
|
new-thread-tab env, users, channels, _items, post-index, item-index
|
|
}
|
|
|
|
fn new-thread-tab _env: (addr environment), users: (addr array user), channels: (addr array channel), _items: (addr item-list), _post-index: int, _item-index: int {
|
|
var env/edi: (addr environment) <- copy _env
|
|
var current-tab-index-addr/eax: (addr int) <- get env, current-tab-index
|
|
increment *current-tab-index-addr
|
|
var current-tab-index/edx: int <- copy *current-tab-index-addr
|
|
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
|
|
var tabs/eax: (addr array tab) <- lookup *tabs-ah
|
|
var max-tabs/ebx: int <- length tabs
|
|
compare current-tab-index, max-tabs
|
|
{
|
|
compare current-tab-index, max-tabs
|
|
break-if-<
|
|
abort "history overflow; grow max-history (we should probably improve this)"
|
|
}
|
|
var current-tab-offset/edi: (offset tab) <- compute-offset tabs, current-tab-index
|
|
var current-tab/edi: (addr tab) <- index tabs, current-tab-offset
|
|
clear-object current-tab
|
|
var current-tab-type/eax: (addr int) <- get current-tab, type
|
|
copy-to *current-tab, 3/thread
|
|
var current-tab-root-index/eax: (addr int) <- get current-tab, root-index
|
|
var post-index/ecx: int <- copy _post-index
|
|
copy-to *current-tab-root-index, post-index
|
|
var items/eax: (addr item-list) <- copy _items
|
|
var items-data-ah/eax: (addr handle array item) <- get items, data
|
|
var items-data/eax: (addr array item) <- lookup *items-data-ah
|
|
var offset/ecx: (offset item) <- compute-offset items-data, post-index
|
|
var post/eax: (addr item) <- index items-data, offset
|
|
var post-comments-first-free-addr/ecx: (addr int) <- get post, comments-first-free
|
|
# terminology:
|
|
# post-comment-index = index of a comment in a post's comment array
|
|
# comment-index = index of a comment in the global item list
|
|
var final-post-comment-index/ecx: int <- copy *post-comments-first-free-addr
|
|
final-post-comment-index <- decrement
|
|
var post-comments-ah/eax: (addr handle array int) <- get post, comments
|
|
var post-comments/eax: (addr array int) <- lookup *post-comments-ah
|
|
# look for item-index in post-comments[0..final-post-comment-index]
|
|
var curr-post-comment-index/edx: int <- copy final-post-comment-index
|
|
{
|
|
compare curr-post-comment-index, 0
|
|
{
|
|
break-if->=
|
|
# if we didn't find the current item in a post's comments, it must be
|
|
# the parent post itself which isn't in the comment list but hackily
|
|
# rendered at the bottom. Just render the whole comment list.
|
|
var item-index/eax: int <- copy _item-index
|
|
var tab-item-index-addr/edi: (addr int) <- get current-tab, item-index
|
|
copy-to *tab-item-index-addr, curr-post-comment-index
|
|
return
|
|
}
|
|
var curr-comment-index/ecx: (addr int) <- index post-comments, curr-post-comment-index
|
|
var item-index/eax: int <- copy _item-index
|
|
compare *curr-comment-index, item-index
|
|
{
|
|
break-if-!=
|
|
# item-index found
|
|
var item-index/eax: int <- copy _item-index
|
|
var tab-item-index-addr/edi: (addr int) <- get current-tab, item-index
|
|
copy-to *tab-item-index-addr, curr-post-comment-index
|
|
return
|
|
}
|
|
curr-post-comment-index <- decrement
|
|
loop
|
|
}
|
|
abort "new-thread-tab: should never leave previous loop without returning"
|
|
}
|
|
|
|
fn new-thread-tab-from-url _env: (addr environment), _url: (addr array byte), users: (addr array user), channels: (addr array channel), _items: (addr item-list) {
|
|
var id-storage: (array byte 0x11)
|
|
var id/ecx: (addr array byte) <- address id-storage
|
|
var url/edx: (addr array byte) <- copy _url
|
|
var len/ebx: int <- length url
|
|
var idx/eax: int <- copy len
|
|
idx <- subtract 0x11/id-length
|
|
{
|
|
var x/eax: (addr byte) <- index url, idx
|
|
var x2/ecx: byte <- copy-byte *x
|
|
compare x2, 0x70/p
|
|
break-if-=
|
|
abort "not p"
|
|
}
|
|
idx <- increment # skip 'p'
|
|
var dest-idx/edi: int <- copy 0
|
|
# insert first 10 digits of id
|
|
{
|
|
compare dest-idx, 0xa/ten
|
|
break-if->=
|
|
{
|
|
var c/eax: (addr byte) <- index url, idx
|
|
var c2/eax: byte <- copy-byte *c
|
|
var dest/ecx: (addr byte) <- index id, dest-idx
|
|
copy-byte-to *dest, c2
|
|
}
|
|
idx <- increment
|
|
dest-idx <- increment
|
|
loop
|
|
}
|
|
# insert a decimal point
|
|
{
|
|
var dest/ecx: (addr byte) <- index id, dest-idx
|
|
var decimal-point/eax: byte <- copy 0x2e
|
|
copy-byte-to *dest, decimal-point
|
|
dest-idx <- increment
|
|
}
|
|
# insert remaining digits of id
|
|
{
|
|
compare dest-idx, 0x11/id-length
|
|
break-if->=
|
|
{
|
|
var c/eax: (addr byte) <- index url, idx
|
|
var c2/eax: byte <- copy-byte *c
|
|
var dest/ecx: (addr byte) <- index id, dest-idx
|
|
copy-byte-to *dest, c2
|
|
}
|
|
idx <- increment
|
|
dest-idx <- increment
|
|
loop
|
|
}
|
|
var post-index/eax: int <- find-item-by-id _items, id
|
|
new-thread-tab _env, users, channels, _items, post-index, post-index
|
|
}
|
|
|
|
fn find-item-by-id _items: (addr item-list), id: (addr array byte) -> _/eax: int {
|
|
var items/eax: (addr item-list) <- copy _items
|
|
var items-data-ah/eax: (addr handle array item) <- get items, data
|
|
var items-data/eax: (addr array item) <- lookup *items-data-ah
|
|
var i/ecx: int <- copy 0
|
|
var len/edx: int <- length items-data
|
|
{
|
|
compare i, len
|
|
break-if->=
|
|
var offset/edx: (offset item) <- compute-offset items-data, i
|
|
var curr-item/eax: (addr item) <- index items-data, offset
|
|
var curr-item-id-ah/eax: (addr handle array byte) <- get curr-item, id
|
|
var curr-item-id/eax: (addr array byte) <- lookup *curr-item-id-ah
|
|
{
|
|
var found?/eax: boolean <- string-equal? curr-item-id, id
|
|
compare found?, 0/false
|
|
break-if-=
|
|
return i
|
|
}
|
|
i <- increment
|
|
loop
|
|
}
|
|
abort "find-item-by-id: not found"
|
|
return -1
|
|
}
|
|
|
|
# hide a thread in a (channel or all-items) tab
|
|
fn hide-thread _env: (addr environment), users: (addr array user), channels: (addr array channel), items: (addr item-list) {
|
|
var env/edi: (addr environment) <- copy _env
|
|
var current-tab-index-addr/eax: (addr int) <- get env, current-tab-index
|
|
var current-tab-index/ecx: int <- copy *current-tab-index-addr
|
|
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
|
|
var tabs/eax: (addr array tab) <- lookup *tabs-ah
|
|
var current-tab-offset/ecx: (offset tab) <- compute-offset tabs, current-tab-index
|
|
var current-tab/ebx: (addr tab) <- index tabs, current-tab-offset
|
|
var current-tab-hidden-items-ah/edx: (addr handle stream int) <- get current-tab, hidden-items
|
|
var current-tab-hidden-items/eax: (addr stream int) <- lookup *current-tab-hidden-items-ah
|
|
{
|
|
compare current-tab-hidden-items, 0
|
|
break-if-!=
|
|
populate-stream current-tab-hidden-items-ah, 0x10/max-hidden-threads
|
|
current-tab-hidden-items <- lookup *current-tab-hidden-items-ah
|
|
}
|
|
{
|
|
var too-many-hidden-items?/eax: boolean <- stream-full? current-tab-hidden-items
|
|
compare too-many-hidden-items?, 0/false
|
|
break-if-=
|
|
abort "too many hidden threads in this tab" # TODO: create a space for flash error messages on screen
|
|
return
|
|
}
|
|
var current-item-index/esi: int <- item-index env, items, channels
|
|
var current-post-index-value/ecx: int <- post-index items, current-item-index
|
|
# . turn current-post-index into an addr
|
|
var current-post-index-storage: int
|
|
copy-to current-post-index-storage, current-post-index-value
|
|
var current-post-index-addr/ecx: (addr int) <- address current-post-index-storage
|
|
#
|
|
write-to-stream current-tab-hidden-items, current-post-index-addr
|
|
# current-tab's item-index is now on a hidden item
|
|
# try to position it on a visible item
|
|
var item-index-addr/esi: (addr int) <- get current-tab, item-index
|
|
var old-item-index/eax: int <- copy *item-index-addr
|
|
next-item env, users, channels, items
|
|
compare *item-index-addr, old-item-index
|
|
break-if-!=
|
|
previous-item env, users, channels, items
|
|
}
|
|
|
|
fn should-hide? _tab: (addr tab), item-index: int, items: (addr item-list) -> _/eax: boolean {
|
|
var post-index/ecx: int <- post-index items, item-index
|
|
var tab/esi: (addr tab) <- copy _tab
|
|
var tab-hidden-items-ah/edx: (addr handle stream int) <- get tab, hidden-items
|
|
var tab-hidden-items/eax: (addr stream int) <- lookup *tab-hidden-items-ah
|
|
compare tab-hidden-items, 0
|
|
{
|
|
break-if-!=
|
|
# either we haven't hidden anything, or we're in a tab type that doesn't
|
|
# support hiding
|
|
return 0/false
|
|
}
|
|
rewind-stream tab-hidden-items
|
|
{
|
|
{
|
|
var done?/eax: boolean <- stream-empty? tab-hidden-items
|
|
compare done?, 0/false
|
|
}
|
|
break-if-!=
|
|
var curr-item: int
|
|
var curr-item-addr/edx: (addr int) <- address curr-item
|
|
read-from-stream tab-hidden-items, curr-item-addr
|
|
# if curr-item == post-index, return true
|
|
compare curr-item, post-index
|
|
{
|
|
break-if-!=
|
|
return 1/true
|
|
}
|
|
loop
|
|
}
|
|
return 0/false
|
|
}
|
|
|
|
# what index in the global items list is the cursor at in the current tab?
|
|
fn item-index _env: (addr environment), _items: (addr item-list), _channels: (addr array channel) -> _/esi: int {
|
|
var env/eax: (addr environment) <- copy _env
|
|
var current-tab-index-addr/esi: (addr int) <- get env, current-tab-index
|
|
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
|
|
var tabs/eax: (addr array tab) <- lookup *tabs-ah
|
|
var tab-index/esi: int <- copy *current-tab-index-addr
|
|
var tab-offset/esi: (offset tab) <- compute-offset tabs, tab-index
|
|
var tab/esi: (addr tab) <- index tabs, tab-offset
|
|
var tab-type/eax: (addr int) <- get tab, type
|
|
{
|
|
compare *tab-type, 0/all-items
|
|
break-if-!=
|
|
var tab-item-index/eax: (addr int) <- get tab, item-index
|
|
return *tab-item-index
|
|
}
|
|
{
|
|
compare *tab-type, 1/channel
|
|
break-if-!=
|
|
var channel-index-addr/eax: (addr int) <- get tab, channel-index
|
|
var channel-index/eax: int <- copy *channel-index-addr
|
|
var channels/ecx: (addr array channel) <- copy _channels
|
|
var channel-offset/eax: (offset channel) <- compute-offset channels, channel-index
|
|
var current-channel/eax: (addr channel) <- index channels, channel-offset
|
|
var current-channel-posts-ah/eax: (addr handle array int) <- get current-channel, posts
|
|
var current-channel-posts/eax: (addr array int) <- lookup *current-channel-posts-ah
|
|
var channel-item-index-addr/ecx: (addr int) <- get tab, item-index
|
|
var channel-item-index/ecx: int <- copy *channel-item-index-addr
|
|
var channel-item-index/eax: (addr int) <- index current-channel-posts, channel-item-index
|
|
return *channel-item-index
|
|
}
|
|
{
|
|
compare *tab-type, 2/search
|
|
break-if-!=
|
|
var tab-search-items-ah/eax: (addr handle array int) <- get tab, search-items
|
|
var tab-search-items/eax: (addr array int) <- lookup *tab-search-items-ah
|
|
var tab-search-items-index-addr/ecx: (addr int) <- get tab, item-index
|
|
var tab-search-items-index/ecx: int <- copy *tab-search-items-index-addr
|
|
var src/eax: (addr int) <- index tab-search-items, tab-search-items-index
|
|
return *src
|
|
}
|
|
{
|
|
compare *tab-type, 3/thread
|
|
break-if-!=
|
|
var items/eax: (addr item-list) <- copy _items
|
|
var items-data-ah/eax: (addr handle array item) <- get items, data
|
|
var _items-data/eax: (addr array item) <- lookup *items-data-ah
|
|
var items-data/edi: (addr array item) <- copy _items-data
|
|
var tab-root-index-addr/eax: (addr int) <- get tab, root-index
|
|
var tab-root-index/eax: int <- copy *tab-root-index-addr
|
|
var tab-root-offset/eax: (offset item) <- compute-offset items-data, tab-root-index
|
|
var post/eax: (addr item) <- index items-data, tab-root-offset
|
|
var post-comments-ah/eax: (addr handle array int) <- get post, comments
|
|
var post-comments/eax: (addr array int) <- lookup *post-comments-ah
|
|
var tab-item-index-addr/ecx: (addr int) <- get tab, item-index
|
|
var tab-item-index/ecx: int <- copy *tab-item-index-addr
|
|
var src/eax: (addr int) <- index post-comments, tab-item-index
|
|
return *src
|
|
}
|
|
abort "item-index: unknown tab type"
|
|
return -1
|
|
}
|
|
|
|
# go from a comment item to its parent post
|
|
fn post-index _items: (addr item-list), item-index: int -> _/ecx: int {
|
|
var items/eax: (addr item-list) <- copy _items
|
|
var items-data-ah/eax: (addr handle array item) <- get items, data
|
|
var items-data/eax: (addr array item) <- lookup *items-data-ah
|
|
var index/ecx: int <- copy item-index
|
|
var offset/ecx: (offset item) <- compute-offset items-data, index
|
|
var item/eax: (addr item) <- index items-data, offset
|
|
var parent/eax: (addr int) <- get item, parent
|
|
compare *parent, 0
|
|
{
|
|
break-if-=
|
|
return *parent
|
|
}
|
|
return item-index
|
|
}
|
|
|
|
fn new-channel-tab _env: (addr environment), channel-index: int, _channels: (addr array channel) {
|
|
var env/edi: (addr environment) <- copy _env
|
|
var current-tab-index-addr/eax: (addr int) <- get env, current-tab-index
|
|
increment *current-tab-index-addr
|
|
var current-tab-index/ecx: int <- copy *current-tab-index-addr
|
|
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
|
|
var tabs/eax: (addr array tab) <- lookup *tabs-ah
|
|
var max-tabs/edx: int <- length tabs
|
|
compare current-tab-index, max-tabs
|
|
{
|
|
compare current-tab-index, max-tabs
|
|
break-if-<
|
|
abort "history overflow; grow max-history (we should probably improve this)"
|
|
}
|
|
var current-tab-offset/ecx: (offset tab) <- compute-offset tabs, current-tab-index
|
|
var current-tab/ecx: (addr tab) <- index tabs, current-tab-offset
|
|
clear-object current-tab
|
|
var current-tab-type/eax: (addr int) <- get current-tab, type
|
|
copy-to *current-tab, 1/channel
|
|
var current-tab-channel-index/eax: (addr int) <- get current-tab, channel-index
|
|
var curr-channel-index/edx: int <- copy channel-index
|
|
copy-to *current-tab-channel-index, curr-channel-index
|
|
var channels/esi: (addr array channel) <- copy _channels
|
|
var curr-channel-offset/eax: (offset channel) <- compute-offset channels, curr-channel-index
|
|
var curr-channel/eax: (addr channel) <- index channels, curr-channel-offset
|
|
var curr-channel-posts-first-free-addr/eax: (addr int) <- get curr-channel, posts-first-free
|
|
var curr-channel-final-post-index/eax: int <- copy *curr-channel-posts-first-free-addr
|
|
curr-channel-final-post-index <- decrement
|
|
var dest/edi: (addr int) <- get current-tab, item-index
|
|
copy-to *dest, curr-channel-final-post-index
|
|
}
|
|
|
|
fn new-search-tab _env: (addr environment), items: (addr item-list) {
|
|
var env/edi: (addr environment) <- copy _env
|
|
var current-tab-index-addr/eax: (addr int) <- get env, current-tab-index
|
|
increment *current-tab-index-addr
|
|
var current-tab-index/ecx: int <- copy *current-tab-index-addr
|
|
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
|
|
var tabs/eax: (addr array tab) <- lookup *tabs-ah
|
|
var max-tabs/edx: int <- length tabs
|
|
compare current-tab-index, max-tabs
|
|
{
|
|
compare current-tab-index, max-tabs
|
|
break-if-<
|
|
abort "history overflow; grow max-history (we should probably improve this)"
|
|
}
|
|
var current-tab-offset/ecx: (offset tab) <- compute-offset tabs, current-tab-index
|
|
var current-tab/ecx: (addr tab) <- index tabs, current-tab-offset
|
|
clear-object current-tab
|
|
var current-tab-type/eax: (addr int) <- get current-tab, type
|
|
copy-to *current-tab, 2/search
|
|
var current-tab-search-terms-ah/edx: (addr handle gap-buffer) <- get current-tab, search-terms
|
|
allocate current-tab-search-terms-ah
|
|
var current-tab-search-terms/eax: (addr gap-buffer) <- lookup *current-tab-search-terms-ah
|
|
initialize-gap-buffer current-tab-search-terms, 0x30/search-capacity
|
|
var search-terms-ah/ebx: (addr handle gap-buffer) <- get env, search-terms
|
|
copy-gap-buffer search-terms-ah, current-tab-search-terms-ah
|
|
var search-terms/eax: (addr gap-buffer) <- lookup *search-terms-ah
|
|
search-items current-tab, items, search-terms
|
|
}
|
|
|
|
fn search-items _tab: (addr tab), _items: (addr item-list), search-terms: (addr gap-buffer) {
|
|
var tab/edi: (addr tab) <- copy _tab
|
|
var tab-items-first-free-addr/esi: (addr int) <- get tab, search-items-first-free
|
|
var tab-items-ah/eax: (addr handle array int) <- get tab, search-items
|
|
populate tab-items-ah, 0x100/max-search-results
|
|
var _tab-items/eax: (addr array int) <- lookup *tab-items-ah
|
|
var tab-items/edi: (addr array int) <- copy _tab-items
|
|
# preprocess search-terms
|
|
var search-terms-stream-storage: (stream byte 0x100)
|
|
var search-terms-stream-addr/ecx: (addr stream byte) <- address search-terms-stream-storage
|
|
emit-gap-buffer search-terms, search-terms-stream-addr
|
|
var search-terms-text-h: (handle array byte)
|
|
var search-terms-text-ah/eax: (addr handle array byte) <- address search-terms-text-h
|
|
stream-to-array search-terms-stream-addr, search-terms-text-ah
|
|
var tmp/eax: (addr array byte) <- lookup *search-terms-text-ah
|
|
var search-terms-text: (addr array byte)
|
|
copy-to search-terms-text, tmp
|
|
#
|
|
var items/ecx: (addr item-list) <- copy _items
|
|
var items-data-ah/eax: (addr handle array item) <- get items, data
|
|
var _items-data/eax: (addr array item) <- lookup *items-data-ah
|
|
var items-data/ebx: (addr array item) <- copy _items-data
|
|
var items-data-first-free-a/edx: (addr int) <- get items, data-first-free
|
|
var i/ecx: int <- copy 0
|
|
{
|
|
compare i, *items-data-first-free-a
|
|
break-if->=
|
|
var curr-offset/eax: (offset item) <- compute-offset items-data, i
|
|
var curr-item/eax: (addr item) <- index items-data, curr-offset
|
|
var found?/eax: boolean <- search-terms-match? curr-item, search-terms-text
|
|
compare found?, 0/false
|
|
{
|
|
break-if-=
|
|
var tab-items-first-free/eax: int <- copy *tab-items-first-free-addr
|
|
compare tab-items-first-free, 0x100/max-search-results
|
|
break-if->=
|
|
var dest/eax: (addr int) <- index tab-items, tab-items-first-free
|
|
copy-to *dest, i
|
|
increment *tab-items-first-free-addr
|
|
}
|
|
i <- increment
|
|
loop
|
|
}
|
|
var tab/edi: (addr tab) <- copy _tab
|
|
var tab-item-index-addr/edi: (addr int) <- get tab, item-index
|
|
var tab-items-first-free/eax: int <- copy *tab-items-first-free-addr
|
|
tab-items-first-free <- decrement
|
|
copy-to *tab-item-index-addr, tab-items-first-free
|
|
}
|
|
|
|
fn search-terms-match? _item: (addr item), search-terms: (addr array byte) -> _/eax: boolean {
|
|
var item/esi: (addr item) <- copy _item
|
|
var item-text-ah/eax: (addr handle array byte) <- get item, text
|
|
var item-text/eax: (addr array byte) <- lookup *item-text-ah
|
|
var i/ecx: int <- copy 0
|
|
var max/edx: int <- length item-text
|
|
var search-terms2/ebx: (addr array byte) <- copy search-terms
|
|
var slen/ebx: int <- length search-terms2
|
|
max <- subtract slen
|
|
{
|
|
compare i, max
|
|
break-if->
|
|
var found?/eax: boolean <- substring-match? item-text, search-terms, i
|
|
compare found?, 0/false
|
|
{
|
|
break-if-=
|
|
return 1/true
|
|
}
|
|
i <- increment
|
|
loop
|
|
}
|
|
return 0/false
|
|
}
|
|
|
|
fn substring-match? _s: (addr array byte), _pat: (addr array byte), start: int -> _/eax: boolean {
|
|
var s/esi: (addr array byte) <- copy _s
|
|
var pat/edi: (addr array byte) <- copy _pat
|
|
var s-idx/edx: int <- copy start
|
|
var pat-idx/ebx: int <- copy 0
|
|
var pat-len: int
|
|
var tmp/eax: int <- length pat
|
|
copy-to pat-len, tmp
|
|
{
|
|
compare pat-idx, pat-len
|
|
break-if->=
|
|
var s-ab/eax: (addr byte) <- index s, s-idx
|
|
var s-b/eax: byte <- copy-byte *s-ab
|
|
var pat-ab/ecx: (addr byte) <- index pat, pat-idx
|
|
var pat-b/ecx: byte <- copy-byte *pat-ab
|
|
compare s-b, pat-b
|
|
{
|
|
break-if-=
|
|
return 0/false
|
|
}
|
|
s-idx <- increment
|
|
pat-idx <- increment
|
|
loop
|
|
}
|
|
return 1/true
|
|
}
|
|
|
|
fn previous-tab _env: (addr environment) {
|
|
var env/edi: (addr environment) <- copy _env
|
|
var current-tab-index-addr/ecx: (addr int) <- get env, current-tab-index
|
|
compare *current-tab-index-addr, 0
|
|
{
|
|
break-if-<=
|
|
decrement *current-tab-index-addr
|
|
# if necessary restore search state
|
|
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
|
|
var tabs/eax: (addr array tab) <- lookup *tabs-ah
|
|
var current-tab-index/ecx: int <- copy *current-tab-index-addr
|
|
var current-tab-offset/ecx: (offset tab) <- compute-offset tabs, current-tab-index
|
|
var current-tab/ecx: (addr tab) <- index tabs, current-tab-offset
|
|
var current-tab-type/eax: (addr int) <- get current-tab, type
|
|
compare *current-tab-type, 2/search
|
|
break-if-!=
|
|
var current-tab-search-terms-ah/ecx: (addr handle gap-buffer) <- get current-tab, search-terms
|
|
var search-terms-ah/edx: (addr handle gap-buffer) <- get env, search-terms
|
|
var search-terms/eax: (addr gap-buffer) <- lookup *search-terms-ah
|
|
clear-gap-buffer search-terms
|
|
copy-gap-buffer current-tab-search-terms-ah, search-terms-ah
|
|
}
|
|
}
|
|
|
|
fn next-item _env: (addr environment), users: (addr array user), _channels: (addr array channel), _items: (addr item-list) {
|
|
var env/edi: (addr environment) <- copy _env
|
|
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
|
|
var _tabs/eax: (addr array tab) <- lookup *tabs-ah
|
|
var tabs/edx: (addr array tab) <- copy _tabs
|
|
var current-tab-index-a/eax: (addr int) <- get env, current-tab-index
|
|
var current-tab-index/eax: int <- copy *current-tab-index-a
|
|
var current-tab-offset/eax: (offset tab) <- compute-offset tabs, current-tab-index
|
|
var current-tab/edx: (addr tab) <- index tabs, current-tab-offset
|
|
var dest/ebx: (addr int) <- get current-tab, item-index
|
|
# if current-tab isn't all-items or channel, no need to worry about hidden items
|
|
var current-tab-type/eax: (addr int) <- get current-tab, type
|
|
{
|
|
compare *current-tab-type, 0/all-items
|
|
break-if-=
|
|
compare *current-tab-type, 1/channel
|
|
break-if-=
|
|
{
|
|
compare *dest, 0
|
|
break-if-<=
|
|
decrement *dest
|
|
}
|
|
return
|
|
}
|
|
var old-value/ecx: int <- copy *dest
|
|
# do { --*dest } while *dest > 0 and should-hide?(current-tab, *dest)
|
|
{
|
|
compare *dest, 0
|
|
break-if-<=
|
|
decrement *dest
|
|
# if current item is not hidden, return
|
|
var current-item-index/esi: int <- item-index env, _items, _channels
|
|
var should-hide?/eax: boolean <- should-hide? current-tab, current-item-index, _items
|
|
compare should-hide?, 0/false
|
|
loop-if-!=
|
|
return
|
|
}
|
|
# couldn't find a visible item. Restore.
|
|
copy-to *dest, old-value
|
|
}
|
|
|
|
fn previous-item _env: (addr environment), users: (addr array user), _channels: (addr array channel), _items: (addr item-list) {
|
|
var env/edi: (addr environment) <- copy _env
|
|
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
|
|
var _tabs/eax: (addr array tab) <- lookup *tabs-ah
|
|
var tabs/edx: (addr array tab) <- copy _tabs
|
|
var current-tab-index-a/eax: (addr int) <- get env, current-tab-index
|
|
var current-tab-index/eax: int <- copy *current-tab-index-a
|
|
var current-tab-offset/eax: (offset tab) <- compute-offset tabs, current-tab-index
|
|
var current-tab/edx: (addr tab) <- index tabs, current-tab-offset
|
|
var current-tab-type/eax: (addr int) <- get current-tab, type
|
|
compare *current-tab-type, 0/all-items
|
|
{
|
|
break-if-!=
|
|
var items/esi: (addr item-list) <- copy _items
|
|
var items-data-first-free-a/ecx: (addr int) <- get items, data-first-free
|
|
var final-item-index/ecx: int <- copy *items-data-first-free-a
|
|
final-item-index <- decrement
|
|
var dest/ebx: (addr int) <- get current-tab, item-index
|
|
var old-value/eax: int <- copy *dest
|
|
# do { ++*dest } while *dest < final-index and should-hide?(current-tab, *dest)
|
|
{
|
|
compare *dest, final-item-index
|
|
break-if->=
|
|
increment *dest
|
|
# if current item is not hidden, return
|
|
var current-item-index/esi: int <- item-index env, _items, _channels
|
|
var should-hide?/eax: boolean <- should-hide? current-tab, current-item-index, _items
|
|
compare should-hide?, 0/false
|
|
loop-if-!=
|
|
return
|
|
}
|
|
# couldn't find a visible item. Restore.
|
|
copy-to *dest, old-value
|
|
return
|
|
}
|
|
compare *current-tab-type, 1/channel
|
|
{
|
|
break-if-!=
|
|
var current-channel-index-addr/eax: (addr int) <- get current-tab, channel-index
|
|
var current-channel-index/eax: int <- copy *current-channel-index-addr
|
|
var channels/esi: (addr array channel) <- copy _channels
|
|
var current-channel-offset/eax: (offset channel) <- compute-offset channels, current-channel-index
|
|
var current-channel/eax: (addr channel) <- index channels, current-channel-offset
|
|
var current-channel-posts-first-free-addr/eax: (addr int) <- get current-channel, posts-first-free
|
|
var final-item-index/ecx: int <- copy *current-channel-posts-first-free-addr
|
|
final-item-index <- decrement
|
|
var dest/ebx: (addr int) <- get current-tab, item-index
|
|
var old-value/eax: int <- copy *dest
|
|
# do { ++*dest } while *dest < final-index and should-hide?(current-tab, *dest)
|
|
{
|
|
compare *dest, final-item-index
|
|
break-if->=
|
|
increment *dest
|
|
# if current item is not hidden, return
|
|
var current-item-index/esi: int <- item-index env, _items, _channels
|
|
var should-hide?/eax: boolean <- should-hide? current-tab, current-item-index, _items
|
|
compare should-hide?, 0/false
|
|
loop-if-!=
|
|
return
|
|
}
|
|
# couldn't find a visible item. Restore.
|
|
copy-to *dest, old-value
|
|
return
|
|
}
|
|
compare *current-tab-type, 2/search
|
|
{
|
|
break-if-!=
|
|
var current-tab-search-items-first-free-addr/eax: (addr int) <- get current-tab, search-items-first-free
|
|
var final-item-index/ecx: int <- copy *current-tab-search-items-first-free-addr
|
|
final-item-index <- decrement
|
|
var dest/eax: (addr int) <- get current-tab, item-index
|
|
compare *dest, final-item-index
|
|
break-if->=
|
|
increment *dest
|
|
return
|
|
}
|
|
compare *current-tab-type, 3/thread
|
|
{
|
|
break-if-!=
|
|
var items/eax: (addr item-list) <- copy _items
|
|
var items-data-ah/eax: (addr handle array item) <- get items, data
|
|
var _items-data/eax: (addr array item) <- lookup *items-data-ah
|
|
var items-data/esi: (addr array item) <- copy _items-data
|
|
var current-tab-root-index-addr/eax: (addr int) <- get current-tab, root-index
|
|
var current-tab-root-index/eax: int <- copy *current-tab-root-index-addr
|
|
var current-tab-root-offset/eax: (offset item) <- compute-offset items-data, current-tab-root-index
|
|
var post/eax: (addr item) <- index items-data, current-tab-root-offset
|
|
var post-comments-first-free-addr/ecx: (addr int) <- get post, comments-first-free
|
|
var final-item-index/ecx: int <- copy *post-comments-first-free-addr
|
|
final-item-index <- decrement
|
|
var dest/eax: (addr int) <- get current-tab, item-index
|
|
compare *dest, final-item-index
|
|
break-if->=
|
|
increment *dest
|
|
return
|
|
}
|
|
}
|
|
|
|
fn page-down _env: (addr environment), users: (addr array user), channels: (addr array channel), _items: (addr item-list) {
|
|
var env/edi: (addr environment) <- copy _env
|
|
var items/eax: (addr item-list) <- copy _items
|
|
var items-data-ah/eax: (addr handle array item) <- get items, data
|
|
var _items-data/eax: (addr array item) <- lookup *items-data-ah
|
|
var items-data/ebx: (addr array item) <- copy _items-data
|
|
var _old-item-index/esi: int <- item-index env, _items, channels
|
|
var old-item-index/ecx: int <- copy _old-item-index
|
|
var y/edx: int <- copy 2
|
|
{
|
|
compare y, 0x28/screen-height-minus-menu
|
|
break-if->=
|
|
var item-index/esi: int <- item-index env, _items, channels
|
|
{
|
|
compare y, 2
|
|
break-if-= # skip this condition on first iteration
|
|
compare item-index, old-item-index
|
|
break-if-!=
|
|
# no forward progress; we're at the bottom of the current tab
|
|
return
|
|
}
|
|
var item-offset/eax: (offset item) <- compute-offset items-data, item-index
|
|
var item/eax: (addr item) <- index items-data, item-offset
|
|
var item-text-ah/eax: (addr handle array byte) <- get item, text
|
|
var item-text/eax: (addr array byte) <- lookup *item-text-ah
|
|
var h/eax: int <- estimate-height item-text
|
|
y <- add h
|
|
next-item env, users, channels, _items
|
|
loop
|
|
}
|
|
# we're past the end of the screen now, so bounce back for some continuity
|
|
previous-item env, users, channels, _items
|
|
{
|
|
# HACK: make sure we make forward progress even if a single post takes up
|
|
# the whole screen.
|
|
# We can't see the rest of that single post at the moment. But at least we
|
|
# can go past it.
|
|
var old-item-index/eax: int <- copy old-item-index
|
|
var item-index/esi: int <- item-index env, _items, channels
|
|
compare item-index, old-item-index
|
|
break-if-!=
|
|
next-item env, users, channels, _items
|
|
}
|
|
}
|
|
|
|
fn page-up _env: (addr environment), users: (addr array user), channels: (addr array channel), _items: (addr item-list) {
|
|
var env/edi: (addr environment) <- copy _env
|
|
var items/eax: (addr item-list) <- copy _items
|
|
var items-data-ah/eax: (addr handle array item) <- get items, data
|
|
var _items-data/eax: (addr array item) <- lookup *items-data-ah
|
|
var items-data/ebx: (addr array item) <- copy _items-data
|
|
var _old-item-index/esi: int <- item-index env, _items, channels
|
|
var old-item-index/ecx: int <- copy _old-item-index
|
|
var y/edx: int <- copy 2
|
|
{
|
|
compare y, 0x28/screen-height-minus-menu
|
|
break-if->=
|
|
var item-index/esi: int <- item-index env, _items, channels
|
|
{
|
|
compare y, 2
|
|
break-if-= # skip this condition on first iteration
|
|
compare item-index, old-item-index
|
|
break-if-!=
|
|
# no forward progress; we're at the bottom of the current tab
|
|
return
|
|
}
|
|
var item-offset/eax: (offset item) <- compute-offset items-data, item-index
|
|
var item/eax: (addr item) <- index items-data, item-offset
|
|
var item-text-ah/eax: (addr handle array byte) <- get item, text
|
|
var item-text/eax: (addr array byte) <- lookup *item-text-ah
|
|
var h/eax: int <- estimate-height item-text
|
|
y <- add h
|
|
previous-item env, users, channels, _items
|
|
loop
|
|
}
|
|
}
|
|
|
|
# keep sync'd with render-item
|
|
fn estimate-height _message-text: (addr array byte) -> _/eax: int {
|
|
var message-text/esi: (addr array byte) <- copy _message-text
|
|
var result/eax: int <- length message-text
|
|
var remainder/edx: int <- copy 0
|
|
result, remainder <- integer-divide result, 0x40/post-width
|
|
compare remainder, 0
|
|
{
|
|
break-if-=
|
|
result <- increment
|
|
}
|
|
result <- add 2/item-padding-ver
|
|
compare result, 6/avatar-space-ver
|
|
{
|
|
break-if->
|
|
return 6/avatar-space-ver
|
|
}
|
|
return result
|
|
}
|