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
|
//! This is the render state that is given to a renderer.
const std = @import("std");
const Allocator = std.mem.Allocator;
const Inspector = @import("../inspector/main.zig").Inspector;
const terminalpkg = @import("../terminal/main.zig");
const inputpkg = @import("../input.zig");
const renderer = @import("../renderer.zig");
/// The mutex that must be held while reading any of the data in the
/// members of this state. Note that the state itself is NOT protected
/// by the mutex and is NOT thread-safe, only the members values of the
/// state (i.e. the terminal, devmode, etc. values).
mutex: *std.Thread.Mutex,
/// The terminal data.
terminal: *terminalpkg.Terminal,
/// The terminal inspector, if any. This will be null while the inspector
/// is not active and will be set when it is active.
inspector: ?*Inspector = null,
/// Dead key state. This will render the current dead key preedit text
/// over the cursor. This currently only ever renders a single codepoint.
/// Preedit can in theory be multiple codepoints long but that is left as
/// a future exercise.
preedit: ?Preedit = null,
/// Mouse state. This only contains state relevant to what renderers
/// need about the mouse.
mouse: Mouse = .{},
pub const Mouse = struct {
/// The point on the viewport where the mouse currently is. We use
/// viewport points to avoid the complexity of mapping the mouse to
/// the renderer state.
point: ?terminalpkg.point.Coordinate = null,
/// The mods that are currently active for the last mouse event.
/// This could really just be mods in general and we probably will
/// move it out of mouse state at some point.
mods: inputpkg.Mods = .{},
};
/// The pre-edit state. See Surface.preeditCallback for more information.
pub const Preedit = struct {
/// The codepoints to render as preedit text.
codepoints: []const Codepoint = &.{},
/// A single codepoint to render as preedit text.
pub const Codepoint = struct {
codepoint: u21,
wide: bool = false,
};
/// Deinit this preedit that was cre
pub fn deinit(self: *const Preedit, alloc: Allocator) void {
alloc.free(self.codepoints);
}
/// Allocate a copy of this preedit in the given allocator..
pub fn clone(self: *const Preedit, alloc: Allocator) !Preedit {
return .{
.codepoints = try alloc.dupe(Codepoint, self.codepoints),
};
}
/// The width in cells of all codepoints in the preedit.
pub fn width(self: *const Preedit) usize {
var result: usize = 0;
for (self.codepoints) |cp| {
result += if (cp.wide) 2 else 1;
}
return result;
}
/// Range returns the start and end x position of the preedit text
/// along with any codepoint offset necessary to fit the preedit
/// into the available space.
pub fn range(
self: *const Preedit,
start: terminalpkg.size.CellCountInt,
max: terminalpkg.size.CellCountInt,
) struct {
start: terminalpkg.size.CellCountInt,
end: terminalpkg.size.CellCountInt,
cp_offset: usize,
} {
// If our width is greater than the number of cells we have
// then we need to adjust our codepoint start to a point where
// our width would be less than the number of cells we have.
const w, const cp_offset = width: {
// max is inclusive, so we need to add 1 to it.
const max_width = max - start + 1;
// Rebuild our width in reverse order. This is because we want
// to offset by the end cells, not the start cells (if we have to).
var w: terminalpkg.size.CellCountInt = 0;
for (0..self.codepoints.len) |i| {
const reverse_i = self.codepoints.len - i - 1;
const cp = self.codepoints[reverse_i];
w += if (cp.wide) 2 else 1;
if (w > max_width) {
break :width .{ w, reverse_i };
}
}
// Width fit in the max width so no offset necessary.
break :width .{ w, 0 };
};
// If our preedit goes off the end of the screen, we adjust it so
// that it shifts left.
const end = start + w;
const start_offset = if (end > max) end - max else 0;
return .{
.start = start -| start_offset,
.end = end -| start_offset,
.cp_offset = cp_offset,
};
}
};
|
