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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
const std = @import("std");
const terminal = @import("../terminal/main.zig");
/// Available cursor styles for drawing that renderers must support.
/// This is a superset of terminal cursor styles since the renderer supports
/// some additional cursor states such as the hollow block.
pub const Style = enum {
// Typical cursor input styles
block,
block_hollow,
bar,
underline,
// Special cursor styles
lock,
/// Create a cursor style from the terminal style request.
pub fn fromTerminal(term: terminal.CursorStyle) Style {
return switch (term) {
.bar => .bar,
.block => .block,
.block_hollow => .block_hollow,
.underline => .underline,
};
}
};
pub const StyleOptions = struct {
preedit: bool = false,
focused: bool = false,
blink_visible: bool = false,
};
/// Returns the cursor style to use for the current render state or null
/// if a cursor should not be rendered at all.
pub fn style(
state: *const terminal.RenderState,
opts: StyleOptions,
) ?Style {
// Note the order of conditionals below is important. It represents
// a priority system of how we determine what state overrides cursor
// visibility and style.
// The cursor must be visible in the viewport to be rendered.
if (state.cursor.viewport == null) return null;
// If we are in preedit, then we always show the block cursor. We do
// this even if the cursor is explicitly not visible because it shows
// an important editing state to the user.
if (opts.preedit) return .block;
// If we're at a password input its always a lock.
if (state.cursor.password_input) return .lock;
// If the cursor is explicitly not visible by terminal mode, we don't render.
if (!state.cursor.visible) return null;
// If we're not focused, our cursor is always visible so that
// we can show the hollow box.
if (!opts.focused) return .block_hollow;
// If the cursor is blinking and our blink state is not visible,
// then we don't show the cursor.
if (state.cursor.blinking and !opts.blink_visible) return null;
// Otherwise, we use whatever style the terminal wants.
return .fromTerminal(state.cursor.visual_style);
}
test "cursor: default uses configured style" {
const testing = std.testing;
const alloc = testing.allocator;
const io = testing.io;
var term: terminal.Terminal = try .init(io, alloc, .{ .cols = 10, .rows = 10 });
defer term.deinit(alloc);
term.screens.active.cursor.cursor_style = .bar;
term.modes.set(.cursor_blinking, true);
var state: terminal.RenderState = .empty;
defer state.deinit(alloc);
try state.update(alloc, &term);
try testing.expect(style(&state, .{ .preedit = false, .focused = true, .blink_visible = true }) == .bar);
try testing.expect(style(&state, .{ .preedit = false, .focused = false, .blink_visible = true }) == .block_hollow);
try testing.expect(style(&state, .{ .preedit = false, .focused = false, .blink_visible = false }) == .block_hollow);
try testing.expect(style(&state, .{ .preedit = false, .focused = true, .blink_visible = false }) == null);
}
test "cursor: blinking disabled" {
const testing = std.testing;
const alloc = testing.allocator;
const io = testing.io;
var term = try terminal.Terminal.init(io, alloc, .{ .cols = 10, .rows = 10 });
defer term.deinit(alloc);
term.screens.active.cursor.cursor_style = .bar;
term.modes.set(.cursor_blinking, false);
var state: terminal.RenderState = .empty;
defer state.deinit(alloc);
try state.update(alloc, &term);
try testing.expect(style(&state, .{ .focused = true, .blink_visible = true }) == .bar);
try testing.expect(style(&state, .{ .focused = true, .blink_visible = false }) == .bar);
try testing.expect(style(&state, .{ .focused = false, .blink_visible = true }) == .block_hollow);
try testing.expect(style(&state, .{ .focused = false, .blink_visible = false }) == .block_hollow);
}
test "cursor: explicitly not visible" {
const testing = std.testing;
const alloc = testing.allocator;
const io = testing.io;
var term = try terminal.Terminal.init(io, alloc, .{ .cols = 10, .rows = 10 });
defer term.deinit(alloc);
term.screens.active.cursor.cursor_style = .bar;
term.modes.set(.cursor_visible, false);
term.modes.set(.cursor_blinking, false);
var state: terminal.RenderState = .empty;
defer state.deinit(alloc);
try state.update(alloc, &term);
try testing.expect(style(&state, .{ .focused = true, .blink_visible = true }) == null);
try testing.expect(style(&state, .{ .focused = true, .blink_visible = false }) == null);
try testing.expect(style(&state, .{ .focused = false, .blink_visible = true }) == null);
try testing.expect(style(&state, .{ .focused = false, .blink_visible = false }) == null);
}
test "cursor: always block with preedit" {
const testing = std.testing;
const alloc = testing.allocator;
const io = testing.io;
var term = try terminal.Terminal.init(io, alloc, .{ .cols = 10, .rows = 10 });
defer term.deinit(alloc);
var state: terminal.RenderState = .empty;
defer state.deinit(alloc);
try state.update(alloc, &term);
// In any bool state
try testing.expect(style(&state, .{ .preedit = true, .focused = false, .blink_visible = false }) == .block);
try testing.expect(style(&state, .{ .preedit = true, .focused = true, .blink_visible = false }) == .block);
try testing.expect(style(&state, .{ .preedit = true, .focused = true, .blink_visible = true }) == .block);
try testing.expect(style(&state, .{ .preedit = true, .focused = false, .blink_visible = true }) == .block);
// If we're scrolled though, then we don't show the cursor.
for (0..100) |_| try term.index();
term.scrollViewport(.{ .top = {} });
try state.update(alloc, &term);
// In any bool state
try testing.expect(style(&state, .{ .preedit = true, .focused = false, .blink_visible = false }) == null);
try testing.expect(style(&state, .{ .preedit = true, .focused = true, .blink_visible = false }) == null);
try testing.expect(style(&state, .{ .preedit = true, .focused = true, .blink_visible = true }) == null);
try testing.expect(style(&state, .{ .preedit = true, .focused = false, .blink_visible = true }) == null);
}
|
