From 99d0bf3669a939fb09ac4ae5a0b2ddbace3d3f63 Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Mon, 2 Nov 2026 09:15:06 -0300 Subject: Fix macOS stale tag borders, spacing and drag cursors --- src/macos.zig | 83 +++++++++++++++++++++++-- src/macos/Sources/PardesView.swift | 25 +++++--- src/macos/pardes.h | 5 +- src/pardes.zig | 4 +- test/macos-snapshots/drag-cursor.golden | 8 +++ test/macos-snapshots/drag-cursor.snap | 20 +++++++ test/macos-snapshots/retired-tags.golden | 2 + test/macos-snapshots/retired-tags.snap | 19 ++++++ test/macos_e2e.swift | 100 +++++++++++++++++++++++++++++++ 9 files changed, 252 insertions(+), 14 deletions(-) create mode 100644 test/macos-snapshots/drag-cursor.golden create mode 100644 test/macos-snapshots/drag-cursor.snap create mode 100644 test/macos-snapshots/retired-tags.golden create mode 100644 test/macos-snapshots/retired-tags.snap diff --git a/src/macos.zig b/src/macos.zig index a63ac626..4f616945 100644 --- a/src/macos.zig +++ b/src/macos.zig @@ -451,6 +451,7 @@ const State = struct { rotate_velocity: f32 = 0, rotate_last_ns: i128 = 0, rotate_coasting: bool = false, + pointer_rule_above: bool = false, scene_ns: u64 = 0, last_tick_ns: u64 = 0, tick_bank_ns: u64 = 0, @@ -1436,7 +1437,7 @@ export fn pardes_paste(text_ptr: ?[*]const u8, len: usize) void { export fn pardes_mouse(button_arg: c_int, kind_arg: c_int, col: u16, row: u16, mods: u32) void { pardes.turn.wake(); defer pardes.turn.rest(); - mouseWithHit(button_arg, kind_arg, col, row, mods, null, null); + mouseWithHit(button_arg, kind_arg, col, row, mods, null, null, false); } export fn pardes_mouse_pixel(button_arg: c_int, kind_arg: c_int, col: u16, row: u16, mods: u32, x: f32, y: f32, bw: f32, bh: f32, tw: f32, th: f32) void { @@ -1456,10 +1457,14 @@ export fn pardes_mouse_pixel(button_arg: c_int, kind_arg: c_int, col: u16, row: tag_hit = layer.tagHit(point.x * bw, point.y * bh, bw, bh, tw, th); if (tag_hit != null) break; } - mouseWithHit(button_arg, kind_arg, col, row, mods, hit, tag_hit); + const rule_above = if (source) |point| + row > 0 and (point.y - @floor(point.y)) * @max(1, bh) < 3 + else + false; + mouseWithHit(button_arg, kind_arg, col, row, mods, hit, tag_hit, rule_above); } -fn mouseWithHit(button_arg: c_int, kind_arg: c_int, col: u16, row: u16, mods: u32, hit: ?pardes.Mouse.BodyHit, tag_hit: ?pardes.TagHit) void { +fn mouseWithHit(button_arg: c_int, kind_arg: c_int, col: u16, row: u16, mods: u32, hit: ?pardes.Mouse.BodyHit, tag_hit: ?pardes.TagHit, rule_above: bool) void { const st = &(state orelse return); const button: pardes.Mouse.Button = switch (button_arg) { 0 => .left, @@ -1481,10 +1486,12 @@ fn mouseWithHit(button_arg: c_int, kind_arg: c_int, col: u16, row: u16, mods: u3 3 => .drag, else => return, }; + st.pointer_rule_above = rule_above; st.core.update(.{ .mouse = .{ .body_hit = hit, .tag_hit = tag_hit, + .rule_above = rule_above, .button = button, .kind = kind, .col = col, @@ -1914,6 +1921,9 @@ export fn pardes_tag_layer_value(index: u32, field: u32) u32 { const st = &(state orelse return 0); if (index >= pardes.MAX_TAG_LAYERS) return 0; const layer = &st.core.surface.tag_layers[index]; + // The renderer retires a layer by clearing rows, retaining its storage + // and geometry for reuse. Do not expose that stale band to AppKit. + if (layer.rows == 0) return 0; return switch (field) { 0 => layer.cols, 1 => @backingInt(layer.kind), @@ -1998,7 +2008,34 @@ export fn pardes_pointer_shape() u32 { pardes.turn.wake(); defer pardes.turn.rest(); const st = &(state orelse return 0); - return @backingInt(st.core.surface.pointer_shape); + return nativePointerShape(st.core, st.pointer_rule_above); +} + +fn nativePointerShape(core: *const pardes.Pardes, rule_above: bool) u32 { + switch (core.drag) { + .move, .column_move => return 3, + .border_v => return 5, + .border_h => return 6, + .select => return @backingInt(core.surface.pointer_shape), + .none => {}, + } + if (core.pointer_inside) for (core.surface.regions[0..core.surface.nregions]) |region| { + if (region.kind != .grip and region.kind != .column_grip) continue; + const r = region.rect; + if (core.hover_col >= r.x and core.hover_col - r.x < r.w and + core.hover_row >= r.y and core.hover_row - r.y < r.h) return 4; + }; + if (core.pointer_inside) { + for (0..core.ncol -| 1) |column| { + if (core.hover_col == core.col_x[column] + core.col_w[column] -| 1) return 5; + } + if (rule_above and core.hover_row > 0) for (0..core.ncol) |column| { + if (core.hover_col < core.col_x[column] or core.hover_col >= core.col_x[column] + core.col_w[column]) continue; + const seam = if (core.settings.tag_bottom) core.hover_row else core.hover_row - 1; + if (@import("mouse.zig").seamIdxAt(core, column, seam) != null) return 6; + }; + } + return @backingInt(core.surface.pointer_shape); } export fn pardes_cursor_y() i32 { @@ -2877,6 +2914,44 @@ test "mac tag layer ABI preserves logical capacity and physical grip" { try std.testing.expectEqual(@as(u8, 'G'), canonical[9].text[0]); try std.testing.expectEqual(@as(u8, 'G'), canonical[18].text[0]); try std.testing.expectEqual(encodeCell(.{}).len, canonical[10].len); + + // Dismissed notices and old tag positions retain their capacity. They + // must disappear from the host's layout as well as its cell buffer, or + // AppKit keeps painting their borders over otherwise empty pane bodies. + core.surface.tag_layers[0].rows = 0; + for (0..13) |field| try std.testing.expectEqual(@as(u32, 0), pardes_tag_layer_value(0, @intCast(field))); + try std.testing.expect(pardes_tag_layer_cells(0) == null); +} + +test "mac drag pointer follows pane and column grips and releases" { + const gpa = std.testing.allocator; + const core = try pardes.Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 }); + defer core.deinit(); + _ = try core.setTestFile("text\n"); + core.presentation.enabled = false; + var arena: std.heap.ArenaAllocator = .init(gpa); + defer arena.deinit(); + _ = try core.render(arena.allocator()); + for ([_]pardes.Region.Kind{ .grip, .column_grip }) |kind| { + const r = for (core.surface.regions[0..core.surface.nregions]) |region| { + if (region.kind == kind) break region.rect; + } else return error.NoGrip; + core.update(.{ .mouse = .{ .button = .none, .kind = .motion, .col = r.x, .row = r.y } }); + try std.testing.expectEqual(@as(u32, 4), nativePointerShape(core, false)); + core.update(.{ .mouse = .{ .button = .left, .kind = .press, .col = r.x, .row = r.y } }); + try std.testing.expectEqual(@as(u32, 3), nativePointerShape(core, false)); + core.update(.{ .mouse = .{ .button = .left, .kind = .release, .col = r.x, .row = r.y } }); + try std.testing.expectEqual(@as(u32, 4), nativePointerShape(core, false)); + } + core.pointer_inside = false; + core.surface.pointer_shape = .arrow; + try std.testing.expectEqual(@as(u32, 0), nativePointerShape(core, false)); + core.surface.pointer_shape = .link; + try std.testing.expectEqual(@as(u32, 1), nativePointerShape(core, false)); + core.drag = .{ .border_v = .{ .left_col = 0, .cur_x = 40 } }; + try std.testing.expectEqual(@as(u32, 5), nativePointerShape(core, false)); + core.drag = .{ .border_h = .{ .col = 0, .top_idx = 0, .cur_y = 12 } }; + try std.testing.expectEqual(@as(u32, 6), nativePointerShape(core, false)); } test "mac window blur builtin reaches the ABI without changing opacity" { diff --git a/src/macos/Sources/PardesView.swift b/src/macos/Sources/PardesView.swift index 4ea4475a..b51f6719 100644 --- a/src/macos/Sources/PardesView.swift +++ b/src/macos/Sources/PardesView.swift @@ -2652,22 +2652,26 @@ final class PardesView: NSView { // .inVisibleRect keeps the area correct across resizes on its own, which // is why the rect argument can be anything. addTrackingArea(NSTrackingArea(rect: .zero, - options: [.mouseMoved, .mouseEnteredAndExited, .inVisibleRect, .activeInKeyWindow], + options: [.mouseMoved, .mouseEnteredAndExited, .cursorUpdate, .inVisibleRect, .activeInKeyWindow], owner: self, userInfo: nil)) } - private enum Pointer: Equatable { case text, link, target } + private enum Pointer: Equatable { case text, link, target, grab, dragging, resizeHorizontal, resizeVertical } private var pointer: Pointer = .text /// The core's pointer_shape, in this shell's cursor vocabulary: a link /// is a PDF hyperlink (the hand), a target is a word the core's own /// Look-hover plumbing validated as a real Look or Exec operand, and - /// anything else is text — the I-beam. + /// grips and dividers carry the native drag/resize affordances. private func pointerShape() -> Pointer { switch pardes_pointer_shape() { case 1: return .link case 2: return .target + case 3: return .dragging + case 4: return .grab + case 5: return .resizeHorizontal + case 6: return .resizeVertical default: return .text } } @@ -2677,14 +2681,21 @@ final class PardesView: NSView { case .link: return .pointingHand case .target: return .arrow case .text: return .iBeam + case .grab: return .openHand + case .dragging: return .closedHand + case .resizeHorizontal: return .resizeLeftRight + case .resizeVertical: return .resizeUpDown } } + override func cursorUpdate(with event: NSEvent) { + pointer = pointerShape() + cursorFor(pointer).set() + } + override func resetCursorRects() { - // Every cell in this view is text, including the tags. An arrow over - // plain text is the wrong affordance — but a word the core has - // validated as a Look or Exec target earns it: middle- and - // right-clicking there acts, and the cursor says so before it does. + // AppKit may reset cursor rectangles between frames. Keep the current + // text, target, grip or drag affordance instead of resetting to I-beam. addCursorRect(bounds, cursor: cursorFor(pointer)) } diff --git a/src/macos/pardes.h b/src/macos/pardes.h index 33db3bb5..f9aa0ec4 100644 --- a/src/macos/pardes.h +++ b/src/macos/pardes.h @@ -519,8 +519,9 @@ bool pardes_active_dirty(void); int32_t pardes_cursor_x(void); int32_t pardes_cursor_y(void); bool pardes_cursor_bar(void); -// Mouse pointer affordance: 0 = default text pointer, 1 = link hand, -// 2 = a validated Look/Exec target under the pointer (the acme arrow). +// Mouse pointer affordance: 0 text, 1 link, 2 Look/Exec target, +// 3 carrying a pane/column, +// 4 over a draggable grip, 5 horizontal resize, 6 vertical resize. uint32_t pardes_pointer_shape(void); // The Look or Exec the core performed since this was last asked, and clears diff --git a/src/pardes.zig b/src/pardes.zig index e14e9273..bd813e0e 100644 --- a/src/pardes.zig +++ b/src/pardes.zig @@ -291,7 +291,9 @@ pub const MAX_JUMPS = 64; pub const TOPBAR_H: u16 = 1; pub const COLBAR_H: u16 = 1; pub const BOX_H: u16 = 1; -pub const TAG_GAP: u16 = 0; +// AppKit's square mode/grip box needs breathing room before the tag text. +// Keep this in the core layout so selection and hit testing share the inset. +pub const TAG_GAP: u16 = if (platform == .macos) 1 else 0; pub const TAG_TEXT_INSET: u16 = config.GUTTER + TAG_GAP; pub fn taglineBandOffset(row: u16, canvas_h: f32, cell_h: u32, tagline_h: u32) u32 { diff --git a/test/macos-snapshots/drag-cursor.golden b/test/macos-snapshots/drag-cursor.golden new file mode 100644 index 00000000..a31c5639 --- /dev/null +++ b/test/macos-snapshots/drag-cursor.golden @@ -0,0 +1,8 @@ +== pointer grab native cursor verified +== pointer dragging native cursor verified +== pointer grab native cursor verified +== pointer grab native cursor verified +== pointer dragging native cursor verified +== pointer grab native cursor verified +== pointer text native cursor verified +== pointer resize-vertical native cursor verified diff --git a/test/macos-snapshots/drag-cursor.snap b/test/macos-snapshots/drag-cursor.snap new file mode 100644 index 00000000..0fcb1e23 --- /dev/null +++ b/test/macos-snapshots/drag-cursor.snap @@ -0,0 +1,20 @@ +start 24 80 +wait 8000 $ +stable 700 20000 +mouse none motion 0 2 +check-pointer grab +mouse left press 0 2 +check-pointer dragging +mouse left release 0 2 +check-pointer grab +mouse none motion 0 1 +check-pointer grab +mouse left press 0 1 +check-pointer dragging +mouse left release 0 1 +check-pointer grab +mouse none motion 40 15 +check-pointer text +command New +stable 700 20000 +check-divider-drag diff --git a/test/macos-snapshots/retired-tags.golden b/test/macos-snapshots/retired-tags.golden new file mode 100644 index 00000000..86d5d98b --- /dev/null +++ b/test/macos-snapshots/retired-tags.golden @@ -0,0 +1,2 @@ +== empty-edges retired-notices clean +== empty-edges moved-tags clean diff --git a/test/macos-snapshots/retired-tags.snap b/test/macos-snapshots/retired-tags.snap new file mode 100644 index 00000000..6949c494 --- /dev/null +++ b/test/macos-snapshots/retired-tags.snap @@ -0,0 +1,19 @@ +start 33 107 +native-metrics +wait 8000 $ +command Theme forge +command New +stable 1800 20000 +capture two-panes +resize 28 85 +command Theme dark +command Theme forge +text ix +key esc +stable 1800 20000 +check-empty-edges retired-notices +command New +command Del +resize 40 120 +stable 1800 20000 +check-empty-edges moved-tags diff --git a/test/macos_e2e.swift b/test/macos_e2e.swift index 2b0eedad..7d183016 100644 --- a/test/macos_e2e.swift +++ b/test/macos_e2e.swift @@ -671,6 +671,100 @@ private final class Driver: PardesViewDelegate { output += "== context \(label) compact separators verified\n" } + /// After notices disappear and tags move, empty pane edges must return to + /// the theme ground. A retired layer's retained geometry used to leave + /// horizontal rules here even though it no longer supplied any cells. + private func checkEmptyEdges(_ label: String) throws { + let view = try live(), rep = try renderedCapture(label) + let scale = CGFloat(rep.pixelsWide) / view.bounds.width + guard let ground = view.themeBG else { + throw ScriptError(message: "empty edges: needs an opaque theme") + } + var tagBands: [Range] = [] + for index in 0.. 0, + pardes_tag_layer_cells(index) != nil else { continue } + let row = Int(pardes_tag_layer_value(index, 5)) + let top = Int(CGFloat(row) * view.cellHeight * scale) + let bottom = Int(CGFloat(row + 1) * view.cellHeight * scale) + tagBands.append(top..> 16) & 255), CGFloat((ground >> 8) & 255), CGFloat(ground & 255)] + for y in 2..<(rep.pixelsHigh - 2) { + if tagBands.contains(where: { $0.contains(y) }) { continue } + guard let c = sample(rep, x: rep.pixelsWide - 3, y: y) else { + throw ScriptError(message: "empty edges: no pixel at row \(y)") + } + let actual = [c.redComponent, c.greenComponent, c.blueComponent] + guard zip(actual, expected).allSatisfy({ abs($0 * 255 - $1) < 4 }) else { + throw ScriptError(message: "empty edges: stray paint at pixel row \(y): \(actual) vs \(expected)") + } + } + output += "== empty-edges \(label) clean\n" + } + + private func checkPointer(_ name: String) throws { + let view = try live() + // The real app presents between gestures. Pay that presentation debt + // here too, so the next press is not held behind an unseen layout. + _ = readFrame() + pump() + let shape: UInt32 + let cursor: NSCursor + switch name { + case "text": shape = 0; cursor = .iBeam + case "grab": shape = 4; cursor = .openHand + case "dragging": shape = 3; cursor = .closedHand + case "resize-vertical": shape = 6; cursor = .resizeUpDown + default: throw ScriptError(message: "unknown pointer \(name)") + } + guard pardes_pointer_shape() == shape else { + throw ScriptError(message: "pointer \(name): core reported \(pardes_pointer_shape())") + } + guard let window, let event = NSEvent.mouseEvent( + with: .mouseMoved, location: .zero, modifierFlags: [], timestamp: 0, + windowNumber: window.windowNumber, context: nil, + eventNumber: 0, clickCount: 0, pressure: 0) else { + throw ScriptError(message: "pointer: no mouse event") + } + let previous = NSCursor.current + defer { previous.set() } + view.cursorUpdate(with: event) + guard NSCursor.current === cursor else { + throw ScriptError(message: "pointer \(name): AppKit did not install the expected cursor") + } + output += "== pointer \(name) native cursor verified\n" + } + + private func checkDividerDrag() throws { + let view = try live() + _ = readFrame() + let paneRows = (0.. UInt32? in + guard pardes_tag_layer_value(index, 0) > 0, + pardes_tag_layer_value(index, 1) == 2 else { return nil } + return pardes_tag_layer_value(index, 5) + }.sorted() + guard paneRows.count >= 2, let window else { + throw ScriptError(message: "divider drag: needs two panes") + } + let scale = window.backingScaleFactor + let point = view.convert(CGPoint( + x: view.bounds.width / 2, + y: CGFloat(paneRows[1]) * view.cellHeight + 0.5 / scale), to: nil) + func event(_ type: NSEvent.EventType) -> NSEvent? { + NSEvent.mouseEvent(with: type, location: point, modifierFlags: [], + timestamp: 0, windowNumber: window.windowNumber, context: nil, + eventNumber: 0, clickCount: 1, pressure: 1) + } + guard let down = event(.leftMouseDown), let up = event(.leftMouseUp) else { + throw ScriptError(message: "divider drag: no mouse event") + } + view.mouseDown(with: down) + pump() + defer { view.mouseUp(with: up); pump() } + try checkPointer("resize-vertical") + } + private func checkPDF(_ label: String) throws { let view = try live(), rep = try renderedCapture(label) guard nativeMetrics, pardes_frame_images() > 0, let images = pardes_frame_image_list() else { @@ -744,6 +838,12 @@ private final class Driver: PardesViewDelegate { try checkBackgrounds(rest) case "check-context": try checkContext(rest) + case "check-empty-edges": + try checkEmptyEdges(rest) + case "check-pointer": + try checkPointer(rest) + case "check-divider-drag": + try checkDividerDrag() case "check-pdf": try checkPDF(rest) case "capture": -- cgit v1.3