about summary refs log tree commit diff stats
path: root/worker/imap/search.go
blob: 42e155b6307ce33bb7cf2418e8b4b6b13d1cc6bf (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
aerc-tutorial(7)

# NAME

aerc - the world's best email client

# INTRODUCTION

Welcome to aerc! This tutorial will guide you through your first steps in using
the client. This tutorial is a man page - you can read it again later with
*:help tutorial* from aerc, or *man aerc-tutorial* from your terminal.

First, let's introduce some basic keybindings. For convention, we'll use *<C-p>*
to represent Ctrl+p, which matches the convention used for writing keybindings
for aerc.

*<C-p>*, *<C-n>*
	Cycles to the previous or next tab

Try using these now to switch between your message list and the tutorial. In
your message list, we use vim-style keys to get around.

*k*, *j*
	Scrolls up and down between messages

*<C-u>*, *<C-d>*
	Scrolls half a page up or down

*g*, *G*
	Selects the first or last message, respectively

*K*, *J*
	Switches between folders in the sidebar

*<Enter>*
	Opens the selected message

You can also search the selected folder with */*, or filter with *\\*. When
searching you can use n and p to jump to the next and previous result.
Filtering hides any non-matching message.

# THE MESSAGE VIEWER

Press *<Enter>* to open a message. By default, the message viewer will display
your message using *less*(1). This should also have familiar, vim-like
keybindings for scrolling around in your message.

Multipart messages (messages with attachments, or messages with several
alternative formats) show a part selector on the bottom of the message viewer.

*<C-k>*, *<C-j>*
	Cycle between parts of a multipart message

*q*
	Close the message viewer

To show HTML messages, comment out the *text/html* filter in your aerc.conf
file (which is probably in ~/.config/aerc/) and install its dependencies: w3m
and dante-utils.

You can also do many tasks you could do in the message list from here, like
replying to emails, deleting the email, or view the next and previous message
(*J* and *K*).

# COMPOSING MESSAGES

Return to the message list by pressing *q* to dismiss the message viewer. Once
there, let's compose a message.

*C*
	Compose a new message

*rr*
	Reply-all to a message

*rq*
	Reply-all to a message, and pre-fill the editor with a quoted version of the
	message being replied to

*Rr*
	Reply to a message

*Rq*
	Reply to a message, and pre-fill the editor with a quoted version of the
	message being replied to

For now, let's use *C* to compose a new message. The message composer will
appear. You should see To, From, and Subject lines, as well as your *$EDITOR*.
You can use *<Tab>* or *<C-j>* and *<C-k>* to cycle between these fields (tab
won't cycle between fields once you enter the editor, but *<C-j>* and *<C-k>*
will).

Let's send an email to yourself. Note that the To and From headers only accept
RFC 5322 addresses, e.g. *John Doe <john@example.org>*, or simply
*<john@example.org>*. Separate multiple recipients with commas. Go ahead and
fill out an email (to yourself, perhaps?), then close the editor. You can add
additional headers like Cc and Reply-To by simply adding them to the top of your
email, adding a blank line between the email's headers and body.

The message review screen is shown next. You have a chance now to revise the
email before it's sent. Press *y* to send the email if it looks good.

*Note*: when using the terminal in the message view, you can summon aerc's ex
command line by using *<C-x>*. ':' is sent to the editor.

# USING THE TERMINAL

aerc comes with an embedded terminal, which you've already used to view and edit
emails. We can also use this for other purposes, such as referencing a git
repository while reviewing a patch. From the message list, we can use the
following keybindings to open a terminal:

*<C-t>*
	Opens a new terminal tab, running your shell

*$*, *!*
	Prompts for a command to run, then opens a new terminal tab running that
	command

*|*
	Prompts for a command to run, then pipes the selected email into that
	command and displays the result on a new terminal tab

Try pressing *$* and entering "top". You can also use the *:cd* command to
change aerc's working directory, and the directory in which new terminals run.
Use *:pwd* to see it again if you're not sure where you are.

# ADDITIONAL N
gu">## MESSAGE FILTERS When displaying messages in the message viewer, aerc will pipe them through a _message filter_ first. This allows you to decode messages in non-plaintext formats, add syntax highlighting, etc. aerc ships with a few default filters: - Emails which begin with "[PATCH" will be piped into a filter for rendering git-format-patch and hg export emails. - text/html is rendered with w3m in a network sandbox - text/\* is rendered with a simple filter for coloring quoted text ## CUSTOMIZING AERC Aerc is highly customizable. Review *aerc-config*(5) (or use *:help config*) to learn more about how to add custom keybindings, install new message filters, change its appearance and behavior, and so on. # AUTHORS Maintained by Drew DeVault <sir@cmpwn.com>, who is assisted by other open source contributors. For more information about aerc development, see https://git.sr.ht/~sircmpwn/aerc. 5' href='#n515'>515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
type environment {
  search-terms: (handle gap-buffer)
  tabs: (handle array tab)
  current-tab-index: int  # index into tabs
  cursor-in-search?: boolean
  cursor-in-channels?: boolean
  channel-cursor-index: int
}

type tab {
  type: int
      # type 0: everything
      # type 1: items in a channel
      # type 2: search for a term
  item-index: int  # what item in the corresponding list we start rendering
                   # the current page at
  # only for type 1
  channel-index: int
  # only for type 2
  search-terms: (handle gap-buffer)
  items: (handle array 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

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) {
  clear-screen screen
  render-search-input screen, env
  render-channels screen, env, channels
  render-item-list screen, env, items, channels, users
  render-menu screen, env
}

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-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 7/grey
      draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, name, 0/black 7/grey
    }
    y <- add 2/channel-padding
    i <- increment
    loop
  }
}

fn render-item-list screen: (addr screen), _env: (addr environment), items: (addr item-list), channels: (addr array channel), users: (addr array user) {
  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
  render-tab screen, current-tab, items, channels, users, 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), items: (addr item-list), channels: (addr array channel), users: (addr array user), 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, items, users, screen-height
    return
  }
  compare *current-tab-type, 1/channel
  {
    break-if-!=
    render-channel-tab screen, current-tab, items, channels, users, screen-height
    return
  }
}

fn render-all-items screen: (addr screen), _current-tab: (addr tab), _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
  {
    compare i, 0
    break-if-<
    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, y, screen-height
    i <- decrement
    loop
  }
}

fn render-channel-tab screen: (addr screen), _current-tab: (addr tab), _items: (addr item-list), _channels: (addr array channel), 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 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, y, screen-height
    i <- decrement
    loop
  }
}

# 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
  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, 1/render-cursor, 0xf/fg 0/bg
  {
    compare x, 0x4a/end-search
    break-if->
    var y/ecx: int <- copy 0
    x, y <- render-grapheme screen, 0x5f/underscore, 0/xmin 1/ymin, 0x80/xmax, 1/ymax, x, 1/y, 0xf/fg 0/bg
    loop
  }
}

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
  }
  compare *cursor-in-channels?, 0/false
  {
    break-if-!=
    render-main-menu screen, env
    return
  }
}

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, " ^b ", width, 0/fg 0xf/bg
  draw-text-rightward-from-cursor screen, " << page  ", width, 0xf/fg, 0/bg
  draw-text-rightward-from-cursor screen, " ^p ", width, 0/fg 0xf/bg
  draw-text-rightward-from-cursor screen, " < item  ", width, 0xf/fg, 0/bg
  draw-text-rightward-from-cursor screen, " ^n ", width, 0/fg 0xf/bg
  draw-text-rightward-from-cursor screen, " item >  ", 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
}

fn render-item screen: (addr screen), _item: (addr item), _users: (addr array user), 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, 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), 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
  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/eax: int <- copy x
  var ycurr/ecx: int <- copy y
  {
    var g/ebx: grapheme <- read-json-grapheme stream
    compare g, 0xffffffff/end-of-file
    break-if-=
    $draw-json-stream-wrapping-right-then-down:render-grapheme: {
      compare g, 0x5c/backslash
      {
        break-if-!=
        xcurr, ycurr <- render-json-escaped-grapheme screen, stream, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
        break $draw-json-stream-wrapping-right-then-down:render-grapheme
      }
      xcurr, ycurr <- render-grapheme screen, g, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
    }
    loop
  }
  set-cursor-position screen, xcurr, ycurr
  return xcurr, ycurr
}

# just return a different register
fn read-json-grapheme stream: (addr stream byte) -> _/ebx: grapheme {
  var result/eax: grapheme <- read-grapheme stream
  return result
}

# '\' encountered
# https://www.json.org/json-en.html
fn render-json-escaped-grapheme 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 g/ebx: grapheme <- read-json-grapheme 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-grapheme screen, stream, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
    return x, y
  }
  # most characters escape to themselves
  x, y <- render-grapheme screen, g, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
  return x, y
}

# '\u' encountered
fn render-json-escaped-unicode-grapheme 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 ustream-storage: (stream byte 4)
  var ustream/esi: (addr stream byte) <- address ustream-storage
  # slurp 4 bytes exactly
  var b/eax: byte <- read-byte stream
  var b-int/eax: int <- copy b
  append-byte ustream, b-int
  var b/eax: byte <- read-byte stream
  var b-int/eax: int <- copy b
  append-byte ustream, b-int
  var b/eax: byte <- read-byte stream
  var b-int/eax: int <- copy b
  append-byte ustream, b-int
  var b/eax: byte <- read-byte stream
  var b-int/eax: int <- copy b
  append-byte ustream, b-int
  # \u2013 = -
  {
    var endash?/eax: boolean <- stream-data-equal? ustream, "2013"
    compare endash?, 0/false
    break-if-=
    var x/eax: int <- copy 0
    var y/ecx: int <- copy 0
    x, y <- render-grapheme screen, 0x2d/dash, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
    return x, y
  }
  # \u2014 = -
  {
    var emdash?/eax: boolean <- stream-data-equal? ustream, "2014"
    compare emdash?, 0/false
    break-if-=
    var x/eax: int <- copy 0
    var y/ecx: int <- copy 0
    x, y <- render-grapheme screen, 0x2d/dash, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
    return x, y
  }
  # \u2018 = '
  {
    var left-quote?/eax: boolean <- stream-data-equal? ustream, "2018"
    compare left-quote?, 0/false
    break-if-=
    var x/eax: int <- copy 0
    var y/ecx: int <- copy 0
    x, y <- render-grapheme screen, 0x27/quote, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
    return x, y
  }
  # \u2019 = '
  {
    var right-quote?/eax: boolean <- stream-data-equal? ustream, "2019"
    compare right-quote?, 0/false
    break-if-=
    var x/eax: int <- copy 0
    var y/ecx: int <- copy 0
    x, y <- render-grapheme screen, 0x27/quote, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
    return x, y
  }
  # \u201c = "
  {
    var left-dquote?/eax: boolean <- stream-data-equal? ustream, "201c"
    compare left-dquote?, 0/false
    break-if-=
    var x/eax: int <- copy 0
    var y/ecx: int <- copy 0
    x, y <- render-grapheme screen, 0x22/dquote, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
    return x, y
  }
  # \u201d = "
  {
    var right-dquote?/eax: boolean <- stream-data-equal? ustream, "201d"
    compare right-dquote?, 0/false
    break-if-=
    var x/eax: int <- copy 0
    var y/ecx: int <- copy 0
    x, y <- render-grapheme screen, 0x22/dquote, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
    return x, y
  }
  # \u2022 = *
  {
    var bullet?/eax: boolean <- stream-data-equal? ustream, "2022"
    compare bullet?, 0/false
    break-if-=
    var x/eax: int <- copy 0
    var y/ecx: int <- copy 0
    x, y <- render-grapheme screen, 0x2a/asterisk, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
    return x, y
  }
  # \u2026 = ...
  {
    var ellipses?/eax: boolean <- stream-data-equal? ustream, "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
  }
  # TODO: rest of Unicode
  var x/eax: int <- copy 0
  var y/ecx: int <- copy 0
  x, y <- draw-stream-wrapping-right-then-down screen, ustream, 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
  # back in history
  {
    compare key, 0x1b/esc
    break-if-!=
    previous-tab env
    return
  }
  {
    compare key, 0x2f/slash
    break-if-!=
    # start search mode
    var cursor-in-search?/eax: (addr boolean) <- get env, cursor-in-search?
    copy-to *cursor-in-search?, 1/true
    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?
    return
  }
  # dispatch based on where the cursor is
  {
    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 *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, 0xe/ctrl-n
    break-if-!=
    next-item env, users, channels, items
    return
  }
  {
    compare key, 0x10/ctrl-p
    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
  }
}

# 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
  {
    compare key, 0xa/newline
    break-if-!=
    new-search-tab env, items
    var cursor-in-search?/eax: (addr boolean) <- get env, cursor-in-search?
    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: grapheme <- copy key
  edit-gap-buffer search-terms, g
}

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/eax: 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 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/ecx: (addr tab) <- index tabs, current-tab-offset
  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
  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) {
}

fn previous-tab _env: (addr environment) {
  var env/edi: (addr environment) <- copy _env
  var current-tab-index-addr/eax: (addr int) <- get env, current-tab-index
  compare *current-tab-index-addr, 0
  {
    break-if-<=
    decrement *current-tab-index-addr
  }
}

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/eax: (addr int) <- get current-tab, item-index
  compare *dest, 0
  break-if-<=
  decrement *dest
}

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/eax: (addr int) <- get current-tab, item-index
    compare *dest, final-item-index
    break-if->=
    increment *dest
    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/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 tabs-ah/eax: (addr handle array tab) <- get env, tabs
  var _tabs/eax: (addr array tab) <- lookup *tabs-ah
  var tabs/ecx: (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-!=
    all-items-page-down current-tab, users, channels, items
    return
  }
  compare *current-tab-type, 1/channel
  {
    break-if-!=
    channel-page-down current-tab, users, channels, items
    return
  }
}

fn all-items-page-down _current-tab: (addr tab), users: (addr array user), channels: (addr array channel), _items: (addr item-list) {
  var items/esi: (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 current-tab/eax: (addr tab) <- copy _current-tab
  var current-tab-item-index-addr/edi: (addr int) <- get current-tab, item-index
  var new-item-index/ecx: int <- copy *current-tab-item-index-addr
  var y/edx: int <- copy 2
  {
    compare new-item-index, 0
    break-if-<
    compare y, 0x28/screen-height-minus-menu
    break-if->=
    var offset/eax: (offset item) <- compute-offset items-data, new-item-index
    var item/eax: (addr item) <- index items-data, 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
    new-item-index <- decrement
    loop
  }
  new-item-index <- increment
  {
    # 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.
    compare new-item-index, *current-tab-item-index-addr
    break-if-!=
    # Don't make "forward progress" past post 0.
    compare new-item-index, 0
    break-if-=
    new-item-index <- decrement
  }
  copy-to *current-tab-item-index-addr, new-item-index
}

fn channel-page-down _current-tab: (addr tab), users: (addr array user), _channels: (addr array channel), _items: (addr item-list) {
  var current-tab/edi: (addr tab) <- copy _current-tab
  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/esi: (addr channel) <- index channels, current-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/esi: (addr array int) <- copy _current-channel-posts
  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 current-tab-item-index-addr/edi: (addr int) <- get current-tab, item-index
  var new-tab-item-index/ecx: int <- copy *current-tab-item-index-addr
  var y/edx: int <- copy 2
  {
    compare new-tab-item-index, 0
    break-if-<
    compare y, 0x28/screen-height-minus-menu
    break-if->=
    var current-item-index-addr/eax: (addr int) <- index current-channel-posts, new-tab-item-index
    var current-item-index/eax: int <- copy *current-item-index-addr
    var offset/eax: (offset item) <- compute-offset items-data, current-item-index
    var item/eax: (addr item) <- index items-data, 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
    new-tab-item-index <- decrement
    loop
  }
  new-tab-item-index <- increment
  {
    # 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.
    compare new-tab-item-index, *current-tab-item-index-addr
    break-if-!=
    # Don't make "forward progress" past post 0.
    compare new-tab-item-index, 0
    break-if-=
    new-tab-item-index <- decrement
  }
  copy-to *current-tab-item-index-addr, new-tab-item-index
}

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 tabs-ah/eax: (addr handle array tab) <- get env, tabs
  var _tabs/eax: (addr array tab) <- lookup *tabs-ah
  var tabs/ecx: (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-!=
    all-items-page-up current-tab, users, channels, items
    return
  }
  compare *current-tab-type, 1/channel
  {
    break-if-!=
    channel-page-up current-tab, users, channels, items
    return
  }
}

fn all-items-page-up _current-tab: (addr tab), users: (addr array user), channels: (addr array channel), _items: (addr item-list) {
  var items/esi: (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/eax: (addr int) <- get items, data-first-free
  var final-item-index/esi: int <- copy *items-data-first-free-a
  final-item-index <- decrement
  var current-tab/eax: (addr tab) <- copy _current-tab
  var current-tab-item-index-addr/edi: (addr int) <- get current-tab, item-index
  var new-item-index/ecx: int <- copy *current-tab-item-index-addr
  var y/edx: int <- copy 2
  {
    compare new-item-index, final-item-index
    break-if->
    compare y, 0x28/screen-height-minus-menu
    break-if->=
    var offset/eax: (offset item) <- compute-offset items-data, new-item-index
    var item/eax: (addr item) <- index items-data, 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
    new-item-index <- increment
    loop
  }
  new-item-index <- decrement
  copy-to *current-tab-item-index-addr, new-item-index
}

fn channel-page-up _current-tab: (addr tab), users: (addr array user), _channels: (addr array channel), _items: (addr item-list) {
  var current-tab/edi: (addr tab) <- copy _current-tab
  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/esi: (addr channel) <- index channels, current-channel-offset
  var current-channel-posts-first-free-addr/eax: (addr int) <- get current-channel, posts-first-free
  var tmp/eax: int <- copy *current-channel-posts-first-free-addr
  var final-tab-post-index: int
  copy-to final-tab-post-index, tmp
  decrement final-tab-post-index
  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/esi: (addr array int) <- copy _current-channel-posts
  var items/esi: (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 current-tab-item-index-addr/edi: (addr int) <- get current-tab, item-index
  var new-tab-item-index/ecx: int <- copy *current-tab-item-index-addr
  var y/edx: int <- copy 2
  {
    compare new-tab-item-index, final-tab-post-index
    break-if->
    compare y, 0x28/screen-height-minus-menu
    break-if->=
    var offset/eax: (offset item) <- compute-offset items-data, new-tab-item-index
    var item/eax: (addr item) <- index items-data, 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
    new-tab-item-index <- increment
    loop
  }
  new-tab-item-index <- decrement
  copy-to *current-tab-item-index-addr, new-tab-item-index
}

# 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
}