+3 -4

TODO.md

reviewed

··· 2 2 3 3 ## Not Bound 4 4 5 5 - - [ ] Key encoding (`key.h`, `key/encoder.h`, `key/event.h`) 6 6 - - [ ] Mouse encoding (`mouse.h`, `mouse/encoder.h`, `mouse/event.h`) 5 5 + - [x] Key encoding (`key.h`, `key/encoder.h`, `key/event.h`) 6 6 + - [x] Mouse encoding (`mouse.h`, `mouse/encoder.h`, `mouse/event.h`) 7 7 - [ ] OSC parser (`osc.h`) 8 8 - [ ] SGR parser (`sgr.h`) 9 9 - [ ] Paste utilities (`paste.h`) 10 10 - - [ ] Focus encoding (`focus.h`) 10 10 + - [x] Focus encoding (`focus.h`) 11 11 - [x] Kitty graphics (`kitty_graphics.h`) 12 12 - [x] Allocator (`allocator.h` — `ghostty_alloc`, `ghostty_free`) 13 13 - [ ] Selection type (`selection.h`) ··· 22 22 - [ ] `ghostty_grid_ref_hyperlink_uri()` 23 23 - [ ] `ghostty_terminal_point_from_grid_ref()` 24 24 - [ ] `ghostty_formatter_format_buf()` 25 25 - - [ ] `ghostty_focus_encode()`

+68

focus.go

reviewed

··· 1 1 + package libghostty 2 2 + 3 3 + // Focus encoding — encode focus in/out events into terminal escape 4 4 + // sequences (CSI I / CSI O) for focus reporting mode (mode 1004). 5 5 + // Wraps the C API from focus.h. 6 6 + 7 7 + /* 8 8 + #include <ghostty/vt.h> 9 9 + */ 10 10 + import "C" 11 11 + 12 12 + import "unsafe" 13 13 + 14 14 + // FocusEvent represents a focus gained or lost event for focus 15 15 + // reporting mode (mode 1004). 16 16 + // 17 17 + // C: GhosttyFocusEvent 18 18 + type FocusEvent int 19 19 + 20 20 + const ( 21 21 + // FocusGained indicates the terminal window gained focus. 22 22 + FocusGained FocusEvent = C.GHOSTTY_FOCUS_GAINED 23 23 + 24 24 + // FocusLost indicates the terminal window lost focus. 25 25 + FocusLost FocusEvent = C.GHOSTTY_FOCUS_LOST 26 26 + ) 27 27 + 28 28 + // FocusEncode encodes a focus event into a terminal escape sequence 29 29 + // and returns the result as a byte slice. 30 30 + func FocusEncode(event FocusEvent) ([]byte, error) { 31 31 + // Focus sequences are short (CSI I or CSI O = 3 bytes). 32 32 + var buf [16]byte 33 33 + var outLen C.size_t 34 34 + result := C.ghostty_focus_encode( 35 35 + C.GhosttyFocusEvent(event), 36 36 + (*C.char)(unsafe.Pointer(&buf[0])), 37 37 + C.size_t(len(buf)), 38 38 + &outLen, 39 39 + ) 40 40 + 41 41 + if result == C.GHOSTTY_SUCCESS { 42 42 + if outLen == 0 { 43 43 + return nil, nil 44 44 + } 45 45 + out := make([]byte, outLen) 46 46 + copy(out, buf[:outLen]) 47 47 + return out, nil 48 48 + } 49 49 + 50 50 + if result == C.GHOSTTY_OUT_OF_SPACE { 51 51 + dynBuf := make([]byte, outLen) 52 52 + var written C.size_t 53 53 + if err := resultError(C.ghostty_focus_encode( 54 54 + C.GhosttyFocusEvent(event), 55 55 + (*C.char)(unsafe.Pointer(&dynBuf[0])), 56 56 + outLen, 57 57 + &written, 58 58 + )); err != nil { 59 59 + return nil, err 60 60 + } 61 61 + if written == 0 { 62 62 + return nil, nil 63 63 + } 64 64 + return dynBuf[:written], nil 65 65 + } 66 66 + 67 67 + return nil, &Error{Result: Result(result)} 68 68 + }

+29

focus_test.go

reviewed

··· 1 1 + package libghostty 2 2 + 3 3 + import ( 4 4 + "testing" 5 5 + ) 6 6 + 7 7 + func TestFocusEncodeGained(t *testing.T) { 8 8 + out, err := FocusEncode(FocusGained) 9 9 + if err != nil { 10 10 + t.Fatal(err) 11 11 + } 12 12 + // Focus gained: CSI I = \x1b[I 13 13 + expected := "\x1b[I" 14 14 + if string(out) != expected { 15 15 + t.Fatalf("expected %q, got %q", expected, string(out)) 16 16 + } 17 17 + } 18 18 + 19 19 + func TestFocusEncodeLost(t *testing.T) { 20 20 + out, err := FocusEncode(FocusLost) 21 21 + if err != nil { 22 22 + t.Fatal(err) 23 23 + } 24 24 + // Focus lost: CSI O = \x1b[O 25 25 + expected := "\x1b[O" 26 26 + if string(out) != expected { 27 27 + t.Fatalf("expected %q, got %q", expected, string(out)) 28 28 + } 29 29 + }

+210

key_encoder.go

reviewed

··· 1 1 + package libghostty 2 2 + 3 3 + // Key encoder — encodes key events into terminal escape sequences. 4 4 + // Wraps the C APIs from key/encoder.h. 5 5 + 6 6 + /* 7 7 + #include <ghostty/vt.h> 8 8 + */ 9 9 + import "C" 10 10 + 11 11 + import "unsafe" 12 12 + 13 13 + // KeyEncoder encodes key events into terminal escape sequences, 14 14 + // supporting both legacy encoding and the Kitty Keyboard Protocol. 15 15 + // 16 16 + // Basic usage: 17 17 + // 1. Create an encoder with NewKeyEncoder. 18 18 + // 2. Configure options with SetOpt* methods or SetOptFromTerminal. 19 19 + // 3. Create key events, encode them with Encode, and free them. 20 20 + // 4. Free the encoder with Close when done. 21 21 + // 22 22 + // C: GhosttyKeyEncoder 23 23 + type KeyEncoder struct { 24 24 + ptr C.GhosttyKeyEncoder 25 25 + } 26 26 + 27 27 + // KittyKeyFlags is a bitmask of Kitty keyboard protocol flags. 28 28 + // C: GhosttyKittyKeyFlags 29 29 + type KittyKeyFlags uint8 30 30 + 31 31 + const ( 32 32 + // KittyKeyDisabled disables the Kitty keyboard protocol (all flags off). 33 33 + KittyKeyDisabled KittyKeyFlags = C.GHOSTTY_KITTY_KEY_DISABLED 34 34 + 35 35 + // KittyKeyDisambiguate enables disambiguating escape codes. 36 36 + KittyKeyDisambiguate KittyKeyFlags = C.GHOSTTY_KITTY_KEY_DISAMBIGUATE 37 37 + 38 38 + // KittyKeyReportEvents enables reporting key press and release events. 39 39 + KittyKeyReportEvents KittyKeyFlags = C.GHOSTTY_KITTY_KEY_REPORT_EVENTS 40 40 + 41 41 + // KittyKeyReportAlternates enables reporting alternate key codes. 42 42 + KittyKeyReportAlternates KittyKeyFlags = C.GHOSTTY_KITTY_KEY_REPORT_ALTERNATES 43 43 + 44 44 + // KittyKeyReportAll reports all key events including those normally 45 45 + // handled by the terminal. 46 46 + KittyKeyReportAll KittyKeyFlags = C.GHOSTTY_KITTY_KEY_REPORT_ALL 47 47 + 48 48 + // KittyKeyReportAssociated reports associated text with key events. 49 49 + KittyKeyReportAssociated KittyKeyFlags = C.GHOSTTY_KITTY_KEY_REPORT_ASSOCIATED 50 50 + 51 51 + // KittyKeyAll enables all Kitty keyboard protocol flags. 52 52 + KittyKeyAll KittyKeyFlags = C.GHOSTTY_KITTY_KEY_ALL 53 53 + ) 54 54 + 55 55 + // OptionAsAlt determines whether the macOS "option" key is treated as 56 56 + // "alt". 57 57 + // 58 58 + // C: GhosttyOptionAsAlt 59 59 + type OptionAsAlt int 60 60 + 61 61 + const ( 62 62 + // OptionAsAltFalse means the option key is not treated as alt. 63 63 + OptionAsAltFalse OptionAsAlt = C.GHOSTTY_OPTION_AS_ALT_FALSE 64 64 + 65 65 + // OptionAsAltTrue means the option key is treated as alt. 66 66 + OptionAsAltTrue OptionAsAlt = C.GHOSTTY_OPTION_AS_ALT_TRUE 67 67 + 68 68 + // OptionAsAltLeft means only the left option key is treated as alt. 69 69 + OptionAsAltLeft OptionAsAlt = C.GHOSTTY_OPTION_AS_ALT_LEFT 70 70 + 71 71 + // OptionAsAltRight means only the right option key is treated as alt. 72 72 + OptionAsAltRight OptionAsAlt = C.GHOSTTY_OPTION_AS_ALT_RIGHT 73 73 + ) 74 74 + 75 75 + // KeyEncoderOption identifies an encoder configuration option for use 76 76 + // with SetOpt. 77 77 + // 78 78 + // C: GhosttyKeyEncoderOption 79 79 + type KeyEncoderOption int 80 80 + 81 81 + const ( 82 82 + // KeyEncoderOptCursorKeyApplication sets DEC mode 1: cursor key 83 83 + // application mode (value: bool). 84 84 + KeyEncoderOptCursorKeyApplication KeyEncoderOption = C.GHOSTTY_KEY_ENCODER_OPT_CURSOR_KEY_APPLICATION 85 85 + 86 86 + // KeyEncoderOptKeypadKeyApplication sets DEC mode 66: keypad key 87 87 + // application mode (value: bool). 88 88 + KeyEncoderOptKeypadKeyApplication KeyEncoderOption = C.GHOSTTY_KEY_ENCODER_OPT_KEYPAD_KEY_APPLICATION 89 89 + 90 90 + // KeyEncoderOptIgnoreKeypadWithNumlock sets DEC mode 1035: ignore 91 91 + // keypad with numlock (value: bool). 92 92 + KeyEncoderOptIgnoreKeypadWithNumlock KeyEncoderOption = C.GHOSTTY_KEY_ENCODER_OPT_IGNORE_KEYPAD_WITH_NUMLOCK 93 93 + 94 94 + // KeyEncoderOptAltEscPrefix sets DEC mode 1036: alt sends escape 95 95 + // prefix (value: bool). 96 96 + KeyEncoderOptAltEscPrefix KeyEncoderOption = C.GHOSTTY_KEY_ENCODER_OPT_ALT_ESC_PREFIX 97 97 + 98 98 + // KeyEncoderOptModifyOtherKeysState2 sets xterm modifyOtherKeys 99 99 + // mode 2 (value: bool). 100 100 + KeyEncoderOptModifyOtherKeysState2 KeyEncoderOption = C.GHOSTTY_KEY_ENCODER_OPT_MODIFY_OTHER_KEYS_STATE_2 101 101 + 102 102 + // KeyEncoderOptKittyFlags sets Kitty keyboard protocol flags 103 103 + // (value: KittyKeyFlags bitmask). 104 104 + KeyEncoderOptKittyFlags KeyEncoderOption = C.GHOSTTY_KEY_ENCODER_OPT_KITTY_FLAGS 105 105 + 106 106 + // KeyEncoderOptMacOSOptionAsAlt sets the macOS option-as-alt 107 107 + // setting (value: OptionAsAlt). 108 108 + KeyEncoderOptMacOSOptionAsAlt KeyEncoderOption = C.GHOSTTY_KEY_ENCODER_OPT_MACOS_OPTION_AS_ALT 109 109 + 110 110 + // KeyEncoderOptBackarrowKeyMode sets backarrow key mode (value: bool). 111 111 + // When false (default), backspace emits 0x7f; when true, 0x08. 112 112 + KeyEncoderOptBackarrowKeyMode KeyEncoderOption = C.GHOSTTY_KEY_ENCODER_OPT_BACKARROW_KEY_MODE 113 113 + ) 114 114 + 115 115 + // NewKeyEncoder creates a new key encoder with default options. 116 116 + // The encoder must be freed with Close when no longer needed. 117 117 + func NewKeyEncoder() (*KeyEncoder, error) { 118 118 + var ptr C.GhosttyKeyEncoder 119 119 + if err := resultError(C.ghostty_key_encoder_new(nil, &ptr)); err != nil { 120 120 + return nil, err 121 121 + } 122 122 + return &KeyEncoder{ptr: ptr}, nil 123 123 + } 124 124 + 125 125 + // Close frees the underlying key encoder handle. After this call, 126 126 + // the encoder must not be used. 127 127 + func (enc *KeyEncoder) Close() { 128 128 + C.ghostty_key_encoder_free(enc.ptr) 129 129 + } 130 130 + 131 131 + // SetOptBool sets a boolean encoder option. Use this for options 132 132 + // that accept a bool value (most encoder options). 133 133 + func (enc *KeyEncoder) SetOptBool(opt KeyEncoderOption, val bool) { 134 134 + v := C.bool(val) 135 135 + C.ghostty_key_encoder_setopt(enc.ptr, C.GhosttyKeyEncoderOption(opt), unsafe.Pointer(&v)) 136 136 + } 137 137 + 138 138 + // SetOptKittyFlags sets the Kitty keyboard protocol flags on the 139 139 + // encoder. 140 140 + func (enc *KeyEncoder) SetOptKittyFlags(flags KittyKeyFlags) { 141 141 + v := C.GhosttyKittyKeyFlags(flags) 142 142 + C.ghostty_key_encoder_setopt(enc.ptr, C.GHOSTTY_KEY_ENCODER_OPT_KITTY_FLAGS, unsafe.Pointer(&v)) 143 143 + } 144 144 + 145 145 + // SetOptOptionAsAlt sets the macOS option-as-alt behavior on the 146 146 + // encoder. 147 147 + func (enc *KeyEncoder) SetOptOptionAsAlt(val OptionAsAlt) { 148 148 + v := C.GhosttyOptionAsAlt(val) 149 149 + C.ghostty_key_encoder_setopt(enc.ptr, C.GHOSTTY_KEY_ENCODER_OPT_MACOS_OPTION_AS_ALT, unsafe.Pointer(&v)) 150 150 + } 151 151 + 152 152 + // SetOptFromTerminal reads the terminal's current modes and flags and 153 153 + // applies them to the encoder's options. This sets cursor key 154 154 + // application mode, keypad mode, alt escape prefix, modifyOtherKeys 155 155 + // state, and Kitty keyboard protocol flags from the terminal state. 156 156 + // 157 157 + // Note that the macOS option-as-alt option cannot be determined from 158 158 + // terminal state and is reset to OptionAsAltFalse by this call. Use 159 159 + // SetOptOptionAsAlt afterward if needed. 160 160 + func (enc *KeyEncoder) SetOptFromTerminal(t *Terminal) { 161 161 + C.ghostty_key_encoder_setopt_from_terminal(enc.ptr, t.ptr) 162 162 + } 163 163 + 164 164 + // Encode encodes a key event into a terminal escape sequence and 165 165 + // returns the result as a byte slice. Not all key events produce 166 166 + // output (e.g. unmodified modifier keys); in that case, a nil slice 167 167 + // and nil error are returned. 168 168 + func (enc *KeyEncoder) Encode(event *KeyEvent) ([]byte, error) { 169 169 + // Most escape sequences fit in 128 bytes. Try with a stack buffer 170 170 + // first; fall back to a larger heap allocation if needed. 171 171 + var buf [128]byte 172 172 + var outLen C.size_t 173 173 + result := C.ghostty_key_encoder_encode( 174 174 + enc.ptr, 175 175 + event.ptr, 176 176 + (*C.char)(unsafe.Pointer(&buf[0])), 177 177 + C.size_t(len(buf)), 178 178 + &outLen, 179 179 + ) 180 180 + 181 181 + if result == C.GHOSTTY_SUCCESS { 182 182 + if outLen == 0 { 183 183 + return nil, nil 184 184 + } 185 185 + out := make([]byte, outLen) 186 186 + copy(out, buf[:outLen]) 187 187 + return out, nil 188 188 + } 189 189 + 190 190 + if result == C.GHOSTTY_OUT_OF_SPACE { 191 191 + // outLen contains the required buffer size. 192 192 + dynBuf := make([]byte, outLen) 193 193 + var written C.size_t 194 194 + if err := resultError(C.ghostty_key_encoder_encode( 195 195 + enc.ptr, 196 196 + event.ptr, 197 197 + (*C.char)(unsafe.Pointer(&dynBuf[0])), 198 198 + outLen, 199 199 + &written, 200 200 + )); err != nil { 201 201 + return nil, err 202 202 + } 203 203 + if written == 0 { 204 204 + return nil, nil 205 205 + } 206 206 + return dynBuf[:written], nil 207 207 + } 208 208 + 209 209 + return nil, &Error{Result: Result(result)} 210 210 + }

+395

key_event.go

reviewed

··· 1 1 + package libghostty 2 2 + 3 3 + // Key event representation and manipulation. 4 4 + // Wraps the C APIs from key/event.h. 5 5 + 6 6 + /* 7 7 + #include <ghostty/vt.h> 8 8 + */ 9 9 + import "C" 10 10 + 11 11 + import "unsafe" 12 12 + 13 13 + // KeyEvent is an opaque handle representing a keyboard input event 14 14 + // containing information about the physical key pressed, modifiers, 15 15 + // and generated text. 16 16 + // 17 17 + // C: GhosttyKeyEvent 18 18 + type KeyEvent struct { 19 19 + ptr C.GhosttyKeyEvent 20 20 + } 21 21 + 22 22 + // KeyAction represents the type of keyboard input event (press, release, 23 23 + // or repeat). 24 24 + // 25 25 + // C: GhosttyKeyAction 26 26 + type KeyAction int 27 27 + 28 28 + const ( 29 29 + // KeyActionRelease indicates a key was released. 30 30 + KeyActionRelease KeyAction = C.GHOSTTY_KEY_ACTION_RELEASE 31 31 + 32 32 + // KeyActionPress indicates a key was pressed. 33 33 + KeyActionPress KeyAction = C.GHOSTTY_KEY_ACTION_PRESS 34 34 + 35 35 + // KeyActionRepeat indicates a key is being held down (repeat). 36 36 + KeyActionRepeat KeyAction = C.GHOSTTY_KEY_ACTION_REPEAT 37 37 + ) 38 38 + 39 39 + // Mods is a bitmask representing keyboard modifier keys. 40 40 + // Use the Mods* constants to test and set individual modifiers. 41 41 + // 42 42 + // C: GhosttyMods 43 43 + type Mods uint16 44 44 + 45 45 + const ( 46 46 + // ModShift indicates the Shift key is pressed. 47 47 + ModShift Mods = C.GHOSTTY_MODS_SHIFT 48 48 + 49 49 + // ModCtrl indicates the Control key is pressed. 50 50 + ModCtrl Mods = C.GHOSTTY_MODS_CTRL 51 51 + 52 52 + // ModAlt indicates the Alt/Option key is pressed. 53 53 + ModAlt Mods = C.GHOSTTY_MODS_ALT 54 54 + 55 55 + // ModSuper indicates the Super/Command/Windows key is pressed. 56 56 + ModSuper Mods = C.GHOSTTY_MODS_SUPER 57 57 + 58 58 + // ModCapsLock indicates Caps Lock is active. 59 59 + ModCapsLock Mods = C.GHOSTTY_MODS_CAPS_LOCK 60 60 + 61 61 + // ModNumLock indicates Num Lock is active. 62 62 + ModNumLock Mods = C.GHOSTTY_MODS_NUM_LOCK 63 63 + 64 64 + // ModShiftSide indicates right Shift is pressed (0 = left, 1 = right). 65 65 + // Only meaningful when ModShift is set. 66 66 + ModShiftSide Mods = C.GHOSTTY_MODS_SHIFT_SIDE 67 67 + 68 68 + // ModCtrlSide indicates right Ctrl is pressed (0 = left, 1 = right). 69 69 + // Only meaningful when ModCtrl is set. 70 70 + ModCtrlSide Mods = C.GHOSTTY_MODS_CTRL_SIDE 71 71 + 72 72 + // ModAltSide indicates right Alt is pressed (0 = left, 1 = right). 73 73 + // Only meaningful when ModAlt is set. 74 74 + ModAltSide Mods = C.GHOSTTY_MODS_ALT_SIDE 75 75 + 76 76 + // ModSuperSide indicates right Super is pressed (0 = left, 1 = right). 77 77 + // Only meaningful when ModSuper is set. 78 78 + ModSuperSide Mods = C.GHOSTTY_MODS_SUPER_SIDE 79 79 + ) 80 80 + 81 81 + // Key represents a physical key code. These are layout-independent and 82 82 + // based on the W3C UI Events KeyboardEvent code standard. 83 83 + // 84 84 + // C: GhosttyKey 85 85 + type Key int 86 86 + 87 87 + // Writing System Keys (W3C § 3.1.1) 88 88 + const ( 89 89 + KeyUnidentified Key = C.GHOSTTY_KEY_UNIDENTIFIED 90 90 + KeyBackquote Key = C.GHOSTTY_KEY_BACKQUOTE 91 91 + KeyBackslash Key = C.GHOSTTY_KEY_BACKSLASH 92 92 + KeyBracketLeft Key = C.GHOSTTY_KEY_BRACKET_LEFT 93 93 + KeyBracketRight Key = C.GHOSTTY_KEY_BRACKET_RIGHT 94 94 + KeyComma Key = C.GHOSTTY_KEY_COMMA 95 95 + KeyDigit0 Key = C.GHOSTTY_KEY_DIGIT_0 96 96 + KeyDigit1 Key = C.GHOSTTY_KEY_DIGIT_1 97 97 + KeyDigit2 Key = C.GHOSTTY_KEY_DIGIT_2 98 98 + KeyDigit3 Key = C.GHOSTTY_KEY_DIGIT_3 99 99 + KeyDigit4 Key = C.GHOSTTY_KEY_DIGIT_4 100 100 + KeyDigit5 Key = C.GHOSTTY_KEY_DIGIT_5 101 101 + KeyDigit6 Key = C.GHOSTTY_KEY_DIGIT_6 102 102 + KeyDigit7 Key = C.GHOSTTY_KEY_DIGIT_7 103 103 + KeyDigit8 Key = C.GHOSTTY_KEY_DIGIT_8 104 104 + KeyDigit9 Key = C.GHOSTTY_KEY_DIGIT_9 105 105 + KeyEqual Key = C.GHOSTTY_KEY_EQUAL 106 106 + KeyIntlBackslash Key = C.GHOSTTY_KEY_INTL_BACKSLASH 107 107 + KeyIntlRo Key = C.GHOSTTY_KEY_INTL_RO 108 108 + KeyIntlYen Key = C.GHOSTTY_KEY_INTL_YEN 109 109 + KeyA Key = C.GHOSTTY_KEY_A 110 110 + KeyB Key = C.GHOSTTY_KEY_B 111 111 + KeyC Key = C.GHOSTTY_KEY_C 112 112 + KeyD Key = C.GHOSTTY_KEY_D 113 113 + KeyE Key = C.GHOSTTY_KEY_E 114 114 + KeyF Key = C.GHOSTTY_KEY_F 115 115 + KeyG Key = C.GHOSTTY_KEY_G 116 116 + KeyH Key = C.GHOSTTY_KEY_H 117 117 + KeyI Key = C.GHOSTTY_KEY_I 118 118 + KeyJ Key = C.GHOSTTY_KEY_J 119 119 + KeyK Key = C.GHOSTTY_KEY_K 120 120 + KeyL Key = C.GHOSTTY_KEY_L 121 121 + KeyM Key = C.GHOSTTY_KEY_M 122 122 + KeyN Key = C.GHOSTTY_KEY_N 123 123 + KeyO Key = C.GHOSTTY_KEY_O 124 124 + KeyP Key = C.GHOSTTY_KEY_P 125 125 + KeyQ Key = C.GHOSTTY_KEY_Q 126 126 + KeyR Key = C.GHOSTTY_KEY_R 127 127 + KeyS Key = C.GHOSTTY_KEY_S 128 128 + KeyT Key = C.GHOSTTY_KEY_T 129 129 + KeyU Key = C.GHOSTTY_KEY_U 130 130 + KeyV Key = C.GHOSTTY_KEY_V 131 131 + KeyW Key = C.GHOSTTY_KEY_W 132 132 + KeyX Key = C.GHOSTTY_KEY_X 133 133 + KeyY Key = C.GHOSTTY_KEY_Y 134 134 + KeyZ Key = C.GHOSTTY_KEY_Z 135 135 + KeyMinus Key = C.GHOSTTY_KEY_MINUS 136 136 + KeyPeriod Key = C.GHOSTTY_KEY_PERIOD 137 137 + KeyQuote Key = C.GHOSTTY_KEY_QUOTE 138 138 + KeySemicolon Key = C.GHOSTTY_KEY_SEMICOLON 139 139 + KeySlash Key = C.GHOSTTY_KEY_SLASH 140 140 + ) 141 141 + 142 142 + // Functional Keys (W3C § 3.1.2) 143 143 + const ( 144 144 + KeyAltLeft Key = C.GHOSTTY_KEY_ALT_LEFT 145 145 + KeyAltRight Key = C.GHOSTTY_KEY_ALT_RIGHT 146 146 + KeyBackspace Key = C.GHOSTTY_KEY_BACKSPACE 147 147 + KeyCapsLock Key = C.GHOSTTY_KEY_CAPS_LOCK 148 148 + KeyContextMenu Key = C.GHOSTTY_KEY_CONTEXT_MENU 149 149 + KeyControlLeft Key = C.GHOSTTY_KEY_CONTROL_LEFT 150 150 + KeyControlRight Key = C.GHOSTTY_KEY_CONTROL_RIGHT 151 151 + KeyEnter Key = C.GHOSTTY_KEY_ENTER 152 152 + KeyMetaLeft Key = C.GHOSTTY_KEY_META_LEFT 153 153 + KeyMetaRight Key = C.GHOSTTY_KEY_META_RIGHT 154 154 + KeyShiftLeft Key = C.GHOSTTY_KEY_SHIFT_LEFT 155 155 + KeyShiftRight Key = C.GHOSTTY_KEY_SHIFT_RIGHT 156 156 + KeySpace Key = C.GHOSTTY_KEY_SPACE 157 157 + KeyTab Key = C.GHOSTTY_KEY_TAB 158 158 + KeyConvert Key = C.GHOSTTY_KEY_CONVERT 159 159 + KeyKanaMode Key = C.GHOSTTY_KEY_KANA_MODE 160 160 + KeyNonConvert Key = C.GHOSTTY_KEY_NON_CONVERT 161 161 + ) 162 162 + 163 163 + // Control Pad Section (W3C § 3.2) 164 164 + const ( 165 165 + KeyDelete Key = C.GHOSTTY_KEY_DELETE 166 166 + KeyEnd Key = C.GHOSTTY_KEY_END 167 167 + KeyHelp Key = C.GHOSTTY_KEY_HELP 168 168 + KeyHome Key = C.GHOSTTY_KEY_HOME 169 169 + KeyInsert Key = C.GHOSTTY_KEY_INSERT 170 170 + KeyPageDown Key = C.GHOSTTY_KEY_PAGE_DOWN 171 171 + KeyPageUp Key = C.GHOSTTY_KEY_PAGE_UP 172 172 + ) 173 173 + 174 174 + // Arrow Pad Section (W3C § 3.3) 175 175 + const ( 176 176 + KeyArrowDown Key = C.GHOSTTY_KEY_ARROW_DOWN 177 177 + KeyArrowLeft Key = C.GHOSTTY_KEY_ARROW_LEFT 178 178 + KeyArrowRight Key = C.GHOSTTY_KEY_ARROW_RIGHT 179 179 + KeyArrowUp Key = C.GHOSTTY_KEY_ARROW_UP 180 180 + ) 181 181 + 182 182 + // Numpad Section (W3C § 3.4) 183 183 + const ( 184 184 + KeyNumLock Key = C.GHOSTTY_KEY_NUM_LOCK 185 185 + KeyNumpad0 Key = C.GHOSTTY_KEY_NUMPAD_0 186 186 + KeyNumpad1 Key = C.GHOSTTY_KEY_NUMPAD_1 187 187 + KeyNumpad2 Key = C.GHOSTTY_KEY_NUMPAD_2 188 188 + KeyNumpad3 Key = C.GHOSTTY_KEY_NUMPAD_3 189 189 + KeyNumpad4 Key = C.GHOSTTY_KEY_NUMPAD_4 190 190 + KeyNumpad5 Key = C.GHOSTTY_KEY_NUMPAD_5 191 191 + KeyNumpad6 Key = C.GHOSTTY_KEY_NUMPAD_6 192 192 + KeyNumpad7 Key = C.GHOSTTY_KEY_NUMPAD_7 193 193 + KeyNumpad8 Key = C.GHOSTTY_KEY_NUMPAD_8 194 194 + KeyNumpad9 Key = C.GHOSTTY_KEY_NUMPAD_9 195 195 + KeyNumpadAdd Key = C.GHOSTTY_KEY_NUMPAD_ADD 196 196 + KeyNumpadBackspace Key = C.GHOSTTY_KEY_NUMPAD_BACKSPACE 197 197 + KeyNumpadClear Key = C.GHOSTTY_KEY_NUMPAD_CLEAR 198 198 + KeyNumpadClearEntry Key = C.GHOSTTY_KEY_NUMPAD_CLEAR_ENTRY 199 199 + KeyNumpadComma Key = C.GHOSTTY_KEY_NUMPAD_COMMA 200 200 + KeyNumpadDecimal Key = C.GHOSTTY_KEY_NUMPAD_DECIMAL 201 201 + KeyNumpadDivide Key = C.GHOSTTY_KEY_NUMPAD_DIVIDE 202 202 + KeyNumpadEnter Key = C.GHOSTTY_KEY_NUMPAD_ENTER 203 203 + KeyNumpadEqual Key = C.GHOSTTY_KEY_NUMPAD_EQUAL 204 204 + KeyNumpadMemoryAdd Key = C.GHOSTTY_KEY_NUMPAD_MEMORY_ADD 205 205 + KeyNumpadMemoryClear Key = C.GHOSTTY_KEY_NUMPAD_MEMORY_CLEAR 206 206 + KeyNumpadMemoryRecall Key = C.GHOSTTY_KEY_NUMPAD_MEMORY_RECALL 207 207 + KeyNumpadMemoryStore Key = C.GHOSTTY_KEY_NUMPAD_MEMORY_STORE 208 208 + KeyNumpadMemorySub Key = C.GHOSTTY_KEY_NUMPAD_MEMORY_SUBTRACT 209 209 + KeyNumpadMultiply Key = C.GHOSTTY_KEY_NUMPAD_MULTIPLY 210 210 + KeyNumpadParenLeft Key = C.GHOSTTY_KEY_NUMPAD_PAREN_LEFT 211 211 + KeyNumpadParenRight Key = C.GHOSTTY_KEY_NUMPAD_PAREN_RIGHT 212 212 + KeyNumpadSubtract Key = C.GHOSTTY_KEY_NUMPAD_SUBTRACT 213 213 + KeyNumpadSeparator Key = C.GHOSTTY_KEY_NUMPAD_SEPARATOR 214 214 + KeyNumpadUp Key = C.GHOSTTY_KEY_NUMPAD_UP 215 215 + KeyNumpadDown Key = C.GHOSTTY_KEY_NUMPAD_DOWN 216 216 + KeyNumpadRight Key = C.GHOSTTY_KEY_NUMPAD_RIGHT 217 217 + KeyNumpadLeft Key = C.GHOSTTY_KEY_NUMPAD_LEFT 218 218 + KeyNumpadBegin Key = C.GHOSTTY_KEY_NUMPAD_BEGIN 219 219 + KeyNumpadHome Key = C.GHOSTTY_KEY_NUMPAD_HOME 220 220 + KeyNumpadEnd Key = C.GHOSTTY_KEY_NUMPAD_END 221 221 + KeyNumpadInsert Key = C.GHOSTTY_KEY_NUMPAD_INSERT 222 222 + KeyNumpadDelete Key = C.GHOSTTY_KEY_NUMPAD_DELETE 223 223 + KeyNumpadPageUp Key = C.GHOSTTY_KEY_NUMPAD_PAGE_UP 224 224 + KeyNumpadPageDown Key = C.GHOSTTY_KEY_NUMPAD_PAGE_DOWN 225 225 + ) 226 226 + 227 227 + // Function Section (W3C § 3.5) 228 228 + const ( 229 229 + KeyEscape Key = C.GHOSTTY_KEY_ESCAPE 230 230 + KeyF1 Key = C.GHOSTTY_KEY_F1 231 231 + KeyF2 Key = C.GHOSTTY_KEY_F2 232 232 + KeyF3 Key = C.GHOSTTY_KEY_F3 233 233 + KeyF4 Key = C.GHOSTTY_KEY_F4 234 234 + KeyF5 Key = C.GHOSTTY_KEY_F5 235 235 + KeyF6 Key = C.GHOSTTY_KEY_F6 236 236 + KeyF7 Key = C.GHOSTTY_KEY_F7 237 237 + KeyF8 Key = C.GHOSTTY_KEY_F8 238 238 + KeyF9 Key = C.GHOSTTY_KEY_F9 239 239 + KeyF10 Key = C.GHOSTTY_KEY_F10 240 240 + KeyF11 Key = C.GHOSTTY_KEY_F11 241 241 + KeyF12 Key = C.GHOSTTY_KEY_F12 242 242 + KeyF13 Key = C.GHOSTTY_KEY_F13 243 243 + KeyF14 Key = C.GHOSTTY_KEY_F14 244 244 + KeyF15 Key = C.GHOSTTY_KEY_F15 245 245 + KeyF16 Key = C.GHOSTTY_KEY_F16 246 246 + KeyF17 Key = C.GHOSTTY_KEY_F17 247 247 + KeyF18 Key = C.GHOSTTY_KEY_F18 248 248 + KeyF19 Key = C.GHOSTTY_KEY_F19 249 249 + KeyF20 Key = C.GHOSTTY_KEY_F20 250 250 + KeyF21 Key = C.GHOSTTY_KEY_F21 251 251 + KeyF22 Key = C.GHOSTTY_KEY_F22 252 252 + KeyF23 Key = C.GHOSTTY_KEY_F23 253 253 + KeyF24 Key = C.GHOSTTY_KEY_F24 254 254 + KeyF25 Key = C.GHOSTTY_KEY_F25 255 255 + KeyFn Key = C.GHOSTTY_KEY_FN 256 256 + KeyFnLock Key = C.GHOSTTY_KEY_FN_LOCK 257 257 + KeyPrintScreen Key = C.GHOSTTY_KEY_PRINT_SCREEN 258 258 + KeyScrollLock Key = C.GHOSTTY_KEY_SCROLL_LOCK 259 259 + KeyPause Key = C.GHOSTTY_KEY_PAUSE 260 260 + ) 261 261 + 262 262 + // Media Keys (W3C § 3.6) 263 263 + const ( 264 264 + KeyBrowserBack Key = C.GHOSTTY_KEY_BROWSER_BACK 265 265 + KeyBrowserFavorites Key = C.GHOSTTY_KEY_BROWSER_FAVORITES 266 266 + KeyBrowserForward Key = C.GHOSTTY_KEY_BROWSER_FORWARD 267 267 + KeyBrowserHome Key = C.GHOSTTY_KEY_BROWSER_HOME 268 268 + KeyBrowserRefresh Key = C.GHOSTTY_KEY_BROWSER_REFRESH 269 269 + KeyBrowserSearch Key = C.GHOSTTY_KEY_BROWSER_SEARCH 270 270 + KeyBrowserStop Key = C.GHOSTTY_KEY_BROWSER_STOP 271 271 + KeyEject Key = C.GHOSTTY_KEY_EJECT 272 272 + KeyLaunchApp1 Key = C.GHOSTTY_KEY_LAUNCH_APP_1 273 273 + KeyLaunchApp2 Key = C.GHOSTTY_KEY_LAUNCH_APP_2 274 274 + KeyLaunchMail Key = C.GHOSTTY_KEY_LAUNCH_MAIL 275 275 + KeyMediaPlayPause Key = C.GHOSTTY_KEY_MEDIA_PLAY_PAUSE 276 276 + KeyMediaSelect Key = C.GHOSTTY_KEY_MEDIA_SELECT 277 277 + KeyMediaStop Key = C.GHOSTTY_KEY_MEDIA_STOP 278 278 + KeyMediaTrackNext Key = C.GHOSTTY_KEY_MEDIA_TRACK_NEXT 279 279 + KeyMediaTrackPrevious Key = C.GHOSTTY_KEY_MEDIA_TRACK_PREVIOUS 280 280 + KeyPower Key = C.GHOSTTY_KEY_POWER 281 281 + KeySleep Key = C.GHOSTTY_KEY_SLEEP 282 282 + KeyAudioVolumeDown Key = C.GHOSTTY_KEY_AUDIO_VOLUME_DOWN 283 283 + KeyAudioVolumeMute Key = C.GHOSTTY_KEY_AUDIO_VOLUME_MUTE 284 284 + KeyAudioVolumeUp Key = C.GHOSTTY_KEY_AUDIO_VOLUME_UP 285 285 + KeyWakeUp Key = C.GHOSTTY_KEY_WAKE_UP 286 286 + ) 287 287 + 288 288 + // Legacy, Non-standard, and Special Keys (W3C § 3.7) 289 289 + const ( 290 290 + KeyCopy Key = C.GHOSTTY_KEY_COPY 291 291 + KeyCut Key = C.GHOSTTY_KEY_CUT 292 292 + KeyPaste Key = C.GHOSTTY_KEY_PASTE 293 293 + ) 294 294 + 295 295 + // NewKeyEvent creates a new key event with default values. The event 296 296 + // must be freed with Close when no longer needed. 297 297 + func NewKeyEvent() (*KeyEvent, error) { 298 298 + var ptr C.GhosttyKeyEvent 299 299 + if err := resultError(C.ghostty_key_event_new(nil, &ptr)); err != nil { 300 300 + return nil, err 301 301 + } 302 302 + return &KeyEvent{ptr: ptr}, nil 303 303 + } 304 304 + 305 305 + // Close frees the underlying key event handle. After this call, the 306 306 + // key event must not be used. 307 307 + func (e *KeyEvent) Close() { 308 308 + C.ghostty_key_event_free(e.ptr) 309 309 + } 310 310 + 311 311 + // SetAction sets the key action (press, release, repeat). 312 312 + func (e *KeyEvent) SetAction(action KeyAction) { 313 313 + C.ghostty_key_event_set_action(e.ptr, C.GhosttyKeyAction(action)) 314 314 + } 315 315 + 316 316 + // Action returns the key action (press, release, repeat). 317 317 + func (e *KeyEvent) Action() KeyAction { 318 318 + return KeyAction(C.ghostty_key_event_get_action(e.ptr)) 319 319 + } 320 320 + 321 321 + // SetKey sets the physical key code. 322 322 + func (e *KeyEvent) SetKey(key Key) { 323 323 + C.ghostty_key_event_set_key(e.ptr, C.GhosttyKey(key)) 324 324 + } 325 325 + 326 326 + // Key returns the physical key code. 327 327 + func (e *KeyEvent) Key() Key { 328 328 + return Key(C.ghostty_key_event_get_key(e.ptr)) 329 329 + } 330 330 + 331 331 + // SetMods sets the modifier keys bitmask. 332 332 + func (e *KeyEvent) SetMods(mods Mods) { 333 333 + C.ghostty_key_event_set_mods(e.ptr, C.GhosttyMods(mods)) 334 334 + } 335 335 + 336 336 + // Mods returns the modifier keys bitmask. 337 337 + func (e *KeyEvent) Mods() Mods { 338 338 + return Mods(C.ghostty_key_event_get_mods(e.ptr)) 339 339 + } 340 340 + 341 341 + // SetConsumedMods sets the consumed modifiers bitmask. 342 342 + func (e *KeyEvent) SetConsumedMods(mods Mods) { 343 343 + C.ghostty_key_event_set_consumed_mods(e.ptr, C.GhosttyMods(mods)) 344 344 + } 345 345 + 346 346 + // ConsumedMods returns the consumed modifiers bitmask. 347 347 + func (e *KeyEvent) ConsumedMods() Mods { 348 348 + return Mods(C.ghostty_key_event_get_consumed_mods(e.ptr)) 349 349 + } 350 350 + 351 351 + // SetComposing sets whether the key event is part of a composition sequence. 352 352 + func (e *KeyEvent) SetComposing(composing bool) { 353 353 + C.ghostty_key_event_set_composing(e.ptr, C.bool(composing)) 354 354 + } 355 355 + 356 356 + // Composing reports whether the key event is part of a composition sequence. 357 357 + func (e *KeyEvent) Composing() bool { 358 358 + return bool(C.ghostty_key_event_get_composing(e.ptr)) 359 359 + } 360 360 + 361 361 + // SetUTF8 sets the UTF-8 text generated by the key for the current 362 362 + // keyboard layout. Must contain the unmodified character before any 363 363 + // Ctrl/Meta transformations. Do not pass C0 control characters or 364 364 + // platform function key codes; pass an empty string instead and let 365 365 + // the encoder use the logical key. 366 366 + // 367 367 + // The string is not copied by the key event. The caller must ensure 368 368 + // the string remains valid for the lifetime needed by the event. 369 369 + func (e *KeyEvent) SetUTF8(s string) { 370 370 + if len(s) == 0 { 371 371 + C.ghostty_key_event_set_utf8(e.ptr, nil, 0) 372 372 + return 373 373 + } 374 374 + C.ghostty_key_event_set_utf8(e.ptr, (*C.char)(unsafe.Pointer(unsafe.StringData(s))), C.size_t(len(s))) 375 375 + } 376 376 + 377 377 + // UTF8 returns the UTF-8 text generated by the key event. 378 378 + func (e *KeyEvent) UTF8() string { 379 379 + var n C.size_t 380 380 + p := C.ghostty_key_event_get_utf8(e.ptr, &n) 381 381 + if p == nil || n == 0 { 382 382 + return "" 383 383 + } 384 384 + return C.GoStringN(p, C.int(n)) 385 385 + } 386 386 + 387 387 + // SetUnshiftedCodepoint sets the unshifted Unicode codepoint. 388 388 + func (e *KeyEvent) SetUnshiftedCodepoint(cp rune) { 389 389 + C.ghostty_key_event_set_unshifted_codepoint(e.ptr, C.uint32_t(cp)) 390 390 + } 391 391 + 392 392 + // UnshiftedCodepoint returns the unshifted Unicode codepoint. 393 393 + func (e *KeyEvent) UnshiftedCodepoint() rune { 394 394 + return rune(C.ghostty_key_event_get_unshifted_codepoint(e.ptr)) 395 395 + }

+252

key_test.go

reviewed

··· 1 1 + package libghostty 2 2 + 3 3 + import ( 4 4 + "testing" 5 5 + ) 6 6 + 7 7 + func TestKeyEventNewClose(t *testing.T) { 8 8 + ev, err := NewKeyEvent() 9 9 + if err != nil { 10 10 + t.Fatal(err) 11 11 + } 12 12 + defer ev.Close() 13 13 + } 14 14 + 15 15 + func TestKeyEventAction(t *testing.T) { 16 16 + ev, err := NewKeyEvent() 17 17 + if err != nil { 18 18 + t.Fatal(err) 19 19 + } 20 20 + defer ev.Close() 21 21 + 22 22 + ev.SetAction(KeyActionPress) 23 23 + if got := ev.Action(); got != KeyActionPress { 24 24 + t.Fatalf("expected KeyActionPress, got %d", got) 25 25 + } 26 26 + 27 27 + ev.SetAction(KeyActionRelease) 28 28 + if got := ev.Action(); got != KeyActionRelease { 29 29 + t.Fatalf("expected KeyActionRelease, got %d", got) 30 30 + } 31 31 + } 32 32 + 33 33 + func TestKeyEventKey(t *testing.T) { 34 34 + ev, err := NewKeyEvent() 35 35 + if err != nil { 36 36 + t.Fatal(err) 37 37 + } 38 38 + defer ev.Close() 39 39 + 40 40 + ev.SetKey(KeyA) 41 41 + if got := ev.Key(); got != KeyA { 42 42 + t.Fatalf("expected KeyA, got %d", got) 43 43 + } 44 44 + } 45 45 + 46 46 + func TestKeyEventMods(t *testing.T) { 47 47 + ev, err := NewKeyEvent() 48 48 + if err != nil { 49 49 + t.Fatal(err) 50 50 + } 51 51 + defer ev.Close() 52 52 + 53 53 + ev.SetMods(ModCtrl | ModShift) 54 54 + if got := ev.Mods(); got != ModCtrl|ModShift { 55 55 + t.Fatalf("expected Ctrl|Shift, got %d", got) 56 56 + } 57 57 + } 58 58 + 59 59 + func TestKeyEventConsumedMods(t *testing.T) { 60 60 + ev, err := NewKeyEvent() 61 61 + if err != nil { 62 62 + t.Fatal(err) 63 63 + } 64 64 + defer ev.Close() 65 65 + 66 66 + ev.SetConsumedMods(ModAlt) 67 67 + if got := ev.ConsumedMods(); got != ModAlt { 68 68 + t.Fatalf("expected ModAlt, got %d", got) 69 69 + } 70 70 + } 71 71 + 72 72 + func TestKeyEventComposing(t *testing.T) { 73 73 + ev, err := NewKeyEvent() 74 74 + if err != nil { 75 75 + t.Fatal(err) 76 76 + } 77 77 + defer ev.Close() 78 78 + 79 79 + ev.SetComposing(true) 80 80 + if !ev.Composing() { 81 81 + t.Fatal("expected composing to be true") 82 82 + } 83 83 + 84 84 + ev.SetComposing(false) 85 85 + if ev.Composing() { 86 86 + t.Fatal("expected composing to be false") 87 87 + } 88 88 + } 89 89 + 90 90 + func TestKeyEventUTF8(t *testing.T) { 91 91 + ev, err := NewKeyEvent() 92 92 + if err != nil { 93 93 + t.Fatal(err) 94 94 + } 95 95 + defer ev.Close() 96 96 + 97 97 + // Default should be empty. 98 98 + if got := ev.UTF8(); got != "" { 99 99 + t.Fatalf("expected empty, got %q", got) 100 100 + } 101 101 + 102 102 + text := "a" 103 103 + ev.SetUTF8(text) 104 104 + if got := ev.UTF8(); got != text { 105 105 + t.Fatalf("expected %q, got %q", text, got) 106 106 + } 107 107 + } 108 108 + 109 109 + func TestKeyEventUnshiftedCodepoint(t *testing.T) { 110 110 + ev, err := NewKeyEvent() 111 111 + if err != nil { 112 112 + t.Fatal(err) 113 113 + } 114 114 + defer ev.Close() 115 115 + 116 116 + ev.SetUnshiftedCodepoint('a') 117 117 + if got := ev.UnshiftedCodepoint(); got != 'a' { 118 118 + t.Fatalf("expected 'a', got %c", got) 119 119 + } 120 120 + } 121 121 + 122 122 + func TestKeyEncoderNewClose(t *testing.T) { 123 123 + enc, err := NewKeyEncoder() 124 124 + if err != nil { 125 125 + t.Fatal(err) 126 126 + } 127 127 + defer enc.Close() 128 128 + } 129 129 + 130 130 + func TestKeyEncoderEncodeSimpleKey(t *testing.T) { 131 131 + enc, err := NewKeyEncoder() 132 132 + if err != nil { 133 133 + t.Fatal(err) 134 134 + } 135 135 + defer enc.Close() 136 136 + 137 137 + ev, err := NewKeyEvent() 138 138 + if err != nil { 139 139 + t.Fatal(err) 140 140 + } 141 141 + defer ev.Close() 142 142 + 143 143 + // Encode 'a' key press with UTF-8 text. 144 144 + ev.SetAction(KeyActionPress) 145 145 + ev.SetKey(KeyA) 146 146 + ev.SetUTF8("a") 147 147 + 148 148 + out, err := enc.Encode(ev) 149 149 + if err != nil { 150 150 + t.Fatal(err) 151 151 + } 152 152 + if len(out) == 0 { 153 153 + t.Fatal("expected non-empty output for 'a' key press") 154 154 + } 155 155 + if string(out) != "a" { 156 156 + t.Fatalf("expected 'a', got %q", string(out)) 157 157 + } 158 158 + } 159 159 + 160 160 + func TestKeyEncoderEncodeArrowKey(t *testing.T) { 161 161 + enc, err := NewKeyEncoder() 162 162 + if err != nil { 163 163 + t.Fatal(err) 164 164 + } 165 165 + defer enc.Close() 166 166 + 167 167 + ev, err := NewKeyEvent() 168 168 + if err != nil { 169 169 + t.Fatal(err) 170 170 + } 171 171 + defer ev.Close() 172 172 + 173 173 + // Arrow up should produce an escape sequence. 174 174 + ev.SetAction(KeyActionPress) 175 175 + ev.SetKey(KeyArrowUp) 176 176 + 177 177 + out, err := enc.Encode(ev) 178 178 + if err != nil { 179 179 + t.Fatal(err) 180 180 + } 181 181 + if len(out) == 0 { 182 182 + t.Fatal("expected non-empty output for arrow up") 183 183 + } 184 184 + // Default mode: CSI A (\x1b[A) 185 185 + if string(out) != "\x1b[A" { 186 186 + t.Fatalf("expected \\x1b[A, got %q", string(out)) 187 187 + } 188 188 + } 189 189 + 190 190 + func TestKeyEncoderSetOptFromTerminal(t *testing.T) { 191 191 + term, err := NewTerminal(WithSize(80, 24)) 192 192 + if err != nil { 193 193 + t.Fatal(err) 194 194 + } 195 195 + defer term.Close() 196 196 + 197 197 + enc, err := NewKeyEncoder() 198 198 + if err != nil { 199 199 + t.Fatal(err) 200 200 + } 201 201 + defer enc.Close() 202 202 + 203 203 + // Should not panic. 204 204 + enc.SetOptFromTerminal(term) 205 205 + 206 206 + ev, err := NewKeyEvent() 207 207 + if err != nil { 208 208 + t.Fatal(err) 209 209 + } 210 210 + defer ev.Close() 211 211 + 212 212 + ev.SetAction(KeyActionPress) 213 213 + ev.SetKey(KeyA) 214 214 + ev.SetUTF8("a") 215 215 + 216 216 + out, err := enc.Encode(ev) 217 217 + if err != nil { 218 218 + t.Fatal(err) 219 219 + } 220 220 + if string(out) != "a" { 221 221 + t.Fatalf("expected 'a', got %q", string(out)) 222 222 + } 223 223 + } 224 224 + 225 225 + func TestKeyEncoderCursorKeyApplicationMode(t *testing.T) { 226 226 + enc, err := NewKeyEncoder() 227 227 + if err != nil { 228 228 + t.Fatal(err) 229 229 + } 230 230 + defer enc.Close() 231 231 + 232 232 + // Enable cursor key application mode. 233 233 + enc.SetOptBool(KeyEncoderOptCursorKeyApplication, true) 234 234 + 235 235 + ev, err := NewKeyEvent() 236 236 + if err != nil { 237 237 + t.Fatal(err) 238 238 + } 239 239 + defer ev.Close() 240 240 + 241 241 + ev.SetAction(KeyActionPress) 242 242 + ev.SetKey(KeyArrowUp) 243 243 + 244 244 + out, err := enc.Encode(ev) 245 245 + if err != nil { 246 246 + t.Fatal(err) 247 247 + } 248 248 + // Application mode: SS3 A (\x1bOA) 249 249 + if string(out) != "\x1bOA" { 250 250 + t.Fatalf("expected \\x1bOA in application mode, got %q", string(out)) 251 251 + } 252 252 + }

+241

mouse_encoder.go

reviewed

··· 1 1 + package libghostty 2 2 + 3 3 + // Mouse encoder — encodes mouse events into terminal escape sequences. 4 4 + // Wraps the C APIs from mouse/encoder.h. 5 5 + 6 6 + /* 7 7 + #include <ghostty/vt.h> 8 8 + 9 9 + // Helper to create a properly initialized GhosttyMouseEncoderSize (sized struct). 10 10 + static inline GhosttyMouseEncoderSize init_mouse_encoder_size() { 11 11 + GhosttyMouseEncoderSize s = {0}; 12 12 + s.size = sizeof(GhosttyMouseEncoderSize); 13 13 + return s; 14 14 + } 15 15 + */ 16 16 + import "C" 17 17 + 18 18 + import "unsafe" 19 19 + 20 20 + // MouseEncoder encodes mouse events into terminal escape sequences, 21 21 + // supporting X10, UTF-8, SGR, URxvt, and SGR-Pixels mouse protocols. 22 22 + // 23 23 + // Basic usage: 24 24 + // 1. Create an encoder with NewMouseEncoder. 25 25 + // 2. Configure options with SetOpt* methods or SetOptFromTerminal. 26 26 + // 3. Create mouse events, encode them with Encode, and free them. 27 27 + // 4. Free the encoder with Close when done. 28 28 + // 29 29 + // C: GhosttyMouseEncoder 30 30 + type MouseEncoder struct { 31 31 + ptr C.GhosttyMouseEncoder 32 32 + } 33 33 + 34 34 + // MouseTrackingMode selects which mouse events the terminal tracks. 35 35 + // 36 36 + // C: GhosttyMouseTrackingMode 37 37 + type MouseTrackingMode int 38 38 + 39 39 + const ( 40 40 + // MouseTrackingNone disables mouse reporting. 41 41 + MouseTrackingNone MouseTrackingMode = C.GHOSTTY_MOUSE_TRACKING_NONE 42 42 + 43 43 + // MouseTrackingX10 enables X10 mouse mode. 44 44 + MouseTrackingX10 MouseTrackingMode = C.GHOSTTY_MOUSE_TRACKING_X10 45 45 + 46 46 + // MouseTrackingNormal enables normal mouse mode (button press/release only). 47 47 + MouseTrackingNormal MouseTrackingMode = C.GHOSTTY_MOUSE_TRACKING_NORMAL 48 48 + 49 49 + // MouseTrackingButton enables button-event tracking mode. 50 50 + MouseTrackingButton MouseTrackingMode = C.GHOSTTY_MOUSE_TRACKING_BUTTON 51 51 + 52 52 + // MouseTrackingAny enables any-event tracking mode. 53 53 + MouseTrackingAny MouseTrackingMode = C.GHOSTTY_MOUSE_TRACKING_ANY 54 54 + ) 55 55 + 56 56 + // MouseFormat selects the wire format for mouse escape sequences. 57 57 + // 58 58 + // C: GhosttyMouseFormat 59 59 + type MouseFormat int 60 60 + 61 61 + const ( 62 62 + MouseFormatX10 MouseFormat = C.GHOSTTY_MOUSE_FORMAT_X10 63 63 + MouseFormatUTF8 MouseFormat = C.GHOSTTY_MOUSE_FORMAT_UTF8 64 64 + MouseFormatSGR MouseFormat = C.GHOSTTY_MOUSE_FORMAT_SGR 65 65 + MouseFormatURxvt MouseFormat = C.GHOSTTY_MOUSE_FORMAT_URXVT 66 66 + MouseFormatSGRPixels MouseFormat = C.GHOSTTY_MOUSE_FORMAT_SGR_PIXELS 67 67 + ) 68 68 + 69 69 + // MouseEncoderSize describes the rendered terminal geometry used to 70 70 + // convert surface-space positions into encoded coordinates. 71 71 + // 72 72 + // C: GhosttyMouseEncoderSize 73 73 + type MouseEncoderSize struct { 74 74 + // ScreenWidth is the full screen width in pixels. 75 75 + ScreenWidth uint32 76 76 + 77 77 + // ScreenHeight is the full screen height in pixels. 78 78 + ScreenHeight uint32 79 79 + 80 80 + // CellWidth is the cell width in pixels. Must be non-zero. 81 81 + CellWidth uint32 82 82 + 83 83 + // CellHeight is the cell height in pixels. Must be non-zero. 84 84 + CellHeight uint32 85 85 + 86 86 + // PaddingTop is the top padding in pixels. 87 87 + PaddingTop uint32 88 88 + 89 89 + // PaddingBottom is the bottom padding in pixels. 90 90 + PaddingBottom uint32 91 91 + 92 92 + // PaddingRight is the right padding in pixels. 93 93 + PaddingRight uint32 94 94 + 95 95 + // PaddingLeft is the left padding in pixels. 96 96 + PaddingLeft uint32 97 97 + } 98 98 + 99 99 + // MouseEncoderOption identifies a mouse encoder configuration option 100 100 + // for use with SetOpt. 101 101 + // 102 102 + // C: GhosttyMouseEncoderOption 103 103 + type MouseEncoderOption int 104 104 + 105 105 + const ( 106 106 + // MouseEncoderOptEvent sets the mouse tracking mode 107 107 + // (value: MouseTrackingMode). 108 108 + MouseEncoderOptEvent MouseEncoderOption = C.GHOSTTY_MOUSE_ENCODER_OPT_EVENT 109 109 + 110 110 + // MouseEncoderOptFormat sets the mouse output format 111 111 + // (value: MouseFormat). 112 112 + MouseEncoderOptFormat MouseEncoderOption = C.GHOSTTY_MOUSE_ENCODER_OPT_FORMAT 113 113 + 114 114 + // MouseEncoderOptSize sets the renderer size context 115 115 + // (value: MouseEncoderSize). 116 116 + MouseEncoderOptSize MouseEncoderOption = C.GHOSTTY_MOUSE_ENCODER_OPT_SIZE 117 117 + 118 118 + // MouseEncoderOptAnyButtonPressed sets whether any mouse button 119 119 + // is currently pressed (value: bool). 120 120 + MouseEncoderOptAnyButtonPressed MouseEncoderOption = C.GHOSTTY_MOUSE_ENCODER_OPT_ANY_BUTTON_PRESSED 121 121 + 122 122 + // MouseEncoderOptTrackLastCell enables motion deduplication by 123 123 + // last cell (value: bool). 124 124 + MouseEncoderOptTrackLastCell MouseEncoderOption = C.GHOSTTY_MOUSE_ENCODER_OPT_TRACK_LAST_CELL 125 125 + ) 126 126 + 127 127 + // NewMouseEncoder creates a new mouse encoder with default options. 128 128 + // The encoder must be freed with Close when no longer needed. 129 129 + func NewMouseEncoder() (*MouseEncoder, error) { 130 130 + var ptr C.GhosttyMouseEncoder 131 131 + if err := resultError(C.ghostty_mouse_encoder_new(nil, &ptr)); err != nil { 132 132 + return nil, err 133 133 + } 134 134 + return &MouseEncoder{ptr: ptr}, nil 135 135 + } 136 136 + 137 137 + // Close frees the underlying mouse encoder handle. After this call, 138 138 + // the encoder must not be used. 139 139 + func (enc *MouseEncoder) Close() { 140 140 + C.ghostty_mouse_encoder_free(enc.ptr) 141 141 + } 142 142 + 143 143 + // SetOptTrackingMode sets the mouse tracking mode on the encoder. 144 144 + func (enc *MouseEncoder) SetOptTrackingMode(mode MouseTrackingMode) { 145 145 + v := C.GhosttyMouseTrackingMode(mode) 146 146 + C.ghostty_mouse_encoder_setopt(enc.ptr, C.GHOSTTY_MOUSE_ENCODER_OPT_EVENT, unsafe.Pointer(&v)) 147 147 + } 148 148 + 149 149 + // SetOptFormat sets the mouse output format on the encoder. 150 150 + func (enc *MouseEncoder) SetOptFormat(format MouseFormat) { 151 151 + v := C.GhosttyMouseFormat(format) 152 152 + C.ghostty_mouse_encoder_setopt(enc.ptr, C.GHOSTTY_MOUSE_ENCODER_OPT_FORMAT, unsafe.Pointer(&v)) 153 153 + } 154 154 + 155 155 + // SetOptSize sets the renderer size context on the encoder. 156 156 + func (enc *MouseEncoder) SetOptSize(s MouseEncoderSize) { 157 157 + cs := C.init_mouse_encoder_size() 158 158 + cs.screen_width = C.uint32_t(s.ScreenWidth) 159 159 + cs.screen_height = C.uint32_t(s.ScreenHeight) 160 160 + cs.cell_width = C.uint32_t(s.CellWidth) 161 161 + cs.cell_height = C.uint32_t(s.CellHeight) 162 162 + cs.padding_top = C.uint32_t(s.PaddingTop) 163 163 + cs.padding_bottom = C.uint32_t(s.PaddingBottom) 164 164 + cs.padding_right = C.uint32_t(s.PaddingRight) 165 165 + cs.padding_left = C.uint32_t(s.PaddingLeft) 166 166 + C.ghostty_mouse_encoder_setopt(enc.ptr, C.GHOSTTY_MOUSE_ENCODER_OPT_SIZE, unsafe.Pointer(&cs)) 167 167 + } 168 168 + 169 169 + // SetOptAnyButtonPressed sets whether any mouse button is currently 170 170 + // pressed. 171 171 + func (enc *MouseEncoder) SetOptAnyButtonPressed(pressed bool) { 172 172 + v := C.bool(pressed) 173 173 + C.ghostty_mouse_encoder_setopt(enc.ptr, C.GHOSTTY_MOUSE_ENCODER_OPT_ANY_BUTTON_PRESSED, unsafe.Pointer(&v)) 174 174 + } 175 175 + 176 176 + // SetOptTrackLastCell enables or disables motion deduplication by 177 177 + // last cell. 178 178 + func (enc *MouseEncoder) SetOptTrackLastCell(track bool) { 179 179 + v := C.bool(track) 180 180 + C.ghostty_mouse_encoder_setopt(enc.ptr, C.GHOSTTY_MOUSE_ENCODER_OPT_TRACK_LAST_CELL, unsafe.Pointer(&v)) 181 181 + } 182 182 + 183 183 + // SetOptFromTerminal reads the terminal's current mouse tracking mode 184 184 + // and output format and applies them to the encoder. It does not 185 185 + // modify size or any-button state. 186 186 + func (enc *MouseEncoder) SetOptFromTerminal(t *Terminal) { 187 187 + C.ghostty_mouse_encoder_setopt_from_terminal(enc.ptr, t.ptr) 188 188 + } 189 189 + 190 190 + // Reset clears internal encoder state such as motion deduplication 191 191 + // (last tracked cell). 192 192 + func (enc *MouseEncoder) Reset() { 193 193 + C.ghostty_mouse_encoder_reset(enc.ptr) 194 194 + } 195 195 + 196 196 + // Encode encodes a mouse event into a terminal escape sequence and 197 197 + // returns the result as a byte slice. Not all mouse events produce 198 198 + // output; in that case, a nil slice and nil error are returned. 199 199 + func (enc *MouseEncoder) Encode(event *MouseEvent) ([]byte, error) { 200 200 + // Most mouse escape sequences fit in 128 bytes. Try with a stack 201 201 + // buffer first; fall back to a larger heap allocation if needed. 202 202 + var buf [128]byte 203 203 + var outLen C.size_t 204 204 + result := C.ghostty_mouse_encoder_encode( 205 205 + enc.ptr, 206 206 + event.ptr, 207 207 + (*C.char)(unsafe.Pointer(&buf[0])), 208 208 + C.size_t(len(buf)), 209 209 + &outLen, 210 210 + ) 211 211 + 212 212 + if result == C.GHOSTTY_SUCCESS { 213 213 + if outLen == 0 { 214 214 + return nil, nil 215 215 + } 216 216 + out := make([]byte, outLen) 217 217 + copy(out, buf[:outLen]) 218 218 + return out, nil 219 219 + } 220 220 + 221 221 + if result == C.GHOSTTY_OUT_OF_SPACE { 222 222 + // outLen contains the required buffer size. 223 223 + dynBuf := make([]byte, outLen) 224 224 + var written C.size_t 225 225 + if err := resultError(C.ghostty_mouse_encoder_encode( 226 226 + enc.ptr, 227 227 + event.ptr, 228 228 + (*C.char)(unsafe.Pointer(&dynBuf[0])), 229 229 + outLen, 230 230 + &written, 231 231 + )); err != nil { 232 232 + return nil, err 233 233 + } 234 234 + if written == 0 { 235 235 + return nil, nil 236 236 + } 237 237 + return dynBuf[:written], nil 238 238 + } 239 239 + 240 240 + return nil, &Error{Result: Result(result)} 241 241 + }

+132

mouse_event.go

reviewed

··· 1 1 + package libghostty 2 2 + 3 3 + // Mouse event representation and manipulation. 4 4 + // Wraps the C APIs from mouse/event.h. 5 5 + 6 6 + /* 7 7 + #include <ghostty/vt.h> 8 8 + */ 9 9 + import "C" 10 10 + 11 11 + // MouseEvent is an opaque handle representing a normalized mouse 12 12 + // input event containing action, button, modifiers, and surface-space 13 13 + // position. 14 14 + // 15 15 + // C: GhosttyMouseEvent 16 16 + type MouseEvent struct { 17 17 + ptr C.GhosttyMouseEvent 18 18 + } 19 19 + 20 20 + // MouseAction represents the type of mouse event (press, release, 21 21 + // or motion). 22 22 + // 23 23 + // C: GhosttyMouseAction 24 24 + type MouseAction int 25 25 + 26 26 + const ( 27 27 + // MouseActionPress indicates a mouse button was pressed. 28 28 + MouseActionPress MouseAction = C.GHOSTTY_MOUSE_ACTION_PRESS 29 29 + 30 30 + // MouseActionRelease indicates a mouse button was released. 31 31 + MouseActionRelease MouseAction = C.GHOSTTY_MOUSE_ACTION_RELEASE 32 32 + 33 33 + // MouseActionMotion indicates the mouse moved. 34 34 + MouseActionMotion MouseAction = C.GHOSTTY_MOUSE_ACTION_MOTION 35 35 + ) 36 36 + 37 37 + // MouseButton identifies which mouse button was involved in an event. 38 38 + // 39 39 + // C: GhosttyMouseButton 40 40 + type MouseButton int 41 41 + 42 42 + const ( 43 43 + MouseButtonUnknown MouseButton = C.GHOSTTY_MOUSE_BUTTON_UNKNOWN 44 44 + MouseButtonLeft MouseButton = C.GHOSTTY_MOUSE_BUTTON_LEFT 45 45 + MouseButtonRight MouseButton = C.GHOSTTY_MOUSE_BUTTON_RIGHT 46 46 + MouseButtonMiddle MouseButton = C.GHOSTTY_MOUSE_BUTTON_MIDDLE 47 47 + MouseButtonFour MouseButton = C.GHOSTTY_MOUSE_BUTTON_FOUR 48 48 + MouseButtonFive MouseButton = C.GHOSTTY_MOUSE_BUTTON_FIVE 49 49 + MouseButtonSix MouseButton = C.GHOSTTY_MOUSE_BUTTON_SIX 50 50 + MouseButtonSeven MouseButton = C.GHOSTTY_MOUSE_BUTTON_SEVEN 51 51 + MouseButtonEight MouseButton = C.GHOSTTY_MOUSE_BUTTON_EIGHT 52 52 + MouseButtonNine MouseButton = C.GHOSTTY_MOUSE_BUTTON_NINE 53 53 + MouseButtonTen MouseButton = C.GHOSTTY_MOUSE_BUTTON_TEN 54 54 + MouseButtonEleven MouseButton = C.GHOSTTY_MOUSE_BUTTON_ELEVEN 55 55 + ) 56 56 + 57 57 + // MousePosition represents a mouse position in surface-space pixels. 58 58 + // 59 59 + // C: GhosttyMousePosition 60 60 + type MousePosition struct { 61 61 + X float32 62 62 + Y float32 63 63 + } 64 64 + 65 65 + // NewMouseEvent creates a new mouse event with default values. The 66 66 + // event must be freed with Close when no longer needed. 67 67 + func NewMouseEvent() (*MouseEvent, error) { 68 68 + var ptr C.GhosttyMouseEvent 69 69 + if err := resultError(C.ghostty_mouse_event_new(nil, &ptr)); err != nil { 70 70 + return nil, err 71 71 + } 72 72 + return &MouseEvent{ptr: ptr}, nil 73 73 + } 74 74 + 75 75 + // Close frees the underlying mouse event handle. After this call, 76 76 + // the mouse event must not be used. 77 77 + func (e *MouseEvent) Close() { 78 78 + C.ghostty_mouse_event_free(e.ptr) 79 79 + } 80 80 + 81 81 + // SetAction sets the mouse action (press, release, motion). 82 82 + func (e *MouseEvent) SetAction(action MouseAction) { 83 83 + C.ghostty_mouse_event_set_action(e.ptr, C.GhosttyMouseAction(action)) 84 84 + } 85 85 + 86 86 + // Action returns the mouse action (press, release, motion). 87 87 + func (e *MouseEvent) Action() MouseAction { 88 88 + return MouseAction(C.ghostty_mouse_event_get_action(e.ptr)) 89 89 + } 90 90 + 91 91 + // SetButton sets the mouse button for the event. 92 92 + func (e *MouseEvent) SetButton(button MouseButton) { 93 93 + C.ghostty_mouse_event_set_button(e.ptr, C.GhosttyMouseButton(button)) 94 94 + } 95 95 + 96 96 + // ClearButton clears the event button, setting it to "none". 97 97 + // Use this for motion events with no button pressed. 98 98 + func (e *MouseEvent) ClearButton() { 99 99 + C.ghostty_mouse_event_clear_button(e.ptr) 100 100 + } 101 101 + 102 102 + // Button returns the mouse button and whether one is set. If no 103 103 + // button is set (e.g. a motion-only event), ok is false. 104 104 + func (e *MouseEvent) Button() (button MouseButton, ok bool) { 105 105 + var b C.GhosttyMouseButton 106 106 + ok = bool(C.ghostty_mouse_event_get_button(e.ptr, &b)) 107 107 + return MouseButton(b), ok 108 108 + } 109 109 + 110 110 + // SetMods sets the keyboard modifiers held during the mouse event. 111 111 + func (e *MouseEvent) SetMods(mods Mods) { 112 112 + C.ghostty_mouse_event_set_mods(e.ptr, C.GhosttyMods(mods)) 113 113 + } 114 114 + 115 115 + // Mods returns the keyboard modifiers held during the mouse event. 116 116 + func (e *MouseEvent) Mods() Mods { 117 117 + return Mods(C.ghostty_mouse_event_get_mods(e.ptr)) 118 118 + } 119 119 + 120 120 + // SetPosition sets the event position in surface-space pixels. 121 121 + func (e *MouseEvent) SetPosition(pos MousePosition) { 122 122 + C.ghostty_mouse_event_set_position(e.ptr, C.GhosttyMousePosition{ 123 123 + x: C.float(pos.X), 124 124 + y: C.float(pos.Y), 125 125 + }) 126 126 + } 127 127 + 128 128 + // Position returns the event position in surface-space pixels. 129 129 + func (e *MouseEvent) Position() MousePosition { 130 130 + p := C.ghostty_mouse_event_get_position(e.ptr) 131 131 + return MousePosition{X: float32(p.x), Y: float32(p.y)} 132 132 + }

+165

mouse_test.go

reviewed

··· 1 1 + package libghostty 2 2 + 3 3 + import ( 4 4 + "testing" 5 5 + ) 6 6 + 7 7 + func TestMouseEventNewClose(t *testing.T) { 8 8 + ev, err := NewMouseEvent() 9 9 + if err != nil { 10 10 + t.Fatal(err) 11 11 + } 12 12 + defer ev.Close() 13 13 + } 14 14 + 15 15 + func TestMouseEventAction(t *testing.T) { 16 16 + ev, err := NewMouseEvent() 17 17 + if err != nil { 18 18 + t.Fatal(err) 19 19 + } 20 20 + defer ev.Close() 21 21 + 22 22 + ev.SetAction(MouseActionPress) 23 23 + if got := ev.Action(); got != MouseActionPress { 24 24 + t.Fatalf("expected MouseActionPress, got %d", got) 25 25 + } 26 26 + 27 27 + ev.SetAction(MouseActionRelease) 28 28 + if got := ev.Action(); got != MouseActionRelease { 29 29 + t.Fatalf("expected MouseActionRelease, got %d", got) 30 30 + } 31 31 + 32 32 + ev.SetAction(MouseActionMotion) 33 33 + if got := ev.Action(); got != MouseActionMotion { 34 34 + t.Fatalf("expected MouseActionMotion, got %d", got) 35 35 + } 36 36 + } 37 37 + 38 38 + func TestMouseEventButton(t *testing.T) { 39 39 + ev, err := NewMouseEvent() 40 40 + if err != nil { 41 41 + t.Fatal(err) 42 42 + } 43 43 + defer ev.Close() 44 44 + 45 45 + ev.SetButton(MouseButtonLeft) 46 46 + btn, ok := ev.Button() 47 47 + if !ok { 48 48 + t.Fatal("expected button to be set") 49 49 + } 50 50 + if btn != MouseButtonLeft { 51 51 + t.Fatalf("expected MouseButtonLeft, got %d", btn) 52 52 + } 53 53 + 54 54 + ev.ClearButton() 55 55 + _, ok = ev.Button() 56 56 + if ok { 57 57 + t.Fatal("expected button to be cleared") 58 58 + } 59 59 + } 60 60 + 61 61 + func TestMouseEventMods(t *testing.T) { 62 62 + ev, err := NewMouseEvent() 63 63 + if err != nil { 64 64 + t.Fatal(err) 65 65 + } 66 66 + defer ev.Close() 67 67 + 68 68 + ev.SetMods(ModCtrl | ModShift) 69 69 + if got := ev.Mods(); got != ModCtrl|ModShift { 70 70 + t.Fatalf("expected Ctrl|Shift, got %d", got) 71 71 + } 72 72 + } 73 73 + 74 74 + func TestMouseEventPosition(t *testing.T) { 75 75 + ev, err := NewMouseEvent() 76 76 + if err != nil { 77 77 + t.Fatal(err) 78 78 + } 79 79 + defer ev.Close() 80 80 + 81 81 + pos := MousePosition{X: 10.5, Y: 20.75} 82 82 + ev.SetPosition(pos) 83 83 + got := ev.Position() 84 84 + if got.X != pos.X || got.Y != pos.Y { 85 85 + t.Fatalf("expected %+v, got %+v", pos, got) 86 86 + } 87 87 + } 88 88 + 89 89 + func TestMouseEncoderNewClose(t *testing.T) { 90 90 + enc, err := NewMouseEncoder() 91 91 + if err != nil { 92 92 + t.Fatal(err) 93 93 + } 94 94 + defer enc.Close() 95 95 + } 96 96 + 97 97 + func TestMouseEncoderEncodeNormalSGR(t *testing.T) { 98 98 + enc, err := NewMouseEncoder() 99 99 + if err != nil { 100 100 + t.Fatal(err) 101 101 + } 102 102 + defer enc.Close() 103 103 + 104 104 + // Configure for normal tracking with SGR format. 105 105 + enc.SetOptTrackingMode(MouseTrackingNormal) 106 106 + enc.SetOptFormat(MouseFormatSGR) 107 107 + enc.SetOptSize(MouseEncoderSize{ 108 108 + ScreenWidth: 640, 109 109 + ScreenHeight: 480, 110 110 + CellWidth: 8, 111 111 + CellHeight: 16, 112 112 + }) 113 113 + 114 114 + ev, err := NewMouseEvent() 115 115 + if err != nil { 116 116 + t.Fatal(err) 117 117 + } 118 118 + defer ev.Close() 119 119 + 120 120 + // Left button press at cell (1,1) — position (0,0) in pixels. 121 121 + ev.SetAction(MouseActionPress) 122 122 + ev.SetButton(MouseButtonLeft) 123 123 + ev.SetPosition(MousePosition{X: 0, Y: 0}) 124 124 + 125 125 + out, err := enc.Encode(ev) 126 126 + if err != nil { 127 127 + t.Fatal(err) 128 128 + } 129 129 + if len(out) == 0 { 130 130 + t.Fatal("expected non-empty output for mouse press") 131 131 + } 132 132 + // SGR press format: \x1b[<0;1;1M 133 133 + expected := "\x1b[<0;1;1M" 134 134 + if string(out) != expected { 135 135 + t.Fatalf("expected %q, got %q", expected, string(out)) 136 136 + } 137 137 + } 138 138 + 139 139 + func TestMouseEncoderReset(t *testing.T) { 140 140 + enc, err := NewMouseEncoder() 141 141 + if err != nil { 142 142 + t.Fatal(err) 143 143 + } 144 144 + defer enc.Close() 145 145 + 146 146 + // Should not panic. 147 147 + enc.Reset() 148 148 + } 149 149 + 150 150 + func TestMouseEncoderSetOptFromTerminal(t *testing.T) { 151 151 + term, err := NewTerminal(WithSize(80, 24)) 152 152 + if err != nil { 153 153 + t.Fatal(err) 154 154 + } 155 155 + defer term.Close() 156 156 + 157 157 + enc, err := NewMouseEncoder() 158 158 + if err != nil { 159 159 + t.Fatal(err) 160 160 + } 161 161 + defer enc.Close() 162 162 + 163 163 + // Should not panic. 164 164 + enc.SetOptFromTerminal(term) 165 165 + }

-31

terminal.go

reviewed

··· 367 367 Len uint64 368 368 } 369 369 370 370 - // KittyKeyFlags holds the current Kitty keyboard protocol flags. 371 371 - // These can be combined using bitwise OR. 372 372 - // C: GhosttyKittyKeyFlags (uint8_t) 373 373 - type KittyKeyFlags uint8 374 374 - 375 375 - // Kitty keyboard protocol flag constants. 376 376 - const ( 377 377 - // KittyKeyDisabled means the Kitty keyboard protocol is disabled. 378 378 - KittyKeyDisabled KittyKeyFlags = C.GHOSTTY_KITTY_KEY_DISABLED 379 379 - 380 380 - // KittyKeyDisambiguate enables disambiguating escape codes. 381 381 - KittyKeyDisambiguate KittyKeyFlags = C.GHOSTTY_KITTY_KEY_DISAMBIGUATE 382 382 - 383 383 - // KittyKeyReportEvents enables reporting key press and release events. 384 384 - KittyKeyReportEvents KittyKeyFlags = C.GHOSTTY_KITTY_KEY_REPORT_EVENTS 385 385 - 386 386 - // KittyKeyReportAlternates enables reporting alternate key codes. 387 387 - KittyKeyReportAlternates KittyKeyFlags = C.GHOSTTY_KITTY_KEY_REPORT_ALTERNATES 388 388 - 389 389 - // KittyKeyReportAll enables reporting all key events including those 390 390 - // normally handled by the terminal. 391 391 - KittyKeyReportAll KittyKeyFlags = C.GHOSTTY_KITTY_KEY_REPORT_ALL 392 392 - 393 393 - // KittyKeyReportAssociated enables reporting associated text with 394 394 - // key events. 395 395 - KittyKeyReportAssociated KittyKeyFlags = C.GHOSTTY_KITTY_KEY_REPORT_ASSOCIATED 396 396 - 397 397 - // KittyKeyAll has all Kitty keyboard protocol flags enabled. 398 398 - KittyKeyAll KittyKeyFlags = C.GHOSTTY_KITTY_KEY_ALL 399 399 - ) 400 400 - 401 370 // KittyGraphics returns the Kitty graphics image storage for the 402 371 // terminal's active screen. The returned handle is borrowed from 403 372 // the terminal and remains valid until the next mutating call