roll.pixi

// Click/Drag: Draw/Edit
// Ctrl + drag: Pan
// Ctrl + scroll: Zoom

CELL_HEIGHT = 8
CELL_WIDTH = 13
MAX_TICKS = 0xffff

NOCHANGE = 0xff
HIGHEST_NOTE = 95

roll_x = 0
roll_y = 0
roll_w = -1
roll_h = -1
roll_sel_h = 12

roll_pan_h = 36 + 2 // Range for pan is [0, 12]
roll_vol_h = 50 + 2 // Range for volume is [0, 248]

roll_px = 0
roll_py = 48 * CELL_HEIGHT

roll_ctrl = 0
roll_shift = 0
roll_activated = 0

roll_moving = 0
roll_mx = -1
roll_my = -1
roll_erasing = 0    // 1 - yes, 2 - yes and already erased something
roll_editing = -1
roll_edit_idx = -1
roll_eside = -1 // X coordinate of a fixed side for editing; -1 if moving
roll_last_vol = 0x80
roll_last_pan = 0x6

roll_selecting = 0
roll_sside = 0  // X coordinate of a fixed side for selection
roll_sfin = 0   // other side
roll_hscroll = 0    // Dragging in the selection area

roll_rpt_a = MAX_TICKS
roll_rpt_b = MAX_TICKS

roll_draw_pan = 0
roll_draw_vol = 0

roll_changed = 0
file_unsaved = 0

fn roll_mouse_down($x, $y, $is_right) {
    if ($x >= roll_x && $x < roll_x + roll_w &&
        $y >= roll_y && $y < roll_y + roll_h)
    {
        roll_activated = 1
        if ($y < roll_y + roll_sel_h) {
            roll_selecting = 1
            roll_changed = 1
            if (roll_shift != 0) {
                roll_sside = roll_sfin
            }
            roll_sfin = floor((roll_px + $x - roll_x) / CELL_WIDTH)
            if (roll_shift == 0) {
                roll_sside = roll_sfin
            }
        }
        if ($y >= roll_y + roll_sel_h && $y < roll_y + roll_h - roll_vol_h - roll_pan_h) {
            roll_moving = roll_ctrl
            if (roll_moving) {
                roll_mx = roll_px + $x
                roll_my = roll_py - $y
            } else {
                if ($is_right) {
                    roll_erasing = 1
                    roll_mouse_move($x, $y)
                } else {
                    roll_mx = floor((roll_px + $x - roll_x) / CELL_WIDTH)
                    roll_my = floor((roll_py - $y + roll_y) / CELL_HEIGHT)
                    roll_locate_note(roll_mx, roll_my)
                    if (roll_editing == -1) {
                        roll_editing = add_note(
                            roll_tid, roll_mx, roll_my, 1, roll_last_vol, roll_last_pan)
                        roll_eside = roll_mx
                    } else {
                        roll_mx = roll_editing.x - roll_mx
                    }
                    if (roll_playing == 0) {
                        note_on(roll_tid, roll_editing.y, roll_editing.vol, roll_editing.pan)
                    }
                }
                roll_changed = 1
            }
        }
        if ($y >= roll_y + roll_h - roll_vol_h - roll_pan_h &&
            $y < roll_y + roll_h - roll_vol_h)
        {
            roll_moving = roll_ctrl
            if (roll_moving) {
                roll_mx = roll_px + $x
                roll_my = roll_py - $y
            } else {
                roll_draw_pan = 1
                roll_mouse_move($x, $y)
            }
        }
        if ($y >= roll_y + roll_h - roll_vol_h) {
            roll_moving = roll_ctrl
            if (roll_moving) {
                roll_mx = roll_px + $x
                roll_my = roll_py - $y
            } else {
                roll_draw_vol = 1
                roll_mouse_move($x, $y)
            }
        }
    }
}

fn roll_mouse_move($x, $y) {
    if (roll_activated == 0) { ret }
    if (roll_moving) {
        roll_px = roll_mx - $x
        roll_py = roll_my + $y
        roll_start_play_px = roll_px
        roll_start_play_py = roll_py
    }
    if (roll_erasing) {
        $mx = floor((roll_px + $x - roll_x) / CELL_WIDTH)
        $my = floor((roll_py - $y + roll_y) / CELL_HEIGHT)
        roll_locate_note($mx, $my)
        if (roll_editing != -1) {
            remove_note(roll_tid, roll_edit_idx)
            roll_editing = -1
            roll_erasing = 2
        }
    }
    if (roll_selecting) {
        roll_sfin = floor((roll_px + $x - roll_x) / CELL_WIDTH)
        if (roll_sfin < 0) { roll_sfin = 0 }
        if (roll_sfin >= MAX_TICKS) { roll_sfin = MAX_TICKS - 1 }
        // Horizontal scroll
        roll_hscroll = 0
        if ($x <= roll_x) { roll_hscroll - 1.5 }
        if ($x <= roll_x + 16) { roll_hscroll - 1 }
        if ($x >= roll_x + roll_w - 16) { roll_hscroll + 1 }
        if ($x >= roll_x + roll_w) { roll_hscroll + 1.5 }
    }
    if (roll_editing != -1) {
        $mx = floor((roll_px + $x - roll_x) / CELL_WIDTH)
        $my = floor((roll_py - $y + roll_y) / CELL_HEIGHT)
        if ($mx < 0) { $mx = 0 }
        if ($mx >= MAX_TICKS) { $mx = MAX_TICKS - 1 }
        if ($my < 0) { $my = 0 }
        if ($my > HIGHEST_NOTE) { $my = HIGHEST_NOTE }
        if (roll_eside == -1) {
            roll_editing.x = roll_mx + $mx
        } else {
            $x1 = $mx
            $x2 = roll_eside
            if ($x1 > $x2) {
                $t = $x1
                $x1 = $x2
                $x2 = $t
            }
            roll_editing.x = $x1
            roll_editing.len = $x2 - $x1 + 1
        }
        if (roll_editing.y != NOCHANGE && roll_editing.y != $my) {
            roll_editing.y = $my
            if (roll_playing == 0) {
                note_on(roll_tid, roll_editing.y, roll_editing.vol, roll_editing.pan)
            }
        }
    }
    if (roll_draw_vol) {
        $mx = floor((roll_px + $x - roll_x) / CELL_WIDTH)
        $my = roll_y + roll_h - 1 - $y
        if ($my < 0) { $my = 0 }
        if ($my > roll_vol_h - 2) { $my = roll_vol_h - 2 }
        roll_last_vol = $my * 0xf8 div (roll_vol_h - 2)
        edit_attr("vol", $mx, roll_last_vol)
    }
    if (roll_draw_pan) {
        $mx = floor((roll_px + $x - roll_x) / CELL_WIDTH)
        $my = roll_y + roll_h - roll_vol_h - 1 - $y
        if ($my < 0) { $my = 0 }
        if ($my > roll_pan_h - 2) { $my = roll_pan_h - 2 }
        roll_last_pan = $my * 0xc div (roll_pan_h - 2)
        edit_attr("pan", $mx, roll_last_pan)
    }
    roll_changed = 1
}

roll_playing = 0
roll_play_pos = 0

fn move_to_play_pos() {
    $bar_start = (roll_sside - roll_sside % roll_bar) * CELL_WIDTH
    if ($bar_start + roll_bar * CELL_WIDTH >= roll_px + roll_w ||
        $bar_start < roll_px)
    {
        roll_px = $bar_start
    }
    roll_changed = 1
}

fn roll_tick($dt) {
    if (roll_hscroll != 0) {
        roll_px + (roll_hscroll * $dt / 4)
        roll_changed = 1
    }
    if (roll_playing) {
        roll_playback_tickfrac + get_playback_timer_delta()
        if (roll_playback_tickfrac >= tick_len) {
            roll_playback_tickfrac - tick_len
            // Update playback
            advance_play_pos()
            // Update position display
            roll_sside = roll_play_pos
            roll_sfin = roll_sside
            // Auto-scroll
            move_to_play_pos()
        }
    }
}

// Handles playback control and sounds only
// Graphics is handled in roll_tick()
fn advance_play_pos() {
    roll_play_pos + 1
    if (roll_play_pos == roll_rpt_b + 1) {
        // Repeat
        // Turn off all melody tracks
        $i = 0
        while ($i < 8) {
            note_off($i)
            $i + 1
        }
        roll_play_pos = roll_rpt_a
    } else {
        if (roll_play_pos >= MAX_TICKS) {
            // Stop playing if the end is reached
            menu_btns_text[8].cb()
        }
    }

    $x = roll_play_pos
    $j = 0
    while ($j < 16) {
        if ((roll_track_sel & (1 << $j)) == 0) { $j + 1 continue }

        $l = roll_tracks[$j]
        $cnt = $l.cnt

        // Note off placed before note on
        // as there may be attributive notes (0-length)
        // and consecutive notes
        // XXX: Optimize?
        $i = 0
        while ($i < $cnt) {
            $n = $l[$i]
            if ($n.y != NOCHANGE && $n.x + $n.len == $x) {
                note_off($j)
            }
            $i + 1
        }

        $i = 0
        while ($i < $cnt) {
            $n = $l[$i]
            if ($n.x == $x) {
                $freq = -1
                $vol = -1
                $pan = -1
                if ($n.y != NOCHANGE) { $freq = $n.y }
                if ($n.vol != NOCHANGE) { $vol = $n.vol }
                if ($n.pan != NOCHANGE) { $pan = $n.pan }
                note_on($j, $freq, $vol, $pan)
            }
            $i + 1
        }

        $j + 1
    }
}

roll_start_play_px = -1
roll_start_play_py = -1
roll_start_play_tick = 0
roll_start_play_sel = -1
roll_start_play_tid = -1
roll_playback_tickfrac = 0

roll_playback_timer_last = 0

fn start_playback_timer() {
    start_timer(1)
    roll_playback_timer_last = 0
}

fn get_playback_timer_delta() {
    $t = get_timer(1)
    $ret = $t - roll_playback_timer_last
    roll_playback_timer_last = $t
    ret($ret)
}

fn roll_toggle_play() {
    if (roll_playing) {
        // Stop
        roll_playing = 0
        all_silence()
        // Restore track & range selection and view position
        if (roll_start_play_sel != -1) {
            roll_track_sel = roll_start_play_sel
            roll_tid = roll_start_play_tid
        }
        roll_sside = roll_start_play_tick
        roll_sfin = roll_sside
        roll_px = roll_start_play_px
        roll_py = roll_start_play_py
    } else {
        // Save current view position
        roll_start_play_px = roll_px
        roll_start_play_py = roll_py
        if (roll_ctrl || roll_shift) {
            // Save current track selection
            roll_start_play_sel = roll_track_sel
            roll_start_play_tid = roll_tid
            roll_track_sel = (1 << 16) - 1
        } else {
            roll_start_play_sel = -1
            roll_start_play_tid = -1
        }
        // Move to selection start
        sort_sel_endpts()
        // Start
        roll_playing = 1
        roll_play_pos = roll_sside - 1
        roll_start_play_tick = roll_sside
        roll_playback_tickfrac = 0
        start_playback_timer()
        // Auto-scroll
        move_to_play_pos()
    }
    update_track_btns()
}

fn roll_mouse_up($x, $y) {
    if (roll_activated == 0) { ret }
    roll_activated = 0
    if (roll_editing != -1) {
        roll_monophonize(roll_editing)
        roll_last_vol = roll_editing.vol
        roll_last_pan = roll_editing.pan
        roll_changed = 1
    }
    if (roll_editing != -1 || roll_erasing == 2 || roll_draw_pan || roll_draw_vol) {
        roll_push_history()
    }
    roll_moving = 0
    roll_erasing = 0
    roll_selecting = 0
    roll_hscroll = 0
    roll_editing = -1
    roll_draw_pan = 0
    roll_draw_vol = 0
    if (roll_playing == 0) { note_off(roll_tid) }
}

fn roll_mouse_scroll($val) {
    if (roll_ctrl == 0) {
        if (roll_shift == 0) {
            // Move horizontally
            roll_px + ($val * 8 * roll_beat)
        } else {
            // Move vertically
            roll_py - ($val * 13)
        }
    } else {
        if (roll_shift == 0) {
            // Zoom horizontally
            $new_width = CELL_WIDTH + $val * 0.25
            if ($new_width >= 2 && $new_width <= 13) {
                roll_px = roll_px / CELL_WIDTH * $new_width
                CELL_WIDTH = $new_width
            }
        } else {
            // Zoom vertically
            $new_height = CELL_HEIGHT + $val * 0.25
            if ($new_height >= 3 && $new_height <= 8) {
                $h = roll_h - roll_pan_h - roll_vol_h
                roll_py = (roll_py - $h) / CELL_HEIGHT * $new_height + $h
                CELL_HEIGHT = $new_height
            }
        }
    }
    roll_start_play_px = roll_px
    roll_start_play_py = roll_py
    roll_changed = 1
    roll_clamp_p()
}

fn roll_mouse_scrollup($x, $y) {
    if ($x >= roll_x && $x < roll_x + roll_w &&
        $y >= roll_y && $y < roll_y + roll_h)
    {
        roll_mouse_scroll(-1)
    }
}

fn roll_mouse_scrolldown($x, $y) {
    if ($x >= roll_x && $x < roll_x + roll_w &&
        $y >= roll_y && $y < roll_y + roll_h)
    {
        roll_mouse_scroll(1)
    }
}

fn roll_clamp_p() {
    if (roll_px > MAX_TICKS * CELL_WIDTH - roll_w) {
        roll_px = MAX_TICKS * CELL_WIDTH - roll_w
    }
    if (roll_px < 0) {
        roll_px = 0
    }
    if (roll_py > (HIGHEST_NOTE + 1) * CELL_HEIGHT) {
        roll_py = (HIGHEST_NOTE + 1) * CELL_HEIGHT
    }
    if (roll_py < roll_h - roll_vol_h - roll_pan_h - 1) {
        roll_py = roll_h - roll_vol_h - roll_pan_h - 1
    }
}

roll_bar = 16
roll_beat = 4
roll_tracks = new(16, 1, INT)

HISTORY = 8
roll_history = new(HISTORY, 1, INT)
roll_hist_top = 0
roll_hist_ptr = 0
roll_no_history = 0

roll_clip_len = 0
roll_clip = new(16, 1, INT)

$i = 0
while ($i < 16) {
    roll_tracks[$i] = new(4096, 1, INT)
    roll_tracks[$i].cnt = 0
    roll_clip[$i] = new(4096, 1, INT)
    roll_clip[$i].cnt = 0
    $i + 1
}

$i = 0
while ($i < HISTORY) {
    roll_history[$i] = new(16, 1, INT)
    $i + 1
}

track_colours = new(16)
track_colours[0] = nord11
track_colours[1] = nord12
track_colours[2] = nord13
track_colours[3] = nord14
track_colours[4] = nord8
track_colours[5] = nord10
track_colours[6] = nord15
track_colours[7] = nord4

$i = 8
while ($i < 16) {
    track_colours[$i] =
        get_blend(track_colours[$i - 8], track_colours[($i + 1) % 8], 128)
    $i + 1
}

// Mask of selected tracks
roll_track_sel = 1
// First selected track
roll_tid = 0

fn switch_track($t) {
    if (roll_ctrl) {
        if ((roll_track_sel ^ (1 << $t)) != 0) {
            if (roll_track_sel & (1 << $t)) {
                // Turn off sustaining notes, if any
                note_off($t)
            }
            roll_track_sel ^ (1 << $t)
        }
        // Take lowest bit
        $b = (roll_track_sel & -roll_track_sel)
        $t = 0
        // Count trailing zeros
        while ($b > 1) {
            $b div 2
            $t + 1
        }
    } else {
        if (roll_shift) {
            $s = last_track_btn
            if ($s > $t) {
                $u = $s
                $s = $t
                $t = $u
            }
        } else {
            $s = $t
        }
        $i = 0
        while ($i < 16) {
            if ($i < $s || $i > $t) { note_off($i) }
            $i + 1
        }
        roll_track_sel = (1 << ($t + 1)) - (1 << $s)
    }
    roll_tid = $t
    roll_changed = 1
}

fn roll_clear() {
    roll_clear_history()
    $i = 0
    while ($i < 16) {
        $j = 0
        while ($j < roll_tracks[$i].cnt) {
            remove_track_notes(roll_tracks[$i][$j])
            remove(roll_tracks[$i][$j])
            $j + 1
        }
        roll_tracks[$i].cnt = 0
        $i + 1
    }
    roll_changed = 1
}

fn add_note($tid, $x, $y, $len, $vol, $pan) {
    roll_remove_dup_attr($tid, $x)

    $l = roll_tracks[$tid]
    if ($l.cnt == get_xsize($l)) {
        send_notif("Too many notes on the track")
        ret(-1)
    }

    $n = new()
    if ($n == -1) {
        send_notif("Insufficient memory... Try restarting the program", nord0)
        ret($n)
    }
    $n.x = $x
    $n.y = $y
    $n.len = $len
    $n.vol = $vol
    $n.pan = $pan

    $l[$l.cnt] = $n
    $l.cnt + 1
    ret($n)
}

fn remove_note($tid, $i) {
    $l = roll_tracks[$tid]
    remove($l[$i])
    $l.cnt - 1
    $l[$i] = $l[$l.cnt]
}

// Finds whether a note exists at cell (x, y) on the first selected track
// and updates global variables <roll_editing>, <roll_edit_idx> and <roll_eside>
fn roll_locate_note($x, $y) {
    $l = roll_tracks[roll_tid]
    $cnt = $l.cnt
    $i = 0
    roll_editing = -1
    roll_edit_idx = -1
    while ($i < $cnt) {
        $n = $l[$i]
        if ($n.y == $y && $n.x <= $x && $n.x + $n.len > $x) {
            roll_editing = $n
            roll_edit_idx = $i
            roll_eside = -1
            if ($n.x == $x) { roll_eside = $n.x + $n.len - 1 }
            if ($n.x + $n.len - 1 == $x) { roll_eside = $n.x }
            break
        }
        $i + 1
    }
}

fn edit_attr($prop, $x, $val) {
    $tid = roll_tid
    $l = roll_tracks[$tid]
    $cnt = $l.cnt
    $i = 0
    while ($i < $cnt) {
        $n = $l[$i]
        if ($n.x == $x) {
            set_prop($n, $prop, $val)
            ret
        }
        $i + 1
    }

    // No note matches, create a new one
    if ($prop[0] == 'v') {
        add_note($tid, $x, NOCHANGE, 1, $val, NOCHANGE)
    } else {
        add_note($tid, $x, NOCHANGE, 1, NOCHANGE, $val)
    }
}

// Make the track monophonic w.r.t. a given newly-added note
fn roll_monophonize($m) {
    $tid = roll_tid
    roll_remove_dup_attr($tid, $m.x)

    $l = roll_tracks[$tid]
    $cnt = $l.cnt
    $i = 0
    while ($i < $cnt) {
        $n = $l[$i]
        if ($n != $m && $n.y != NOCHANGE &&
            $n.x + $n.len > $m.x && $m.x + $m.len > $n.x)
        {
            if ($n.x < $m.x) {
                if ($n.x + $n.len <= $m.x + $m.len) {
                    // Truncate from the right
                    $n.len = $m.x - $n.x
                } else {
                    // Split into two notes
                    add_note($tid, $m.x + $m.len, $n.y,
                        ($n.x + $n.len) - ($m.x + $m.len), $n.vol, $n.pan)
                    $n.len = $m.x - $n.x
                }
            } else {
                if ($n.x + $n.len <= $m.x + $m.len) {
                    // Remove
                    remove_note($tid, $i)
                    $cnt - 1
                    continue
                } else {
                    // Truncate from the left
                    $t = $n.x + $n.len
                    $n.x = $m.x + $m.len
                    $n.len = $t - $n.x
                    roll_remove_dup_attr($tid, $n.x)
                }
            }
        }
        $i + 1
    }
}

// For the first selected track,
// remove attributive notes at position $x, if any
fn roll_remove_dup_attr($tid, $x) {
    $l = roll_tracks[$tid]
    $cnt = $l.cnt
    $i = 0
    while ($i < $cnt) {
        $n = $l[$i]
        if ($n.y == NOCHANGE && $n.x == $x) {
            remove_note($tid, $i)
            $cnt - 1
            continue
        }
        $i + 1
    }
}

// Break all selected tracks at position $x
// i.e. for each note [l, r] (l < x <= r), replace it with [l, x) and [x, r]
fn roll_break($x) {
    $j = 0
    while ($j < 16) {
        if ((roll_track_sel & (1 << $j)) == 0) { $j + 1 continue }

        $l = roll_tracks[$j]
        $cnt = $l.cnt
        $i = 0
        while ($i < $cnt) {
            $n = $l[$i]
            if ($n.x < $x && $n.x + $n.len > $x) {
                add_note($j, $x, $n.y, $n.x + $n.len - $x, $n.vol, $n.pan)
                $n.len = $x - $n.x
            }
            $i + 1
        }

        $j + 1
    }
}

fn roll_cut() {
    roll_copy()
    roll_shrink()
    roll_sfin = roll_sside
}

fn sort_sel_endpts() {
    if (roll_sside > roll_sfin) {
        $t = roll_sside
        roll_sside = roll_sfin
        roll_sfin = $t
    }
}

fn roll_copy() {
    sort_sel_endpts()
    $x1 = roll_sside
    $x2 = roll_sfin

    if (roll_shift) {
        roll_rpt_a = $x1
        roll_rpt_b = $x2
        roll_changed = 1
        ret
    }

    roll_break($x1)
    roll_break($x2 + 1)

    roll_clip_len = $x2 - $x1 + 1
    roll_clear_clipboard()

    $j = 0
    while ($j < 16) {
        if ((roll_track_sel & (1 << $j)) == 0) { $j + 1 continue }

        $l = roll_tracks[$j]
        $cnt = $l.cnt
        $i = 0
        $new = 0
        while ($i < $cnt) {
            $n = $l[$i]
            if ($n.x >= $x1 && $n.x <= $x2) {
                roll_clip[$j][$new] = clone($n)
                roll_clip[$j][$new].x - $x1
                $new + 1
            }
            $i + 1
        }

        roll_clip[$j].cnt = $new
        $j + 1
    }

    roll_reload_current_undo_state()
}

fn roll_clear_clipboard() {
    $i = 0
    while ($i < 16) {
        $j = 0
        while ($j < roll_clip[$i].cnt) {
            remove(roll_clip[$i][$j])
            $j + 1
        }
        roll_clip[$i].cnt = 0
        $i + 1
    }
}

fn roll_paste() {
    if (roll_clip_len == 0) {
        send_notif("Clipboard empty", nord13)
        ret
    }

    sort_sel_endpts()
    $x1 = roll_sside
    $x2 = roll_sfin

    roll_break($x1)

    $j = 0
    while ($j < 16) {
        if ((roll_track_sel & (1 << $j)) == 0) { $j + 1 continue }

        $l = roll_tracks[$j]
        $cnt = $l.cnt
        $i = 0
        while ($i < $cnt) {
            $n = $l[$i]
            if ($n.x >= $x1) {
                $n.x + roll_clip_len
            }
            $i + 1
        }

        $cnt = roll_clip[$j].cnt
        $i = 0
        while ($i < $cnt) {
            $n = roll_clip[$j][$i]
            add_note($j, $n.x + $x1, $n.y, $n.len, $n.vol, $n.pan)
            $i + 1
        }

        $j + 1
    }

    roll_push_history()
    roll_sfin = roll_sside + roll_clip_len - 1
}

fn roll_shrink() {
    sort_sel_endpts()
    $x1 = roll_sside
    $x2 = roll_sfin

    roll_break($x1)
    roll_break($x2 + 1)

    $j = 0
    while ($j < 16) {
        if ((roll_track_sel & (1 << $j)) == 0) { $j + 1 continue }

        $l = roll_tracks[$j]
        $cnt = $l.cnt
        $i = 0
        while ($i < $cnt) {
            $n = $l[$i]
            if ($n.x > $x2) {
                $n.x - ($x2 - $x1 + 1)
            } else {
                if ($n.x >= $x1) {
                    remove_note($j, $i)
                    $cnt - 1
                    continue
                }
            }
            $i + 1
        }

        $j + 1
    }

    roll_push_history()
}

fn roll_transpose($delta) {
    sort_sel_endpts()
    $x1 = roll_sside
    $x2 = roll_sfin

    if (roll_ctrl) { $delta * 12 }

    $j = 0
    while ($j < 16) {
        if ((roll_track_sel & (1 << $j)) == 0) { $j + 1 continue }

        $l = roll_tracks[$j]
        $cnt = $l.cnt
        $i = 0
        while ($i < $cnt) {
            $n = $l[$i]
            if ($n.x >= $x1 && $n.x <= $x2 &&
                $n.y + $delta >= 0 && $n.y + $delta <= HIGHEST_NOTE)
            {
                $n.y + $delta
            }

            $i + 1
        }

        $j + 1
    }

    roll_push_history()
    roll_changed = 1
}

fn roll_special_edit() {
    // NOTE: Replace this with anything!
    $l = roll_tracks[2]
    $cnt = $l.cnt
    $i = 0
    while ($i < $cnt) {
        $n = $l[$i]
        $n.vol = 0x80
        $i + 1
    }
}

fn roll_clearsel() {
    sort_sel_endpts()
    $x1 = roll_sside
    $x2 = roll_sfin

    roll_break($x1)
    roll_break($x2 + 1)

    $j = 0
    while ($j < 16) {
        if ((roll_track_sel & (1 << $j)) == 0) { $j + 1 continue }

        $l = roll_tracks[$j]
        $cnt = $l.cnt
        $i = 0
        while ($i < $cnt) {
            $n = $l[$i]
            if ($n.x >= $x1 && $n.x <= $x2) {
                remove_note($j, $i)
                $cnt - 1
                continue
            }
            $i + 1
        }

        $j + 1
    }

    roll_push_history()
}

fn duplicate_track($l) {
    $ret = new(4096, 1, INT)

    $cnt = $l.cnt
    $ret.cnt = $cnt
    $i = 0
    while ($i < $cnt) {
        $ret[$i] = clone($l[$i])
        $i + 1
    }

    autorel($ret)
    ret($ret)
}

fn remove_track_notes($l) {
    $cnt = $l.cnt
    $i = 0
    while ($i < $cnt) {
        remove($l[$i])
        $i + 1
    }
}

fn release_track($l) {
    if ($l.ref == 1) { remove_track_notes($l) }
    release($l)
}

fn roll_push_history() {
    if (roll_no_history) { ret }
    if (roll_hist_ptr == HISTORY - 1) {
        // Release the oldest record
        $i = 0
        while ($i < 16) {
            release_track(roll_history[0][$i])
            $i + 1
        }
        // Shift out
        $i = 1
        while ($i < HISTORY) {
            copy(roll_history[$i - 1], roll_history[$i])
            $i + 1
        }
        roll_hist_ptr - 1
    } else {
        // Release discarded history entries
        // Range: (roll_hist_ptr, roll_hist_top]
        $j = roll_hist_ptr + 1
        while ($j <= roll_hist_top) {
            $i = 0
            while ($i < 16) {
                release_track(roll_history[$j][$i])
                $i + 1
            }
            $j + 1
        }
    }

    $last = roll_history[roll_hist_ptr]
    $h = roll_history[roll_hist_ptr + 1]
    $j = 0
    while ($j < 16) {
        if ((roll_track_sel & (1 << $j)) == 0) {
            // Copy unchanged track
            $h[$j] = $last[$j]
            retain($h[$j])
        } else {
            $h[$j] = duplicate_track(roll_tracks[$j])
        }
        $j + 1
    }

    roll_hist_ptr + 1
    roll_hist_top = roll_hist_ptr
    file_unsaved = 1
}

fn roll_reload_current_undo_state() {
    $i = 0
    while ($i < 16) {
        $orig = roll_tracks[$i]
        roll_tracks[$i] = duplicate_track(roll_history[roll_hist_ptr][$i])
        remove_track_notes($orig)
        remove($orig)
        $i + 1
    }
}

fn roll_undo() {
    if (roll_shift) { roll_redo() ret }
    if (roll_hist_ptr > 0) {
        roll_hist_ptr - 1
        roll_reload_current_undo_state()
    }
}

fn roll_redo() {
    if (roll_hist_ptr < roll_hist_top) {
        roll_hist_ptr + 1
        roll_reload_current_undo_state()
    }
}

fn roll_clear_history() {
    $j = 0
    while ($j <= roll_hist_top) {
        $i = 0
        while ($i < 16) {
            release_track(roll_history[$j][$i])
            $i + 1
        }
        $j + 1
    }
}

fn roll_init_history() {
    $i = 0
    while ($i < 16) {
        roll_history[0][$i] = duplicate_track(roll_tracks[$i])
        $i + 1
    }
    roll_hist_ptr = 0
    roll_hist_top = 0
}

roll_init_history()

fn draw_track($t, $x_sta, $x_fin, $y_sta, $y_fin) {
    $l = roll_tracks[$t]
    $cnt = $l.cnt
    $i = 0
    $col = track_colours[$t]

    while ($i < $cnt) {
        $n = $l[$i]

        if ($n.x <= $x_fin && $n.x + $n.len - 1 >= $x_sta &&
            $n.y >= $y_sta && $n.y <= $y_fin)
        {
            $x = roll_x + $n.x * CELL_WIDTH - roll_px + 1
            $y = roll_y - ($n.y + 1) * CELL_HEIGHT + roll_py
            $w = CELL_WIDTH * $n.len - 1
            $h = CELL_HEIGHT
            if ($t < 8) {
                fbox($x, $y, $w, $h, $col)
            } else {
                box($x, $y, $w - 1, $h, $col)
                $x0 = $w - 3
                while ($x0 > 0) {
                    line($x + $x0, $y, $x + $x0, $y + $h - 1, $col)
                    $x0 - 2
                }
            }
        }

        $i + 1
    }
}

fn round($x) {
    ret(floor($x + 0.5))
}

fn draw_track_attr($t, $x_sta, $x_fin, $y_sta, $y_fin, $alpha) {
    $l = roll_tracks[$t]
    $cnt = $l.cnt
    $i = 0
    $col = get_blend(track_colours[$t], WHITE, 96)

    transp($alpha)
    while ($i < $cnt) {
        $n = $l[$i]

        if ($n.x <= $x_fin && $n.x >= $x_sta) {
            if ($n.vol != NOCHANGE) {
                fbox(roll_x + $n.x * CELL_WIDTH - roll_px + 1,
                    roll_y + roll_h - round((roll_vol_h - 3) * $n.vol / 0xf8) - 3,
                    CELL_WIDTH - 1, 3, $col)
            }
            if ($n.pan != NOCHANGE) {
                fbox(roll_x + $n.x * CELL_WIDTH - roll_px + 1,
                    roll_y + roll_h - roll_vol_h - round((roll_pan_h - 3) * $n.pan / 0xc) - 3,
                    CELL_WIDTH - 1, 3, $col)
            }
        }

        $i + 1
    }
}

fn draw_roll() {
    roll_clamp_p()
    fbox(roll_x, roll_y, roll_w, roll_h, nord1)

    $x_sta = floor(roll_px / CELL_WIDTH)
    $x_fin = ceil((roll_px + roll_w) / CELL_WIDTH)
    $y_sta = floor((roll_py - roll_h) / CELL_HEIGHT)
    $y_fin = floor(roll_py / CELL_HEIGHT)

    $i = $y_sta
    while $i <= $y_fin {
        $ly = roll_y - ($i + 1) * CELL_HEIGHT + roll_py
        $pc = $i % 12
        if ($pc == 1 || $pc == 3 || $pc == 6 || $pc == 8 || $pc == 10) {
            fbox(roll_x, $ly, roll_w, CELL_HEIGHT, nord0)
        }
        if ($pc != 0) {
            line(roll_x, $ly, roll_x + roll_w - 1, $ly, nord2)
        }
        $i + 1
    }

    $i = $x_sta
    while $i <= $x_fin {
        $lx = roll_x + $i * CELL_WIDTH - roll_px
        if ($i % roll_bar == 0) {
            line($lx, roll_y, $lx, roll_y + roll_h, nord9)
        } else {
            if ($i % roll_beat == 0) {
                line($lx, roll_y, $lx, roll_y + roll_h - 1, nord3)
            } else {
                line($lx, roll_y, $lx, roll_y + roll_h - 1, nord2)
            }
        }
        $i + 1
    }

    $i = $y_sta
    while $i <= $y_fin {
        $ly = roll_y - ($i + 1) * CELL_HEIGHT + roll_py
        if ($i % 12 == 0) {
            line(roll_x, $ly + CELL_HEIGHT,
                roll_x + roll_w - 1, $ly + CELL_HEIGHT, nord10)
        }
        $i + 1
    }

    // Unselected tracks
    transp(32)
    $i = 15
    while ($i >= 0) {
        if ((roll_track_sel & (1 << $i)) == 0) {
            draw_track($i, $x_sta, $x_fin, $y_sta, $y_fin)
        }
        $i - 1
    }

    // Selected tracks
    transp(255)
    $i = 15
    while ($i >= 0) {
        if ((roll_track_sel & (1 << $i)) != 0) {
            draw_track($i, $x_sta, $x_fin, $y_sta, $y_fin)
        }
        $i - 1
    }

    $s = ""

    $i = $y_sta
    while $i <= $y_fin {
        $ly = roll_y - ($i + 1) * CELL_HEIGHT + roll_py
        if ($i % 12 == 0) {
            num_to_str($s, $i div 12)
            print($s, roll_x + 1, $ly + CELL_HEIGHT + 1, nord4, BOTTOM | LEFT)
        }
        $i + 1
    }

    // Selection range
    transp(128)
    fbox(roll_x, roll_y, roll_w, roll_sel_h, nord4)

    // Do not call sort_sel_endpts() as it interferes with current selection
    $x1 = roll_sside
    $x2 = roll_sfin
    if ($x1 > $x2) { $t = $x1 $x1 = $x2 $x2 = $t }

    transp(216)
    fbox(roll_x + roll_rpt_a * CELL_WIDTH - roll_px, roll_y,
        (roll_rpt_b - roll_rpt_a + 1) * CELL_WIDTH, roll_sel_h, nord7)
    fbox(roll_x + $x1 * CELL_WIDTH - roll_px, roll_y,
        ($x2 - $x1 + 1) * CELL_WIDTH, roll_sel_h, nord9)
    transp(64)
    fbox(roll_x + $x1 * CELL_WIDTH - roll_px, roll_y + roll_sel_h,
        ($x2 - $x1 + 1) * CELL_WIDTH, roll_h - roll_sel_h, nord9)

    // Bar number
    transp(255)
    $i = $x_sta
    while $i <= $x_fin {
        $lx = roll_x + $i * CELL_WIDTH - roll_px
        if ($i % roll_bar == 0 &&
            (CELL_WIDTH >= 4 || $i % (roll_bar * 2) == 0))
        {
            num_to_str($s, $i div roll_bar)
            print($s, $lx + 1, roll_y + 1, nord5, TOP | LEFT)
        }
        $i + 1
    }

    // Pan area
    if (roll_playing) {
        $sel_count = 0
        $i = 0
        while $i < 16 {
            $sel_count + ((roll_track_sel >> $i) & 1)
            $i + 1
        }
        transp(224 - $sel_count * 14)
    } else { transp(224) }
    fbox(roll_x, roll_y + roll_h - roll_vol_h - roll_pan_h,
        roll_w, roll_pan_h, get_blend(nord9, BLACK, 64))
    print("L", roll_x + 1,
        roll_y + roll_h - roll_vol_h, nord9, BOTTOM | LEFT)
    print("R", roll_x + 1,
        roll_y + roll_h - roll_vol_h - roll_pan_h + 1, nord9, TOP | LEFT)
    $cen_y = roll_y + roll_h - roll_vol_h - roll_pan_h div 2 - 1
    line(roll_x, $cen_y, roll_x + roll_w - 1, $cen_y, nord9)

    // Volume area
    fbox(roll_x, roll_y + roll_h - roll_vol_h,
        roll_w, roll_vol_h, get_blend(nord7, BLACK, 64))

    // Draw attributes for selected track
    $alpha = 192
    if (roll_playing) { $alpha - $sel_count * 12 }
    draw_track_attr(roll_tid, $x_sta, $x_fin, $y_sta, $y_fin, $alpha)
}