diff options
| -rw-r--r-- | CHANGELOG.md | 4 | ||||
| -rw-r--r-- | man/man1/fzf.1 | 6 | ||||
| -rw-r--r-- | src/options.go | 162 | ||||
| -rw-r--r-- | src/options_test.go | 121 | ||||
| -rw-r--r-- | src/terminal.go | 177 | ||||
| -rw-r--r-- | src/tui/light.go | 43 | ||||
| -rw-r--r-- | src/tui/tcell.go | 71 | ||||
| -rw-r--r-- | src/tui/tui.go | 50 |
8 files changed, 323 insertions, 311 deletions
diff --git a/CHANGELOG.md b/CHANGELOG.md index b02dcbe4..77296b09 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -26,6 +26,10 @@ CHANGELOG - Added `last` action to move the cursor to the last match - The opposite action `top` is renamed to `first`, but `top` is still recognized as a synonym for backward compatibility +- Extended support for alt key chords: alt with any case-sensitive single character + ```sh + fzf --bind alt-,:first,alt-.:last + ``` 0.24.4 ------ diff --git a/man/man1/fzf.1 b/man/man1/fzf.1 index b6ae8a62..f0161cd9 100644 --- a/man/man1/fzf.1 +++ b/man/man1/fzf.1 @@ -666,9 +666,7 @@ e.g. .br \fIctrl-alt-[a-z]\fR .br -\fIalt-[a-z]\fR -.br -\fIalt-[0-9]\fR +\fIalt-[*]\fR (Any case-sensitive single character is allowed) .br \fIf[1-12]\fR .br @@ -692,8 +690,6 @@ e.g. .br \fIalt-bspace\fR (\fIalt-bs\fR) .br -\fIalt-/\fR -.br \fItab\fR .br \fIbtab\fR (\fIshift-tab\fR) diff --git a/src/options.go b/src/options.go index 5eff033f..c33f14ce 100644 --- a/src/options.go +++ b/src/options.go @@ -7,7 +7,6 @@ import ( "strconv" "strings" "unicode" - "unicode/utf8" "github.com/junegunn/fzf/src/algo" "github.com/junegunn/fzf/src/tui" @@ -211,8 +210,8 @@ type Options struct { Exit0 bool Filter *string ToggleSort bool - Expect map[int]string - Keymap map[int][]action + Expect map[tui.Event]string + Keymap map[tui.Event][]action Preview previewOpts PrintQuery bool ReadZero bool @@ -272,8 +271,8 @@ func defaultOptions() *Options { Exit0: false, Filter: nil, ToggleSort: false, - Expect: make(map[int]string), - Keymap: make(map[int][]action), + Expect: make(map[tui.Event]string), + Keymap: make(map[tui.Event][]action), Preview: defaultPreviewOpts(""), PrintQuery: false, ReadZero: false, @@ -445,7 +444,7 @@ func parseBorder(str string, optional bool) tui.BorderShape { return tui.BorderNone } -func parseKeyChords(str string, message string) map[int]string { +func parseKeyChords(str string, message string) map[tui.Event]string { if len(str) == 0 { errorExit(message) } @@ -455,124 +454,129 @@ func parseKeyChords(str string, message string) map[int]string { tokens = append(tokens, ",") } - chords := make(map[int]string) + chords := make(map[tui.Event]string) for _, key := range tokens { if len(key) == 0 { continue // ignore } lkey := strings.ToLower(key) - chord := 0 + add := func(e tui.EventType) { + chords[e.AsEvent()] = key + } switch lkey { case "up": - chord = tui.Up + add(tui.Up) case "down": - chord = tui.Down + add(tui.Down) case "left": - chord = tui.Left + add(tui.Left) case "right": - chord = tui.Right + add(tui.Right) case "enter", "return": - chord = tui.CtrlM + add(tui.CtrlM) case "space": - chord = tui.AltZ + int(' ') + chords[tui.Key(' ')] = key case "bspace", "bs": - chord = tui.BSpace + add(tui.BSpace) case "ctrl-space": - chord = tui.CtrlSpace + add(tui.CtrlSpace) case "ctrl-^", "ctrl-6": - chord = tui.CtrlCaret + add(tui.CtrlCaret) case "ctrl-/", "ctrl-_": - chord = tui.CtrlSlash + add(tui.CtrlSlash) case "ctrl-\\": - chord = tui.CtrlBackSlash + add(tui.CtrlBackSlash) case "ctrl-]": - chord = tui.CtrlRightBracket + add(tui.CtrlRightBracket) case "change": - chord = tui.Change + add(tui.Change) case "backward-eof": - chord = tui.BackwardEOF + add(tui.BackwardEOF) case "alt-enter", "alt-return": - chord = tui.CtrlAltM + chords[tui.CtrlAltKey('m')] = key case "alt-space": - chord = tui.AltSpace - case "alt-/": - chord = tui.AltSlash + chords[tui.AltKey(' ')] = key case "alt-bs", "alt-bspace": - chord = tui.AltBS + add(tui.AltBS) case "alt-up": - chord = tui.AltUp + add(tui.AltUp) case "alt-down": - chord = tui.AltDown + add(tui.AltDown) case "alt-left": - chord = tui.AltLeft + add(tui.AltLeft) case "alt-right": - chord = tui.AltRight + add(tui.AltRight) case "tab": - chord = tui.Tab + add(tui.Tab) case "btab", "shift-tab": - chord = tui.BTab + add(tui.BTab) case "esc": - chord = tui.ESC + add(tui.ESC) case "del": - chord = tui.Del + add(tui.Del) case "home": - chord = tui.Home + add(tui.Home) case "end": - chord = tui.End + add(tui.End) case "insert": - chord = tui.Insert + add(tui.Insert) case "pgup", "page-up": - chord = tui.PgUp + add(tui.PgUp) case "pgdn", "page-down": - chord = tui.PgDn + add(tui.PgDn) case "alt-shift-up", "shift-alt-up": - chord = tui.AltSUp + add(tui.AltSUp) case "alt-shift-down", "shift-alt-down": - chord = tui.AltSDown + add(tui.AltSDown) case "alt-shift-left", "shift-alt-left": - chord = tui.AltSLeft + add(tui.AltSLeft) case "alt-shift-right", "shift-alt-right": - chord = tui.AltSRight + add(tui.AltSRight) case "shift-up": - chord = tui.SUp + add(tui.SUp) case "shift-down": - chord = tui.SDown + add(tui.SDown) case "shift-left": - chord = tui.SLeft + add(tui.SLeft) case "shift-right": - chord = tui.SRight + add(tui.SRight) case "left-click": - chord = tui.LeftClick + add(tui.LeftClick) case "right-click": - chord = tui.RightClick + add(tui.RightClick) case "double-click": - chord = tui.DoubleClick + add(tui.DoubleClick) case "f10": - chord = tui.F10 + add(tui.F10) case "f11": - chord = tui.F11 + add(tui.F11) case "f12": - chord = tui.F12 + add(tui.F12) default: + runes := []rune(key) if len(key) == 10 && strings.HasPrefix(lkey, "ctrl-alt-") && isAlphabet(lkey[9]) { - chord = tui.CtrlAltA + int(lkey[9]) - 'a' + chords[tui.CtrlAltKey(rune(key[9]))] = key } else if len(key) == 6 && strings.HasPrefix(lkey, "ctrl-") && isAlphabet(lkey[5]) { - chord = tui.CtrlA + int(lkey[5]) - 'a' - } else if len(key) == 5 && strings.HasPrefix(lkey, "alt-") && isAlphabet(lkey[4]) { - chord = tui.AltA + int(lkey[4]) - 'a' - } else if len(key) == 5 && strings.HasPrefix(lkey, "alt-") && isNumeric(lkey[4]) { - chord = tui.Alt0 + int(lkey[4]) - '0' + add(tui.EventType(tui.CtrlA.Int() + int(lkey[5]) - 'a')) + } else if len(runes) == 5 && strings.HasPrefix(lkey, "alt-") { + r := runes[4] + switch r { + case escapedColon: + r = ':' + case escapedComma: + r = ',' + case escapedPlus: + r = '+' + } + chords[tui.AltKey(r)] = key } else if len(key) == 2 && strings.HasPrefix(lkey, "f") && key[1] >= '1' && key[1] <= '9' { - chord = tui.F1 + int(key[1]) - '1' - } else if utf8.RuneCountInString(key) == 1 { - chord = tui.AltZ + int([]rune(key)[0]) + add(tui.EventType(tui.F1.Int() + int(key[1]) - '1')) + } else if len(runes) == 1 { + chords[tui.Key(runes[0])] = key } else { errorExit("unsupported key: " + key) } } - if chord > 0 { - chords[chord] = key - } } return chords } @@ -720,11 +724,11 @@ func parseTheme(defaultTheme *tui.ColorTheme, str string) *tui.ColorTheme { var executeRegexp *regexp.Regexp -func firstKey(keymap map[int]string) int { +func firstKey(keymap map[tui.Event]string) tui.Event { for k := range keymap { return k } - return 0 + return tui.EventType(0).AsEvent() } const ( @@ -740,7 +744,7 @@ func init() { `(?si)[:+](execute(?:-multi|-silent)?|reload|preview|change-prompt):.+|[:+](execute(?:-multi|-silent)?|reload|preview|change-prompt)(\([^)]*\)|\[[^\]]*\]|~[^~]*~|![^!]*!|@[^@]*@|\#[^\#]*\#|\$[^\$]*\$|%[^%]*%|\^[^\^]*\^|&[^&]*&|\*[^\*]*\*|;[^;]*;|/[^/]*/|\|[^\|]*\|)`) } -func parseKeymap(keymap map[int][]action, str string) { +func parseKeymap(keymap map[tui.Event][]action, str string) { masked := executeRegexp.ReplaceAllStringFunc(str, func(src string) string { symbol := ":" if strings.HasPrefix(src, "+") { @@ -776,13 +780,13 @@ func parseKeymap(keymap map[int][]action, str string) { if len(pair) < 2 { errorExit("bind action not specified: " + origPairStr) } - var key int + var key tui.Event if len(pair[0]) == 1 && pair[0][0] == escapedColon { - key = ':' + tui.AltZ + key = tui.Key(':') } else if len(pair[0]) == 1 && pair[0][0] == escapedComma { - key = ',' + tui.AltZ + key = tui.Key(',') } else if len(pair[0]) == 1 && pair[0][0] == escapedPlus { - key = '+' + tui.AltZ + key = tui.Key('+') } else { keys := parseKeyChords(pair[0], "key name required") key = firstKey(keys) @@ -981,7 +985,7 @@ func isExecuteAction(str string) actionType { return actIgnore } -func parseToggleSort(keymap map[int][]action, str string) { +func parseToggleSort(keymap map[tui.Event][]action, str string) { keys := parseKeyChords(str, "key name required") if len(keys) != 1 { errorExit("multiple keys specified") @@ -1188,7 +1192,7 @@ func parseOptions(opts *Options, allArgs []string) { opts.Expect[k] = v } case "--no-expect": - opts.Expect = make(map[int]string) + opts.Expect = make(map[tui.Event]string) case "--no-phony": opts.Phony = false case "--phony": @@ -1512,11 +1516,11 @@ func postProcessOptions(opts *Options) { } // Default actions for CTRL-N / CTRL-P when --history is set if opts.History != nil { - if _, prs := opts.Keymap[tui.CtrlP]; !prs { - opts.Keymap[tui.CtrlP] = toActions(actPreviousHistory) + if _, prs := opts.Keymap[tui.CtrlP.AsEvent()]; !prs { + opts.Keymap[tui.CtrlP.AsEvent()] = toActions(actPreviousHistory) } - if _, prs := opts.Keymap[tui.CtrlN]; !prs { - opts.Keymap[tui.CtrlN] = toActions(actNextHistory) + if _, prs := opts.Keymap[tui.CtrlN.AsEvent()]; !prs { + opts.Keymap[tui.CtrlN.AsEvent()] = toActions(actNextHistory) } } diff --git a/src/options_test.go b/src/options_test.go index 5cc11c85..4311aa4d 100644 --- a/src/options_test.go +++ b/src/options_test.go @@ -125,26 +125,29 @@ func TestIrrelevantNth(t *testing.T) { func TestParseKeys(t *testing.T) { pairs := parseKeyChords("ctrl-z,alt-z,f2,@,Alt-a,!,ctrl-G,J,g,ctrl-alt-a,ALT-enter,alt-SPACE", "") - check := func(i int, s string) { - if pairs[i] != s { - t.Errorf("%s != %s", pairs[i], s) + checkEvent := func(e tui.Event, s string) { + if pairs[e] != s { + t.Errorf("%s != %s", pairs[e], s) } } + check := func(et tui.EventType, s string) { + checkEvent(et.AsEvent(), s) + } if len(pairs) != 12 { t.Error(12) } check(tui.CtrlZ, "ctrl-z") - check(tui.AltZ, "alt-z") check(tui.F2, "f2") - check(tui.AltZ+'@', "@") - check(tui.AltA, "Alt-a") - check(tui.AltZ+'!', "!") - check(tui.CtrlA+'g'-'a', "ctrl-G") - check(tui.AltZ+'J', "J") - check(tui.AltZ+'g', "g") - check(tui.CtrlAltA, "ctrl-alt-a") - check(tui.CtrlAltM, "ALT-enter") - check(tui.AltSpace, "alt-SPACE") + check(tui.CtrlG, "ctrl-G") + checkEvent(tui.AltKey('z'), "alt-z") + checkEvent(tui.Key('@'), "@") + checkEvent(tui.AltKey('a'), "Alt-a") + checkEvent(tui.Key('!'), "!") + checkEvent(tui.Key('J'), "J") + checkEvent(tui.Key('g'), "g") + checkEvent(tui.CtrlAltKey('a'), "ctrl-alt-a") + checkEvent(tui.CtrlAltKey('m'), "ALT-enter") + checkEvent(tui.AltKey(' '), "alt-SPACE") // Synonyms pairs = parseKeyChords("enter,Return,space,tab,btab,esc,up,down,left,right", "") @@ -152,7 +155,7 @@ func TestParseKeys(t *testing.T) { t.Error(9) } check(tui.CtrlM, "Return") - check(tui.AltZ+' ', "space") + checkEvent(tui.Key(' '), "space") check(tui.Tab, "tab") check(tui.BTab, "btab") check(tui.ESC, "esc") @@ -184,63 +187,64 @@ func TestParseKeysWithComma(t *testing.T) { t.Errorf("%d != %d", a, b) } } - check := func(pairs map[int]string, i int, s string) { - if pairs[i] != s { - t.Errorf("%s != %s", pairs[i], s) + check := func(pairs map[tui.Event]string, e tui.Event, s string) { + if pairs[e] != s { + t.Errorf("%s != %s", pairs[e], s) } } pairs := parseKeyChords(",", "") checkN(len(pairs), 1) - check(pairs, tui.AltZ+',', ",") + check(pairs, tui.Key(','), ",") pairs = parseKeyChords(",,a,b", "") checkN(len(pairs), 3) - check(pairs, tui.AltZ+'a', "a") - check(pairs, tui.AltZ+'b', "b") - check(pairs, tui.AltZ+',', ",") + check(pairs, tui.Key('a'), "a") + check(pairs, tui.Key('b'), "b") + check(pairs, tui.Key(','), ",") pairs = parseKeyChords("a,b,,", "") checkN(len(pairs), 3) - check(pairs, tui.AltZ+'a', "a") - check(pairs, tui.AltZ+'b', "b") - check(pairs, tui.AltZ+',', ",") + check(pairs, tui.Key('a'), "a") + check(pairs, tui.Key('b'), "b") + check(pairs, tui.Key(','), ",") pairs = parseKeyChords("a,,,b", "") checkN(len(pairs), 3) - check(pairs, tui.AltZ+'a', "a") - check(pairs, tui.AltZ+'b', "b") - check(pairs, tui.AltZ+',', ",") + check(pairs, tui.Key('a'), "a") + check(pairs, tui.Key('b'), "b") + check(pairs, tui.Key(','), ",") pairs = parseKeyChords("a,,,b,c", "") checkN(len(pairs), 4) - check(pairs, tui.AltZ+'a', "a") - check(pairs, tui.AltZ+'b', "b") - check(pairs, tui.AltZ+'c', "c") - check(pairs, tui.AltZ+',', ",") + check(pairs, tui.Key('a'), "a") + check(pairs, tui.Key('b'), "b") + check(pairs, tui.Key('c'), "c") + check(pairs, tui.Key(','), ",") pairs = parseKeyChords(",,,", "") checkN(len(pairs), 1) - check(pairs, tui.AltZ+',', ",") + check(pairs, tui.Key(','), ",") } func TestBind(t *testing.T) { keymap := defaultKeymap() - check := func(keyName int, arg1 string, types ...actionType) { - if len(keymap[keyName]) != len(types) { - t.Errorf("invalid number of actions (%d != %d)", len(types), len(keymap[keyName])) + check := func(event tui.Event, arg1 string, types ...actionType) { + if len(keymap[event]) != len(types) { + t.Errorf("invalid number of actions for %v (%d != %d)", + event, len(types), len(keymap[event])) return } - for idx, action := range keymap[keyName] { + for idx, action := range keymap[event] { if types[idx] != action.t { t.Errorf("invalid action type (%d != %d)", types[idx], action.t) } } - if len(arg1) > 0 && keymap[keyName][0].a != arg1 { - t.Errorf("invalid action argument: (%s != %s)", arg1, keymap[keyName][0].a) + if len(arg1) > 0 && keymap[event][0].a != arg1 { + t.Errorf("invalid action argument: (%s != %s)", arg1, keymap[event][0].a) } } - check(tui.CtrlA, "", actBeginningOfLine) + check(tui.CtrlA.AsEvent(), "", actBeginningOfLine) parseKeymap(keymap, "ctrl-a:kill-line,ctrl-b:toggle-sort+up+down,c:page-up,alt-z:page-down,"+ "f1:execute(ls {+})+abort+execute(echo {+})+select-all,f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+ @@ -248,29 +252,29 @@ func TestBind(t *testing.T) { "x:Execute(foo+bar),X:execute/bar+baz/"+ ",f1:+first,f1:+top"+ ",,:abort,::accept,+:execute:++\nfoobar,Y:execute(baz)+up") - check(tui.CtrlA, "", actKillLine) - check(tui.CtrlB, "", actToggleSort, actUp, actDown) - check(tui.AltZ+'c', "", actPageUp) - check(tui.AltZ+',', "", actAbort) - check(tui.AltZ+':', "", actAccept) - check(tui.AltZ, "", actPageDown) - check(tui.F1, "ls {+}", actExecute, actAbort, actExecute, actSelectAll, actFirst, actFirst) - check(tui.F2, "echo {}, {}, {}", actExecute) - check(tui.F3, "echo '({})'", actExecute) - check(tui.F4, "less {}", actExecute) - check(tui.AltZ+'x', "foo+bar", actExecute) - check(tui.AltZ+'X', "bar+baz", actExecute) - check(tui.AltA, "echo (,),[,],/,:,;,%,{}", actExecuteMulti) - check(tui.AltB, "echo (,),[,],/,:,@,%,{}", actExecute) - check(tui.AltZ+'+', "++\nfoobar,Y:execute(baz)+up", actExecute) + check(tui.CtrlA.AsEvent(), "", actKillLine) + check(tui.CtrlB.AsEvent(), "", actToggleSort, actUp, actDown) + check(tui.Key('c'), "", actPageUp) + check(tui.Key(','), "", actAbort) + check(tui.Key(':'), "", actAccept) + check(tui.AltKey('z'), "", actPageDown) + check(tui.F1.AsEvent(), "ls {+}", actExecute, actAbort, actExecute, actSelectAll, actFirst, actFirst) + check(tui.F2.AsEvent(), "echo {}, {}, {}", actExecute) + check(tui.F3.AsEvent(), "echo '({})'", actExecute) + check(tui.F4.AsEvent(), "less {}", actExecute) + check(tui.Key('x'), "foo+bar", actExecute) + check(tui.Key('X'), "bar+baz", actExecute) + check(tui.AltKey('a'), "echo (,),[,],/,:,;,%,{}", actExecuteMulti) + check(tui.AltKey('b'), "echo (,),[,],/,:,@,%,{}", actExecute) + check(tui.Key('+'), "++\nfoobar,Y:execute(baz)+up", actExecute) for idx, char := range []rune{'~', '!', '@', '#', '$', '%', '^', '&', '*', '|', ';', '/'} { parseKeymap(keymap, fmt.Sprintf("%d:execute%cfoobar%c", idx%10, char, char)) - check(tui.AltZ+int([]rune(fmt.Sprintf("%d", idx%10))[0]), "foobar", actExecute) + check(tui.Key([]rune(fmt.Sprintf("%d", idx%10))[0]), "foobar", actExecute) } parseKeymap(keymap, "f1:abort") - check(tui.F1, "", actAbort) + check(tui.F1.AsEvent(), "", actAbort) } func TestColorSpec(t *testing.T) { @@ -314,11 +318,12 @@ func TestColorSpec(t *testing.T) { } func TestDefaultCtrlNP(t *testing.T) { - check := func(words []string, key int, expected actionType) { + check := func(words []string, et tui.EventType, expected actionType) { + e := et.AsEvent() opts := defaultOptions() parseOptions(opts, words) postProcessOptions(opts) - if opts.Keymap[key][0].t != expected { + if opts.Keymap[e][0].t != expected { t.Error() } } diff --git a/src/terminal.go b/src/terminal.go index 2bba9c21..00370b3b 100644 --- a/src/terminal.go +++ b/src/terminal.go @@ -109,8 +109,8 @@ type Terminal struct { sort bool toggleSort bool delimiter Delimiter - expect map[int]string - keymap map[int][]action + expect map[tui.Event]string + keymap map[tui.Event][]action pressed string printQuery bool history *History @@ -304,62 +304,68 @@ func toActions(types ...actionType) []action { return actions } -func defaultKeymap() map[int][]action { - keymap := make(map[int][]action) - keymap[tui.Invalid] = toActions(actInvalid) - keymap[tui.Resize] = toActions(actClearScreen) - keymap[tui.CtrlA] = toActions(actBeginningOfLine) - keymap[tui.CtrlB] = toActions(actBackwardChar) - keymap[tui.CtrlC] = toActions(actAbort) - keymap[tui.CtrlG] = toActions(actAbort) - keymap[tui.CtrlQ] = toActions(actAbort) - keymap[tui.ESC] = toActions(actAbort) - keymap[tui.CtrlD] = toActions(actDeleteCharEOF) - keymap[tui.CtrlE] = toActions(actEndOfLine) - keymap[tui.CtrlF] = toActions(actForwardChar) - keymap[tui.CtrlH] = toActions(actBackwardDeleteChar) - keymap[tui.BSpace] = toActions(actBackwardDeleteChar) - keymap[tui.Tab] = toActions(actToggleDown) - keymap[tui.BTab] = toActions(actToggleUp) - keymap[tui.CtrlJ] = toActions(actDown) - keymap[tui.CtrlK] = toActions(actUp) - keymap[tui.CtrlL] = toActions(actClearScreen) - keymap[tui.CtrlM] = toActions(actAccept) - keymap[tui.CtrlN] = toActions(actDown) - keymap[tui.CtrlP] = toActions(actUp) - keymap[tui.CtrlU] = toActions(actUnixLineDiscard) - keymap[tui.CtrlW] = toActions(actUnixWordRubout) - keymap[tui.CtrlY] = toActions(actYank) +func defaultKeymap() map[tui.Event][]action { + keymap := make(map[tui.Event][]action) + add := func(e tui.EventType, a actionType) { + keymap[e.AsEvent()] = toActions(a) + } + addEvent := func(e tui.Event, a actionType) { + keymap[e] = toActions(a) + } + + add(tui.Invalid, actInvalid) + add(tui.Resize, actClearScreen) + add(tui.CtrlA, actBeginningOfLine) + add(tui.CtrlB, actBackwardChar) + add(tui.CtrlC, actAbort) + add(tui.CtrlG, actAbort) + add(tui.CtrlQ, actAbort) + add(tui.ESC, actAbort) + add(tui.CtrlD, actDeleteCharEOF) + add(tui.CtrlE, actEndOfLine) + add(tui.CtrlF, actForwardChar) + add(tui.CtrlH, actBackwardDeleteChar) + add(tui.BSpace, actBackwardDeleteChar) + add(tui.Tab, actToggleDown) + add(tui.BTab, actToggleUp) + add(tui.CtrlJ, actDown) + add(tui.CtrlK, actUp) + add(tui.CtrlL, actClearScreen) + add(tui.CtrlM, actAccept) + add(tui.CtrlN, actDown) + add(tui.CtrlP, actUp) + add(tui.CtrlU, actUnixLineDiscard) + add(tui.CtrlW, actUnixWordRubout) + add(tui.CtrlY, actYank) if !util.IsWindows() { - keymap[tui.CtrlZ] = toActions(actSigStop) - } - - keymap[tui.AltB] = toActions(actBackwardWord) - keymap[tui.SLeft] = toActions(actBackwardWord) - keymap[tui.AltF] = toActions(actForwardWord) - keymap[tui.SRight] = toActions(actForwardWord) - keymap[tui.AltD] = toActions(actKillWord) - keymap[tui.AltBS] = toActions(actBackwardKillWord) - - keymap[tui.Up] = toActions(actUp) - keymap[tui.Down] = toActions(actDown) - keymap[tui.Left] = toActions(actBackwardChar) - keymap[tui.Right] = toActions(actForwardChar) - - keymap[tui.Home] = toActions(actBeginningOfLine) - keymap[tui.End] = toActions(actEndOfLine) - keymap[tui.Del] = toActions(actDeleteChar) - keymap[tui.PgUp] = toActions(actPageUp) - keymap[tui.PgDn] = toActions(actPageDown) - - keymap[tui.SUp] = toActions(actPreviewUp) - keymap[tui.SDown] = toActions(actPreviewDown) - - keymap[tui.Rune] = toActions(actRune) - keymap[tui.Mouse] = toActions(actMouse) - keymap[tui.DoubleClick] = toActions(actAccept) - keymap[tui.LeftClick] = toActions(actIgnore) - keymap[tui.RightClick] = toActions(actToggle) + add(tui.CtrlZ, actSigStop) + } + + addEvent(tui.AltKey('b'), actBackwardWord) + add(tui.SLeft, actBackwardWord) + addEvent(tui.AltKey('f'), actForwardWord) + add(tui.SRight, actForwardWord) + addEvent(tui.AltKey('d'), actKillWord) + add(tui.AltBS, actBackwardKillWord) + + add(tui.Up, actUp) + add(tui.Down, actDown) + add(tui.Left, actBackwardChar) + add(tui.Right, actForwardChar) + + add(tui.Home, actBeginningOfLine) + add(tui.End, actEndOfLine) + add(tui.Del, actDeleteChar) + add(tui.PgUp, actPageUp) + add(tui.PgDn, actPageDown) + + add(tui.SUp, actPreviewUp) + add(tui.SDown, actPreviewDown) + + add(tui.Mouse, actMouse) + add(tui.DoubleClick, actAccept) + add(tui.LeftClick, actIgnore) + add(tui.RightClick, actToggle) return keymap } @@ -1452,10 +1458,9 @@ func (t *Terminal) rubout(pattern string) { t.input = append(t.input[:t.cx], after...) } -func keyMatch(key int, event tui.Event) bool { - return event.Type == key || - event.Type == tui.Rune && int(event.Char) == key-tui.AltZ || - event.Type == tui.Mouse && key == tui.DoubleClick && event.MouseEvent.Double +func keyMatch(key tui.Event, event tui.Event) bool { + return event.Type == key.Type && event.Char == key.Char || + key.Type == tui.DoubleClick && event.Type == tui.Mouse && event.MouseEvent.Double } func quoteEntryCmd(entry string) string { @@ -2163,16 +2168,20 @@ func (t *Terminal) Loop() { } } - var doAction func(action, int) bool - doActions := func(actions []action, mapkey int) bool { + actionsFor := func(eventType tui.EventType) []action { + return t.keymap[eventType.AsEvent()] + } + + var doAction func(action) bool + doActions := func(actions []action) bool { for _, action := range actions { - if !doAction(action, mapkey) { + if !doAction(action) { return false } } return true } - doAction = func(a action, mapkey int) bool { + doAction = func(a action) bool { switch a.t { case actIgnore: case actExecute, actExecuteSilent: @@ -2326,14 +2335,14 @@ func (t *Terminal) Loop() { } case actToggleIn: if t.layout != layoutDefault { - return doAction(action{t: actToggleUp}, mapkey) + return doAction(action{t: actToggleUp}) } - return doAction(action{t: actToggleDown}, mapkey) + return doAction(action{t: actToggleDown}) case actToggleOut: if t.layout != layoutDefault { - return doAction(action{t: actToggleDown}, mapkey) + return doAction(action{t: actToggleDown}) } - return doAction(action{t: actToggleUp}, mapkey) + return doAction(action{t: actToggleUp}) case actToggleDown: if t.multi > 0 && t.merger.Length() > 0 && toggle() { t.vmove(-1, true) @@ -2490,7 +2499,7 @@ func (t *Terminal) Loop() { // Double-click if my >= min { if t.vset(t.offset+my-min) && t.cy < t.merger.Length() { - return doActions(t.keymap[tui.DoubleClick], tui.DoubleClick) + return doActions(actionsFor(tui.DoubleClick)) } } } else if me.Down { @@ -2504,9 +2513,9 @@ func (t *Terminal) Loop() { } req(reqList) if me.Left { - return doActions(t.keymap[tui.LeftClick], tui.LeftClick) + return doActions(actionsFor(tui.LeftClick)) } - return doActions(t.keymap[tui.RightClick], tui.RightClick) + return doActions(actionsFor(tui.RightClick)) } } } @@ -2528,33 +2537,29 @@ func (t *Terminal) Loop() { } return true } - mapkey := event.Type + if t.jumping == jumpDisabled { - actions := t.keymap[mapkey] - if mapkey == tui.Rune { - mapkey = int(event.Char) + int(tui.AltZ) - if act, prs := t.keymap[mapkey]; prs { - actions = act - } - } - if !doActions(actions, mapkey) { + actions := t.keymap[event.Comparable()] + if len(actions) == 0 && event.Type == tui.Rune { + doAction(action{t: actRune}) + } else if !doActions(actions) { continue } t.truncateQuery() queryChanged = string(previousInput) != string(t.input) changed = changed || queryChanged - if onChanges, prs := t.keymap[tui.Change]; queryChanged && prs { - if !doActions(onChanges, tui.Change) { + if onChanges, prs := t.keymap[tui.Change.AsEvent()]; queryChanged && prs { + if !doActions(onChanges) { continue } } - if onEOFs, prs := t.keymap[tui.BackwardEOF]; beof && prs { - if !doActions(onEOFs, tui.BackwardEOF) { + if onEOFs, prs := t.keymap[tui.BackwardEOF.AsEvent()]; beof && prs { + if !doActions(onEOFs) { continue } } } else { - if mapkey == tui.Rune { + if event.Type == tui.Rune { if idx := strings.IndexRune(t.jumpLabels, event.Char); idx >= 0 && idx < t.maxItems() && idx < t.merger.Length() { t.cy = idx + t.offset if t.jumping == jumpAcceptEnabled { diff --git a/src/tui/light.go b/src/tui/light.go index 4f50d687..9c48b465 100644 --- a/src/tui/light.go +++ b/src/tui/light.go @@ -1,6 +1,7 @@ package tui import ( + "bytes" "fmt" "os" "regexp" @@ -230,7 +231,7 @@ func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) []byte { } retries := 0 - if c == ESC || nonblock { + if c == ESC.Int() || nonblock { retries = r.escDelay / escPollInterval } buffer = append(buffer, byte(c)) @@ -245,7 +246,7 @@ func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) []byte { continue } break - } else if c == ESC && pc != c { + } else if c == ESC.Int() && pc != c { retries = r.escDelay / escPollInterval } else { retries = 0 @@ -278,11 +279,11 @@ func (r *LightRenderer) GetChar() Event { }() switch r.buffer[0] { - case CtrlC: + case CtrlC.Byte(): return Event{CtrlC, 0, nil} - case CtrlG: + case CtrlG.Byte(): return Event{CtrlG, 0, nil} - case CtrlQ: + case CtrlQ.Byte(): return Event{CtrlQ, 0, nil} case 127: return Event{BSpace, 0, nil} @@ -296,7 +297,7 @@ func (r *LightRenderer) GetChar() Event { return Event{CtrlCaret, 0, nil} case 31: return Event{CtrlSlash, 0, nil} - case ESC: + case ESC.Byte(): ev := r.escSequence(&sz) // Second chance if ev.Type == Invalid { @@ -307,8 +308,8 @@ func (r *LightRenderer) GetChar() Event { } // CTRL-A ~ CTRL-Z - if r.buffer[0] <= CtrlZ { - return Event{int(r.buffer[0]), 0, nil} + if r.buffer[0] <= CtrlZ.Byte() { + return Event{EventType(r.buffer[0]), 0, nil} } char, rsz := utf8.DecodeRune(r.buffer) if char == utf8.RuneError { @@ -331,26 +332,16 @@ func (r *LightRenderer) escSequence(sz *int) Event { *sz = 2 if r.buffer[1] >= 1 && r.buffer[1] <= 'z'-'a'+1 { - return Event{int(CtrlAltA + r.buffer[1] - 1), 0, nil} + return CtrlAltKey(rune(r.buffer[1] + 'a' - 1)) } alt := false - if len(r.buffer) > 2 && r.buffer[1] == ESC { + if len(r.buffer) > 2 && r.buffer[1] == ESC.Byte() { r.buffer = r.buffer[1:] alt = true } switch r.buffer[1] { - case ESC: + case ESC.Byte(): return Event{ESC, 0, nil} - case ' ': - return Event{AltSpace, 0, nil} - case '/': - return Event{AltSlash, 0, nil} - case 'b': - return Event{AltB, 0, nil} - case 'd': - return Event{AltD, 0, nil} - case 'f': - return Event{AltF, 0, nil} case 127: return Event{AltBS, 0, nil} case '[', 'O': @@ -518,11 +509,11 @@ func (r *LightRenderer) escSequence(sz *int) Event { } // r.buffer[2] } // r.buffer[2] } // r.buffer[1] - if r.buffer[1] >= 'a' && r.buffer[1] <= 'z' { - return Event{AltA + int(r.buffer[1]) - 'a', 0, nil} - } - if r.buffer[1] >= '0' && r.buffer[1] <= '9' { - return Event{Alt0 + int(r.buffer[1]) - '0', 0, nil} + rest := bytes.NewBuffer(r.buffer[1:]) + c, size, err := rest.ReadRune() + if err == nil { + *sz = 1 + size + return AltKey(c) } return Event{Invalid, 0, nil} } diff --git a/src/tui/tcell.go b/src/tui/tcell.go index 16d3151a..938c1ba0 100644 --- a/src/tui/tcell.go +++ b/src/tui/tcell.go @@ -226,65 +226,65 @@ func (r *FullscreenRenderer) GetChar() Event { alt := (mods & tcell.ModAlt) > 0 shift := (mods & tcell.ModShift) > 0 altShift := alt && shift - keyfn := func(r rune) int { + keyfn := func(r rune) Event { if alt { - return CtrlAltA - 'a' + int(r) + return CtrlAltKey(r) } - return CtrlA - 'a' + int(r) + return EventType(CtrlA.Int() - 'a' + int(r)).AsEvent() } switch ev.Key() { case tcell.KeyCtrlA: - return Event{keyfn('a'), 0, nil} + return keyfn('a') case tcell.KeyCtrlB: - return Event{keyfn('b'), 0, nil} + return keyfn('b') case tcell.KeyCtrlC: - return Event{keyfn('c'), 0, nil} + return keyfn('c') case tcell.KeyCtrlD: - return Event{keyfn('d'), 0, nil} + return keyfn('d') case tcell.KeyCtrlE: - return Event{keyfn('e'), 0, nil} + return keyfn('e') case tcell.KeyCtrlF: - return Event{keyfn('f'), 0, nil} + return keyfn('f') case tcell.KeyCtrlG: - return Event{keyfn('g'), 0, nil} + return keyfn('g') case tcell.KeyCtrlH: - return Event{keyfn('h'), 0, nil} + return keyfn('h') case tcell.KeyCtrlI: - return Event{keyfn('i'), 0, nil} + return keyfn('i') case tcell.KeyCtrlJ: - return Event{keyfn('j'), 0, nil} + return keyfn('j') case tcell.KeyCtrlK: - return Event{keyfn('k'), 0, nil} + return keyfn('k') case tcell.KeyCtrlL: - return Event{keyfn('l'), 0, nil} + return keyfn('l') case tcell.KeyCtrlM: - return Event{keyfn('m'), 0, nil} + return keyfn('m') case tcell.KeyCtrlN: - return Event{keyfn('n'), 0, nil} + return keyfn('n') case tcell.KeyCtrlO: - return Event{keyfn('o'), 0, nil} + return keyfn('o') case tcell.KeyCtrlP: - return Event{keyfn('p'), 0, nil} + return keyfn('p') case tcell.KeyCtrlQ: - return Event{keyfn('q'), 0, nil} + return keyfn('q') case tcell.KeyCtrlR: - return Event{keyfn('r'), 0, nil} + return keyfn('r') case tcell.KeyCtrlS: - return Event{keyfn('s'), 0, nil} + return keyfn('s') case tcell.KeyCtrlT: - return Event{keyfn('t'), 0, nil} + return keyfn('t') case tcell.KeyCtrlU: - return Event{keyfn('u'), 0, nil} + return keyfn('u') case tcell.KeyCtrlV: - return Event{keyfn('v'), 0, nil} + return keyfn('v') case tcell.KeyCtrlW: - return Event{keyfn('w'), 0, nil} + return keyfn('w') case tcell.KeyCtrlX: - return Event{keyfn('x'), 0, nil} + return keyfn('x') case tcell.KeyCtrlY: - return Event{keyfn('y'), 0, nil} + return keyfn('y') case tcell.KeyCtrlZ: - return Event{keyfn('z'), 0, nil} + return keyfn('z') case tcell.KeyCtrlSpace: return Event{CtrlSpace, 0, nil} case tcell.KeyCtrlBackslash: @@ -389,18 +389,7 @@ func (r *FullscreenRenderer) GetChar() Event { case tcell.KeyRune: r := ev.Rune() if alt { - switch r { - case ' ': - return Event{AltSpace, 0, nil} - case '/': - return Event{AltSlash, 0, nil} - } - if r >= 'a' && r <= 'z' { - return Event{AltA + int(r) - 'a', 0, nil} - } - if r >= '0' && r <= '9' { - return Event{Alt0 + int(r) - '0', 0, nil} - } + return AltKey(r) } return Event{Rune, r, nil} diff --git a/src/tui/tui.go b/src/tui/tui.go index edbc9a14..cc9c7f67 100644 --- a/src/tui/tui.go +++ b/src/tui/tui.go @@ -8,8 +8,10 @@ import ( ) // Types of user action +type EventType int + const ( - Rune = iota + Rune EventType = iota CtrlA CtrlB @@ -89,8 +91,6 @@ const ( Change BackwardEOF - AltSpace - AltSlash AltBS AltUp @@ -103,20 +103,38 @@ const ( AltSLeft AltSRight - Alt0 + Alt + CtrlAlt ) -const ( // Reset iota - AltA = Alt0 + 'a' - '0' + iota - AltB - AltC - AltD - AltE - AltF - AltZ = AltA + 'z' - 'a' - CtrlAltA = AltZ + 1 - CtrlAltM = CtrlAltA + 'm' - 'a' -) < |