diff --git a/commands.go b/commands.go index bfa3b70455..0cb6da710c 100644 --- a/commands.go +++ b/commands.go @@ -214,3 +214,25 @@ func WindowSize() Cmd { return windowSizeMsg{} } } + +// setEnhancedKeyboardMsg is a message to enable/disable enhanced keyboard +// features. +type setEnhancedKeyboardMsg bool + +// EnableEnhancedKeyboard is a command to enable enhanced keyboard features. +// This unambiguously reports more key combinations than traditional terminal +// keyboard sequences. This might also enable reporting of release key events +// depending on the terminal emulator supporting it. +// +// This is equivalent to calling EnablieKittyKeyboard(3) and +// EnableModifyOtherKeys(1). +func EnableEnhancedKeyboard() Msg { + return setEnhancedKeyboardMsg(true) +} + +// DisableEnhancedKeyboard is a command to disable enhanced keyboard features. +// +// This is equivalent to calling DisableKittyKeyboard() and DisableModifyOtherKeys(). +func DisableEnhancedKeyboard() Msg { + return setEnhancedKeyboardMsg(false) +} diff --git a/examples/go.mod b/examples/go.mod index 40598a5479..0ccbcf8ccb 100644 --- a/examples/go.mod +++ b/examples/go.mod @@ -22,7 +22,7 @@ require ( github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect github.com/aymanbagabas/go-udiff v0.2.0 // indirect github.com/aymerick/douceur v0.2.0 // indirect - github.com/charmbracelet/x/ansi v0.1.4 // indirect + github.com/charmbracelet/x/ansi v0.1.5-0.20240814160751-e2dc8b53b604 // indirect github.com/charmbracelet/x/exp/golden v0.0.0-20240715153702-9ba8adf781c4 // indirect github.com/charmbracelet/x/input v0.1.0 // indirect github.com/charmbracelet/x/term v0.1.1 // indirect diff --git a/examples/go.sum b/examples/go.sum index 75ebdfe9b3..aa013f4db5 100644 --- a/examples/go.sum +++ b/examples/go.sum @@ -20,8 +20,8 @@ github.com/charmbracelet/harmonica v0.2.0 h1:8NxJWRWg/bzKqqEaaeFNipOu77YR5t8aSwG github.com/charmbracelet/harmonica v0.2.0/go.mod h1:KSri/1RMQOZLbw7AHqgcBycp8pgJnQMYYT8QZRqZ1Ao= github.com/charmbracelet/lipgloss v0.12.1 h1:/gmzszl+pedQpjCOH+wFkZr/N90Snz40J/NR7A0zQcs= github.com/charmbracelet/lipgloss v0.12.1/go.mod h1:V2CiwIuhx9S1S1ZlADfOj9HmxeMAORuz5izHb0zGbB8= -github.com/charmbracelet/x/ansi v0.1.4 h1:IEU3D6+dWwPSgZ6HBH+v6oUuZ/nVawMiWj5831KfiLM= -github.com/charmbracelet/x/ansi v0.1.4/go.mod h1:dk73KoMTT5AX5BsX0KrqhsTqAnhZZoCBjs7dGWp4Ktw= +github.com/charmbracelet/x/ansi v0.1.5-0.20240814160751-e2dc8b53b604 h1:UBOeE/UdmNlTa7KVGdCdYGYpOBZPD0LMMw0Bcp6fCj4= +github.com/charmbracelet/x/ansi v0.1.5-0.20240814160751-e2dc8b53b604/go.mod h1:dk73KoMTT5AX5BsX0KrqhsTqAnhZZoCBjs7dGWp4Ktw= github.com/charmbracelet/x/exp/golden v0.0.0-20240715153702-9ba8adf781c4 h1:6KzMkQeAF56rggw2NZu1L+TH7j9+DM1/2Kmh7KUxg1I= github.com/charmbracelet/x/exp/golden v0.0.0-20240715153702-9ba8adf781c4/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U= github.com/charmbracelet/x/exp/teatest v0.0.0-20240521184646-23081fb03b28 h1:sOWKNRjt8uOEVgPiJVIJCse1+mUDM2F/vYY6W0Go640= diff --git a/examples/print-key/main.go b/examples/print-key/main.go new file mode 100644 index 0000000000..dbdb814ab4 --- /dev/null +++ b/examples/print-key/main.go @@ -0,0 +1,36 @@ +package main + +import ( + "log" + + tea "github.com/charmbracelet/bubbletea" +) + +type model struct{} + +func (m model) Init() tea.Cmd { + return nil +} + +func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) { + switch msg := msg.(type) { + case tea.KeyPressMsg: + switch msg.String() { + case "ctrl+c": + return m, tea.Quit + } + return m, tea.Printf("You pressed: %s\n", msg.String()) + } + return m, nil +} + +func (m model) View() string { + return "Press any key to see it printed to the terminal. Press 'ctrl+c' to quit." +} + +func main() { + p := tea.NewProgram(model{}, tea.WithEnhancedKeyboard()) + if _, err := p.Run(); err != nil { + log.Printf("Error running program: %v", err) + } +} diff --git a/go.mod b/go.mod index 34bcfa4f9a..d1c2fb6f4d 100644 --- a/go.mod +++ b/go.mod @@ -3,11 +3,12 @@ module github.com/charmbracelet/bubbletea go 1.18 require ( - github.com/charmbracelet/x/ansi v0.1.4 + github.com/charmbracelet/x/ansi v0.1.5-0.20240814160751-e2dc8b53b604 github.com/charmbracelet/x/term v0.1.1 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 github.com/muesli/cancelreader v0.2.2 + github.com/rivo/uniseg v0.4.7 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e golang.org/x/sync v0.8.0 golang.org/x/sys v0.24.0 @@ -17,5 +18,4 @@ require ( github.com/charmbracelet/x/input v0.1.0 // indirect github.com/charmbracelet/x/windows v0.1.0 // indirect github.com/mattn/go-runewidth v0.0.15 // indirect - github.com/rivo/uniseg v0.4.7 // indirect ) diff --git a/go.sum b/go.sum index afe8f921d0..6b8c345d95 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,5 @@ -github.com/charmbracelet/x/ansi v0.1.4 h1:IEU3D6+dWwPSgZ6HBH+v6oUuZ/nVawMiWj5831KfiLM= -github.com/charmbracelet/x/ansi v0.1.4/go.mod h1:dk73KoMTT5AX5BsX0KrqhsTqAnhZZoCBjs7dGWp4Ktw= +github.com/charmbracelet/x/ansi v0.1.5-0.20240814160751-e2dc8b53b604 h1:UBOeE/UdmNlTa7KVGdCdYGYpOBZPD0LMMw0Bcp6fCj4= +github.com/charmbracelet/x/ansi v0.1.5-0.20240814160751-e2dc8b53b604/go.mod h1:dk73KoMTT5AX5BsX0KrqhsTqAnhZZoCBjs7dGWp4Ktw= github.com/charmbracelet/x/input v0.1.0 h1:TEsGSfZYQyOtp+STIjyBq6tpRaorH0qpwZUj8DavAhQ= github.com/charmbracelet/x/input v0.1.0/go.mod h1:ZZwaBxPF7IG8gWWzPUVqHEtWhc1+HXJPNuerJGRGZ28= github.com/charmbracelet/x/term v0.1.1 h1:3cosVAiPOig+EV4X9U+3LDgtwwAoEzJjNdwbXDjF6yI= diff --git a/key.go b/key.go index 9997321037..33679414f2 100644 --- a/key.go +++ b/key.go @@ -226,14 +226,14 @@ const ( // one character, though certain input method editors (most notably Chinese // IMEs) can input multiple runes at once. type Key struct { - // Type is a special key, like enter, tab, backspace, and so on. - Type KeyType - // Runes contains the actual characters received. This usually has a length // of 1. Use [Rune()] to get the first key rune received. If the user // presses shift+a, the Runes will be `[]rune{'A'}`. Runes []rune + // Type is a special key, like enter, tab, backspace, and so on. + Type KeyType + // altRune is the actual, unshifted key pressed by the user. For example, // if the user presses shift+a, or caps lock is on, the altRune will be // 'a'. @@ -323,22 +323,22 @@ func (k Key) Rune() rune { // "shift+ctrl+alt+a". func (k Key) String() string { var s string - if k.Mod.HasCtrl() && k.Type != KeyLeftCtrl && k.Type != KeyRightCtrl { + if k.Mod.Contains(ModCtrl) && k.Type != KeyLeftCtrl && k.Type != KeyRightCtrl { s += "ctrl+" } - if k.Mod.HasAlt() && k.Type != KeyLeftAlt && k.Type != KeyRightAlt { + if k.Mod.Contains(ModAlt) && k.Type != KeyLeftAlt && k.Type != KeyRightAlt { s += "alt+" } - if k.Mod.HasShift() && k.Type != KeyLeftShift && k.Type != KeyRightShift { + if k.Mod.Contains(ModShift) && k.Type != KeyLeftShift && k.Type != KeyRightShift { s += "shift+" } - if k.Mod.HasMeta() && k.Type != KeyLeftMeta && k.Type != KeyRightMeta { + if k.Mod.Contains(ModMeta) && k.Type != KeyLeftMeta && k.Type != KeyRightMeta { s += "meta+" } - if k.Mod.HasHyper() && k.Type != KeyLeftHyper && k.Type != KeyRightHyper { + if k.Mod.Contains(ModHyper) && k.Type != KeyLeftHyper && k.Type != KeyRightHyper { s += "hyper+" } - if k.Mod.HasSuper() && k.Type != KeyLeftSuper && k.Type != KeyRightSuper { + if k.Mod.Contains(ModSuper) && k.Type != KeyLeftSuper && k.Type != KeyRightSuper { s += "super+" } diff --git a/key_test.go b/key_test.go index d46da05379..0b3eae31f1 100644 --- a/key_test.go +++ b/key_test.go @@ -113,6 +113,106 @@ func buildBaseSeqTests() []seqTest { func TestParseSequence(t *testing.T) { td := buildBaseSeqTests() td = append(td, + // Xterm modifyOtherKeys CSI 27 ; ; ~ + seqTest{ + []byte("\x1b[27;3;20320~"), + []Msg{KeyPressMsg{Runes: []rune{'你'}, Mod: ModAlt}}, + }, + seqTest{ + []byte("\x1b[27;3;65~"), + []Msg{KeyPressMsg{Runes: []rune{'A'}, Mod: ModAlt}}, + }, + seqTest{ + []byte("\x1b[27;3;8~"), + []Msg{KeyPressMsg{Type: KeyBackspace, Mod: ModAlt}}, + }, + seqTest{ + []byte("\x1b[27;3;27~"), + []Msg{KeyPressMsg{Type: KeyEscape, Mod: ModAlt}}, + }, + seqTest{ + []byte("\x1b[27;3;127~"), + []Msg{KeyPressMsg{Type: KeyBackspace, Mod: ModAlt}}, + }, + + // Kitty keyboard / CSI u (fixterms) + seqTest{ + []byte("\x1b[1B"), + []Msg{KeyPressMsg{Type: KeyDown}}, + }, + seqTest{ + []byte("\x1b[1;B"), + []Msg{KeyPressMsg{Type: KeyDown}}, + }, + seqTest{ + []byte("\x1b[1;4B"), + []Msg{KeyPressMsg{Mod: ModShift | ModAlt, Type: KeyDown}}, + }, + seqTest{ + []byte("\x1b[8~"), + []Msg{KeyPressMsg{Type: KeyEnd}}, + }, + seqTest{ + []byte("\x1b[8;~"), + []Msg{KeyPressMsg{Type: KeyEnd}}, + }, + seqTest{ + []byte("\x1b[8;10~"), + []Msg{KeyPressMsg{Mod: ModShift | ModMeta, Type: KeyEnd}}, + }, + seqTest{ + []byte("\x1b[27;4u"), + []Msg{KeyPressMsg{Mod: ModShift | ModAlt, Type: KeyEscape}}, + }, + seqTest{ + []byte("\x1b[127;4u"), + []Msg{KeyPressMsg{Mod: ModShift | ModAlt, Type: KeyBackspace}}, + }, + seqTest{ + []byte("\x1b[57358;4u"), + []Msg{KeyPressMsg{Mod: ModShift | ModAlt, Type: KeyCapsLock}}, + }, + seqTest{ + []byte("\x1b[9;2u"), + []Msg{KeyPressMsg{Mod: ModShift, Type: KeyTab}}, + }, + seqTest{ + []byte("\x1b[195;u"), + []Msg{KeyPressMsg{Runes: []rune{'Ã'}, Type: KeyRunes}}, + }, + seqTest{ + []byte("\x1b[20320;2u"), + []Msg{KeyPressMsg{Runes: []rune{'你'}, Mod: ModShift, Type: KeyRunes}}, + }, + seqTest{ + []byte("\x1b[195;:1u"), + []Msg{KeyPressMsg{Runes: []rune{'Ã'}, Type: KeyRunes}}, + }, + seqTest{ + []byte("\x1b[195;2:3u"), + []Msg{KeyReleaseMsg{Runes: []rune{'Ã'}, Mod: ModShift}}, + }, + seqTest{ + []byte("\x1b[195;2:2u"), + []Msg{KeyPressMsg{Runes: []rune{'Ã'}, IsRepeat: true, Mod: ModShift}}, + }, + seqTest{ + []byte("\x1b[195;2:1u"), + []Msg{KeyPressMsg{Runes: []rune{'Ã'}, Mod: ModShift}}, + }, + seqTest{ + []byte("\x1b[195;2:3u"), + []Msg{KeyReleaseMsg{Runes: []rune{'Ã'}, Mod: ModShift}}, + }, + seqTest{ + []byte("\x1b[97;2;65u"), + []Msg{KeyPressMsg{Runes: []rune{'A'}, Mod: ModShift, altRune: 'a'}}, + }, + seqTest{ + []byte("\x1b[97;;229u"), + []Msg{KeyPressMsg{Runes: []rune{'å'}, altRune: 'a'}}, + }, + // focus/blur seqTest{ []byte{'\x1b', '[', 'I'}, diff --git a/kitty.go b/kitty.go index ff6279d78d..56b83186df 100644 --- a/kitty.go +++ b/kitty.go @@ -7,32 +7,59 @@ import ( "github.com/charmbracelet/x/ansi" ) -// KittyKeyboardMsg represents Kitty keyboard progressive enhancement flags message. -type KittyKeyboardMsg int +// setKittyKeyboardFlagsMsg is a message to set Kitty keyboard progressive +// enhancement protocol flags. +type setKittyKeyboardFlagsMsg int -// IsDisambiguateEscapeCodes returns true if the DisambiguateEscapeCodes flag is set. -func (e KittyKeyboardMsg) IsDisambiguateEscapeCodes() bool { - return e&ansi.KittyDisambiguateEscapeCodes != 0 +// EnableKittyKeyboard is a command to enable Kitty keyboard progressive +// enhancements. +// +// The flags parameter is a bitmask of the following +// +// 1: Disambiguate escape codes +// 2: Report event types +// 4: Report alternate keys +// 8: Report all keys as escape codes +// 16: Report associated text +// +// See https://sw.kovidgoyal.net/kitty/keyboard-protocol/ for more information. +func EnableKittyKeyboard(flags int) Cmd { + return func() Msg { + return setKittyKeyboardFlagsMsg(flags) + } } -// IsReportEventTypes returns true if the ReportEventTypes flag is set. -func (e KittyKeyboardMsg) IsReportEventTypes() bool { - return e&ansi.KittyReportEventTypes != 0 +// DisableKittyKeyboard is a command to disable Kitty keyboard progressive +// enhancements. +func DisableKittyKeyboard() Msg { + return setKittyKeyboardFlagsMsg(0) } -// IsReportAlternateKeys returns true if the ReportAlternateKeys flag is set. -func (e KittyKeyboardMsg) IsReportAlternateKeys() bool { - return e&ansi.KittyReportAlternateKeys != 0 -} +// kittyKeyboardMsg is a message that queries the current Kitty keyboard +// progressive enhancement flags. +type kittyKeyboardMsg struct{} -// IsReportAllKeys returns true if the ReportAllKeys flag is set. -func (e KittyKeyboardMsg) IsReportAllKeys() bool { - return e&ansi.KittyReportAllKeys != 0 +// KittyKeyboard is a command that queries the current Kitty keyboard +// progressive enhancement flags from the terminal. +func KittyKeyboard() Msg { + return kittyKeyboardMsg{} } -// IsReportAssociatedKeys returns true if the ReportAssociatedKeys flag is set. -func (e KittyKeyboardMsg) IsReportAssociatedKeys() bool { - return e&ansi.KittyReportAssociatedKeys != 0 +// KittyKeyboardMsg represents Kitty keyboard progressive enhancement flags message. +type KittyKeyboardMsg int + +// Kitty Keyboard Protocol flags. +const ( + KittyDisambiguateEscapeCodes KittyKeyboardMsg = 1 << iota + KittyReportEventTypes + KittyReportAlternateKeys + KittyReportAllKeys + KittyReportAssociatedKeys +) + +// Contains reports whether m contains the given flags. +func (m KittyKeyboardMsg) Contains(flags KittyKeyboardMsg) bool { + return m&flags == flags } // Kitty Clipboard Control Sequences @@ -268,13 +295,13 @@ func parseKittyKeyboard(csi *ansi.CsiSequence) Msg { } } } - // TODO: Associated keys are not support yet. - // if params := csi.Subparams(2); len(params) > 0 { - // r := rune(params[0]) - // if unicode.IsPrint(r) { - // key.AltRune = r - // } - // } + if params := csi.Subparams(2); len(params) > 0 { + r := rune(params[0]) + if unicode.IsPrint(r) { + key.altRune = key.Rune() + key.Runes = []rune{r} + } + } if isRelease { return KeyReleaseMsg(key) } diff --git a/mod.go b/mod.go index a93ec72df4..9bb43a0cb3 100644 --- a/mod.go +++ b/mod.go @@ -24,47 +24,14 @@ const ( ModScrollLock // Defined in Windows API only ) -// HasShift reports whether the Shift modifier is set. -func (m KeyMod) HasShift() bool { - return m&ModShift != 0 -} - -// HasAlt reports whether the Alt modifier is set. -func (m KeyMod) HasAlt() bool { - return m&ModAlt != 0 -} - -// HasCtrl reports whether the Ctrl modifier is set. -func (m KeyMod) HasCtrl() bool { - return m&ModCtrl != 0 -} - -// HasMeta reports whether the Meta modifier is set. -func (m KeyMod) HasMeta() bool { - return m&ModMeta != 0 -} - -// HasHyper reports whether the Hyper modifier is set. -func (m KeyMod) HasHyper() bool { - return m&ModHyper != 0 -} - -// HasSuper reports whether the Super modifier is set. -func (m KeyMod) HasSuper() bool { - return m&ModSuper != 0 -} - -// HasCapsLock reports whether the CapsLock key is enabled. -func (m KeyMod) HasCapsLock() bool { - return m&ModCapsLock != 0 -} - -// HasNumLock reports whether the NumLock key is enabled. -func (m KeyMod) HasNumLock() bool { - return m&ModNumLock != 0 -} - -// HasScrollLock reports whether the ScrollLock key is enabled. -func (m KeyMod) HasScrollLock() bool { - return m&ModScrollLock != 0 +// Contains reports whether m contains the given modifiers. +// +// Example: +// +// m := ModAlt | ModCtrl +// m.Contains(ModCtrl) // true +// m.Contains(ModAlt | ModCtrl) // true +// m.Contains(ModAlt | ModCtrl | ModShift) // false +func (m KeyMod) Contains(mods KeyMod) bool { + return m&mods == mods } diff --git a/mouse.go b/mouse.go index 710770d2bb..f3460fa8f8 100644 --- a/mouse.go +++ b/mouse.go @@ -63,13 +63,13 @@ type Mouse struct { // String returns a string representation of the mouse message. func (m Mouse) String() (s string) { - if m.Mod.HasCtrl() { + if m.Mod.Contains(ModCtrl) { s += "ctrl+" } - if m.Mod.HasAlt() { + if m.Mod.Contains(ModAlt) { s += "alt+" } - if m.Mod.HasShift() { + if m.Mod.Contains(ModShift) { s += "shift+" } diff --git a/mouse_deprecated.go b/mouse_deprecated.go index fb2c41da6c..714b63fd22 100644 --- a/mouse_deprecated.go +++ b/mouse_deprecated.go @@ -154,9 +154,9 @@ func toMouseMsg(m Mouse) MouseMsg { return MouseMsg{ X: m.X, Y: m.Y, - Shift: m.Mod.HasShift(), - Alt: m.Mod.HasAlt(), - Ctrl: m.Mod.HasCtrl(), + Shift: m.Mod.Contains(ModShift), + Alt: m.Mod.Contains(ModAlt), + Ctrl: m.Mod.Contains(ModCtrl), Button: m.Button, } } diff --git a/options.go b/options.go index a810fe1c7b..6ff48f47ea 100644 --- a/options.go +++ b/options.go @@ -234,3 +234,56 @@ func WithFPS(fps int) ProgramOption { p.fps = fps } } + +// WithEnhancedKeyboard enables support for enhanced keyboard features. This +// unambiguously reports more key combinations than traditional terminal +// keyboard sequences. This might also enable reporting of release key events +// depending on the terminal emulator supporting it. +// +// This is a syntactic sugar for WithKittyKeyboard(3) and WithXtermModifyOtherKeys(1). +func WithEnhancedKeyboard() ProgramOption { + return func(p *Program) { + WithKittyKeyboard(3)(p) + WithModifyOtherKeys(1)(p) + } +} + +// WithKittyKeyboard enables support for the Kitty keyboard protocol. This +// protocol enables more key combinations and events than the traditional +// ambiguous terminal keyboard sequences. +// +// Use flags to specify which features you want to enable. +// +// 0: Disable all features +// 1: Disambiguate escape codes +// 2: Report event types +// 4: Report alternate keys +// 8: Report all keys as escape codes +// 16: Report associated text +// +// See https://sw.kovidgoyal.net/kitty/keyboard-protocol/ for more information. +func WithKittyKeyboard(flags int) ProgramOption { + return func(p *Program) { + p.kittyFlags = flags + p.startupOptions |= withKittyKeyboard + } +} + +// WithModifyOtherKeys enables support for the XTerm modifyOtherKeys feature. +// This feature allows the terminal to report ambiguous keys as escape codes. +// This is useful for terminals that don't support the Kitty keyboard protocol. +// +// The mode can be one of the following: +// +// 0: Disable modifyOtherKeys +// 1: Report ambiguous keys as escape codes +// 2: Report ambiguous keys as escape codes including modified keys like Alt- +// and Meta- +// +// See https://invisible-island.net/xterm/manpage/xterm.html#VT100-Widget-Resources:modifyOtherKeys +func WithModifyOtherKeys(mode int) ProgramOption { + return func(p *Program) { + p.modifyOtherKeys = mode + p.startupOptions |= withModifyOtherKeys + } +} diff --git a/screen_test.go b/screen_test.go index 478944abe3..863a67557b 100644 --- a/screen_test.go +++ b/screen_test.go @@ -66,6 +66,9 @@ func TestClearMsg(t *testing.T) { name: "bg_set_color", cmds: []Cmd{SetBackgroundColor(color.RGBA{255, 255, 255, 255})}, expected: "\x1b[?25l\x1b[?2004h\x1b]11;#ffffff\a\rsuccess\r\n\x1b[D\x1b[2K\r\x1b[?2004l\x1b[?25h\x1b[?1002l\x1b[?1003l\x1b[?1006l", + name: "kitty_start", + cmds: []Cmd{DisableKittyKeyboard, EnableKittyKeyboard(3)}, + expected: "\x1b[?25l\x1b[?2004h\x1b[>u\x1b[>3u\rsuccess\r\n\x1b[D\x1b[2K\r\x1b[?2004l\x1b[?25h\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[>0u", }, } diff --git a/tea.go b/tea.go index eab5f6050f..5f293fb70a 100644 --- a/tea.go +++ b/tea.go @@ -97,6 +97,8 @@ const ( // feature is on by default. withoutCatchPanics withoutBracketedPaste + withKittyKeyboard + withModifyOtherKeys ) // channelHandlers manages the series of channels returned by various processes. @@ -173,6 +175,12 @@ type Program struct { // fps is the frames per second we should set on the renderer, if // applicable, fps int + + // kittyFlags stores kitty keyboard protocol progressive enhancement flags. + kittyFlags int + + // modifyOtherKeys stores the XTerm modifyOtherKeys mode. + modifyOtherKeys int } // Quit is a special command that tells the Bubble Tea program to exit. @@ -416,6 +424,32 @@ func (p *Program) eventLoop(model Model, cmds chan Cmd) (Model, error) { case cursorColorMsg: p.renderer.execute(ansi.RequestCursorColor) + case KittyKeyboardMsg: + // Store the kitty flags whenever they are queried. + p.kittyFlags = int(msg) + + case setKittyKeyboardFlagsMsg: + p.kittyFlags = int(msg) + p.renderer.execute(ansi.PushKittyKeyboard(p.kittyFlags)) + + case kittyKeyboardMsg: + p.renderer.execute(ansi.RequestKittyKeyboard) + + case setModifyOtherKeysMsg: + p.modifyOtherKeys = int(msg) + p.renderer.execute(ansi.ModifyOtherKeys(p.modifyOtherKeys)) + + case setEnhancedKeyboardMsg: + if bool(msg) { + p.kittyFlags = 3 + p.modifyOtherKeys = 1 + } else { + p.kittyFlags = 0 + p.modifyOtherKeys = 0 + } + p.renderer.execute(ansi.ModifyOtherKeys(p.modifyOtherKeys)) + p.renderer.execute(ansi.PushKittyKeyboard(p.kittyFlags)) + case execMsg: // NB: this blocks. p.exec(msg.cmd, msg.fn) @@ -580,6 +614,12 @@ func (p *Program) Run() (Model, error) { p.renderer.execute(ansi.EnableMouseAllMotion) p.renderer.execute(ansi.EnableMouseSgrExt) } + if p.startupOptions&withModifyOtherKeys != 0 { + p.renderer.execute(ansi.ModifyOtherKeys(p.modifyOtherKeys)) + } + if p.startupOptions&withKittyKeyboard != 0 { + p.renderer.execute(ansi.PushKittyKeyboard(p.kittyFlags)) + } // Start the renderer. p.renderer.start() @@ -751,6 +791,12 @@ func (p *Program) RestoreTerminal() error { p.renderer.hideCursor() p.renderer.execute(ansi.EnableBracketedPaste) p.bpActive = true + if p.modifyOtherKeys != 0 { + p.renderer.execute(ansi.ModifyOtherKeys(p.modifyOtherKeys)) + } + if p.kittyFlags != 0 { + p.renderer.execute(ansi.PushKittyKeyboard(p.kittyFlags)) + } } // If the output is a terminal, it may have been resized while another diff --git a/tty.go b/tty.go index 9d5612cfbb..116f598f15 100644 --- a/tty.go +++ b/tty.go @@ -37,6 +37,12 @@ func (p *Program) restoreTerminalState() error { p.bpActive = false p.renderer.showCursor() p.disableMouse() + if p.modifyOtherKeys != 0 { + p.renderer.execute(ansi.DisableModifyOtherKeys) + } + if p.kittyFlags != 0 { + p.renderer.execute(ansi.DisableKittyKeyboard) + } if p.renderer.altScreen() { p.renderer.exitAltScreen() @@ -116,14 +122,14 @@ func readInputs(ctx context.Context, msgs chan<- Msg, reader *driver) error { incomingMsgs = append(incomingMsgs, k) case KeyPressMsg: k := KeyMsg{ - Alt: e.Mod.HasAlt(), + Alt: e.Mod.Contains(ModAlt), Runes: e.Runes, Type: e.Type, } // Backwards compatibility for ctrl- and shift- keys switch { - case e.Mod.HasCtrl() && e.Mod.HasShift(): + case e.Mod.Contains(ModCtrl | ModShift): switch e.Type { case KeyUp, KeyDown, KeyRight, KeyLeft: k.Runes = nil @@ -132,7 +138,7 @@ func readInputs(ctx context.Context, msgs chan<- Msg, reader *driver) error { k.Runes = nil k.Type = KeyCtrlShiftHome - e.Type + KeyHome } - case e.Mod.HasCtrl(): + case e.Mod.Contains(ModCtrl): switch e.Type { case KeyRunes: // KeyRunes switch r := e.Rune(); r { @@ -158,7 +164,7 @@ func readInputs(ctx context.Context, msgs chan<- Msg, reader *driver) error { k.Runes = nil k.Type = KeyCtrlUp - e.Type + KeyUp } - case e.Mod.HasShift(): + case e.Mod.Contains(ModShift): switch e.Type { case KeyTab: k.Runes = nil diff --git a/xterm.go b/xterm.go index f09caeba52..0589e21a1f 100644 --- a/xterm.go +++ b/xterm.go @@ -4,6 +4,29 @@ import ( "github.com/charmbracelet/x/ansi" ) +// setModifyOtherKeysMsg is a message to set XTerm modifyOtherKeys mode. +type setModifyOtherKeysMsg int + +// EnableXtermModifyOtherKeys is a command to enable XTerm modifyOtherKeys mode. +// +// The mode can be on of the following: +// +// 1: Report ambiguous keys as escape codes +// 2: Report ambiguous keys as escape codes including modified keys like Alt- +// and Meta- +// +// See https://invisible-island.net/xterm/manpage/xterm.html#VT100-Widget-Resources:modifyOtherKeys +func EnableModifyOtherKeys(mode int) Cmd { + return func() Msg { + return setModifyOtherKeysMsg(mode) + } +} + +// DisableModifyOtherKeys is a command to disable XTerm modifyOtherKeys mode. +func DisableModifyOtherKeys() Msg { + return setModifyOtherKeysMsg(0) +} + func parseXTermModifyOtherKeys(csi *ansi.CsiSequence) Msg { // XTerm modify other keys starts with ESC [ 27 ; ; ~ mod := KeyMod(csi.Param(1) - 1)