1 files changed, 109 insertions, 26 deletions

diff --git a/src/surface.zig b/src/surface.zig
index a9e69cca..b6f41853 100644
--- a/src/surface.zig
+++ b/src/surface.zig
@@ -3,6 +3,7 @@
 const pardes = @import("pardes.zig");
 const std = @import("std");
 const layout = @import("layout.zig");
+const animation = @import("animation.zig");
 const uucode = @import("uucode");
 const vaxis = @import("vaxis");
 const panes = @import("panes.zig");
@@ -10,8 +11,7 @@ const config = @import("config.zig");
 const pdf_enabled = panes.Pdf.enabled;
 const image = @import("image.zig");
 const MAX_PANES = pardes.MAX_PANES;
-const BodyLayer = @import("body_layer.zig").Layer;
-const TagLayer = @import("tag_layer.zig").Layer;
+const Layer = @import("Layer.zig");
 const MAX_TAG_LAYERS = pardes.MAX_TAG_LAYERS;
 const CellPixels = pardes.CellPixels;
 
@@ -38,12 +38,6 @@ pub const Cell = struct {
     len: u8 = 1,
     style: CellStyle = .{},
     default: bool = true,
-    /// The look-hover affordance is on this cell: the word under the pointer
-    /// is a real Look or Exec operand, and hosts that draw the quiet tint as
-    /// more than a flat fill — macOS renders it as a glass overlay — read
-    /// this instead of guessing from the background colour, which a real
-    /// selection shares.
-    hover: bool = false,
 
     pub fn grapheme(c: *const Cell) []const u8 {
         return c.text[0..c.len];
@@ -70,7 +64,7 @@ pub const AsciiDiff = struct {
 
     /// Long printable-byte walks complete in about the same time as the other
     /// panel effects. Extra distance is crossed by eased character skips.
-    pub const max_movement_frames = layout.ascii_max_movement_frames;
+    pub const max_movement_frames = animation.ascii_max_movement_frames;
 
     pub fn between(old: *const Cell, new: *const Cell) ?AsciiDiff {
         const from = old.printableAscii() orelse return null;
@@ -323,40 +317,133 @@ test "pixel attachment fit and pan do not invalidate cached pixels" {
     try std.testing.expect(key.eql(place.cacheKey()));
 }
 
+/// One part of the frame and where it is, placed once by `draw.place`
+/// before anything is painted: every painter and every shell reads the
+/// geometry here instead of working it out again. `rect` is in grid cells
+/// and is the hit-test geometry.
+pub const Region = struct {
+    pub const Kind = enum(u8) {
+        /// The frame-wide border fill every other part is painted over.
+        page,
+        /// A pane's grip: the mode mark at the head of its tag rows.
+        grip,
+        /// A pane's tag rows, right of its grip.
+        tag,
+        /// A pane's body, right of its rail: absent while it is collapsed.
+        body,
+        /// The scroll rail down a pane's left edge, beside its body.
+        rail,
+        /// A transient band over the body's top rows (a message, a prompt).
+        notice,
+        column_grip,
+        column_tag,
+        workspace_tag,
+        /// A column below the workspace tag, its bar and panes: its left
+        /// edge is the spine a pixel shell rules down it.
+        column,
+        /// A drag's guide or a seam's hover hint, drawn over the panes.
+        guide,
+        /// The debug stats box, drawn over the panes.
+        debug,
+    };
+    pub const none = std.math.maxInt(u8);
+
+    kind: Kind,
+    /// The pane slot, or the column, the part belongs to; `none` for the
+    /// page and the workspace tag.
+    owner: u8 = none,
+    serial: u32 = 0,
+    rect: layout.Rect,
+    /// The pane or column has the keyboard's focus.
+    active: bool = false,
+    /// A rail's thumb: rows from the rail's top, and how many. Zero rows is
+    /// a rail with no thumb (an image). A native PDF's thumb is measured in
+    /// document pixels and filled in by Pdf.draw while it paints, so read
+    /// regions once render has returned.
+    thumb_y: u16 = 0,
+    thumb_h: u16 = 0,
+    /// A notice's index in its pane's `notices`.
+    notice: u8 = 0,
+    /// Cells the column-move rail takes off the right edge while it runs
+    /// there: layers and pixel shells stop short of them, the grid does not.
+    clip: u16 = 0,
+};
+
+/// Guides a frame can draw: a run of a column-move rail per pane it skips
+/// the tags of, and a handful of border and hover dashes.
+pub const MAX_GUIDES = MAX_PANES + 4;
+pub const MAX_REGIONS = 1 + MAX_PANES * (4 + panes.Pane.Notices.max) + pardes.MAX_COLS * 3 + 1 + MAX_GUIDES + 1;
+
+/// The colours a pixel shell draws its chrome in (rules, rails, grips, the
+/// tag underlay), resolved by the core each frame, so a frontend attached
+/// to a detached session draws them from the frame alone.
+pub const Chrome = struct {
+    /// The theme's ground and ink; null where it leaves them to the shell.
+    page: ?[3]u8 = null,
+    fg: ?[3]u8 = null,
+    /// Rules and column spines.
+    border: [3]u8 = .{ 0, 0, 0 },
+    /// The rule under the workspace tag.
+    topbar_rule: [3]u8 = .{ 0, 0, 0 },
+    tag_bg: [3]u8 = .{ 0, 0, 0 },
+    /// The focused pane's and column's tag underlay: `tag_bg` unless
+    /// FocusTint is on.
+    tag_focus_bg: [3]u8 = .{ 0, 0, 0 },
+    tag_fg: [3]u8 = .{ 0, 0, 0 },
+    scroll_track: [3]u8 = .{ 0, 0, 0 },
+    scroll_thumb: [3]u8 = .{ 0, 0, 0 },
+};
+
 /// The canonical interface: what a frame of pardes IS. The tty shell writes
 /// these cells to vaxis one-to-one; the SDL shells rasterize them.
 pub const Surface = struct {
     pub const PointerShape = enum(u8) { arrow, link, target };
     pointer_shape: PointerShape = .arrow,
-    /// Set only for the duration of the look-hover paint, so the cells that
-    /// paint the quiet affordance can carry the hover bit through the ABI
-    /// without every selection painter learning a new parameter.
-    mark_hover: bool = false,
-    body_layers: [MAX_PANES]BodyLayer = @splat(.{}),
-    tag_layers: [MAX_TAG_LAYERS]TagLayer = @splat(.{}),
+    body_layers: [MAX_PANES]Layer = @splat(.{}),
+    tag_layers: [MAX_TAG_LAYERS]Layer = @splat(.{}),
     cols: u16 = 0,
     rows: u16 = 0,
+    regions: [MAX_REGIONS]Region = undefined,
+    nregions: u16 = 0,
+    chrome: Chrome = .{},
     cells: []Cell = &.{},
     /// bar: draw an insert-style thin cursor instead of the block
     cursor: ?struct { x: u16, y: u16, bar: bool = false } = null,
     images: []?ImagePlace = &.{},
     nimages: usize = 0,
-    panel_tracks: [MAX_PANES * 2]layout.Track = undefined,
+    panel_tracks: [MAX_PANES * 2]animation.Track = undefined,
     npanel_tracks: usize = 0,
     previous_cells: []const Cell = &.{},
-    previous_body_layers: []const BodyLayer = &.{},
-    previous_tag_layers: []const TagLayer = &.{},
+    previous_body_layers: []const Layer = &.{},
+    previous_tag_layers: []const Layer = &.{},
+    previous_regions: []const Region = &.{},
     cell_diffs: []const PanelCellDiff = &.{},
 
-    pub fn tagLayers(s: *const Surface) []const TagLayer {
+    pub fn tagLayers(s: *const Surface) []const Layer {
         return &s.tag_layers;
     }
 
-    pub fn bodyLayers(s: *const Surface) []const BodyLayer {
+    pub fn bodyLayers(s: *const Surface) []const Layer {
         return &s.body_layers;
     }
 
-    pub fn panelTracks(s: *const Surface) []const layout.Track {
+    pub fn regionList(s: *const Surface) []const Region {
+        return s.regions[0..s.nregions];
+    }
+
+    pub fn addRegion(s: *Surface, r: Region) void {
+        std.debug.assert(s.nregions < s.regions.len);
+        s.regions[s.nregions] = r;
+        s.nregions += 1;
+    }
+
+    /// The first part of `kind` that `owner` has: its tag, its rail.
+    pub fn region(s: *Surface, kind: Region.Kind, owner: usize) ?*Region {
+        for (s.regions[0..s.nregions]) |*r| if (r.kind == kind and r.owner == owner) return r;
+        return null;
+    }
+
+    pub fn panelTracks(s: *const Surface) []const animation.Track {
         return s.panel_tracks[0..s.npanel_tracks];
     }
 
@@ -377,11 +464,7 @@ pub const Surface = struct {
 
     pub fn at(s: *Surface, x: u16, y: u16) *Cell {
         std.debug.assert(x < s.cols and y < s.rows);
-        const cell = &s.cells[@as(usize, y) * s.cols + x];
-        // The look-hover paint runs with mark_hover set, and its cells are
-        // exactly the ones this marks — see render's preview block.
-        if (s.mark_hover) cell.hover = true;
-        return cell;
+        return &s.cells[@as(usize, y) * s.cols + x];
     }
 
     pub fn set(s: *Surface, x: u16, y: u16, text: []const u8, style: CellStyle) void {