742 lines
22 KiB
GDScript
742 lines
22 KiB
GDScript
class_name KeyMap extends RefCounted
|
|
## Hanldes input stream and key mapping
|
|
##
|
|
## You may also set your keybindings in the [method map] function
|
|
|
|
|
|
## * SET YOUR KEYBINDINGS HERE *
|
|
## Also see the "COMMANDS" section at the bottom of cursor.gd
|
|
## E.g. the command for
|
|
## KeyRemap.new(...) .motion("foo", { "bar": 1 })
|
|
## is handled in Cursor::cmd_foo(args: Dictionary)
|
|
## where `args` is `{ "type": "foo", "bar": 1 }`
|
|
## Example:
|
|
## [codeblock]
|
|
## return [
|
|
## # Move 5 characters to the right with "L"
|
|
## KeyRemap.new([ "L" ])
|
|
## .motion("move_by_chars", { "move_by": 5 }),
|
|
##
|
|
## # Let's remove "d" (the delete operator) and replace it with "q"
|
|
## # You may additionally specify the type and context of the cmd to remove
|
|
## # using .operator() (or .motion() or .action() etc...) and .with_context()
|
|
## KeyRemap.new([ "d" ])
|
|
## .remove(),
|
|
## # "q" is now the new delete operator
|
|
## KeyRemap.new([ "q" ])
|
|
## .operator("delete"),
|
|
##
|
|
## # Delete this line along with the next two with "Z"
|
|
## # .operator() and .motion() automatically merge together
|
|
## KeyRemap.new([ "Z" ])
|
|
## .operator("delete")
|
|
## .motion("move_by_lines", { "move_by": 2, "line_wise": true }),
|
|
##
|
|
## # In Insert mode, return to Normal mode with "jk"
|
|
## KeyRemap.new([ "j", "k" ])
|
|
## .action("normal", { "backspaces": 1, "offset": 1 })
|
|
## .with_context(Mode.INSERT),
|
|
## ]
|
|
## [/codeblock]
|
|
static func map() -> Array[KeyRemap]:
|
|
# Example:
|
|
return [
|
|
# In Insert mode, return to Normal mode with "jk"
|
|
# KeyRemap.new([ "j", "k" ])
|
|
# .action("normal", { "backspaces": 1, "offset": 0 })
|
|
# .with_context(Mode.INSERT),
|
|
# Make "/" search in case insensitive mode
|
|
# KeyRemap.new([ "/" ])
|
|
# .action("command", { "command": "/(?i)" })
|
|
# .replace(),
|
|
# In Insert mode, return to Normal mode with "Ctrl-["
|
|
# KeyRemap.new([ "<C-[>" ])
|
|
# .action("normal")
|
|
# .with_context(Mode.INSERT),
|
|
]
|
|
|
|
|
|
const Constants = preload("res://addons/godot_vim/constants.gd")
|
|
const Mode = Constants.Mode
|
|
|
|
const INSERT_MODE_TIMEOUT_MS: int = 700
|
|
|
|
enum {
|
|
## Moves the cursor. Can be used in tandem with Operator
|
|
Motion,
|
|
## Operators (like delete, change, yank) work on selections
|
|
## In Normal mode, they need a Motion or another Operator bound to them (e.g. dj, yy)
|
|
Operator,
|
|
## Operator but with a motion already bound to it
|
|
## Can only be executed in Normal mode
|
|
OperatorMotion,
|
|
## A single action (e.g. i, o, v, J, u)
|
|
## Cannot be executed in Visual mode unless specified with "context": Mode.VISUAL
|
|
Action,
|
|
Incomplete, ## Incomplete command
|
|
NotFound, ## Command not found
|
|
}
|
|
|
|
#region key_map
|
|
|
|
# Also see the "COMMANDS" section at the bottom of cursor.gd
|
|
# Command for { "type": "foo", ... } is handled in Cursor::cmd_foo(args: Dictionary)
|
|
# where `args` is ^^^^^ this Dict ^^^^^^
|
|
var key_map: Array[Dictionary] = [
|
|
# MOTIONS
|
|
{"keys": ["h"], "type": Motion, "motion": {"type": "move_by_chars", "move_by": -1}},
|
|
{"keys": ["l"], "type": Motion, "motion": {"type": "move_by_chars", "move_by": 1}},
|
|
{
|
|
"keys": ["j"],
|
|
"type": Motion,
|
|
"motion": {"type": "move_by_lines", "move_by": 1, "line_wise": true}
|
|
},
|
|
{
|
|
"keys": ["k"],
|
|
"type": Motion,
|
|
"motion": {"type": "move_by_lines", "move_by": -1, "line_wise": true}
|
|
},
|
|
# About motions: the argument `inclusive` is used with Operators (see execute_operator_motion())
|
|
{
|
|
"keys": ["w"],
|
|
"type": Motion,
|
|
"motion": {"type": "move_by_word", "forward": true, "word_end": false}
|
|
},
|
|
{
|
|
"keys": ["e"],
|
|
"type": Motion,
|
|
"motion": {"type": "move_by_word", "forward": true, "word_end": true, "inclusive": true}
|
|
},
|
|
{
|
|
"keys": ["b"],
|
|
"type": Motion,
|
|
"motion": {"type": "move_by_word", "forward": false, "word_end": false}
|
|
},
|
|
{
|
|
"keys": ["g", "e"],
|
|
"type": Motion,
|
|
"motion": {"type": "move_by_word", "forward": false, "word_end": true}
|
|
},
|
|
{
|
|
"keys": ["W"],
|
|
"type": Motion,
|
|
"motion": {"type": "move_by_word", "forward": true, "word_end": false, "big_word": true}
|
|
},
|
|
{
|
|
"keys": ["E"],
|
|
"type": Motion,
|
|
"motion":
|
|
{
|
|
"type": "move_by_word",
|
|
"forward": true,
|
|
"word_end": true,
|
|
"big_word": true,
|
|
"inclusive": true
|
|
}
|
|
},
|
|
{
|
|
"keys": ["B"],
|
|
"type": Motion,
|
|
"motion": {"type": "move_by_word", "forward": false, "word_end": false, "big_word": true}
|
|
},
|
|
{
|
|
"keys": ["g", "E"],
|
|
"type": Motion,
|
|
"motion": {"type": "move_by_word", "forward": false, "word_end": true, "big_word": true}
|
|
},
|
|
# Find & search
|
|
{
|
|
"keys": ["f", "{char}"],
|
|
"type": Motion,
|
|
"motion": {"type": "find_in_line", "forward": true, "inclusive": true}
|
|
},
|
|
{
|
|
"keys": ["t", "{char}"],
|
|
"type": Motion,
|
|
"motion": {"type": "find_in_line", "forward": true, "stop_before": true, "inclusive": true}
|
|
},
|
|
{"keys": ["F", "{char}"], "type": Motion, "motion": {"type": "find_in_line", "forward": false}},
|
|
{
|
|
"keys": ["T", "{char}"],
|
|
"type": Motion,
|
|
"motion": {"type": "find_in_line", "forward": false, "stop_before": true}
|
|
},
|
|
{"keys": [";"], "type": Motion, "motion": {"type": "find_in_line_again", "invert": false}},
|
|
{"keys": [","], "type": Motion, "motion": {"type": "find_in_line_again", "invert": true}},
|
|
{"keys": ["n"], "type": Motion, "motion": {"type": "find_again", "forward": true}},
|
|
{"keys": ["N"], "type": Motion, "motion": {"type": "find_again", "forward": false}},
|
|
{"keys": ["0"], "type": Motion, "motion": {"type": "move_to_bol"}},
|
|
{"keys": ["$"], "type": Motion, "motion": {"type": "move_to_eol"}},
|
|
{"keys": ["^"], "type": Motion, "motion": {"type": "move_to_first_non_whitespace_char"}},
|
|
{
|
|
"keys": ["{"],
|
|
"type": Motion,
|
|
"motion": {"type": "move_by_paragraph", "forward": false, "line_wise": true}
|
|
},
|
|
{
|
|
"keys": ["}"],
|
|
"type": Motion,
|
|
"motion": {"type": "move_by_paragraph", "forward": true, "line_wise": true}
|
|
},
|
|
{
|
|
"keys": ["[", "["],
|
|
"type": Motion,
|
|
"motion": {"type": "move_by_section", "forward": false, "line_wise": true}
|
|
},
|
|
{
|
|
"keys": ["]", "]"],
|
|
"type": Motion,
|
|
"motion": {"type": "move_by_section", "forward": true, "line_wise": true}
|
|
},
|
|
{"keys": ["g", "g"], "type": Motion, "motion": {"type": "move_to_bof", "line_wise": true}},
|
|
{"keys": ["G"], "type": Motion, "motion": {"type": "move_to_eof", "line_wise": true}},
|
|
{"keys": ["g", "m"], "type": Motion, "motion": {"type": "move_to_center_of_line"}},
|
|
{
|
|
"keys": ["<C-u>"],
|
|
"type": Motion,
|
|
"motion": {"type": "move_by_screen", "percentage": -0.5, "line_wise": true}
|
|
},
|
|
{
|
|
"keys": ["<C-d>"],
|
|
"type": Motion,
|
|
"motion": {"type": "move_by_screen", "percentage": 0.5, "line_wise": true}
|
|
},
|
|
{"keys": ["%"], "type": Motion, "motion": {"type": "jump_to_next_brace_pair"}},
|
|
# TEXT OBJECTS
|
|
{
|
|
"keys": ["a", "w"],
|
|
"type": Motion,
|
|
"motion": {"type": "text_object_word", "around": true, "inclusive": true}
|
|
},
|
|
{
|
|
"keys": ["a", "W"],
|
|
"type": Motion,
|
|
"motion": {"type": "text_object_word", "around": true, "inclusive": true}
|
|
},
|
|
{"keys": ["i", "w"], "type": Motion, "motion": {"type": "text_object_word", "inclusive": true}},
|
|
{
|
|
"keys": ["i", "W"],
|
|
"type": Motion,
|
|
"motion": {"type": "text_object_word", "big_word": true, "inclusive": true}
|
|
},
|
|
{
|
|
"keys": ["i", "p"],
|
|
"type": Motion,
|
|
"motion": {"type": "text_object_paragraph", "line_wise": true}
|
|
},
|
|
{
|
|
"keys": ["a", "p"],
|
|
"type": Motion,
|
|
"motion": {"type": "text_object_paragraph", "around": true, "line_wise": true}
|
|
},
|
|
{
|
|
"keys": ["i", '"'],
|
|
"type": Motion,
|
|
"motion": {"type": "text_object", "object": '"', "inclusive": true, "inline": true}
|
|
},
|
|
{
|
|
"keys": ["a", '"'],
|
|
"type": Motion,
|
|
"motion":
|
|
{"type": "text_object", "object": '"', "around": true, "inclusive": true, "inline": true}
|
|
},
|
|
{
|
|
"keys": ["i", "'"],
|
|
"type": Motion,
|
|
"motion": {"type": "text_object", "object": "'", "inclusive": true, "inline": true}
|
|
},
|
|
{
|
|
"keys": ["a", "'"],
|
|
"type": Motion,
|
|
"motion":
|
|
{"type": "text_object", "object": "'", "around": true, "inclusive": true, "inline": true}
|
|
},
|
|
{
|
|
"keys": ["i", "`"],
|
|
"type": Motion,
|
|
"motion": {"type": "text_object", "object": "`", "inclusive": true, "inline": true}
|
|
},
|
|
{
|
|
"keys": ["a", "`"],
|
|
"type": Motion,
|
|
"motion":
|
|
{"type": "text_object", "object": "`", "around": true, "inclusive": true, "inline": true}
|
|
},
|
|
# "i" + any of "(", ")", or "b"
|
|
{
|
|
"keys": ["i", ["(", ")", "b"]],
|
|
"type": Motion,
|
|
"motion": {"type": "text_object", "object": "(", "inclusive": true}
|
|
},
|
|
{
|
|
"keys": ["a", ["(", ")", "b"]],
|
|
"type": Motion,
|
|
"motion": {"type": "text_object", "object": "(", "around": true, "inclusive": true}
|
|
},
|
|
{
|
|
"keys": ["i", ["[", "]"]],
|
|
"type": Motion,
|
|
"motion": {"type": "text_object", "object": "[", "inclusive": true}
|
|
},
|
|
{
|
|
"keys": ["a", ["[", "]"]],
|
|
"type": Motion,
|
|
"motion": {"type": "text_object", "object": "[", "around": true, "inclusive": true}
|
|
},
|
|
{
|
|
"keys": ["i", ["{", "}", "B"]],
|
|
"type": Motion,
|
|
"motion": {"type": "text_object", "object": "{", "inclusive": true}
|
|
},
|
|
{
|
|
"keys": ["a", ["{", "}", "B"]],
|
|
"type": Motion,
|
|
"motion": {"type": "text_object", "object": "{", "around": true, "inclusive": true}
|
|
},
|
|
# OPERATORS
|
|
{"keys": ["d"], "type": Operator, "operator": {"type": "delete"}},
|
|
{
|
|
"keys": ["D"],
|
|
"type": OperatorMotion,
|
|
"operator": {"type": "delete"},
|
|
"motion": {"type": "move_to_eol"}
|
|
},
|
|
{
|
|
"keys": ["x"],
|
|
"type": OperatorMotion,
|
|
"operator": {"type": "delete"},
|
|
"motion": {"type": "move_by_chars", "move_by": 1}
|
|
},
|
|
{"keys": ["x"], "type": Operator, "context": Mode.VISUAL, "operator": {"type": "delete"}},
|
|
{"keys": ["y"], "type": Operator, "operator": {"type": "yank"}},
|
|
{
|
|
"keys": ["Y"],
|
|
"type": OperatorMotion,
|
|
"operator": {"type": "yank", "line_wise": true}, # No motion. Same as yy
|
|
},
|
|
{"keys": ["c"], "type": Operator, "operator": {"type": "change"}},
|
|
{
|
|
"keys": ["C"],
|
|
"type": OperatorMotion,
|
|
"operator": {"type": "change"},
|
|
"motion": {"type": "move_to_eol"}
|
|
},
|
|
{
|
|
"keys": ["s"],
|
|
"type": OperatorMotion,
|
|
"operator": {"type": "change"},
|
|
"motion": {"type": "move_by_chars", "move_by": 1}
|
|
},
|
|
{"keys": ["s"], "type": Operator, "context": Mode.VISUAL, "operator": {"type": "change"}},
|
|
{
|
|
"keys": ["p"],
|
|
"type": OperatorMotion,
|
|
"operator": {"type": "paste"},
|
|
"motion": {"type": "move_by_chars", "move_by": 1}
|
|
},
|
|
{"keys": ["p"], "type": Operator, "context": Mode.VISUAL, "operator": {"type": "paste"}},
|
|
{"keys": ["p"], "type": Operator, "context": Mode.VISUAL_LINE, "operator": {"type": "paste"}},
|
|
{"keys": [">"], "type": Operator, "operator": {"type": "indent", "forward": true}},
|
|
{"keys": ["<"], "type": Operator, "operator": {"type": "indent", "forward": false}},
|
|
{
|
|
"keys": ["g", "c", "c"],
|
|
"type": OperatorMotion,
|
|
"operator": {"type": "comment"},
|
|
"motion": {"type": "move_by_chars", "move_by": 1}
|
|
},
|
|
{"keys": ["g", "c"], "type": Operator, "operator": {"type": "comment"}},
|
|
{
|
|
"keys": ["~"],
|
|
"type": OperatorMotion,
|
|
"operator": {"type": "toggle_uppercase"},
|
|
"motion": {"type": "move_by_chars", "move_by": 1}
|
|
},
|
|
{
|
|
"keys": ["~"],
|
|
"type": Operator,
|
|
"context": Mode.VISUAL,
|
|
"operator": {"type": "toggle_uppercase"}
|
|
},
|
|
{
|
|
"keys": ["u"],
|
|
"type": Operator,
|
|
"context": Mode.VISUAL,
|
|
"operator": {"type": "set_uppercase", "uppercase": false}
|
|
},
|
|
{
|
|
"keys": ["U"],
|
|
"type": Operator,
|
|
"context": Mode.VISUAL,
|
|
"operator": {"type": "set_uppercase", "uppercase": true}
|
|
},
|
|
{
|
|
"keys": ["V"],
|
|
"type": Operator,
|
|
"context": Mode.VISUAL,
|
|
"operator": {"type": "visual", "line_wise": true}
|
|
},
|
|
{
|
|
"keys": ["v"],
|
|
"type": Operator,
|
|
"context": Mode.VISUAL_LINE,
|
|
"operator": {"type": "visual", "line_wise": false}
|
|
},
|
|
# ACTIONS
|
|
{"keys": ["i"], "type": Action, "action": {"type": "insert"}},
|
|
{"keys": ["a"], "type": Action, "action": {"type": "insert", "offset": "after"}},
|
|
{"keys": ["I"], "type": Action, "action": {"type": "insert", "offset": "bol"}},
|
|
{"keys": ["A"], "type": Action, "action": {"type": "insert", "offset": "eol"}},
|
|
{"keys": ["o"], "type": Action, "action": {"type": "insert", "offset": "new_line_below"}},
|
|
{"keys": ["O"], "type": Action, "action": {"type": "insert", "offset": "new_line_above"}},
|
|
{"keys": ["v"], "type": Action, "action": {"type": "visual"}},
|
|
{"keys": ["V"], "type": Action, "action": {"type": "visual", "line_wise": true}},
|
|
{"keys": ["u"], "type": Action, "action": {"type": "undo"}},
|
|
{"keys": ["<C-r>"], "type": Action, "action": {"type": "redo"}},
|
|
{"keys": ["r", "{char}"], "type": Action, "action": {"type": "replace"}},
|
|
{"keys": [":"], "type": Action, "action": {"type": "command"}},
|
|
{"keys": ["/"], "type": Action, "action": {"type": "command", "command": "/"}},
|
|
{"keys": ["J"], "type": Action, "action": {"type": "join"}},
|
|
{"keys": ["z", "z"], "type": Action, "action": {"type": "center_caret"}},
|
|
{"keys": ["m", "{char}"], "type": Action, "action": {"type": "mark"}},
|
|
{"keys": ["`", "{char}"], "type": Action, "action": {"type": "jump_to_mark"}},
|
|
# MISCELLANEOUS
|
|
{
|
|
"keys": ["o"],
|
|
"type": Operator,
|
|
"context": Mode.VISUAL,
|
|
"operator": {"type": "visual_jump_to_other_end"}
|
|
},
|
|
{
|
|
"keys": ["o"],
|
|
"type": Operator,
|
|
"context": Mode.VISUAL_LINE,
|
|
"operator": {"type": "visual_jump_to_other_end"}
|
|
},
|
|
]
|
|
|
|
#endregion key_map
|
|
|
|
# Keys we won't handle
|
|
const BLACKLIST: Array[String] = [
|
|
"<C-s>", # Save
|
|
"<C-b>", # Bookmark
|
|
]
|
|
|
|
enum KeyMatch {
|
|
None = 0, # Keys don't match
|
|
Partial = 1, # Keys match partially
|
|
Full = 2, # Keys match totally
|
|
}
|
|
|
|
var input_stream: Array[String] = []
|
|
var cursor: Control
|
|
var last_insert_mode_input_ms: int = 0
|
|
|
|
|
|
func _init(cursor_: Control):
|
|
cursor = cursor_
|
|
apply_remaps(KeyMap.map())
|
|
|
|
|
|
## Returns: Dictionary with the found command: { "type": Motion or Operator or OperatorMotion or Action or Incomplete or NotFound, ... }
|
|
## Warning: the returned Dict can be empty in if the event wasn't processed
|
|
func register_event(event: InputEventKey, with_context: Mode) -> Dictionary:
|
|
# Stringify event
|
|
var ch: String = event_to_string(event)
|
|
if ch.is_empty():
|
|
return {} # Invalid
|
|
if BLACKLIST.has(ch):
|
|
return {}
|
|
|
|
# Handle Insert mode timeout
|
|
if with_context == Mode.INSERT:
|
|
if handle_insert_mode_timeout():
|
|
clear()
|
|
return {}
|
|
|
|
# Process input stream
|
|
# print("[KeyMap::register_event()] ch = ", ch) # DEBUG
|
|
input_stream.append(ch)
|
|
var cmd: Dictionary = parse_keys(input_stream, with_context)
|
|
if !is_cmd_valid(cmd):
|
|
return {"type": NotFound}
|
|
|
|
execute(cmd)
|
|
return cmd
|
|
|
|
|
|
func parse_keys(keys: Array[String], with_context: Mode) -> Dictionary:
|
|
var blacklist: Array = get_blacklist_types_in_context(with_context)
|
|
var cmd: Dictionary = find_cmd(keys, with_context, blacklist)
|
|
if cmd.is_empty() or cmd.type == NotFound:
|
|
call_deferred(&"clear")
|
|
return cmd
|
|
if cmd.type == Incomplete:
|
|
# print(cmd)
|
|
return cmd
|
|
|
|
# Execute the operation as-is if in VISUAL mode
|
|
# If in NORMAL mode, await further input
|
|
if cmd.type == Operator and with_context == Mode.NORMAL:
|
|
var op_args: Array[String] = keys.slice(cmd.keys.size()) # Get the rest of keys for motion
|
|
if op_args.is_empty(): # Incomplete; await further input
|
|
return {"type": Incomplete}
|
|
|
|
var next: Dictionary = find_cmd(op_args, with_context, [Action, OperatorMotion])
|
|
|
|
if next.is_empty() or next.type == NotFound: # Invalid sequence
|
|
call_deferred(&"clear")
|
|
return {"type": NotFound}
|
|
elif next.type == Incomplete:
|
|
return {"type": Incomplete}
|
|
|
|
cmd.modifier = next
|
|
|
|
call_deferred(&"clear")
|
|
return cmd
|
|
|
|
|
|
## The returned cmd will always have a 'type' key
|
|
# TODO use bitmask instead of Array?
|
|
func find_cmd(keys: Array[String], with_context: Mode, blacklist: Array = []) -> Dictionary:
|
|
var partial: bool = false # In case none were found
|
|
var is_visual: bool = with_context == Mode.VISUAL or with_context == Mode.VISUAL_LINE
|
|
|
|
for cmd in key_map:
|
|
# FILTERS
|
|
# Don't allow anything in Insert mode unless specified
|
|
if with_context == Mode.INSERT and cmd.get("context", -1) != Mode.INSERT:
|
|
continue
|
|
|
|
if blacklist.has(cmd.type):
|
|
continue
|
|
|
|
# Skip if contexts don't match
|
|
if cmd.has("context") and with_context != cmd.context:
|
|
continue
|
|
|
|
# CHECK KEYS
|
|
var m: KeyMatch = match_keys(cmd.keys, keys)
|
|
partial = partial or m == KeyMatch.Partial # Set/keep partial = true if it was a partial match
|
|
|
|
if m != KeyMatch.Full:
|
|
continue
|
|
|
|
var cmd_mut: Dictionary = cmd.duplicate(true) # 'mut' ('mutable') because key_map is read-only
|
|
# Keep track of selected character, which will later be copied into the fucntion call for the command
|
|
# (See execute() where we check if cmd.has('selected_char'))
|
|
if cmd.keys[-1] is String and cmd.keys[-1] == "{char}":
|
|
cmd_mut.selected_char = keys.back()
|
|
return cmd_mut
|
|
|
|
return {"type": Incomplete if partial else NotFound}
|
|
|
|
|
|
# TODO use bitmask instead of Array?
|
|
func get_blacklist_types_in_context(context: Mode) -> Array:
|
|
match context:
|
|
Mode.VISUAL, Mode.VISUAL_LINE:
|
|
return [OperatorMotion, Action]
|
|
_:
|
|
return []
|
|
|
|
|
|
func execute_operator_motion(cmd: Dictionary):
|
|
if cmd.has("motion"):
|
|
if cmd.has("selected_char"):
|
|
cmd.motion.selected_char = cmd.selected_char
|
|
operator_motion(cmd.operator, cmd.motion)
|
|
else:
|
|
call_cmd(cmd.operator)
|
|
|
|
|
|
func execute_operator(cmd: Dictionary):
|
|
# print("[KeyMay::execute()] op: ", cmd) # DEBUG
|
|
if !cmd.has("modifier"): # Execute as-is
|
|
call_cmd(cmd.operator)
|
|
return
|
|
|
|
var mod: Dictionary = cmd.modifier
|
|
# Execute with motion
|
|
if mod.type == Motion:
|
|
if mod.has("selected_char"):
|
|
mod.motion.selected_char = mod.selected_char
|
|
operator_motion(cmd.operator, mod.motion)
|
|
|
|
# Execute with `line_wise = true` if repeating operations (e.g. dd, yy)
|
|
elif mod.type == Operator and mod.operator.type == cmd.operator.type:
|
|
var op_cmd: Dictionary = cmd.operator.duplicate()
|
|
op_cmd.line_wise = true
|
|
call_cmd(op_cmd)
|
|
|
|
|
|
func execute_action(cmd: Dictionary):
|
|
if cmd.has("selected_char"):
|
|
cmd.action.selected_char = cmd.selected_char
|
|
call_cmd(cmd.action)
|
|
|
|
|
|
func execute_motion(cmd: Dictionary):
|
|
if cmd.has("selected_char"):
|
|
cmd.motion.selected_char = cmd.selected_char
|
|
var pos = call_cmd(cmd.motion) # Vector2i for normal motion, or [Vector2i, Vector2i] for text object
|
|
|
|
if pos is Vector2i:
|
|
cursor.set_caret_pos(pos.y, pos.x)
|
|
elif pos is Array:
|
|
assert(pos.size() == 2)
|
|
# print("[execute_motion() -> text obj] pos = ", pos)
|
|
cursor.select(pos[0].y, pos[0].x, pos[1].y, pos[1].x)
|
|
|
|
|
|
func execute(cmd: Dictionary):
|
|
if !is_cmd_valid(cmd):
|
|
return
|
|
|
|
match cmd.type:
|
|
Motion:
|
|
execute_motion(cmd)
|
|
OperatorMotion:
|
|
execute_operator_motion(cmd)
|
|
Operator:
|
|
execute_operator(cmd)
|
|
Action:
|
|
execute_action(cmd)
|
|
_:
|
|
push_error("[KeyMap::execute()] Unknown command type: %s" % cmd.type)
|
|
|
|
|
|
func operator_motion(operator: Dictionary, motion: Dictionary):
|
|
# print("[KeyMay::execute_operator_motion()] op = ", operator, ", motion = ", motion) # DEBUG
|
|
|
|
# Execute motion before operation
|
|
var p = call_cmd(motion) # Vector2i for normal motion, or [Vector2i, Vector2i] for text object
|
|
if p is Vector2i:
|
|
var p0: Vector2i = cursor.get_caret_pos()
|
|
if motion.get("inclusive", false):
|
|
p.x += 1
|
|
cursor.code_edit.select(p0.y, p0.x, p.y, p.x)
|
|
elif p is Array:
|
|
assert(p.size() == 2)
|
|
if motion.get("inclusive", false):
|
|
p[1].x += 1
|
|
cursor.code_edit.select(p[0].y, p[0].x, p[1].y, p[1].x)
|
|
|
|
# Add line_wise flag if line wise motion
|
|
var op: Dictionary = operator.duplicate()
|
|
op.line_wise = motion.get("line_wise", false)
|
|
call_cmd(op)
|
|
|
|
|
|
## Unsafe: does not check if the function exists
|
|
func call_cmd(cmd: Dictionary) -> Variant:
|
|
var func_name: StringName = StringName("cmd_" + cmd.type)
|
|
return cursor.call(func_name, cmd)
|
|
|
|
|
|
static func is_cmd_valid(cmd: Dictionary):
|
|
return !cmd.is_empty() and cmd.type != Incomplete and cmd.type != NotFound
|
|
|
|
|
|
static func event_to_string(event: InputEventKey) -> String:
|
|
# Special chars
|
|
if event.keycode == KEY_ENTER:
|
|
return "<CR>"
|
|
if event.keycode == KEY_TAB:
|
|
return "<TAB>"
|
|
if event.keycode == KEY_ESCAPE:
|
|
return "<ESC>"
|
|
|
|
# Ctrl + key
|
|
if event.is_command_or_control_pressed():
|
|
if !OS.is_keycode_unicode(event.keycode):
|
|
return ""
|
|
var c: String = char(event.keycode)
|
|
return "<C-%s>" % [c if event.shift_pressed else c.to_lower()]
|
|
|
|
# You're not special.
|
|
return char(event.unicode)
|
|
|
|
|
|
## Matches single command keys
|
|
## expected_keys: Array[key: String] or Array[any_of_these_keys: Array[key: String]]
|
|
static func match_keys(expected_keys: Array, input_keys: Array) -> KeyMatch:
|
|
var in_size: int = input_keys.size()
|
|
var ex_size: int = expected_keys.size()
|
|
|
|
if expected_keys[-1] is String and expected_keys[-1] == "{char}":
|
|
# If everything + {char} matches
|
|
if _do_keys_match(input_keys.slice(0, -1), expected_keys.slice(0, -1)):
|
|
return KeyMatch.Full
|
|
|
|
# If everything up until {char} matches
|
|
elif _do_keys_match(input_keys, expected_keys.slice(0, in_size)):
|
|
return KeyMatch.Partial
|
|
|
|
else:
|
|
# Check for full match
|
|
if _do_keys_match(input_keys, expected_keys):
|
|
return KeyMatch.Full
|
|
# Check for incomplete command (e.g. "ge", "gcc")
|
|
elif _do_keys_match(input_keys, expected_keys.slice(0, in_size)):
|
|
return KeyMatch.Partial
|
|
# Cases with operators like "dj", "ce"
|
|
elif _do_keys_match(input_keys.slice(0, ex_size), expected_keys) and in_size > ex_size:
|
|
return KeyMatch.Full
|
|
|
|
return KeyMatch.None
|
|
|
|
|
|
## input_keys: Array[key: String]
|
|
## expected_keys: Array[key: String] or Array[any_of_these_keys: Array[key: String]]
|
|
static func _do_keys_match(input_keys: Array, match_keys: Array) -> bool:
|
|
if match_keys.size() != input_keys.size():
|
|
return false
|
|
|
|
for i in input_keys.size():
|
|
var key: String = input_keys[i]
|
|
if match_keys[i] is String:
|
|
if !match_keys[i] == key:
|
|
return false
|
|
elif match_keys[i] is Array:
|
|
if !match_keys[i].has(key):
|
|
return false
|
|
else:
|
|
push_error("expected String or Array[String], found ", match_keys[i])
|
|
return false
|
|
|
|
return true
|
|
|
|
|
|
## Clears the input stream
|
|
func clear():
|
|
input_stream = []
|
|
|
|
|
|
func get_input_stream_as_string() -> String:
|
|
return "".join(PackedStringArray(input_stream))
|
|
|
|
|
|
## Returns whether the Insert mode input has timed out, in which case we
|
|
## don't want to process it
|
|
func handle_insert_mode_timeout() -> bool:
|
|
var current_tick_ms: int = Time.get_ticks_msec()
|
|
|
|
if input_stream.is_empty():
|
|
last_insert_mode_input_ms = current_tick_ms
|
|
return false
|
|
|
|
if current_tick_ms - last_insert_mode_input_ms > INSERT_MODE_TIMEOUT_MS:
|
|
last_insert_mode_input_ms = current_tick_ms
|
|
return true
|
|
last_insert_mode_input_ms = current_tick_ms
|
|
return false
|
|
|
|
|
|
func apply_remaps(map: Array[KeyRemap]):
|
|
if map.is_empty():
|
|
return
|
|
print("[Godot VIM] Applying keybind remaps...")
|
|
for remap in map:
|
|
remap.apply(key_map)
|