Preditor/defaults.go at master · amirrezaask/Preditor · GitHub

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
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
package preditor

import rl "github.com/gen2brain/raylib-go/raylib"

func MakeInsertionKeys(insertor func(c *Context, b byte)) Keymap {
	return Keymap{
		Key{K: "a"}:                    func(c *Context) { insertor(c, 'a') },
		Key{K: "b"}:                    func(c *Context) { insertor(c, 'b') },
		Key{K: "c"}:                    func(c *Context) { insertor(c, 'c') },
		Key{K: "d"}:                    func(c *Context) { insertor(c, 'd') },
		Key{K: "e"}:                    func(c *Context) { insertor(c, 'e') },
		Key{K: "f"}:                    func(c *Context) { insertor(c, 'f') },
		Key{K: "g"}:                    func(c *Context) { insertor(c, 'g') },
		Key{K: "h"}:                    func(c *Context) { insertor(c, 'h') },
		Key{K: "i"}:                    func(c *Context) { insertor(c, 'i') },
		Key{K: "j"}:                    func(c *Context) { insertor(c, 'j') },
		Key{K: "k"}:                    func(c *Context) { insertor(c, 'k') },
		Key{K: "l"}:                    func(c *Context) { insertor(c, 'l') },
		Key{K: "m"}:                    func(c *Context) { insertor(c, 'm') },
		Key{K: "n"}:                    func(c *Context) { insertor(c, 'n') },
		Key{K: "o"}:                    func(c *Context) { insertor(c, 'o') },
		Key{K: "p"}:                    func(c *Context) { insertor(c, 'p') },
		Key{K: "q"}:                    func(c *Context) { insertor(c, 'q') },
		Key{K: "r"}:                    func(c *Context) { insertor(c, 'r') },
		Key{K: "s"}:                    func(c *Context) { insertor(c, 's') },
		Key{K: "t"}:                    func(c *Context) { insertor(c, 't') },
		Key{K: "u"}:                    func(c *Context) { insertor(c, 'u') },
		Key{K: "v"}:                    func(c *Context) { insertor(c, 'v') },
		Key{K: "w"}:                    func(c *Context) { insertor(c, 'w') },
		Key{K: "x"}:                    func(c *Context) { insertor(c, 'x') },
		Key{K: "y"}:                    func(c *Context) { insertor(c, 'y') },
		Key{K: "z"}:                    func(c *Context) { insertor(c, 'z') },
		Key{K: "0"}:                    func(c *Context) { insertor(c, '0') },
		Key{K: "1"}:                    func(c *Context) { insertor(c, '1') },
		Key{K: "2"}:                    func(c *Context) { insertor(c, '2') },
		Key{K: "3"}:                    func(c *Context) { insertor(c, '3') },
		Key{K: "4"}:                    func(c *Context) { insertor(c, '4') },
		Key{K: "5"}:                    func(c *Context) { insertor(c, '5') },
		Key{K: "6"}:                    func(c *Context) { insertor(c, '6') },
		Key{K: "7"}:                    func(c *Context) { insertor(c, '7') },
		Key{K: "8"}:                    func(c *Context) { insertor(c, '8') },
		Key{K: "9"}:                    func(c *Context) { insertor(c, '9') },
		Key{K: "\\"}:                   func(c *Context) { insertor(c, '\\') },
		Key{K: "\\", Shift: true}:      func(c *Context) { insertor(c, '|') },
		Key{K: "0", Shift: true}:       func(c *Context) { insertor(c, ')') },
		Key{K: "1", Shift: true}:       func(c *Context) { insertor(c, '!') },
		Key{K: "2", Shift: true}:       func(c *Context) { insertor(c, '@') },
		Key{K: "3", Shift: true}:       func(c *Context) { insertor(c, '#') },
		Key{K: "4", Shift: true}:       func(c *Context) { insertor(c, '$') },
		Key{K: "5", Shift: true}:       func(c *Context) { insertor(c, '%') },
		Key{K: "6", Shift: true}:       func(c *Context) { insertor(c, '^') },
		Key{K: "7", Shift: true}:       func(c *Context) { insertor(c, '&') },
		Key{K: "8", Shift: true}:       func(c *Context) { insertor(c, '*') },
		Key{K: "9", Shift: true}:       func(c *Context) { insertor(c, '(') },
		Key{K: "a", Shift: true}:       func(c *Context) { insertor(c, 'A') },
		Key{K: "b", Shift: true}:       func(c *Context) { insertor(c, 'B') },
		Key{K: "c", Shift: true}:       func(c *Context) { insertor(c, 'C') },
		Key{K: "d", Shift: true}:       func(c *Context) { insertor(c, 'D') },
		Key{K: "e", Shift: true}:       func(c *Context) { insertor(c, 'E') },
		Key{K: "f", Shift: true}:       func(c *Context) { insertor(c, 'F') },
		Key{K: "g", Shift: true}:       func(c *Context) { insertor(c, 'G') },
		Key{K: "h", Shift: true}:       func(c *Context) { insertor(c, 'H') },
		Key{K: "i", Shift: true}:       func(c *Context) { insertor(c, 'I') },
		Key{K: "j", Shift: true}:       func(c *Context) { insertor(c, 'J') },
		Key{K: "k", Shift: true}:       func(c *Context) { insertor(c, 'K') },
		Key{K: "l", Shift: true}:       func(c *Context) { insertor(c, 'L') },
		Key{K: "m", Shift: true}:       func(c *Context) { insertor(c, 'M') },
		Key{K: "n", Shift: true}:       func(c *Context) { insertor(c, 'N') },
		Key{K: "o", Shift: true}:       func(c *Context) { insertor(c, 'O') },
		Key{K: "p", Shift: true}:       func(c *Context) { insertor(c, 'P') },
		Key{K: "q", Shift: true}:       func(c *Context) { insertor(c, 'Q') },
		Key{K: "r", Shift: true}:       func(c *Context) { insertor(c, 'R') },
		Key{K: "s", Shift: true}:       func(c *Context) { insertor(c, 'S') },
		Key{K: "t", Shift: true}:       func(c *Context) { insertor(c, 'T') },
		Key{K: "u", Shift: true}:       func(c *Context) { insertor(c, 'U') },
		Key{K: "v", Shift: true}:       func(c *Context) { insertor(c, 'V') },
		Key{K: "w", Shift: true}:       func(c *Context) { insertor(c, 'W') },
		Key{K: "x", Shift: true}:       func(c *Context) { insertor(c, 'X') },
		Key{K: "y", Shift: true}:       func(c *Context) { insertor(c, 'Y') },
		Key{K: "z", Shift: true}:       func(c *Context) { insertor(c, 'Z') },
		Key{K: "["}:                    func(c *Context) { insertor(c, '[') },
		Key{K: "]"}:                    func(c *Context) { insertor(c, ']') },
		Key{K: "[", Shift: true}:       func(c *Context) { insertor(c, '{') },
		Key{K: "]", Shift: true}:       func(c *Context) { insertor(c, '}') },
		Key{K: ";"}:                    func(c *Context) { insertor(c, ';') },
		Key{K: ";", Shift: true}:       func(c *Context) { insertor(c, ':') },
		Key{K: "'"}:                    func(c *Context) { insertor(c, '\'') },
		Key{K: "'", Shift: true}:       func(c *Context) { insertor(c, '"') },
		Key{K: "\""}:                   func(c *Context) { insertor(c, '"') },
		Key{K: ","}:                    func(c *Context) { insertor(c, ',') },
		Key{K: "."}:                    func(c *Context) { insertor(c, '.') },
		Key{K: ",", Shift: true}:       func(c *Context) { insertor(c, '<') },
		Key{K: ".", Shift: true}:       func(c *Context) { insertor(c, '>') },
		Key{K: "/"}:                    func(c *Context) { insertor(c, '/') },
		Key{K: "/", Shift: true}:       func(c *Context) { insertor(c, '?') },
		Key{K: "-"}:                    func(c *Context) { insertor(c, '-') },
		Key{K: "="}:                    func(c *Context) { insertor(c, '=') },
		Key{K: "-", Shift: true}:       func(c *Context) { insertor(c, '_') },
		Key{K: "=", Shift: true}:       func(c *Context) { insertor(c, '+') },
		Key{K: "`"}:                    func(c *Context) { insertor(c, '`') },
		Key{K: "`", Shift: true}:       func(c *Context) { insertor(c, '~') },
		Key{K: "<space>", Shift: true}: func(c *Context) { insertor(c, ' ') },
		Key{K: "<space>"}:              func(c *Context) { insertor(c, ' ') },
	}
}

func setupDefaults() {
	PromptKeymap.SetKeys(MakeInsertionKeys(func(c *Context, b byte) {
		c.Prompt.UserInput += string(b)
		if c.Prompt.ChangeHook != nil {
			c.Prompt.ChangeHook(c.Prompt.UserInput, c)
		}
	}))
	PromptKeymap.BindKey(Key{K: "<enter>"}, func(c *Context) {
		userInput := c.Prompt.UserInput
		if c.Prompt.DoneHook != nil {
			c.Prompt.IsActive = false
			c.Prompt.UserInput = ""
			hook := c.Prompt.DoneHook
			c.Prompt.DoneHook = nil
			hook(userInput, c)
		}
	})

	PromptKeymap.BindKey(Key{K: "<backspace>"}, func(c *Context) {
		c.Prompt.UserInput = c.Prompt.UserInput[:len(c.Prompt.UserInput)-1]
		if c.Prompt.ChangeHook != nil {
			c.Prompt.ChangeHook(c.Prompt.UserInput, c)
		}
	})

	PromptKeymap.BindKey(Key{K: "<esc>"}, func(c *Context) {
		c.ResetPrompt()
	})

	BufferKeymap.SetKeys(MakeInsertionKeys(func(c *Context, b byte) {
		BufferInsertChar(c.ActiveDrawable().(*BufferView), b)
	}))

	BufferKeymap.BindKey(Key{K: ",", Shift: true, Control: true}, MakeCommand(ScrollToTop))
	BufferKeymap.BindKey(Key{K: "l", Control: true}, MakeCommand(CentralizePoint))
	BufferKeymap.BindKey(Key{K: ";", Control: true}, MakeCommand(CompileNoAsk))
	BufferKeymap.BindKey(Key{K: ";", Control: true, Shift: true}, MakeCommand(CompileAskForCommand))
	BufferKeymap.BindKey(Key{K: "g", Alt: true}, MakeCommand(GrepAsk))
	BufferKeymap.BindKey(Key{K: ".", Shift: true, Control: true}, MakeCommand(ScrollToBottom))
	BufferKeymap.BindKey(Key{K: "<right>", Shift: true}, MakeCommand(func(e *BufferView) { MarkRight(e, 1) }))
	BufferKeymap.BindKey(Key{K: "<right>", Shift: true, Control: true}, MakeCommand(MarkNextWord))
	BufferKeymap.BindKey(Key{K: "<left>", Shift: true, Control: true}, MakeCommand(MarkPreviousWord))
	BufferKeymap.BindKey(Key{K: "<left>", Shift: true}, MakeCommand(func(e *BufferView) { MarkLeft(e, 1) }))
	BufferKeymap.BindKey(Key{K: "<up>", Shift: true}, MakeCommand(func(e *BufferView) { MarkUp(e, 1) }))
	BufferKeymap.BindKey(Key{K: "<down>", Shift: true}, MakeCommand(func(e *BufferView) { MarkDown(e, 1) }))
	BufferKeymap.BindKey(Key{K: "n", Shift: true, Control: true}, MakeCommand(func(e *BufferView) { MarkDown(e, 1) }))
	BufferKeymap.BindKey(Key{K: "p", Shift: true, Control: true}, MakeCommand(func(e *BufferView) { MarkUp(e, 1) }))
	BufferKeymap.BindKey(Key{K: "f", Shift: true, Control: true}, MakeCommand(func(e *BufferView) { MarkRight(e, 1) }))
	BufferKeymap.BindKey(Key{K: "b", Shift: true, Control: true}, MakeCommand(func(e *BufferView) { MarkLeft(e, 1) }))
	BufferKeymap.BindKey(Key{K: "a", Shift: true, Control: true}, MakeCommand(MarkToBeginningOfLine))
	BufferKeymap.BindKey(Key{K: "e", Shift: true, Control: true}, MakeCommand(MarkToEndOfLine))
	BufferKeymap.BindKey(Key{K: "5", Shift: true, Control: true}, MakeCommand(MarkToMatchingChar))
	BufferKeymap.BindKey(Key{K: "m", Shift: true, Control: true}, MakeCommand(MarkToMatchingChar))
	BufferKeymap.BindKey(Key{K: "r", Control: true}, MakeCommand(QueryReplaceActivate))
	BufferKeymap.BindKey(Key{K: "r", Control: true, Shift: true}, MakeCommand(RevertBuffer))
	BufferKeymap.BindKey(Key{K: "r", Alt: true}, MakeCommand(func(e *BufferView) {
		e.readFileFromDisk()
	}))
	BufferKeymap.BindKey(Key{K: "z", Control: true}, MakeCommand(func(e *BufferView) {
		RevertLastBufferAction(e)
	}))
	BufferKeymap.BindKey(Key{K: "f", Control: true}, MakeCommand(func(e *BufferView) {
		PointRight(e, 1)
	}))
	BufferKeymap.BindKey(Key{K: "x", Control: true}, MakeCommand(func(e *BufferView) {
		Cut(e)
	}))
	BufferKeymap.BindKey(Key{K: "v", Control: true}, MakeCommand(func(e *BufferView) {
		Paste(e)
	}))
	BufferKeymap.BindKey(Key{K: "k", Control: true}, MakeCommand(func(e *BufferView) {
		KillLine(e)
	}))
	BufferKeymap.BindKey(Key{K: "g", Control: true}, MakeCommand(func(e *BufferView) {
		InteractiveGotoLine(e)
	}))
	BufferKeymap.BindKey(Key{K: "c", Control: true}, MakeCommand(func(e *BufferView) {
		Copy(e)
	}))
	BufferKeymap.BindKey(Key{K: "c", Alt: true}, MakeCommand(func(a *BufferView) {
		CompileAskForCommand(a)
	}))
	BufferKeymap.BindKey(Key{K: "s", Control: true}, MakeCommand(func(a *BufferView) {
		SearchActivate(a)
	}))
	BufferKeymap.BindKey(Key{K: "w", Control: true}, MakeCommand(func(a *BufferView) {
		Write(a)
	}))
	BufferKeymap.BindKey(Key{K: "<lmouse>-click"}, MakeCommand(func(e *BufferView) {
		e.moveCursorTo(rl.GetMousePosition())
	}))

	BufferKeymap.BindKey(Key{K: "<mouse-wheel-down>"}, MakeCommand(func(e *BufferView) {
		ScrollDown(e, 5)
	}))
	BufferKeymap.BindKey(Key{K: "<mouse-wheel-up>"}, MakeCommand(func(e *BufferView) {
		ScrollUp(e, 5)
	}))
	BufferKeymap.BindKey(Key{K: "<lmouse>-hold"}, MakeCommand(func(e *BufferView) {
		e.moveCursorTo(rl.GetMousePosition())
	}))

	BufferKeymap.BindKey(Key{K: "a", Control: true}, MakeCommand(func(e *BufferView) {
		PointToBeginningOfLine(e)
	}))
	BufferKeymap.BindKey(Key{K: "e", Control: true}, MakeCommand(func(e *BufferView) {
		PointToEndOfLine(e)
	}))
	BufferKeymap.BindKey(Key{K: "5", Control: true}, MakeCommand(func(e *BufferView) {
		PointToMatchingChar(e)
	}))
	BufferKeymap.BindKey(Key{K: "m", Control: true}, MakeCommand(func(e *BufferView) {
		PointToMatchingChar(e)
	}))
	BufferKeymap.BindKey(Key{K: "p", Control: true}, MakeCommand(func(e *BufferView) {
		PointUp(e)
	}))
	BufferKeymap.BindKey(Key{K: "n", Control: true}, MakeCommand(func(e *BufferView) {
		PointDown(e)
	}))

	BufferKeymap.BindKey(Key{K: "<up>"}, MakeCommand(func(e *BufferView) {
		PointUp(e)
	}))
	BufferKeymap.BindKey(Key{K: "<down>"}, MakeCommand(func(e *BufferView) {
		PointDown(e)
	}))
	BufferKeymap.BindKey(Key{K: "<right>"}, MakeCommand(func(e *BufferView) {
		PointRight(e, 1)
	}))
	BufferKeymap.BindKey(Key{K: "<right>", Control: true}, MakeCommand(func(e *BufferView) {
		PointRightWord(e)
	}))
	BufferKeymap.BindKey(Key{K: "<left>"}, MakeCommand(func(e *BufferView) {
		PointLeft(e, 1)
	}))
	BufferKeymap.BindKey(Key{K: "<left>", Control: true}, MakeCommand(func(e *BufferView) {
		PointLeftWord(e)
	}))

	BufferKeymap.BindKey(Key{K: "b", Control: true}, MakeCommand(func(e *BufferView) {
		PointLeft(e, 1)
	}))
	BufferKeymap.BindKey(Key{K: "<home>"}, MakeCommand(func(e *BufferView) {
		PointToBeginningOfLine(e)
	}))
	BufferKeymap.BindKey(Key{K: "<pagedown>"}, MakeCommand(func(e *BufferView) {
		ScrollDown(e, 1)
	}))
	BufferKeymap.BindKey(Key{K: "<pageup>"}, MakeCommand(func(e *BufferView) {
		ScrollUp(e, 1)
	}))
	BufferKeymap.BindKey(Key{K: "<enter>"}, MakeCommand(func(e *BufferView) {
		BufferInsertChar(e, '\n')
	}))
	BufferKeymap.BindKey(Key{K: "<backspace>", Control: true}, MakeCommand(func(e *BufferView) {
		DeleteWordBackward(e)
	}))
	BufferKeymap.BindKey(Key{K: "<backspace>"}, MakeCommand(func(e *BufferView) {
		DeleteCharBackward(e)
	}))
	BufferKeymap.BindKey(Key{K: "<backspace>", Shift: true}, MakeCommand(func(e *BufferView) {
		DeleteCharBackward(e)
	}))
	BufferKeymap.BindKey(Key{K: "d", Control: true}, MakeCommand(func(e *BufferView) {
		DeleteCharForward(e)
	}))
	BufferKeymap.BindKey(Key{K: "<delete>"}, MakeCommand(func(e *BufferView) {
		DeleteCharForward(e)
	}))
	BufferKeymap.BindKey(Key{K: "<tab>"}, MakeCommand(func(e *BufferView) { Indent(e) }))

	CompileKeymap.BindKey(Key{K: "<enter>"}, BufferOpenLocationInCurrentLine)

	GlobalKeymap.BindKey(Key{K: "\\", Alt: true}, func(c *Context) { VSplit(c) })
	GlobalKeymap.BindKey(Key{K: "=", Alt: true}, func(c *Context) { HSplit(c) })
	GlobalKeymap.BindKey(Key{K: ";", Control: true}, func(c *Context) { Compile(c) })
	GlobalKeymap.BindKey(Key{K: "q", Alt: true}, func(c *Context) { c.CloseWindow(c.ActiveWindowIndex) })
	GlobalKeymap.BindKey(Key{K: "q", Alt: true, Shift: true}, Exit)
	GlobalKeymap.BindKey(Key{K: "0", Control: true}, func(c *Context) { c.CloseWindow(c.ActiveWindowIndex) })
	GlobalKeymap.BindKey(Key{K: "1", Control: true}, func(c *Context) { c.BuildWindowToggleState() })
	GlobalKeymap.BindKey(Key{K: "k", Alt: true}, func(c *Context) { c.KillDrawable(c.ActiveDrawableID()) })
	GlobalKeymap.BindKey(Key{K: "t", Alt: true}, func(c *Context) { c.OpenThemesList() })
	GlobalKeymap.BindKey(Key{K: "o", Control: true}, func(c *Context) { c.OpenFileList() })
	GlobalKeymap.BindKey(Key{K: "b", Alt: true}, func(c *Context) { c.OpenBufferList() })
	GlobalKeymap.BindKey(Key{K: "<mouse-wheel-down>", Control: true}, func(c *Context) { c.DecreaseFontSize(2) })
	GlobalKeymap.BindKey(Key{K: "<mouse-wheel-up>", Control: true}, func(c *Context) { c.IncreaseFontSize(2) })
	GlobalKeymap.BindKey(Key{K: "=", Control: true}, func(c *Context) { c.IncreaseFontSize(2) })
	GlobalKeymap.BindKey(Key{K: "-", Control: true}, func(c *Context) { c.DecreaseFontSize(2) })
	GlobalKeymap.BindKey(Key{K: "w", Alt: true}, func(c *Context) { c.OtherWindow() })
	GlobalKeymap.BindKey(Key{K:"i", Control: true}, ToggleGlobalNoStatusbar)

	// Search
	SearchKeymap.BindKey(Key{K: "<enter>"}, MakeCommand(func(editor *BufferView) {
		SearchNextMatch(editor)
	}))
	SearchKeymap.BindKey(Key{K: "s", Control: true}, MakeCommand(func(editor *BufferView) {
		SearchNextMatch(editor)
	}))
	SearchKeymap.BindKey(Key{K: "r", Control: true}, MakeCommand(func(editor *BufferView) {
		SearchPreviousMatch(editor)
	}))
	SearchKeymap.BindKey(Key{K: "<enter>", Control: true}, MakeCommand(func(editor *BufferView) {
		SearchPreviousMatch(editor)
	}))
	SearchKeymap.BindKey(Key{K: "<esc>"}, MakeCommand(func(editor *BufferView) {
		SearchExit(editor)
	}))
	SearchKeymap.BindKey(Key{K: "<mouse-wheel-up>"}, MakeCommand(func(e *BufferView) {
		e.Search.MovedAwayFromCurrentMatch = true
		ScrollUp(e, 30)
	}))
	SearchKeymap.BindKey(Key{K: "<mouse-wheel-down>"}, MakeCommand(func(e *BufferView) {
		e.Search.MovedAwayFromCurrentMatch = true
		ScrollDown(e, 30)
	}))
	SearchKeymap.BindKey(Key{K: "<rmouse>-click"}, MakeCommand(func(editor *BufferView) {
		SearchNextMatch(editor)
	}))
	SearchKeymap.BindKey(Key{K: "<mmouse>-click"}, MakeCommand(func(editor *BufferView) {
		SearchPreviousMatch(editor)
	}))
	SearchKeymap.BindKey(Key{K: "<pagedown>"}, MakeCommand(func(e *BufferView) {
		e.Search.MovedAwayFromCurrentMatch = true
		ScrollDown(e, 1)
	}))
	SearchKeymap.BindKey(Key{K: "<pageup>"}, MakeCommand(func(e *BufferView) {
		e.Search.MovedAwayFromCurrentMatch = true
		ScrollUp(e, 1)
	}))

	// Query replace
	QueryReplaceKeymap.BindKey(Key{K: "r", Control: true}, MakeCommand(func(editor *BufferView) {
		QueryReplaceReplaceThisMatch(editor)
	}))

	QueryReplaceKeymap.BindKey(Key{K: "<enter>"}, MakeCommand(func(editor *BufferView) {
		QueryReplaceReplaceThisMatch(editor)
	}))
	QueryReplaceKeymap.BindKey(Key{K: "y"}, MakeCommand(func(editor *BufferView) {
		QueryReplaceReplaceThisMatch(editor)
	}))
	QueryReplaceKeymap.BindKey(Key{K: "<enter>", Control: true}, MakeCommand(func(editor *BufferView) {
		QueryReplaceIgnoreThisMatch(editor)
	}))
	QueryReplaceKeymap.BindKey(Key{K: "<esc>"}, MakeCommand(func(editor *BufferView) {
		QueryReplaceExit(editor)
	}))
	QueryReplaceKeymap.BindKey(Key{K: "<lmouse>-click"}, MakeCommand(func(e *BufferView) {
		e.moveCursorTo(rl.GetMousePosition())
	}))
	QueryReplaceKeymap.BindKey(Key{K: "<mouse-wheel-up>"}, MakeCommand(func(e *BufferView) {
		e.QueryReplace.MovedAwayFromCurrentMatch = true
		ScrollUp(e, 30)
	}))
	QueryReplaceKeymap.BindKey(Key{K: "<mouse-wheel-down>"}, MakeCommand(func(e *BufferView) {
		e.QueryReplace.MovedAwayFromCurrentMatch = true
		ScrollDown(e, 30)
	}))
	QueryReplaceKeymap.BindKey(Key{K: "<pagedown>"}, MakeCommand(func(e *BufferView) {
		e.QueryReplace.MovedAwayFromCurrentMatch = true
		ScrollDown(e, 1)
	}))
	QueryReplaceKeymap.BindKey(Key{K: "<pageup>"}, MakeCommand(func(e *BufferView) {
		e.QueryReplace.MovedAwayFromCurrentMatch = true
		ScrollUp(e, 1)
	}))

}