mirror of
https://github.com/ghostty-org/ghostty.git
synced 2026-08-06 15:39:10 +00:00
input: extract mouse encoding to a pure, testable file
Move mouse event encoding logic from Surface.zig into a new input/mouse_encode.zig file. The new file encapsulates event filtering (shouldReport), button code computation, viewport bounds checking, motion deduplication, and all five wire formats (X10, UTF-8, SGR, urxvt, SGR-pixels). This makes the encoding independently testable and adds unit tests covering each format and edge case. Additionally, Surface `mouseReport` can no longer fail, since the only failure mode is no buffer space which should be impossible. Updated the signature to remove the error set.
This commit is contained in:
Mitchell Hashimoto
780
src/input/mouse_encode.zig
Normal file
780
src/input/mouse_encode.zig
Normal file
@@ -0,0 +1,780 @@
|
||||
const std = @import("std");
|
||||
const testing = std.testing;
|
||||
const Terminal = @import("../terminal/Terminal.zig");
|
||||
const renderer_size = @import("../renderer/size.zig");
|
||||
const point = @import("../terminal/point.zig");
|
||||
const key = @import("key.zig");
|
||||
const mouse = @import("mouse.zig");
|
||||
|
||||
const log = std.log.scoped(.mouse_encode);
|
||||
|
||||
/// Options that affect mouse encoding behavior and provide runtime context.
|
||||
pub const Options = struct {
|
||||
/// Terminal mouse reporting mode (X10, normal, button, any).
|
||||
event: Terminal.MouseEvent = .none,
|
||||
|
||||
/// Terminal mouse reporting format.
|
||||
format: Terminal.MouseFormat = .x10,
|
||||
|
||||
/// Full renderer size used to convert surface-space pixel positions
|
||||
/// into grid cell coordinates (for most formats) and terminal-space
|
||||
/// pixel coordinates (for SGR-Pixels), as well as to determine
|
||||
/// whether a position falls outside the visible viewport.
|
||||
size: renderer_size.Size,
|
||||
|
||||
/// Whether any mouse button is currently pressed. When a motion
|
||||
/// event occurs outside the viewport, it is only reported if a
|
||||
/// button is held down and the event mode supports motion tracking.
|
||||
/// Without this, out-of-viewport motions are silently dropped.
|
||||
///
|
||||
/// This should reflect the state of the current event as well, so
|
||||
/// if the encoded event is a button press, this should be true.
|
||||
any_button_pressed: bool = false,
|
||||
|
||||
/// Last reported viewport cell for motion deduplication.
|
||||
/// If null, motion deduplication state is not tracked.
|
||||
last_cell: ?*?point.Coordinate = null,
|
||||
|
||||
/// Initialize from terminal and renderer state. The caller may still
|
||||
/// set any_button_pressed and last_cell on the returned value.
|
||||
pub fn fromTerminal(
|
||||
t: *const Terminal,
|
||||
size: renderer_size.Size,
|
||||
) Options {
|
||||
return .{
|
||||
.event = t.flags.mouse_event,
|
||||
.format = t.flags.mouse_format,
|
||||
.size = size,
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
/// A normalized mouse event for protocol encoding.
|
||||
pub const Event = struct {
|
||||
/// The action of this mouse event.
|
||||
action: mouse.Action = .press,
|
||||
|
||||
/// The button involved in this event. This can be null in the
|
||||
/// case of a motion action with no pressed buttons.
|
||||
button: ?mouse.Button = null,
|
||||
|
||||
/// Keyboard modifiers held during this event.
|
||||
mods: key.Mods = .{},
|
||||
|
||||
/// Mouse position in terminal-space pixels, with (0, 0) at the top-left
|
||||
/// of the terminal. Negative values are allowed and indicate positions
|
||||
/// above or to the left of the terminal. Values larger than the terminal
|
||||
/// size are also allowed and indicate right or below the terminal.
|
||||
pos: Pos = .{},
|
||||
|
||||
/// Mouse position in surface-space pixels.
|
||||
pub const Pos = struct {
|
||||
x: f32 = 0,
|
||||
y: f32 = 0,
|
||||
};
|
||||
};
|
||||
|
||||
/// Encode the mouse event to the writer according to the options.
|
||||
///
|
||||
/// Not all events result in output.
|
||||
pub fn encode(
|
||||
writer: *std.Io.Writer,
|
||||
event: Event,
|
||||
opts: Options,
|
||||
) std.Io.Writer.Error!void {
|
||||
if (!shouldReport(event, opts)) return;
|
||||
|
||||
// Handle scenarios where the mouse position is outside the viewport.
|
||||
// We always report release events no matter where they happen.
|
||||
if (event.action != .release and
|
||||
posOutOfViewport(event.pos, opts.size))
|
||||
{
|
||||
// If we don't have a motion-tracking event mode, do nothing,
|
||||
// because events outside the viewport are never reported in
|
||||
// such cases.
|
||||
if (!opts.event.motion()) return;
|
||||
|
||||
// For motion modes, we only report if a button is currently pressed.
|
||||
// This lets a TUI detect a click over the surface + drag out
|
||||
// of the surface.
|
||||
if (!opts.any_button_pressed) return;
|
||||
}
|
||||
|
||||
const cell = posToCell(event.pos, opts.size);
|
||||
|
||||
// We only send motion events when the cell changed unless
|
||||
// we're tracking raw pixels.
|
||||
if (event.action == .motion and opts.format != .sgr_pixels) {
|
||||
if (opts.last_cell) |last| {
|
||||
if (last.*) |last_cell| {
|
||||
if (last_cell.eql(cell)) return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Update the last reported cell if we are tracking it.
|
||||
if (opts.last_cell) |last| last.* = cell;
|
||||
|
||||
const button_code = buttonCode(event, opts) orelse return;
|
||||
switch (opts.format) {
|
||||
.x10 => {
|
||||
if (cell.x > 222 or cell.y > 222) {
|
||||
log.info("X10 mouse format can only encode X/Y up to 223", .{});
|
||||
return;
|
||||
}
|
||||
|
||||
// + 1 because our x/y are zero-indexed and the protocol uses 1-indexing.
|
||||
try writer.writeAll("\x1B[M");
|
||||
try writer.writeByte(32 + button_code);
|
||||
try writer.writeByte(32 + @as(u8, @intCast(cell.x)) + 1);
|
||||
try writer.writeByte(32 + @as(u8, @intCast(cell.y)) + 1);
|
||||
},
|
||||
|
||||
.utf8 => {
|
||||
try writer.writeAll("\x1B[M");
|
||||
|
||||
// The button code always fits in a single byte.
|
||||
try writer.writeByte(32 + button_code);
|
||||
|
||||
var buf: [4]u8 = undefined;
|
||||
const x_cp: u21 = @intCast(@as(u32, cell.x) + 33);
|
||||
const y_cp: u21 = @intCast(cell.y + 33);
|
||||
|
||||
const x_len = std.unicode.utf8Encode(x_cp, &buf) catch unreachable;
|
||||
try writer.writeAll(buf[0..x_len]);
|
||||
|
||||
const y_len = std.unicode.utf8Encode(y_cp, &buf) catch unreachable;
|
||||
try writer.writeAll(buf[0..y_len]);
|
||||
},
|
||||
|
||||
.sgr => try writer.print("\x1B[<{d};{d};{d}{c}", .{
|
||||
button_code,
|
||||
cell.x + 1,
|
||||
cell.y + 1,
|
||||
@as(u8, if (event.action == .release) 'm' else 'M'),
|
||||
}),
|
||||
|
||||
.urxvt => try writer.print("\x1B[{d};{d};{d}M", .{
|
||||
32 + button_code,
|
||||
cell.x + 1,
|
||||
cell.y + 1,
|
||||
}),
|
||||
|
||||
.sgr_pixels => {
|
||||
const pixels = posToPixels(event.pos, opts.size);
|
||||
try writer.print("\x1B[<{d};{d};{d}{c}", .{
|
||||
button_code,
|
||||
pixels.x,
|
||||
pixels.y,
|
||||
@as(u8, if (event.action == .release) 'm' else 'M'),
|
||||
});
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if this event should be reported for the given mouse
|
||||
/// event mode.
|
||||
fn shouldReport(event: Event, opts: Options) bool {
|
||||
return switch (opts.event) {
|
||||
.none => false,
|
||||
|
||||
// X10 only reports button presses of left, middle, and right.
|
||||
.x10 => event.action == .press and
|
||||
event.button != null and
|
||||
(event.button.? == .left or
|
||||
event.button.? == .middle or
|
||||
event.button.? == .right),
|
||||
|
||||
// Normal mode does not report motion.
|
||||
.normal => event.action != .motion,
|
||||
|
||||
// Button mode requires an active button for motion events.
|
||||
.button => event.button != null,
|
||||
|
||||
// Any mode reports everything.
|
||||
.any => true,
|
||||
};
|
||||
}
|
||||
|
||||
fn buttonCode(event: Event, opts: Options) ?u8 {
|
||||
var acc: u8 = code: {
|
||||
if (event.button == null) {
|
||||
// Null button means motion with no pressed button.
|
||||
break :code 3;
|
||||
}
|
||||
|
||||
if (event.action == .release and
|
||||
opts.format != .sgr and
|
||||
opts.format != .sgr_pixels)
|
||||
{
|
||||
// Legacy releases are always encoded as button 3.
|
||||
break :code 3;
|
||||
}
|
||||
|
||||
break :code switch (event.button.?) {
|
||||
.left => 0,
|
||||
.middle => 1,
|
||||
.right => 2,
|
||||
.four => 64,
|
||||
.five => 65,
|
||||
.six => 66,
|
||||
.seven => 67,
|
||||
.eight => 128,
|
||||
.nine => 129,
|
||||
else => return null,
|
||||
};
|
||||
};
|
||||
|
||||
// X10 does not include modifiers.
|
||||
if (opts.event != .x10) {
|
||||
if (event.mods.shift) acc += 4;
|
||||
if (event.mods.alt) acc += 8;
|
||||
if (event.mods.ctrl) acc += 16;
|
||||
}
|
||||
|
||||
// Motion adds another bit.
|
||||
if (event.action == .motion) acc += 32;
|
||||
|
||||
return acc;
|
||||
}
|
||||
|
||||
/// Terminal-space pixel position for SGR pixel reporting.
|
||||
const PixelPoint = struct {
|
||||
x: i32,
|
||||
y: i32,
|
||||
};
|
||||
|
||||
/// Returns true if the surface-space pixel position is outside the
|
||||
/// visible viewport bounds (negative or beyond screen dimensions).
|
||||
fn posOutOfViewport(pos: Event.Pos, size: renderer_size.Size) bool {
|
||||
const max_x: f32 = @floatFromInt(size.screen.width);
|
||||
const max_y: f32 = @floatFromInt(size.screen.height);
|
||||
return pos.x < 0 or pos.y < 0 or pos.x > max_x or pos.y > max_y;
|
||||
}
|
||||
|
||||
/// Converts a surface-space pixel position to a zero-based grid cell
|
||||
/// coordinate (column, row) within the terminal viewport. Out-of-bounds
|
||||
/// values are clamped to the valid grid range (0 to columns/rows - 1).
|
||||
fn posToCell(pos: Event.Pos, size: renderer_size.Size) point.Coordinate {
|
||||
const coord: renderer_size.Coordinate = .{ .surface = .{
|
||||
.x = @as(f64, @floatCast(pos.x)),
|
||||
.y = @as(f64, @floatCast(pos.y)),
|
||||
} };
|
||||
const grid = coord.convert(.grid, size).grid;
|
||||
return .{ .x = grid.x, .y = grid.y };
|
||||
}
|
||||
|
||||
/// Converts a surface-space pixel position to terminal-space pixel
|
||||
/// coordinates (accounting for padding/scaling) used by SGR-Pixels mode.
|
||||
/// Unlike grid conversion, terminal-space coordinates are not clamped
|
||||
/// and may be negative or exceed the terminal dimensions.
|
||||
fn posToPixels(pos: Event.Pos, size: renderer_size.Size) PixelPoint {
|
||||
const coord: renderer_size.Coordinate.Terminal = (renderer_size.Coordinate{ .surface = .{
|
||||
.x = @as(f64, @floatCast(pos.x)),
|
||||
.y = @as(f64, @floatCast(pos.y)),
|
||||
} }).convert(.terminal, size).terminal;
|
||||
|
||||
return .{
|
||||
.x = @as(i32, @intFromFloat(@round(coord.x))),
|
||||
.y = @as(i32, @intFromFloat(@round(coord.y))),
|
||||
};
|
||||
}
|
||||
|
||||
fn testSize() renderer_size.Size {
|
||||
return .{
|
||||
.screen = .{ .width = 1_000, .height = 1_000 },
|
||||
.cell = .{ .width = 1, .height = 1 },
|
||||
.padding = .{},
|
||||
};
|
||||
}
|
||||
|
||||
test "shouldReport: none mode never reports" {
|
||||
const size = testSize();
|
||||
inline for ([_]mouse.Action{ .press, .release, .motion }) |action| {
|
||||
try testing.expect(!shouldReport(.{
|
||||
.button = .left,
|
||||
.action = action,
|
||||
}, .{ .event = .none, .size = size }));
|
||||
}
|
||||
}
|
||||
|
||||
test "shouldReport: x10 reports only left/middle/right press" {
|
||||
const size = testSize();
|
||||
// Left, middle, right presses should report.
|
||||
inline for ([_]mouse.Button{ .left, .middle, .right }) |btn| {
|
||||
try testing.expect(shouldReport(.{
|
||||
.button = btn,
|
||||
.action = .press,
|
||||
}, .{ .event = .x10, .size = size }));
|
||||
}
|
||||
|
||||
// Release is not reported.
|
||||
try testing.expect(!shouldReport(.{
|
||||
.button = .left,
|
||||
.action = .release,
|
||||
}, .{ .event = .x10, .size = size }));
|
||||
|
||||
// Motion is not reported.
|
||||
try testing.expect(!shouldReport(.{
|
||||
.button = .left,
|
||||
.action = .motion,
|
||||
}, .{ .event = .x10, .size = size }));
|
||||
|
||||
// Other buttons are not reported.
|
||||
try testing.expect(!shouldReport(.{
|
||||
.button = .four,
|
||||
.action = .press,
|
||||
}, .{ .event = .x10, .size = size }));
|
||||
|
||||
// Null button is not reported.
|
||||
try testing.expect(!shouldReport(.{
|
||||
.button = null,
|
||||
.action = .press,
|
||||
}, .{ .event = .x10, .size = size }));
|
||||
}
|
||||
|
||||
test "shouldReport: normal reports press and release but not motion" {
|
||||
const size = testSize();
|
||||
try testing.expect(shouldReport(.{
|
||||
.button = .left,
|
||||
.action = .press,
|
||||
}, .{ .event = .normal, .size = size }));
|
||||
|
||||
try testing.expect(shouldReport(.{
|
||||
.button = .left,
|
||||
.action = .release,
|
||||
}, .{ .event = .normal, .size = size }));
|
||||
|
||||
try testing.expect(!shouldReport(.{
|
||||
.button = .left,
|
||||
.action = .motion,
|
||||
}, .{ .event = .normal, .size = size }));
|
||||
}
|
||||
|
||||
test "shouldReport: button mode requires a button" {
|
||||
const size = testSize();
|
||||
// With a button, all actions report.
|
||||
inline for ([_]mouse.Action{ .press, .release, .motion }) |action| {
|
||||
try testing.expect(shouldReport(.{
|
||||
.button = .left,
|
||||
.action = action,
|
||||
}, .{ .event = .button, .size = size }));
|
||||
}
|
||||
|
||||
// Without a button (null), nothing reports.
|
||||
inline for ([_]mouse.Action{ .press, .release, .motion }) |action| {
|
||||
try testing.expect(!shouldReport(.{
|
||||
.button = null,
|
||||
.action = action,
|
||||
}, .{ .event = .button, .size = size }));
|
||||
}
|
||||
}
|
||||
|
||||
test "shouldReport: any mode reports everything" {
|
||||
const size = testSize();
|
||||
inline for ([_]mouse.Action{ .press, .release, .motion }) |action| {
|
||||
try testing.expect(shouldReport(.{
|
||||
.button = .left,
|
||||
.action = action,
|
||||
}, .{ .event = .any, .size = size }));
|
||||
}
|
||||
|
||||
// Even null button + motion reports.
|
||||
try testing.expect(shouldReport(.{
|
||||
.button = null,
|
||||
.action = .motion,
|
||||
}, .{ .event = .any, .size = size }));
|
||||
}
|
||||
|
||||
test "x10 press left" {
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = .left,
|
||||
.action = .press,
|
||||
.mods = .{ .shift = true, .alt = true, .ctrl = true },
|
||||
.pos = .{ .x = 0, .y = 0 },
|
||||
}, .{
|
||||
.event = .x10,
|
||||
.format = .x10,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
try testing.expectEqualSlices(u8, &.{
|
||||
0x1B,
|
||||
'[',
|
||||
'M',
|
||||
32,
|
||||
33,
|
||||
33,
|
||||
}, writer.buffered());
|
||||
}
|
||||
|
||||
test "x10 ignores release" {
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = .left,
|
||||
.action = .release,
|
||||
}, .{
|
||||
.event = .x10,
|
||||
.format = .x10,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
try testing.expectEqual(@as(usize, 0), writer.buffered().len);
|
||||
}
|
||||
|
||||
test "normal ignores motion" {
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = .left,
|
||||
.action = .motion,
|
||||
}, .{
|
||||
.event = .normal,
|
||||
.format = .sgr,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
try testing.expectEqual(@as(usize, 0), writer.buffered().len);
|
||||
}
|
||||
|
||||
test "button mode requires button" {
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = null,
|
||||
.action = .motion,
|
||||
}, .{
|
||||
.event = .button,
|
||||
.format = .sgr,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
try testing.expectEqual(@as(usize, 0), writer.buffered().len);
|
||||
}
|
||||
|
||||
test "sgr release keeps button identity" {
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = .right,
|
||||
.action = .release,
|
||||
.pos = .{ .x = 4, .y = 5 },
|
||||
}, .{
|
||||
.event = .any,
|
||||
.format = .sgr,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
try testing.expectEqualStrings("\x1B[<2;5;6m", writer.buffered());
|
||||
}
|
||||
|
||||
test "sgr motion with no button" {
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = null,
|
||||
.action = .motion,
|
||||
.pos = .{ .x = 1, .y = 2 },
|
||||
}, .{
|
||||
.event = .any,
|
||||
.format = .sgr,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
try testing.expectEqualStrings("\x1B[<35;2;3M", writer.buffered());
|
||||
}
|
||||
|
||||
test "urxvt with modifiers" {
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = .left,
|
||||
.action = .press,
|
||||
.mods = .{ .shift = true, .alt = true, .ctrl = true },
|
||||
.pos = .{ .x = 2, .y = 3 },
|
||||
}, .{
|
||||
.event = .any,
|
||||
.format = .urxvt,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
try testing.expectEqualStrings("\x1B[60;3;4M", writer.buffered());
|
||||
}
|
||||
|
||||
test "utf8 encodes large coordinates" {
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = .left,
|
||||
.action = .press,
|
||||
.pos = .{ .x = 300, .y = 400 },
|
||||
}, .{
|
||||
.event = .any,
|
||||
.format = .utf8,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
const out = writer.buffered();
|
||||
try testing.expectEqualSlices(u8, &.{ 0x1B, '[', 'M', 32 }, out[0..4]);
|
||||
|
||||
const view = try std.unicode.Utf8View.init(out[4..]);
|
||||
var it = view.iterator();
|
||||
try testing.expectEqual(@as(u21, 333), it.nextCodepoint().?);
|
||||
try testing.expectEqual(@as(u21, 433), it.nextCodepoint().?);
|
||||
try testing.expectEqual(@as(?u21, null), it.nextCodepoint());
|
||||
}
|
||||
|
||||
test "x10 coordinate limit" {
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = .left,
|
||||
.action = .press,
|
||||
.pos = .{ .x = 223, .y = 0 },
|
||||
}, .{
|
||||
.event = .x10,
|
||||
.format = .x10,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
try testing.expectEqual(@as(usize, 0), writer.buffered().len);
|
||||
}
|
||||
|
||||
test "sgr wheel button mappings" {
|
||||
const Case = struct {
|
||||
button: mouse.Button,
|
||||
code: u8,
|
||||
};
|
||||
|
||||
inline for ([_]Case{
|
||||
.{ .button = .four, .code = 64 },
|
||||
.{ .button = .five, .code = 65 },
|
||||
.{ .button = .six, .code = 66 },
|
||||
.{ .button = .seven, .code = 67 },
|
||||
}) |c| {
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = c.button,
|
||||
.action = .press,
|
||||
.pos = .{ .x = 0, .y = 0 },
|
||||
}, .{
|
||||
.event = .any,
|
||||
.format = .sgr,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
var expected: [32]u8 = undefined;
|
||||
const want = try std.fmt.bufPrint(&expected, "\x1B[<{d};1;1M", .{c.code});
|
||||
try testing.expectEqualStrings(want, writer.buffered());
|
||||
}
|
||||
}
|
||||
|
||||
test "urxvt release uses legacy button 3 encoding" {
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = .right,
|
||||
.action = .release,
|
||||
.pos = .{ .x = 2, .y = 3 },
|
||||
}, .{
|
||||
.event = .any,
|
||||
.format = .urxvt,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
try testing.expectEqualStrings("\x1B[35;3;4M", writer.buffered());
|
||||
}
|
||||
|
||||
test "unsupported button is ignored" {
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = .ten,
|
||||
.action = .press,
|
||||
.pos = .{ .x = 1, .y = 1 },
|
||||
}, .{
|
||||
.event = .any,
|
||||
.format = .sgr,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
try testing.expectEqual(@as(usize, 0), writer.buffered().len);
|
||||
}
|
||||
|
||||
test "sgr pixels uses terminal-space cursor coordinates" {
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = .left,
|
||||
.action = .press,
|
||||
.pos = .{ .x = 10, .y = 20 },
|
||||
}, .{
|
||||
.event = .any,
|
||||
.format = .sgr_pixels,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
try testing.expectEqualStrings("\x1B[<0;10;20M", writer.buffered());
|
||||
}
|
||||
|
||||
test "sgr pixels release keeps button identity" {
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = .right,
|
||||
.action = .release,
|
||||
.pos = .{ .x = 10, .y = 20 },
|
||||
}, .{
|
||||
.event = .any,
|
||||
.format = .sgr_pixels,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
try testing.expectEqualStrings("\x1B[<2;10;20m", writer.buffered());
|
||||
}
|
||||
|
||||
test "position exactly at viewport boundary is encoded in final cell" {
|
||||
const size: renderer_size.Size = .{
|
||||
.screen = .{ .width = 10, .height = 10 },
|
||||
.cell = .{ .width = 2, .height = 2 },
|
||||
.padding = .{},
|
||||
};
|
||||
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = .left,
|
||||
.action = .press,
|
||||
.pos = .{ .x = 10, .y = 10 },
|
||||
}, .{
|
||||
.event = .any,
|
||||
.format = .sgr,
|
||||
.size = size,
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
try testing.expectEqualStrings("\x1B[<0;5;5M", writer.buffered());
|
||||
}
|
||||
|
||||
test "outside viewport motion with no pressed button is ignored" {
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = .left,
|
||||
.action = .motion,
|
||||
.pos = .{ .x = -1, .y = -1 },
|
||||
}, .{
|
||||
.event = .any,
|
||||
.format = .sgr,
|
||||
.size = testSize(),
|
||||
.any_button_pressed = false,
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
try testing.expectEqual(@as(usize, 0), writer.buffered().len);
|
||||
}
|
||||
|
||||
test "outside viewport motion with pressed button is reported" {
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
var last: ?point.Coordinate = null;
|
||||
try encode(&writer, .{
|
||||
.button = .left,
|
||||
.action = .motion,
|
||||
.pos = .{ .x = -1, .y = -1 },
|
||||
}, .{
|
||||
.event = .any,
|
||||
.format = .sgr,
|
||||
.size = testSize(),
|
||||
.any_button_pressed = true,
|
||||
.last_cell = &last,
|
||||
});
|
||||
|
||||
try testing.expectEqualStrings("\x1B[<32;1;1M", writer.buffered());
|
||||
}
|
||||
|
||||
test "motion is deduped by last cell except sgr pixels" {
|
||||
var last: ?point.Coordinate = null;
|
||||
|
||||
{
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
try encode(&writer, .{
|
||||
.button = .left,
|
||||
.action = .motion,
|
||||
.pos = .{ .x = 5, .y = 6 },
|
||||
}, .{
|
||||
.event = .any,
|
||||
.format = .sgr,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
try testing.expect(writer.buffered().len > 0);
|
||||
}
|
||||
|
||||
{
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
try encode(&writer, .{
|
||||
.button = .left,
|
||||
.action = .motion,
|
||||
.pos = .{ .x = 5, .y = 6 },
|
||||
}, .{
|
||||
.event = .any,
|
||||
.format = .sgr,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
try testing.expectEqual(@as(usize, 0), writer.buffered().len);
|
||||
}
|
||||
|
||||
{
|
||||
var data: [32]u8 = undefined;
|
||||
var writer: std.Io.Writer = .fixed(&data);
|
||||
try encode(&writer, .{
|
||||
.button = .left,
|
||||
.action = .motion,
|
||||
.pos = .{ .x = 5, .y = 6 },
|
||||
}, .{
|
||||
.event = .any,
|
||||
.format = .sgr_pixels,
|
||||
.size = testSize(),
|
||||
.last_cell = &last,
|
||||
});
|
||||
try testing.expect(writer.buffered().len > 0);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user