| " Test MS-Windows input event handling. |
| " Most of this works the same in Windows GUI as well as Windows console. |
| |
| source check.vim |
| CheckMSWindows |
| source mouse.vim |
| |
| " Helper function for sending a grouped sequence of low level key presses |
| " The modifier key(s) can be included as VK Key Codes in the sequence |
| " Keydown events will be sent, to to the end of the group, then keyup events |
| " will be sent in reverse order to release the keys. |
| func SendKeyGroup(keygroup) |
| for k in a:keygroup |
| call test_mswin_event("key", {'event': "keydown", 'keycode': k}) |
| endfor |
| for k in reverse(copy(a:keygroup)) |
| call test_mswin_event("key", {'event': "keyup", 'keycode': k}) |
| endfor |
| endfunc |
| |
| " Send individual key press and release events. |
| " the modifiers for the key press can be specified in the modifiers arg. |
| func SendKeyWithModifiers(key, modifiers) |
| let args = { } |
| let args.keycode = a:key |
| let args.modifiers = a:modifiers |
| let args.event = "keydown" |
| call test_mswin_event("key", args) |
| let args.event = "keyup" |
| call test_mswin_event("key", args) |
| unlet args |
| endfunc |
| |
| " Send an individual key press, without modifiers. |
| func SendKey(key) |
| call SendKeyWithModifiers(a:key, 0) |
| endfunc |
| |
| " getcharstr(0) but catch Vim:Interrupt |
| func Getcharstr() |
| try |
| let ch = getcharstr(0) |
| catch /^Vim:Interrupt$/ |
| let ch = "\<c-c>" |
| endtry |
| return ch |
| endfunc |
| |
| |
| " Send a string of individual key-press events, without modifiers. |
| func SendKeyStr(keystring) |
| for k in a:keystring |
| call SendKey(k) |
| endfor |
| endfunc |
| |
| " This tells Vim to execute the buffered keys as user commands, |
| " ie. same as feekdeys with mode X would do. |
| func ExecuteBufferedKeys() |
| if has('gui_running') |
| call feedkeys("\<Esc>", 'Lx!') |
| else |
| call test_mswin_event("key", {'execute': v:true}) |
| endif |
| endfunc |
| |
| " Refer to the following page for the virtual key codes: |
| " https://docs.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes |
| let s:VK = { |
| \ 'ENTER' : 0x0D, |
| \ 'SPACE' : 0x20, |
| \ 'SHIFT' : 0x10, |
| \ 'LSHIFT' : 0xA0, |
| \ 'RSHIFT' : 0xA1, |
| \ 'CONTROL' : 0x11, |
| \ 'LCONTROL' : 0xA2, |
| \ 'RCONTROL' : 0xA3, |
| \ 'MENU' : 0x12, |
| \ 'ALT' : 0x12, |
| \ 'LMENU' : 0xA4, |
| \ 'LALT' : 0xA4, |
| \ 'RMENU' : 0xA5, |
| \ 'RALT' : 0xA5, |
| \ 'OEM_1' : 0xBA, |
| \ 'OEM_2' : 0xBF, |
| \ 'OEM_3' : 0xC0, |
| \ 'OEM_4' : 0xDB, |
| \ 'OEM_5' : 0xDC, |
| \ 'OEM_6' : 0xDD, |
| \ 'OEM_7' : 0xDE, |
| \ 'OEM_PLUS' : 0xBB, |
| \ 'OEM_COMMA' : 0xBC, |
| \ 'OEM_MINUS' : 0xBD, |
| \ 'OEM_PERIOD' : 0xBE, |
| \ 'PRIOR' : 0x21, |
| \ 'NEXT' : 0x22, |
| \ 'END' : 0x23, |
| \ 'HOME' : 0x24, |
| \ 'LEFT' : 0x25, |
| \ 'UP' : 0x26, |
| \ 'RIGHT' : 0x27, |
| \ 'DOWN' : 0x28, |
| \ 'KEY_0' : 0x30, |
| \ 'KEY_1' : 0x31, |
| \ 'KEY_2' : 0x32, |
| \ 'KEY_3' : 0x33, |
| \ 'KEY_4' : 0x34, |
| \ 'KEY_5' : 0x35, |
| \ 'KEY_6' : 0x36, |
| \ 'KEY_7' : 0x37, |
| \ 'KEY_8' : 0x38, |
| \ 'KEY_9' : 0x39, |
| \ 'KEY_A' : 0x41, |
| \ 'KEY_B' : 0x42, |
| \ 'KEY_C' : 0x43, |
| \ 'KEY_D' : 0x44, |
| \ 'KEY_E' : 0x45, |
| \ 'KEY_F' : 0x46, |
| \ 'KEY_G' : 0x47, |
| \ 'KEY_H' : 0x48, |
| \ 'KEY_I' : 0x49, |
| \ 'KEY_J' : 0x4A, |
| \ 'KEY_K' : 0x4B, |
| \ 'KEY_L' : 0x4C, |
| \ 'KEY_M' : 0x4D, |
| \ 'KEY_N' : 0x4E, |
| \ 'KEY_O' : 0x4F, |
| \ 'KEY_P' : 0x50, |
| \ 'KEY_Q' : 0x51, |
| \ 'KEY_R' : 0x52, |
| \ 'KEY_S' : 0x53, |
| \ 'KEY_T' : 0x54, |
| \ 'KEY_U' : 0x55, |
| \ 'KEY_V' : 0x56, |
| \ 'KEY_W' : 0x57, |
| \ 'KEY_X' : 0x58, |
| \ 'KEY_Y' : 0x59, |
| \ 'KEY_Z' : 0x5A, |
| \ 'NUMPAD0' : 0x60, |
| \ 'NUMPAD1' : 0x61, |
| \ 'NUMPAD2' : 0x62, |
| \ 'NUMPAD3' : 0x63, |
| \ 'NUMPAD4' : 0x64, |
| \ 'NUMPAD5' : 0x65, |
| \ 'NUMPAD6' : 0x66, |
| \ 'NUMPAD7' : 0x67, |
| \ 'NUMPAD8' : 0x68, |
| \ 'NUMPAD9' : 0x69, |
| \ 'MULTIPLY' : 0x6A, |
| \ 'ADD' : 0x6B, |
| \ 'SUBTRACT' : 0x6D, |
| \ 'F1' : 0x70, |
| \ 'F2' : 0x71, |
| \ 'F3' : 0x72, |
| \ 'F4' : 0x73, |
| \ 'F5' : 0x74, |
| \ 'F6' : 0x75, |
| \ 'F7' : 0x76, |
| \ 'F8' : 0x77, |
| \ 'F9' : 0x78, |
| \ 'F10' : 0x79, |
| \ 'F11' : 0x7A, |
| \ 'F12' : 0x7B, |
| \ 'DELETE' : 0x2E, |
| \ 'BACK' : 0x08, |
| \ 'ESCAPE' : 0x1B |
| \ } |
| |
| let s:MOD_MASK_SHIFT = 0x02 |
| let s:MOD_MASK_CTRL = 0x04 |
| let s:MOD_MASK_ALT = 0x08 |
| |
| let s:vim_key_modifiers = [ |
| \ ["", 0, []], |
| \ ["S-", 2, [s:VK.LSHIFT]], |
| \ ["C-", 4, [s:VK.LCONTROL]], |
| \ ["C-S-", 6, [s:VK.LCONTROL, s:VK.LSHIFT]], |
| \ ["A-", 8, [s:VK.LMENU]], |
| \ ["A-S-", 10, [s:VK.LMENU, s:VK.LSHIFT]], |
| \ ["A-C-", 12, [s:VK.LMENU, s:VK.LCONTROL]], |
| \ ["A-C-S-", 14, [s:VK.LMENU, s:VK.LCONTROL, s:VK.LSHIFT]], |
| \] |
| |
| " Assuming Standard US PC Keyboard layout |
| let s:test_ascii_key_chars = [ |
| \ [[s:VK.SPACE], ' '], |
| \ [[s:VK.OEM_1], ';'], |
| \ [[s:VK.OEM_2], '/'], |
| \ [[s:VK.OEM_3], '`'], |
| \ [[s:VK.OEM_4], '['], |
| \ [[s:VK.OEM_5], '\'], |
| \ [[s:VK.OEM_6], ']'], |
| \ [[s:VK.OEM_7], ''''], |
| \ [[s:VK.OEM_PLUS], '='], |
| \ [[s:VK.OEM_COMMA], ','], |
| \ [[s:VK.OEM_MINUS], '-'], |
| \ [[s:VK.OEM_PERIOD], '.'], |
| \ [[s:VK.SHIFT, s:VK.OEM_1], ':'], |
| \ [[s:VK.SHIFT, s:VK.OEM_2], '?'], |
| \ [[s:VK.SHIFT, s:VK.OEM_3], '~'], |
| \ [[s:VK.SHIFT, s:VK.OEM_4], '{'], |
| \ [[s:VK.SHIFT, s:VK.OEM_5], '|'], |
| \ [[s:VK.SHIFT, s:VK.OEM_6], '}'], |
| \ [[s:VK.SHIFT, s:VK.OEM_7], '"'], |
| \ [[s:VK.SHIFT, s:VK.OEM_PLUS], '+'], |
| \ [[s:VK.SHIFT, s:VK.OEM_COMMA], '<'], |
| \ [[s:VK.SHIFT, s:VK.OEM_MINUS], '_'], |
| \ [[s:VK.SHIFT, s:VK.OEM_PERIOD], '>'], |
| \ [[s:VK.KEY_1], '1'], |
| \ [[s:VK.KEY_2], '2'], |
| \ [[s:VK.KEY_3], '3'], |
| \ [[s:VK.KEY_4], '4'], |
| \ [[s:VK.KEY_5], '5'], |
| \ [[s:VK.KEY_6], '6'], |
| \ [[s:VK.KEY_7], '7'], |
| \ [[s:VK.KEY_8], '8'], |
| \ [[s:VK.KEY_9], '9'], |
| \ [[s:VK.KEY_0], '0'], |
| \ [[s:VK.SHIFT, s:VK.KEY_1], '!'], |
| \ [[s:VK.SHIFT, s:VK.KEY_2], '@'], |
| \ [[s:VK.SHIFT, s:VK.KEY_3], '#'], |
| \ [[s:VK.SHIFT, s:VK.KEY_4], '$'], |
| \ [[s:VK.SHIFT, s:VK.KEY_5], '%'], |
| \ [[s:VK.SHIFT, s:VK.KEY_6], '^'], |
| \ [[s:VK.SHIFT, s:VK.KEY_7], '&'], |
| \ [[s:VK.SHIFT, s:VK.KEY_8], '*'], |
| \ [[s:VK.SHIFT, s:VK.KEY_9], '('], |
| \ [[s:VK.SHIFT, s:VK.KEY_0], ')'], |
| \ [[s:VK.KEY_A], 'a'], |
| \ [[s:VK.KEY_B], 'b'], |
| \ [[s:VK.KEY_C], 'c'], |
| \ [[s:VK.KEY_D], 'd'], |
| \ [[s:VK.KEY_E], 'e'], |
| \ [[s:VK.KEY_F], 'f'], |
| \ [[s:VK.KEY_G], 'g'], |
| \ [[s:VK.KEY_H], 'h'], |
| \ [[s:VK.KEY_I], 'i'], |
| \ [[s:VK.KEY_J], 'j'], |
| \ [[s:VK.KEY_K], 'k'], |
| \ [[s:VK.KEY_L], 'l'], |
| \ [[s:VK.KEY_M], 'm'], |
| \ [[s:VK.KEY_N], 'n'], |
| \ [[s:VK.KEY_O], 'o'], |
| \ [[s:VK.KEY_P], 'p'], |
| \ [[s:VK.KEY_Q], 'q'], |
| \ [[s:VK.KEY_R], 'r'], |
| \ [[s:VK.KEY_S], 's'], |
| \ [[s:VK.KEY_T], 't'], |
| \ [[s:VK.KEY_U], 'u'], |
| \ [[s:VK.KEY_V], 'v'], |
| \ [[s:VK.KEY_W], 'w'], |
| \ [[s:VK.KEY_X], 'x'], |
| \ [[s:VK.KEY_Y], 'y'], |
| \ [[s:VK.KEY_Z], 'z'], |
| \ [[s:VK.SHIFT, s:VK.KEY_A], 'A'], |
| \ [[s:VK.SHIFT, s:VK.KEY_B], 'B'], |
| \ [[s:VK.SHIFT, s:VK.KEY_C], 'C'], |
| \ [[s:VK.SHIFT, s:VK.KEY_D], 'D'], |
| \ [[s:VK.SHIFT, s:VK.KEY_E], 'E'], |
| \ [[s:VK.SHIFT, s:VK.KEY_F], 'F'], |
| \ [[s:VK.SHIFT, s:VK.KEY_G], 'G'], |
| \ [[s:VK.SHIFT, s:VK.KEY_H], 'H'], |
| \ [[s:VK.SHIFT, s:VK.KEY_I], 'I'], |
| \ [[s:VK.SHIFT, s:VK.KEY_J], 'J'], |
| \ [[s:VK.SHIFT, s:VK.KEY_K], 'K'], |
| \ [[s:VK.SHIFT, s:VK.KEY_L], 'L'], |
| \ [[s:VK.SHIFT, s:VK.KEY_M], 'M'], |
| \ [[s:VK.SHIFT, s:VK.KEY_N], 'N'], |
| \ [[s:VK.SHIFT, s:VK.KEY_O], 'O'], |
| \ [[s:VK.SHIFT, s:VK.KEY_P], 'P'], |
| \ [[s:VK.SHIFT, s:VK.KEY_Q], 'Q'], |
| \ [[s:VK.SHIFT, s:VK.KEY_R], 'R'], |
| \ [[s:VK.SHIFT, s:VK.KEY_S], 'S'], |
| \ [[s:VK.SHIFT, s:VK.KEY_T], 'T'], |
| \ [[s:VK.SHIFT, s:VK.KEY_U], 'U'], |
| \ [[s:VK.SHIFT, s:VK.KEY_V], 'V'], |
| \ [[s:VK.SHIFT, s:VK.KEY_W], 'W'], |
| \ [[s:VK.SHIFT, s:VK.KEY_X], 'X'], |
| \ [[s:VK.SHIFT, s:VK.KEY_Y], 'Y'], |
| \ [[s:VK.SHIFT, s:VK.KEY_Z], 'Z'], |
| \ [[s:VK.CONTROL, s:VK.KEY_A], 0x01], |
| \ [[s:VK.CONTROL, s:VK.KEY_B], 0x02], |
| \ [[s:VK.CONTROL, s:VK.KEY_C], 0x03], |
| \ [[s:VK.CONTROL, s:VK.KEY_D], 0x04], |
| \ [[s:VK.CONTROL, s:VK.KEY_E], 0x05], |
| \ [[s:VK.CONTROL, s:VK.KEY_F], 0x06], |
| \ [[s:VK.CONTROL, s:VK.KEY_G], 0x07], |
| \ [[s:VK.CONTROL, s:VK.KEY_H], 0x08], |
| \ [[s:VK.CONTROL, s:VK.KEY_I], 0x09], |
| \ [[s:VK.CONTROL, s:VK.KEY_J], 0x0A], |
| \ [[s:VK.CONTROL, s:VK.KEY_K], 0x0B], |
| \ [[s:VK.CONTROL, s:VK.KEY_L], 0x0C], |
| \ [[s:VK.CONTROL, s:VK.KEY_M], 0x0D], |
| \ [[s:VK.CONTROL, s:VK.KEY_N], 0x0E], |
| \ [[s:VK.CONTROL, s:VK.KEY_O], 0x0F], |
| \ [[s:VK.CONTROL, s:VK.KEY_P], 0x10], |
| \ [[s:VK.CONTROL, s:VK.KEY_Q], 0x11], |
| \ [[s:VK.CONTROL, s:VK.KEY_R], 0x12], |
| \ [[s:VK.CONTROL, s:VK.KEY_S], 0x13], |
| \ [[s:VK.CONTROL, s:VK.KEY_T], 0x14], |
| \ [[s:VK.CONTROL, s:VK.KEY_U], 0x15], |
| \ [[s:VK.CONTROL, s:VK.KEY_V], 0x16], |
| \ [[s:VK.CONTROL, s:VK.KEY_W], 0x17], |
| \ [[s:VK.CONTROL, s:VK.KEY_X], 0x18], |
| \ [[s:VK.CONTROL, s:VK.KEY_Y], 0x19], |
| \ [[s:VK.CONTROL, s:VK.KEY_Z], 0x1A], |
| \ [[s:VK.CONTROL, s:VK.OEM_4], 0x1B], |
| \ [[s:VK.CONTROL, s:VK.OEM_5], 0x1C], |
| \ [[s:VK.CONTROL, s:VK.OEM_6], 0x1D], |
| \ [[s:VK.CONTROL, s:VK.KEY_6], 0x1E], |
| \ [[s:VK.CONTROL, s:VK.OEM_MINUS], 0x1F], |
| \ ] |
| |
| let s:test_extra_key_chars = [ |
| \ [[s:VK.ALT, s:VK.KEY_1], '±'], |
| \ [[s:VK.ALT, s:VK.KEY_2], '²'], |
| \ [[s:VK.ALT, s:VK.KEY_3], '³'], |
| \ [[s:VK.ALT, s:VK.KEY_4], '´'], |
| \ [[s:VK.ALT, s:VK.KEY_5], 'µ'], |
| \ [[s:VK.ALT, s:VK.KEY_6], '¶'], |
| \ [[s:VK.ALT, s:VK.KEY_7], '·'], |
| \ [[s:VK.ALT, s:VK.KEY_8], '¸'], |
| \ [[s:VK.ALT, s:VK.KEY_9], '¹'], |
| \ [[s:VK.ALT, s:VK.KEY_0], '°'], |
| \ [[s:VK.ALT, s:VK.KEY_A], 'á'], |
| \ [[s:VK.ALT, s:VK.KEY_B], 'â'], |
| \ [[s:VK.ALT, s:VK.KEY_C], 'ã'], |
| \ [[s:VK.ALT, s:VK.KEY_D], 'ä'], |
| \ [[s:VK.ALT, s:VK.KEY_E], 'Ã¥'], |
| \ [[s:VK.ALT, s:VK.KEY_F], 'æ'], |
| \ [[s:VK.ALT, s:VK.KEY_G], 'ç'], |
| \ [[s:VK.ALT, s:VK.KEY_H], 'è'], |
| \ [[s:VK.ALT, s:VK.KEY_I], 'é'], |
| \ [[s:VK.ALT, s:VK.KEY_J], 'ê'], |
| \ [[s:VK.ALT, s:VK.KEY_K], 'ë'], |
| \ [[s:VK.ALT, s:VK.KEY_L], 'ì'], |
| \ [[s:VK.ALT, s:VK.KEY_M], 'Ã'], |
| \ [[s:VK.ALT, s:VK.KEY_N], 'î'], |
| \ [[s:VK.ALT, s:VK.KEY_O], 'ï'], |
| \ [[s:VK.ALT, s:VK.KEY_P], 'ð'], |
| \ [[s:VK.ALT, s:VK.KEY_Q], 'ñ'], |
| \ [[s:VK.ALT, s:VK.KEY_R], 'ò'], |
| \ [[s:VK.ALT, s:VK.KEY_S], 'ó'], |
| \ [[s:VK.ALT, s:VK.KEY_T], 'ô'], |
| \ [[s:VK.ALT, s:VK.KEY_U], 'õ'], |
| \ [[s:VK.ALT, s:VK.KEY_V], 'ö'], |
| \ [[s:VK.ALT, s:VK.KEY_W], '÷'], |
| \ [[s:VK.ALT, s:VK.KEY_X], 'ø'], |
| \ [[s:VK.ALT, s:VK.KEY_Y], 'ù'], |
| \ [[s:VK.ALT, s:VK.KEY_Z], 'ú'], |
| \ ] |
| |
| func s:LoopTestKeyArray(arr) |
| " flush out the typeahead buffer |
| while getchar(0) |
| endwhile |
| |
| for [kcodes, kstr] in a:arr |
| " Send as a sequence of key presses. |
| call SendKeyGroup(kcodes) |
| let ch = Getcharstr() |
| " need to deal a bit differently with the non-printable ascii chars < 0x20 |
| if kstr < 0x20 && index([s:VK.CONTROL, s:VK.LCONTROL, s:VK.RCONTROL], kcodes[0]) >= 0 |
| call assert_equal(nr2char(kstr), $"{ch}") |
| else |
| call assert_equal(kstr, $"{ch}") |
| endif |
| let mod_mask = getcharmod() |
| " the mod_mask is zero when no modifiers are used |
| " and when the virtual termcap maps the character |
| call assert_equal(0, mod_mask, $"key = {kstr}") |
| |
| " Send as a single key press with a modifiers mask. |
| let modifiers = 0 |
| let key = kcodes[0] |
| for key in kcodes |
| if index([s:VK.SHIFT, s:VK.LSHIFT, s:VK.RSHIFT], key) >= 0 |
| let modifiers = modifiers + s:MOD_MASK_SHIFT |
| endif |
| if index([s:VK.CONTROL, s:VK.LCONTROL, s:VK.RCONTROL], key) >= 0 |
| let modifiers = modifiers + s:MOD_MASK_CTRL |
| endif |
| if index([s:VK.ALT, s:VK.LALT, s:VK.RALT], key) >= 0 |
| let modifiers = modifiers + s:MOD_MASK_ALT |
| endif |
| endfor |
| call SendKeyWithModifiers(key, modifiers) |
| let ch = Getcharstr() |
| " need to deal a bit differently with the non-printable ascii chars < 0x20 |
| if kstr < 0x20 && index([s:VK.CONTROL, s:VK.LCONTROL, s:VK.RCONTROL], kcodes[0]) >= 0 |
| call assert_equal(nr2char(kstr), $"{ch}") |
| else |
| call assert_equal(kstr, $"{ch}") |
| endif |
| let mod_mask = getcharmod() |
| " the mod_mask is zero when no modifiers are used |
| " and when the virtual termcap maps the character |
| call assert_equal(0, mod_mask, $"key = {kstr}") |
| endfor |
| |
| " flush out the typeahead buffer |
| while getchar(0) |
| endwhile |
| |
| endfunc |
| |
| " Test MS-Windows key events |
| func Test_mswin_event_character_keys() |
| CheckMSWindows |
| new |
| |
| call s:LoopTestKeyArray(s:test_ascii_key_chars) |
| |
| if !has('gui_running') |
| call s:LoopTestKeyArray(s:test_extra_key_chars) |
| endif |
| |
| " Test keyboard codes for digits |
| " (0x30 - 0x39) : VK_0 - VK_9 are the same as ASCII '0' - '9' |
| for kc in range(48, 57) |
| call SendKey(kc) |
| let ch = Getcharstr() |
| call assert_equal(nr2char(kc), ch) |
| call SendKeyWithModifiers(kc, 0) |
| let ch = Getcharstr() |
| call assert_equal(nr2char(kc), ch) |
| endfor |
| |
| " Test keyboard codes for Alt-0 to Alt-9 |
| " Expect +128 from the digit char codes |
| for modkey in [s:VK.ALT, s:VK.LALT, s:VK.RALT] |
| for kc in range(48, 57) |
| call SendKeyGroup([modkey, kc]) |
| let ch = getchar(0) |
| call assert_equal(kc+128, ch) |
| call SendKeyWithModifiers(kc, s:MOD_MASK_ALT) |
| let ch = getchar(0) |
| call assert_equal(kc+128, ch) |
| endfor |
| endfor |
| |
| " Test for lowercase 'a' to 'z', VK codes 65(0x41) - 90(0x5A) |
| " Note: VK_A-VK_Z virtual key codes coincide with uppercase ASCII codes A-Z. |
| " eg VK_A is 65, and the ASCII character code for uppercase 'A' is also 65. |
| " Caution: these are interpreted as lowercase when Shift is NOT pressed. |
| " eg, sending VK_A (65) 'A' Key code without shift modifier, will produce ASCII |
| " char 'a' (91) as the output. The ASCII codes for the lowercase letters are |
| " numbered 32 higher than their uppercase versions. |
| for kc in range(65, 90) |
| call SendKey(kc) |
| let ch = Getcharstr() |
| call assert_equal(nr2char(kc + 32), ch) |
| call SendKeyWithModifiers(kc, 0) |
| let ch = Getcharstr() |
| call assert_equal(nr2char(kc + 32), ch) |
| endfor |
| |
| " Test for Uppercase 'A' - 'Z' keys |
| " ie. with VK_SHIFT, expect the keycode = character code. |
| for modkey in [s:VK.SHIFT, s:VK.LSHIFT, s:VK.RSHIFT] |
| for kc in range(65, 90) |
| call SendKeyGroup([modkey, kc]) |
| let ch = Getcharstr() |
| call assert_equal(nr2char(kc), ch) |
| call SendKeyWithModifiers(kc, s:MOD_MASK_SHIFT) |
| let ch = Getcharstr() |
| call assert_equal(nr2char(kc), ch) |
| endfor |
| endfor |
| |
| " Test for <Ctrl-A> to <Ctrl-Z> keys |
| " Expect the unicode characters 0x01 to 0x1A |
| " Note: Skip C because it triggers an Interrupt (CTRL-C) |
| " which causes a test failure |
| for modkey in [s:VK.CONTROL, s:VK.LCONTROL, s:VK.RCONTROL] |
| for kc in range(65, 90) |
| if kc == 67 |
| continue |
| endif |
| call SendKeyGroup([modkey, kc]) |
| let ch = Getcharstr() |
| call assert_equal(nr2char(kc - 64), ch) |
| call SendKeyWithModifiers(kc, s:MOD_MASK_CTRL) |
| let ch = Getcharstr() |
| call assert_equal(nr2char(kc - 64), ch) |
| endfor |
| endfor |
| |
| " Windows intercepts some of these keys in the GUI. |
| if !has("gui_running") |
| " Test for <Alt-A> to <Alt-Z> keys |
| " Expect the unicode characters 0xE1 to 0xFA |
| " ie. 160 higher than the lowercase equivalent |
| for modkey in [s:VK.ALT, s:VK.LALT, s:VK.RALT] |
| for kc in range(65, 90) |
| call SendKeyGroup([modkey, kc]) |
| let ch = getchar(0) |
| call assert_equal(kc+160, ch) |
| call SendKeyWithModifiers(kc, s:MOD_MASK_ALT) |
| let ch = getchar(0) |
| call assert_equal(kc+160, ch) |
| endfor |
| endfor |
| endif |
| |
| endfun |
| |
| " Test for Function Keys 'F1' to 'F12' |
| " VK codes 112(0x70) - 123(0x7B) |
| " Also with ALL permutatios of modifiers; Shift, Ctrl & Alt |
| func Test_mswin_event_function_keys() |
| |
| if has('gui_running') |
| let g:test_is_flaky = 1 |
| endif |
| |
| " NOTE: Windows intercepts these combinations in the GUI |
| let gui_nogo = ["A-F1", "A-F2", "A-F3", "A-F4", "A-S-F4", "A-C-S-F4", |
| \ "A-F5", "A-F6", "A-F7", "A-F8", "A-C-F8", "A-F9", |
| \ "A-F10", "A-F11" , "A-C-F11", "A-C-F12"] |
| |
| " flush out the typeahead buffer |
| while getchar(0) |
| endwhile |
| |
| for [mod_str, vim_mod_mask, mod_keycodes] in s:vim_key_modifiers |
| for n in range(1, 12) |
| let expected_mod_mask = vim_mod_mask |
| let kstr = $"{mod_str}F{n}" |
| if !has('gui_running') || (has('gui_running') && n != 10 |
| \ && index(gui_nogo, kstr) == -1) |
| let keycode = eval('"\<' .. kstr .. '>"') |
| " flush out the typeahead buffer |
| while getchar(0) |
| endwhile |
| call SendKeyWithModifiers(111+n, vim_mod_mask) |
| let ch = Getcharstr() |
| let mod_mask = getcharmod() |
| call assert_equal(keycode, $"{ch}", $"key = {kstr}") |
| " workaround for the virtual termcap maps changing the character |
| "instead of sending Shift |
| for mod_key in mod_keycodes |
| if index([s:VK.SHIFT, s:VK.LSHIFT, s:VK.RSHIFT], mod_key) >= 0 |
| let expected_mod_mask -= s:MOD_MASK_SHIFT |
| break |
| endif |
| endfor |
| call assert_equal(expected_mod_mask, mod_mask, $"mod = {expected_mod_mask} for key = {kstr}") |
| endif |
| endfor |
| endfor |
| endfunc |
| |
| func ExtractModifiers(mod_keycodes) |
| let has_shift = 0 |
| let has_ctrl = 0 |
| let has_alt = 0 |
| for mod_key in a:mod_keycodes |
| if index([s:VK.SHIFT, s:VK.LSHIFT, s:VK.RSHIFT], mod_key) >= 0 |
| let has_shift = 1 |
| endif |
| if index([s:VK.CONTROL, s:VK.LCONTROL, s:VK.RCONTROL], mod_key) >= 0 |
| let has_ctrl = 1 |
| endif |
| if index([s:VK.MENU, s:VK.LMENU, s:VK.RMENU], mod_key) >= 0 |
| let has_alt = 1 |
| endif |
| endfor |
| return [has_shift, has_ctrl, has_alt] |
| endfunc |
| |
| " Test for Movement Keys; |
| " VK_PRIOR 0x21, VK_NEXT 0x22, |
| " VK_END 0x23, VK_HOME 0x24, |
| " VK_LEFT 0x25, VK_UP 0x26, |
| " VK_RIGHT 0x27, VK_DOWN 0x28 |
| " With ALL permutations of modifiers; none, Shift, Ctrl & Alt |
| func Test_mswin_event_movement_keys() |
| |
| if has('gui_running') |
| let g:test_is_flaky = 1 |
| endif |
| |
| let movement_keys = [ |
| \ [s:VK.PRIOR, "PageUp"], |
| \ [s:VK.NEXT, "PageDown"], |
| \ [s:VK.END, "End"], |
| \ [s:VK.HOME, "Home"], |
| \ [s:VK.LEFT, "Left"], |
| \ [s:VK.UP, "Up"], |
| \ [s:VK.RIGHT, "Right"], |
| \ [s:VK.DOWN, "Down"], |
| \ ] |
| |
| " flush out the typeahead buffer |
| while getchar(0) |
| endwhile |
| |
| for [mod_str, vim_mod_mask, mod_keycodes] in s:vim_key_modifiers |
| for [kcode, kname] in movement_keys |
| let exp_mod_mask = vim_mod_mask |
| let kstr = $"{mod_str}{kname}" |
| let chstr_eval = eval('"\<' .. kstr .. '>"') |
| |
| " flush out the typeahead buffer |
| while getchar(0) |
| endwhile |
| execute 'call feedkeys("\<' .. kstr .. '>")' |
| let chstr_fk = Getcharstr() |
| call assert_equal(chstr_eval, chstr_fk, $"feedkeys = <{kstr}>") |
| |
| " flush out the typeahead buffer |
| while getchar(0) |
| endwhile |
| call SendKey(kcode) |
| let chstr_alone = Getcharstr() |
| let chstr_alone_end = chstr_alone[len(chstr_alone)-2:len(chstr_alone)-1] |
| |
| " flush out the typeahead buffer |
| while getchar(0) |
| endwhile |
| call SendKeyGroup(mod_keycodes + [kcode]) |
| let chstr_mswin = Getcharstr() |
| let chstr_mswin_end = chstr_mswin[len(chstr_mswin)-2:len(chstr_mswin)-1] |
| let mod_mask = getcharmod() |
| |
| " The virtual termcap maps may** change the character and either; |
| " - remove the Shift modifier, or |
| " - remove the Ctrl modifier if the Shift modifier was not removed. |
| let [has_shift, has_ctrl, has_alt] = ExtractModifiers(mod_keycodes) |
| if chstr_alone_end != chstr_mswin_end |
| if has_shift != 0 |
| let exp_mod_mask -= s:MOD_MASK_SHIFT |
| elseif has_ctrl != 0 |
| let exp_mod_mask -= s:MOD_MASK_CTRL |
| endif |
| endif |
| " **Note: The appveyor Windows GUI test environments, from VS2017 on, |
| " consistently intercepts the Shift modifier WITHOUT changing the |
| " MOVEMENT character. This issue does not happen in any github actions |
| " CI Windows test environments. Attempted to reproduce this manually |
| " on Windows versions; 7, 8.1, 10, 11, Server 2019 and Server 2022, but |
| " the issue did not occur on any of those environments. |
| " Below is a workaround for the issue. |
| if has('gui_running') && has_shift != 0 |
| if exp_mod_mask != mod_mask && chstr_eval != chstr_mswin |
| let kstr_sub = substitute(kstr, "S-", "", "") |
| let chstr_eval = eval('"\<' .. kstr_sub .. '>"') |
| if exp_mod_mask - s:MOD_MASK_SHIFT == mod_mask |
| let exp_mod_mask -= s:MOD_MASK_SHIFT |
| elseif has_ctrl != 0 && exp_mod_mask - s:MOD_MASK_CTRL == mod_mask |
| let exp_mod_mask -= s:MOD_MASK_CTRL |
| endif |
| endif |
| endif |
| call assert_equal(chstr_eval, chstr_mswin, $"key = {kstr}") |
| call assert_equal(exp_mod_mask, mod_mask, $"mod_mask for key = {kstr}") |
| endfor |
| endfor |
| |
| bw! |
| endfunc |
| |
| |
| " Test for QWERTY Ctrl+- which should result in ^_ |
| " issue #10817 |
| func Test_QWERTY_Ctrl_minus() |
| CheckMSWindows |
| new |
| |
| call SendKeyGroup([s:VK.CONTROL, s:VK.OEM_MINUS]) |
| let ch = Getcharstr() |
| call assert_equal(nr2char(0x1f),ch) |
| |
| call SendKey(s:VK.KEY_I) |
| call SendKeyGroup([s:VK.CONTROL, s:VK.SUBTRACT]) |
| call SendKey(s:VK.ESCAPE) |
| call ExecuteBufferedKeys() |
| call assert_equal('-', getline('$')) |
| |
| %d _ |
| imapclear |
| imap <C-_> BINGO |
| call SendKey(s:VK.KEY_I) |
| call SendKeyGroup([s:VK.CONTROL, s:VK.OEM_MINUS]) |
| call SendKey(s:VK.ESCAPE) |
| call ExecuteBufferedKeys() |
| call assert_equal('BINGO', getline('$')) |
| |
| %d _ |
| imapclear |
| exec "imap \x1f BILBO" |
| call SendKey(s:VK.KEY_I) |
| call SendKeyGroup([s:VK.CONTROL, s:VK.OEM_MINUS]) |
| call SendKey(s:VK.ESCAPE) |
| call ExecuteBufferedKeys() |
| call assert_equal('BILBO', getline('$')) |
| |
| imapclear |
| bw! |
| endfunc |
| |
| " Test MS-Windows mouse events |
| func Test_mswin_event_mouse() |
| CheckMSWindows |
| new |
| |
| set mousemodel=extend |
| call test_override('no_query_mouse', 1) |
| call WaitForResponses() |
| |
| let msg = '' |
| |
| call setline(1, ['one two three', 'four five six']) |
| |
| " Test mouse movement |
| " by default, no mouse move events are generated |
| " this setting enables it to generate move events |
| set mousemev |
| |
| if !has('gui_running') |
| " console version needs a button pressed, |
| " otherwise it ignores mouse movements. |
| call MouseLeftClick(2, 3) |
| endif |
| call MSWinMouseEvent(0x700, 8, 13, 0, 0, 0) |
| if has('gui_running') |
| call feedkeys("\<Esc>", 'Lx!') |
| endif |
| let pos = getmousepos() |
| call assert_equal(8, pos.screenrow) |
| call assert_equal(13, pos.screencol) |
| |
| if !has('gui_running') |
| call MouseLeftClick(2, 3) |
| call MSWinMouseEvent(0x700, 6, 4, 1, 0, 0) |
| let pos = getmousepos() |
| call assert_equal(6, pos.screenrow) |
| call assert_equal(4, pos.screencol) |
| endif |
| |
| " test cells vs pixels |
| if has('gui_running') |
| let args = { } |
| let args.row = 9 |
| let args.col = 5 |
| let args.move = 1 |
| let args.cell = 1 |
| call test_mswin_event("mouse", args) |
| call feedkeys("\<Esc>", 'Lx!') |
| let pos = getmousepos() |
| call assert_equal(9, pos.screenrow) |
| call assert_equal(5, pos.screencol) |
| |
| let args.cell = 0 |
| call test_mswin_event("mouse", args) |
| call feedkeys("\<Esc>", 'Lx!') |
| let pos = getmousepos() |
| call assert_equal(1, pos.screenrow) |
| call assert_equal(1, pos.screencol) |
| |
| unlet args |
| endif |
| |
| " finish testing mouse movement |
| set mousemev& |
| |
| " place the cursor using left click and release in normal mode |
| call MouseLeftClick(2, 4) |
| call MouseLeftRelease(2, 4) |
| if has('gui_running') |
| call feedkeys("\<Esc>", 'Lx!') |
| endif |
| call assert_equal([0, 2, 4, 0], getpos('.')) |
| |
| " select and yank a word |
| let @" = '' |
| call MouseLeftClick(1, 9) |
| let args = #{button: 0, row: 1, col: 9, multiclick: 1, modifiers: 0} |
| call test_mswin_event('mouse', args) |
| call MouseLeftRelease(1, 9) |
| call feedkeys("y", 'Lx!') |
| call assert_equal('three', @") |
| |
| " create visual selection using right click |
| let @" = '' |
| |
| call MouseLeftClick(2 ,6) |
| call MouseLeftRelease(2, 6) |
| call MouseRightClick(2, 13) |
| call MouseRightRelease(2, 13) |
| call feedkeys("y", 'Lx!') |
| call assert_equal('five six', @") |
| |
| " paste using middle mouse button |
| let @* = 'abc ' |
| call feedkeys('""', 'Lx!') |
| call MouseMiddleClick(1, 9) |
| call MouseMiddleRelease(1, 9) |
| if has('gui_running') |
| call feedkeys("\<Esc>", 'Lx!') |
| endif |
| call assert_equal(['one two abc three', 'four five six'], getline(1, '$')) |
| |
| " test mouse scrolling (aka touchpad scrolling.) |
| %d _ |
| set scrolloff=0 |
| call setline(1, range(1, 100)) |
| |
| " Scroll Down |
| call MouseWheelDown(2, 1) |
| call MouseWheelDown(2, 1) |
| call MouseWheelDown(2, 1) |
| call feedkeys("H", 'Lx!') |
| call assert_equal(10, line('.')) |
| |
| " Scroll Up |
| call MouseWheelUp(2, 1) |
| call MouseWheelUp(2, 1) |
| call feedkeys("H", 'Lx!') |
| call assert_equal(4, line('.')) |
| |
| " Shift Scroll Down |
| call MouseShiftWheelDown(2, 1) |
| call feedkeys("H", 'Lx!') |
| " should scroll from where it is (4) + visible buffer height - cmdheight |
| let shift_scroll_height = line('w$') - line('w0') - &cmdheight |
| call assert_equal(4 + shift_scroll_height, line('.')) |
| |
| " Shift Scroll Up |
| call MouseShiftWheelUp(2, 1) |
| call feedkeys("H", 'Lx!') |
| call assert_equal(4, line('.')) |
| |
| if !has('gui_running') |
| " Shift Scroll Down (using MOD) |
| call MSWinMouseEvent(0x100, 2, 1, 0, 0, 0x04) |
| call feedkeys("H", 'Lx!') |
| " should scroll from where it is (4) + visible buffer height - cmdheight |
| let shift_scroll_height = line('w$') - line('w0') - &cmdheight |
| call assert_equal(4 + shift_scroll_height, line('.')) |
| |
| " Shift Scroll Up (using MOD) |
| call MSWinMouseEvent(0x200, 2, 1, 0, 0, 0x04) |
| call feedkeys("H", 'Lx!') |
| call assert_equal(4, line('.')) |
| endif |
| |
| set scrolloff& |
| |
| %d _ |
| set nowrap |
| " make the buffer 500 wide. |
| call setline(1, range(10)->join('')->repeat(50)) |
| " Scroll Right |
| call MouseWheelRight(1, 5) |
| call MouseWheelRight(1, 10) |
| call MouseWheelRight(1, 15) |
| call feedkeys('g0', 'Lx!') |
| call assert_equal(19, col('.')) |
| |
| " Scroll Left |
| call MouseWheelLeft(1, 15) |
| call MouseWheelLeft(1, 10) |
| call feedkeys('g0', 'Lx!') |
| call assert_equal(7, col('.')) |
| |
| " Shift Scroll Right |
| call MouseShiftWheelRight(1, 10) |
| call feedkeys('g0', 'Lx!') |
| " should scroll from where it is (7) + window width |
| call assert_equal(7 + winwidth(0), col('.')) |
| |
| " Shift Scroll Left |
| call MouseShiftWheelLeft(1, 50) |
| call feedkeys('g0', 'Lx!') |
| call assert_equal(7, col('.')) |
| set wrap& |
| |
| %d _ |
| call setline(1, repeat([repeat('a', 60)], 10)) |
| |
| " record various mouse events |
| let mouseEventNames = [ |
| \ 'LeftMouse', 'LeftRelease', '2-LeftMouse', '3-LeftMouse', |
| \ 'S-LeftMouse', 'A-LeftMouse', 'C-LeftMouse', 'MiddleMouse', |
| \ 'MiddleRelease', '2-MiddleMouse', '3-MiddleMouse', |
| \ 'S-MiddleMouse', 'A-MiddleMouse', 'C-MiddleMouse', |
| \ 'RightMouse', 'RightRelease', '2-RightMouse', |
| \ '3-RightMouse', 'S-RightMouse', 'A-RightMouse', 'C-RightMouse', |
| \ ] |
| let mouseEventCodes = map(copy(mouseEventNames), "'<' .. v:val .. '>'") |
| let g:events = [] |
| for e in mouseEventCodes |
| exe 'nnoremap ' .. e .. ' <Cmd>call add(g:events, "' .. |
| \ substitute(e, '[<>]', '', 'g') .. '")<CR>' |
| endfor |
| |
| " Test various mouse buttons |
| "(0 - Left, 1 - Middle, 2 - Right, |
| " 0x300 - MOUSE_X1/FROM_LEFT_3RD_BUTTON, |
| " 0x400 - MOUSE_X2/FROM_LEFT_4TH_BUTTON) |
| for button in [0, 1, 2, 0x300, 0x400] |
| " Single click |
| let args = #{button: button, row: 2, col: 5, multiclick: 0, modifiers: 0} |
| call test_mswin_event('mouse', args) |
| let args.button = 3 |
| call test_mswin_event('mouse', args) |
| |
| " Double Click |
| let args.button = button |
| call test_mswin_event('mouse', args) |
| let args.multiclick = 1 |
| call test_mswin_event('mouse', args) |
| let args.button = 3 |
| let args.multiclick = 0 |
| call test_mswin_event('mouse', args) |
| |
| " Triple Click |
| let args.button = button |
| call test_mswin_event('mouse', args) |
| let args.multiclick = 1 |
| call test_mswin_event('mouse', args) |
| call test_mswin_event('mouse', args) |
| let args.button = 3 |
| let args.multiclick = 0 |
| call test_mswin_event('mouse', args) |
| |
| " Shift click |
| let args = #{button: button, row: 3, col: 7, multiclick: 0, modifiers: 4} |
| call test_mswin_event('mouse', args) |
| let args.button = 3 |
| call test_mswin_event('mouse', args) |
| |
| " Alt click |
| let args.button = button |
| let args.modifiers = 8 |
| call test_mswin_event('mouse', args) |
| let args.button = 3 |
| call test_mswin_event('mouse', args) |
| |
| " Ctrl click |
| let args.button = button |
| let args.modifiers = 16 |
| call test_mswin_event('mouse', args) |
| let args.button = 3 |
| call test_mswin_event('mouse', args) |
| |
| call feedkeys("\<Esc>", 'Lx!') |
| endfor |
| |
| if has('gui_running') |
| call assert_equal(['LeftMouse', 'LeftRelease', 'LeftMouse', |
| \ '2-LeftMouse', 'LeftMouse', '2-LeftMouse', '3-LeftMouse', |
| \ 'S-LeftMouse', 'A-LeftMouse', 'C-LeftMouse', 'MiddleMouse', |
| \ 'MiddleRelease', 'MiddleMouse', '2-MiddleMouse', 'MiddleMouse', |
| \ '2-MiddleMouse', '3-MiddleMouse', 'S-MiddleMouse', 'A-MiddleMouse', |
| \ 'C-MiddleMouse', 'RightMouse', 'RightRelease', 'RightMouse', |
| \ '2-RightMouse', 'RightMouse', '2-RightMouse', '3-RightMouse', |
| \ 'S-RightMouse', 'A-RightMouse', 'C-RightMouse'], |
| \ g:events) |
| else |
| call assert_equal(['MiddleRelease', 'LeftMouse', '2-LeftMouse', |
| \ '3-LeftMouse', 'S-LeftMouse', 'MiddleMouse', '2-MiddleMouse', |
| \ '3-MiddleMouse', 'MiddleMouse', 'S-MiddleMouse', 'RightMouse', |
| \ '2-RightMouse', '3-RightMouse'], |
| \ g:events) |
| endif |
| |
| for e in mouseEventCodes |
| exe 'nunmap ' .. e |
| endfor |
| |
| bw! |
| call test_override('no_query_mouse', 0) |
| set mousemodel& |
| endfunc |
| |
| |
| " Test MS-Windows test_mswin_event error handling |
| func Test_mswin_event_error_handling() |
| |
| let args = #{button: 0xfff, row: 2, col: 4, move: 0, multiclick: 0, modifiers: 0} |
| if !has('gui_running') |
| call assert_fails("call test_mswin_event('mouse', args)",'E475:') |
| endif |
| let args = #{button: 0, row: 2, col: 4, move: 0, multiclick: 0, modifiers: 0} |
| call assert_fails("call test_mswin_event('a1b2c3', args)", 'E475:') |
| call assert_fails("call test_mswin_event(test_null_string(), {})", 'E475:') |
| |
| call assert_fails("call test_mswin_event([], args)", 'E1174:') |
| call assert_fails("call test_mswin_event('abc', [])", 'E1206:') |
| |
| call assert_false(test_mswin_event('mouse', test_null_dict())) |
| let args = #{row: 2, col: 4, multiclick: 0, modifiers: 0} |
| call assert_false(test_mswin_event('mouse', args)) |
| let args = #{button: 0, col: 4, multiclick: 0, modifiers: 0} |
| call assert_false(test_mswin_event('mouse', args)) |
| let args = #{button: 0, row: 2, multiclick: 0, modifiers: 0} |
| call assert_false(test_mswin_event('mouse', args)) |
| let args = #{button: 0, row: 2, col: 4, modifiers: 0} |
| call assert_false(test_mswin_event('mouse', args)) |
| let args = #{button: 0, row: 2, col: 4, multiclick: 0} |
| call assert_false(test_mswin_event('mouse', args)) |
| |
| call assert_false(test_mswin_event('key', test_null_dict())) |
| call assert_fails("call test_mswin_event('key', [])", 'E1206:') |
| call assert_fails("call test_mswin_event('key', {'event': 'keydown', 'keycode': 0x0})", 'E1291:') |
| call assert_fails("call test_mswin_event('key', {'event': 'keydown', 'keycode': [15]})", 'E745:') |
| call assert_fails("call test_mswin_event('key', {'event': 'keys', 'keycode': 0x41})", 'E475:') |
| call assert_fails("call test_mswin_event('key', {'keycode': 0x41})", 'E417:') |
| call assert_fails("call test_mswin_event('key', {'event': 'keydown'})", 'E1291:') |
| |
| call assert_fails("sandbox call test_mswin_event('key', {'event': 'keydown', 'keycode': 61 })", 'E48:') |
| |
| " flush out the typeahead buffer |
| while getchar(0) |
| endwhile |
| endfunc |
| |
| |
| " vim: shiftwidth=2 sts=2 expandtab |