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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
|
#include "dged/binding.h"
#include "dged/buffer.h"
#include "dged/minibuffer.h"
#include "dged/vec.h"
#include "bindings.h"
static struct keymap g_global_keymap, g_ctrlx_map, g_windows_keymap,
g_buffer_default_keymap;
HOOK_IMPL(buffer_keymaps, buffer_keymaps_cb);
static buffer_keymaps_hook_vec g_buffer_keymaps_hooks;
uint32_t g_buffer_keymaps_hook_id = 0;
struct buffer_keymap {
buffer_keymap_id id;
struct buffer *buffer;
struct keymap keymap;
};
static VEC(struct buffer_keymap) g_buffer_keymaps;
static buffer_keymap_id g_current_keymap_id;
struct keymap *buffer_default_keymap(void) { return &g_buffer_default_keymap; }
void set_default_buffer_bindings(struct keymap *keymap) {
struct binding buffer_bindings[] = {
BINDING(Ctrl, 'B', "backward-char"),
BINDING(LEFT, "backward-char"),
BINDING(Ctrl, 'F', "forward-char"),
BINDING(RIGHT, "forward-char"),
BINDING(Ctrl, 'P', "backward-line"),
BINDING(UP, "backward-line"),
BINDING(Ctrl, 'N', "forward-line"),
BINDING(DOWN, "forward-line"),
BINDING(Meta, 'f', "forward-word"),
BINDING(Meta, 'b', "backward-word"),
BINDING(Ctrl, 'A', "beginning-of-line"),
BINDING(Ctrl, 'E', "end-of-line"),
BINDING(Ctrl, 'S', "find-next"),
BINDING(Ctrl, 'R', "find-prev"),
BINDING(Meta, 'g', "goto-line"),
BINDING(Meta, '<', "goto-beginning"),
BINDING(Meta, '>', "goto-end"),
BINDING(Ctrl, 'V', "scroll-down"),
BINDING(Meta, 'v', "scroll-up"),
BINDING(Spec, '6', "scroll-down"),
BINDING(Spec, '5', "scroll-up"),
BINDING(ENTER, "newline"),
BINDING(TAB, "indent"),
BINDING(Spec, 'Z', "indent-alt"),
BINDING(Ctrl, 'K', "kill-line"),
BINDING(DELETE, "delete-char"),
BINDING(Ctrl, 'D', "delete-char"),
BINDING(Meta, 'd', "delete-word"),
BINDING(BACKSPACE, "backward-delete-char"),
BINDING(Ctrl, '@', "set-mark"),
BINDING(Ctrl, 'W', "cut"),
BINDING(Ctrl, 'Y', "paste"),
BINDING(Meta, 'y', "paste-older"),
BINDING(Meta, 'w', "copy"),
BINDING(Ctrl, '_', "undo"),
};
keymap_bind_keys(keymap, buffer_bindings,
sizeof(buffer_bindings) / sizeof(buffer_bindings[0]));
}
int32_t execute(struct command_ctx ctx, int argc, const char *argv[]) {
(void)ctx;
(void)argc;
(void)argv;
// TODO: this should be more lib-like
return minibuffer_execute();
}
static struct command execute_minibuffer_command = {
.fn = execute,
.name = "minibuffer-execute",
.userdata = NULL,
};
void init_bindings(void) {
g_global_keymap = keymap_create("global", 32);
g_ctrlx_map = keymap_create("c-x", 32);
g_windows_keymap = keymap_create("c-x w", 32);
struct binding global_binds[] = {
PREFIX(Ctrl, 'X', &g_ctrlx_map),
BINDING(Ctrl, 'G', "abort"),
BINDING(Meta, 'x', "run-command-interactive"),
};
struct binding ctrlx_bindings[] = {
BINDING(Ctrl, 'C', "exit"),
BINDING(Ctrl, 'S', "buffer-write-to-file"),
BINDING(Ctrl, 'F', "find-file"),
BINDING(Ctrl, 'G', "find-file-relative"),
BINDING(Ctrl, 'W', "write-file"),
BINDING(None, 'b', "switch-buffer"),
BINDING(None, 'k', "kill-buffer"),
BINDING(Ctrl, 'B', "buffer-list"),
BINDING(None, '0', "window-close"),
BINDING(None, '1', "window-close-others"),
BINDING(None, '2', "window-split-horizontal"),
BINDING(None, '3', "window-split-vertical"),
BINDING(None, 'o', "window-focus-next"),
PREFIX(None, 'w', &g_windows_keymap),
};
// windows
struct binding window_subbinds[] = {
BINDING(None, '0', "window-focus-0"),
BINDING(None, '1', "window-focus-1"),
BINDING(None, '2', "window-focus-2"),
BINDING(None, '3', "window-focus-3"),
BINDING(None, '4', "window-focus-4"),
BINDING(None, '5', "window-focus-5"),
BINDING(None, '6', "window-focus-6"),
BINDING(None, '7', "window-focus-7"),
BINDING(None, '8', "window-focus-8"),
BINDING(None, '9', "window-focus-9"),
};
// buffers
g_buffer_default_keymap = keymap_create("buffer-default", 128);
set_default_buffer_bindings(&g_buffer_default_keymap);
keymap_bind_keys(&g_windows_keymap, window_subbinds,
sizeof(window_subbinds) / sizeof(window_subbinds[0]));
keymap_bind_keys(&g_global_keymap, global_binds,
sizeof(global_binds) / sizeof(global_binds[0]));
keymap_bind_keys(&g_ctrlx_map, ctrlx_bindings,
sizeof(ctrlx_bindings) / sizeof(ctrlx_bindings[0]));
VEC_INIT(&g_buffer_keymaps, 32);
g_current_keymap_id = 0;
VEC_INIT(&g_buffer_keymaps_hooks, 16);
/* Minibuffer binds.
* This map is actually never removed so forget about the id.
*/
struct binding minibuffer_binds[] = {
ANONYMOUS_BINDING(ENTER, &execute_minibuffer_command),
};
struct keymap minibuffer_map = keymap_create("minibuffer", 8);
keymap_bind_keys(&minibuffer_map, minibuffer_binds,
sizeof(minibuffer_binds) / sizeof(minibuffer_binds[0]));
buffer_add_keymap(minibuffer_buffer(), minibuffer_map);
}
buffer_keymap_id buffer_add_keymap(struct buffer *buffer,
struct keymap keymap) {
buffer_keymap_id id = ++g_current_keymap_id;
VEC_PUSH(&g_buffer_keymaps, ((struct buffer_keymap){
.id = id,
.buffer = buffer,
.keymap = keymap,
}));
return id;
}
void buffer_remove_keymap(buffer_keymap_id id) {
VEC_FOR_EACH_INDEXED(&g_buffer_keymaps, struct buffer_keymap * km, i) {
if (km->id == id) {
VEC_SWAP(&g_buffer_keymaps, i, VEC_SIZE(&g_buffer_keymaps) - 1);
VEC_POP(&g_buffer_keymaps, struct buffer_keymap removed);
keymap_destroy(&removed.keymap);
}
}
}
uint32_t buffer_keymaps(struct buffer *buffer, struct keymap *keymaps[],
uint32_t max_nkeymaps) {
uint32_t nkeymaps = 0;
// global keybinds
if (nkeymaps < max_nkeymaps) {
keymaps[nkeymaps] = &g_global_keymap;
++nkeymaps;
}
// buffer keybinds
if (nkeymaps < max_nkeymaps) {
keymaps[nkeymaps] = &g_buffer_default_keymap;
++nkeymaps;
}
// keybinds specific to this buffer
if (nkeymaps < max_nkeymaps) {
VEC_FOR_EACH(&g_buffer_keymaps, struct buffer_keymap * km) {
if (buffer == km->buffer && nkeymaps < max_nkeymaps) {
keymaps[nkeymaps] = &km->keymap;
++nkeymaps;
}
}
}
// hooks
VEC_FOR_EACH(&g_buffer_keymaps_hooks, struct buffer_keymaps_hook * hook) {
if (nkeymaps < max_nkeymaps) {
nkeymaps += hook->callback(buffer, &keymaps[nkeymaps],
max_nkeymaps - nkeymaps, hook->userdata);
}
}
return nkeymaps;
}
void destroy_bindings(void) {
keymap_destroy(&g_windows_keymap);
keymap_destroy(&g_global_keymap);
keymap_destroy(&g_ctrlx_map);
keymap_destroy(&g_buffer_default_keymap);
VEC_FOR_EACH(&g_buffer_keymaps, struct buffer_keymap * km) {
keymap_destroy(&km->keymap);
}
VEC_DESTROY(&g_buffer_keymaps);
}
uint32_t buffer_add_keymaps_hook(buffer_keymaps_cb callback, void *userdata) {
return insert_buffer_keymaps_hook(
&g_buffer_keymaps_hooks, &g_buffer_keymaps_hook_id, callback, userdata);
}
void buffer_remove_keymaps_hook(uint32_t id, remove_hook_cb callback) {
remove_buffer_keymaps_hook(&g_buffer_keymaps_hooks, id, callback);
}
|
