system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-10-31 11:43:31 +00:00
Code Issues Projects Releases Packages Wiki Activity
wine/dlls/winewayland.drv/wayland_keyboard.c

982 lines
39 KiB
C
Raw Blame History

/*
* Keyboard related functions
*
* Copyright 2020 Alexandros Frantzis for Collabora Ltd.
* Copyright 2023 Rémi Bernon for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#if 0
#pragma makedep unix
#endif
#include "config.h"
#include <stdlib.h>
#include <linux/input.h>
#undef SW_MAX /* Also defined in winuser.rh */
#include <sys/mman.h>
#include <unistd.h>
#include "waylanddrv.h"
#include "wine/debug.h"
#include "wine/server.h"
WINE_DEFAULT_DEBUG_CHANNEL(keyboard);
WINE_DECLARE_DEBUG_CHANNEL(key);
struct layout
{
struct list entry;
char *xkb_layout;
LONG ref;
int xkb_group;
LANGID lang;
WORD index;
/* "Layout Id", used by NtUserGetKeyboardLayoutName / LoadKeyboardLayoutW */
WORD layout_id;
KBDTABLES tables;
VSC_LPWSTR key_names[0x100];
VSC_LPWSTR key_names_ext[0x200];
WCHAR *key_names_str;
USHORT vsc2vk[0x100];
VSC_VK vsc2vk_e0[0x100];
VSC_VK vsc2vk_e1[0x100];
VK_TO_WCHAR_TABLE vk_to_wchar_table[2];
VK_TO_WCHARS8 vk_to_wchars8[0x100 * 2 /* SGCAPS */];
VK_TO_BIT vk2bit[4];
union
{
MODIFIERS modifiers;
char modifiers_buf[offsetof(MODIFIERS, ModNumber[8])];
};
};
static pthread_mutex_t xkb_layouts_mutex = PTHREAD_MUTEX_INITIALIZER;
static struct list xkb_layouts = LIST_INIT(xkb_layouts);
/* These are only used from the wayland event thread and don't need locking */
static struct rxkb_context *rxkb_context;
static HKL keyboard_hkl; /* the HKL matching the currently active xkb group */
static void xkb_layout_addref(struct layout *layout)
{
InterlockedIncrement(&layout->ref);
}
static void xkb_layout_release(struct layout *layout)
{
if (!InterlockedDecrement(&layout->ref))
free(layout);
}
#define EXTRA_SCAN2VK \
T36 | KBDEXT, T37 | KBDMULTIVK, \
T38, T39, T3A, T3B, T3C, T3D, T3E, T3F, \
T40, T41, T42, T43, T44, T45 | KBDEXT | KBDMULTIVK, T46 | KBDMULTIVK, T47 | KBDNUMPAD | KBDSPECIAL, \
T48 | KBDNUMPAD | KBDSPECIAL, T49 | KBDNUMPAD | KBDSPECIAL, T4A, T4B | KBDNUMPAD | KBDSPECIAL, \
T4C | KBDNUMPAD | KBDSPECIAL, T4D | KBDNUMPAD | KBDSPECIAL, T4E, T4F | KBDNUMPAD | KBDSPECIAL, \
T50 | KBDNUMPAD | KBDSPECIAL, T51 | KBDNUMPAD | KBDSPECIAL, T52 | KBDNUMPAD | KBDSPECIAL, \
T53 | KBDNUMPAD | KBDSPECIAL, T54, T55, T56, T57, \
T58, T59, T5A, T5B, T5C, T5D, T5E, T5F, \
T60, T61, T62, T63, T64, T65, T66, T67, \
T68, T69, T6A, T6B, T6C, T6D, T6E, T6F, \
T70, T71, T72, T73, T74, T75, T76, T77, \
T78, T79, T7A, T7B, T7C, T7D, T7E, \
[0x110] = X10 | KBDEXT, [0x119] = X19 | KBDEXT, [0x11d] = X1D | KBDEXT, [0x120] = X20 | KBDEXT, \
[0x121] = X21 | KBDEXT, [0x122] = X22 | KBDEXT, [0x124] = X24 | KBDEXT, [0x12e] = X2E | KBDEXT, \
[0x130] = X30 | KBDEXT, [0x132] = X32 | KBDEXT, [0x135] = X35 | KBDEXT, [0x137] = X37 | KBDEXT, \
[0x138] = X38 | KBDEXT, [0x147] = X47 | KBDEXT, [0x148] = X48 | KBDEXT, [0x149] = X49 | KBDEXT, \
[0x14b] = X4B | KBDEXT, [0x14d] = X4D | KBDEXT, [0x14f] = X4F | KBDEXT, [0x150] = X50 | KBDEXT, \
[0x151] = X51 | KBDEXT, [0x152] = X52 | KBDEXT, [0x153] = X53 | KBDEXT, [0x15b] = X5B | KBDEXT, \
[0x15c] = X5C | KBDEXT, [0x15d] = X5D | KBDEXT, [0x15f] = X5F | KBDEXT, [0x165] = X65 | KBDEXT, \
[0x166] = X66 | KBDEXT, [0x167] = X67 | KBDEXT, [0x168] = X68 | KBDEXT, [0x169] = X69 | KBDEXT, \
[0x16a] = X6A | KBDEXT, [0x16b] = X6B | KBDEXT, [0x16c] = X6C | KBDEXT, [0x16d] = X6D | KBDEXT, \
[0x11c] = X1C | KBDEXT, [0x146] = X46 | KBDEXT, [0x21d] = Y1D,
static const USHORT scan2vk_qwerty[0x280] =
{
T00, T01, T02, T03, T04, T05, T06, T07, T08, T09, T0A, T0B, T0C, T0D, T0E,
T0F, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T1A, T1B, T1C,
T1D, T1E, T1F, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
T2A, T2B, T2C, T2D, T2E, T2F, T30, T31, T32, T33, T34, T35,
EXTRA_SCAN2VK
};
static const USHORT scan2vk_azerty[0x280] =
{
T00, T01, T02, T03, T04, T05, T06, T07, T08, T09, T0A, T0B, VK_OEM_4, T0D, T0E,
T0F, 'A', 'Z', T12, T13, T14, T15, T16, T17, T18, T19, VK_OEM_6, VK_OEM_1, T1C,
T1D, 'Q', T1F, T20, T21, T22, T23, T24, T25, T26, 'M', VK_OEM_3, VK_OEM_7,
T2A, T2B, 'W', T2D, T2E, T2F, T30, T31, VK_OEM_COMMA, VK_OEM_PERIOD, VK_OEM_2, VK_OEM_8,
EXTRA_SCAN2VK
};
static const USHORT scan2vk_qwertz[0x280] =
{
T00, T01, T02, T03, T04, T05, T06, T07, T08, T09, T0A, T0B, VK_OEM_4, VK_OEM_6, T0E,
T0F, T10, T11, T12, T13, T14, 'Z', T16, T17, T18, T19, VK_OEM_1, VK_OEM_3, T1C,
T1D, T1E, T1F, T20, T21, T22, T23, T24, T25, T26, VK_OEM_7, VK_OEM_5, VK_OEM_2,
T2A, VK_OEM_8, 'Y', T2D, T2E, T2F, T30, T31, T32, T33, T34, VK_OEM_MINUS,
EXTRA_SCAN2VK
};
static const USHORT scan2vk_dvorak[0x280] =
{
T00, T01, T02, T03, T04, T05, T06, T07, T08, T09, T0A, T0B, VK_OEM_4, VK_OEM_6, T0E,
T0F, VK_OEM_7, VK_OEM_COMMA, VK_OEM_PERIOD, 'P', 'Y', 'F', 'G', 'C', 'R', 'L', VK_OEM_2, VK_OEM_PLUS, T1C,
T1D, T1E, 'O', 'E', 'U', 'I', 'D', 'H', 'T', 'N', 'S', VK_OEM_MINUS, T29,
T2A, T2B, VK_OEM_1, 'Q', 'J', 'K', 'X', 'B', 'M', 'W', 'V', 'Z',
EXTRA_SCAN2VK
};
static WORD key2scan(UINT key)
{
/* base keys can be mapped directly */
if (key <= KEY_KPDOT) return key;
/* map keys found in KBDTABLES definitions (Txx Xxx Yxx macros) */
switch (key)
{
case 84 /* ISO_Level3_Shift */: return 0x005a; /* T5A / VK_OEM_WSCTRL */
case KEY_SYSRQ: return 0x0054; /* T54 / VK_SNAPSHOT */
case KEY_102ND: return 0x0056; /* T56 / VK_OEM_102 */
case KEY_F11: return 0x0057; /* T57 / VK_F11 */
case KEY_F12: return 0x0058; /* T58 / VK_F12 */
case KEY_LINEFEED: return 0x0059; /* T59 / VK_CLEAR */
case KEY_EXIT: return 0x005b; /* T5B / VK_OEM_FINISH */
case KEY_OPEN: return 0x005c; /* T5C / VK_OEM_JUMP */
/* FIXME: map a KEY to T5D / VK_EREOF */
/* FIXME: map a KEY to T5E / VK_OEM_BACKTAB */
case KEY_COMPOSE: return 0x005f; /* T5F / VK_OEM_AUTO */
case KEY_SCALE: return 0x0062; /* T62 / VK_ZOOM */
case KEY_HELP: return 0x0063; /* T63 / VK_HELP */
case KEY_F13: return 0x0064; /* T64 / VK_F13 */
case KEY_F14: return 0x0065; /* T65 / VK_F14 */
case KEY_F15: return 0x0066; /* T66 / VK_F15 */
case KEY_F16: return 0x0067; /* T67 / VK_F16 */
case KEY_F17: return 0x0068; /* T68 / VK_F17 */
case KEY_F18: return 0x0069; /* T69 / VK_F18 */
case KEY_F19: return 0x006a; /* T6A / VK_F19 */
case KEY_F20: return 0x006b; /* T6B / VK_F20 */
case KEY_F21: return 0x006c; /* T6C / VK_F21 */
case KEY_F22: return 0x006d; /* T6D / VK_F22 */
case KEY_F23: return 0x006e; /* T6E / VK_F23 */
/* FIXME: map a KEY to T6F / VK_OEM_PA3 */
case KEY_COMPUTER: return 0x0071; /* T71 / VK_OEM_RESET */
/* FIXME: map a KEY to T73 / VK_ABNT_C1 */
case KEY_F24: return 0x0076; /* T76 / VK_F24 */
case KEY_KPPLUSMINUS: return 0x007b; /* T7B / VK_OEM_PA1 */
/* FIXME: map a KEY to T7C / VK_TAB */
/* FIXME: map a KEY to T7E / VK_ABNT_C2 */
/* FIXME: map a KEY to T7F / VK_OEM_PA2 */
case KEY_PREVIOUSSONG: return 0x0110; /* X10 / VK_MEDIA_PREV_TRACK */
case KEY_NEXTSONG: return 0x0119; /* X19 / VK_MEDIA_NEXT_TRACK */
case KEY_KPENTER: return 0x011c; /* X1C / VK_RETURN */
case KEY_RIGHTCTRL: return 0x011d; /* X1D / VK_RCONTROL */
case KEY_MUTE: return 0x0120; /* X20 / VK_VOLUME_MUTE */
case KEY_PROG2: return 0x0121; /* X21 / VK_LAUNCH_APP2 */
case KEY_PLAYPAUSE: return 0x0122; /* X22 / VK_MEDIA_PLAY_PAUSE */
case KEY_STOPCD: return 0x0124; /* X24 / VK_MEDIA_STOP */
case KEY_VOLUMEDOWN: return 0x012e; /* X2E / VK_VOLUME_DOWN */
case KEY_VOLUMEUP: return 0x0130; /* X30 / VK_VOLUME_UP */
case KEY_HOMEPAGE: return 0x0132; /* X32 / VK_BROWSER_HOME */
case KEY_KPSLASH: return 0x0135; /* X35 / VK_DIVIDE */
case KEY_PRINT: return 0x0137; /* X37 / VK_SNAPSHOT */
case KEY_RIGHTALT: return 0x0138; /* X38 / VK_RMENU */
case KEY_CANCEL: return 0x0146; /* X46 / VK_CANCEL */
case KEY_HOME: return 0x0147; /* X47 / VK_HOME */
case KEY_UP: return 0x0148; /* X48 / VK_UP */
case KEY_PAGEUP: return 0x0149; /* X49 / VK_PRIOR */
case KEY_LEFT: return 0x014b; /* X4B / VK_LEFT */
case KEY_RIGHT: return 0x014d; /* X4D / VK_RIGHT */
case KEY_END: return 0x014f; /* X4F / VK_END */
case KEY_DOWN: return 0x0150; /* X50 / VK_DOWN */
case KEY_PAGEDOWN: return 0x0151; /* X51 / VK_NEXT */
case KEY_INSERT: return 0x0152; /* X52 / VK_INSERT */
case KEY_DELETE: return 0x0153; /* X53 / VK_DELETE */
case KEY_LEFTMETA: return 0x015b; /* X5B / VK_LWIN */
case KEY_RIGHTMETA: return 0x015c; /* X5C / VK_RWIN */
case KEY_MENU: return 0x015d; /* X5D / VK_APPS */
case KEY_POWER: return 0x015e; /* X5E / VK_POWER */
case KEY_SLEEP: return 0x015f; /* X5F / VK_SLEEP */
case KEY_FIND: return 0x0165; /* X65 / VK_BROWSER_SEARCH */
case KEY_BOOKMARKS: return 0x0166; /* X66 / VK_BROWSER_FAVORITES */
case KEY_REFRESH: return 0x0167; /* X67 / VK_BROWSER_REFRESH */
case KEY_STOP: return 0x0168; /* X68 / VK_BROWSER_STOP */
case KEY_FORWARD: return 0x0169; /* X69 / VK_BROWSER_FORWARD */
case KEY_BACK: return 0x016a; /* X6A / VK_BROWSER_BACK */
case KEY_PROG1: return 0x016b; /* X6B / VK_LAUNCH_APP1 */
case KEY_MAIL: return 0x016c; /* X6C / VK_LAUNCH_MAIL */
case KEY_MEDIA: return 0x016d; /* X6D / VK_LAUNCH_MEDIA_SELECT */
case KEY_PAUSE: return 0x021d; /* Y1D / VK_PAUSE */
}
/* otherwise just make up some extended scancode */
return 0x200 | (key & 0x7f);
}
static inline LANGID langid_from_xkb_layout(const char *layout, size_t layout_len)
{
#define MAKEINDEX(c0, c1) (MAKEWORD(c0, c1) - MAKEWORD('a', 'a'))
static const LANGID langids[] =
{
[MAKEINDEX('a','f')] = MAKELANGID(LANG_DARI, SUBLANG_DEFAULT),
[MAKEINDEX('a','l')] = MAKELANGID(LANG_ALBANIAN, SUBLANG_DEFAULT),
[MAKEINDEX('a','m')] = MAKELANGID(LANG_ARMENIAN, SUBLANG_DEFAULT),
[MAKEINDEX('a','t')] = MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN_AUSTRIAN),
[MAKEINDEX('a','z')] = MAKELANGID(LANG_AZERBAIJANI, SUBLANG_DEFAULT),
[MAKEINDEX('a','u')] = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_AUS),
[MAKEINDEX('b','a')] = MAKELANGID(LANG_BOSNIAN, SUBLANG_BOSNIAN_BOSNIA_HERZEGOVINA_CYRILLIC),
[MAKEINDEX('b','d')] = MAKELANGID(LANG_BANGLA, SUBLANG_DEFAULT),
[MAKEINDEX('b','e')] = MAKELANGID(LANG_FRENCH, SUBLANG_FRENCH_BELGIAN),
[MAKEINDEX('b','g')] = MAKELANGID(LANG_BULGARIAN, SUBLANG_DEFAULT),
[MAKEINDEX('b','r')] = MAKELANGID(LANG_PORTUGUESE, 2),
[MAKEINDEX('b','t')] = MAKELANGID(LANG_TIBETAN, 3),
[MAKEINDEX('b','w')] = MAKELANGID(LANG_TSWANA, SUBLANG_TSWANA_BOTSWANA),
[MAKEINDEX('b','y')] = MAKELANGID(LANG_BELARUSIAN, SUBLANG_DEFAULT),
[MAKEINDEX('c','a')] = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_CAN),
[MAKEINDEX('c','d')] = MAKELANGID(LANG_FRENCH, SUBLANG_CUSTOM_UNSPECIFIED),
[MAKEINDEX('c','h')] = MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN_SWISS),
[MAKEINDEX('c','m')] = MAKELANGID(LANG_FRENCH, 11),
[MAKEINDEX('c','n')] = MAKELANGID(LANG_CHINESE, SUBLANG_DEFAULT),
[MAKEINDEX('c','z')] = MAKELANGID(LANG_CZECH, SUBLANG_DEFAULT),
[MAKEINDEX('d','e')] = MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT),
[MAKEINDEX('d','k')] = MAKELANGID(LANG_DANISH, SUBLANG_DEFAULT),
[MAKEINDEX('d','z')] = MAKELANGID(LANG_TAMAZIGHT, SUBLANG_TAMAZIGHT_ALGERIA_LATIN),
[MAKEINDEX('e','e')] = MAKELANGID(LANG_ESTONIAN, SUBLANG_DEFAULT),
[MAKEINDEX('e','s')] = MAKELANGID(LANG_SPANISH, SUBLANG_DEFAULT),
[MAKEINDEX('e','t')] = MAKELANGID(LANG_AMHARIC, SUBLANG_DEFAULT),
[MAKEINDEX('f','i')] = MAKELANGID(LANG_FINNISH, SUBLANG_DEFAULT),
[MAKEINDEX('f','o')] = MAKELANGID(LANG_FAEROESE, SUBLANG_DEFAULT),
[MAKEINDEX('f','r')] = MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT),
[MAKEINDEX('g','b')] = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_UK),
[MAKEINDEX('g','e')] = MAKELANGID(LANG_GEORGIAN, SUBLANG_DEFAULT),
[MAKEINDEX('g','h')] = MAKELANGID(LANG_ENGLISH, SUBLANG_CUSTOM_UNSPECIFIED),
[MAKEINDEX('g','n')] = MAKELANGID(LANG_NEUTRAL, SUBLANG_CUSTOM_DEFAULT),
[MAKEINDEX('g','r')] = MAKELANGID(LANG_GREEK, SUBLANG_DEFAULT),
[MAKEINDEX('h','r')] = MAKELANGID(LANG_CROATIAN, SUBLANG_DEFAULT),
[MAKEINDEX('h','u')] = MAKELANGID(LANG_HUNGARIAN, SUBLANG_DEFAULT),
[MAKEINDEX('i','d')] = MAKELANGID(LANG_INDONESIAN, SUBLANG_DEFAULT),
[MAKEINDEX('i','e')] = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_EIRE),
[MAKEINDEX('i','l')] = MAKELANGID(LANG_HEBREW, SUBLANG_DEFAULT),
[MAKEINDEX('i','n')] = MAKELANGID(LANG_HINDI, SUBLANG_DEFAULT),
[MAKEINDEX('i','q')] = MAKELANGID(LANG_ARABIC, SUBLANG_ARABIC_IRAQ),
[MAKEINDEX('i','r')] = MAKELANGID(LANG_PERSIAN, SUBLANG_DEFAULT),
[MAKEINDEX('i','s')] = MAKELANGID(LANG_ICELANDIC, SUBLANG_DEFAULT),
[MAKEINDEX('i','t')] = MAKELANGID(LANG_ITALIAN, SUBLANG_DEFAULT),
[MAKEINDEX('j','p')] = MAKELANGID(LANG_JAPANESE, SUBLANG_DEFAULT),
[MAKEINDEX('k','e')] = MAKELANGID(LANG_NEUTRAL, SUBLANG_CUSTOM_DEFAULT),
[MAKEINDEX('k','g')] = MAKELANGID(LANG_KYRGYZ, SUBLANG_DEFAULT),
[MAKEINDEX('k','h')] = MAKELANGID(LANG_KHMER, SUBLANG_DEFAULT),
[MAKEINDEX('k','r')] = MAKELANGID(LANG_KOREAN, SUBLANG_DEFAULT),
[MAKEINDEX('k','z')] = MAKELANGID(LANG_KAZAK, SUBLANG_DEFAULT),
[MAKEINDEX('l','a')] = MAKELANGID(LANG_LAO, SUBLANG_DEFAULT),
[MAKEINDEX('l','k')] = MAKELANGID(LANG_SINHALESE, SUBLANG_DEFAULT),
[MAKEINDEX('l','t')] = MAKELANGID(LANG_LITHUANIAN, SUBLANG_DEFAULT),
[MAKEINDEX('l','v')] = MAKELANGID(LANG_LATVIAN, SUBLANG_DEFAULT),
[MAKEINDEX('m','a')] = MAKELANGID(LANG_ARABIC, SUBLANG_ARABIC_MOROCCO),
[MAKEINDEX('m','d')] = MAKELANGID(LANG_ROMANIAN, SUBLANG_CUSTOM_UNSPECIFIED),
[MAKEINDEX('m','e')] = MAKELANGID(LANG_SERBIAN, SUBLANG_SERBIAN_MONTENEGRO_LATIN),
[MAKEINDEX('m','k')] = MAKELANGID(LANG_MACEDONIAN, SUBLANG_DEFAULT),
[MAKEINDEX('m','l')] = MAKELANGID(LANG_NEUTRAL, SUBLANG_CUSTOM_DEFAULT),
[MAKEINDEX('m','m')] = MAKELANGID(0x55 /*LANG_BURMESE*/, SUBLANG_DEFAULT),
[MAKEINDEX('m','n')] = MAKELANGID(LANG_MONGOLIAN, SUBLANG_DEFAULT),
[MAKEINDEX('m','t')] = MAKELANGID(LANG_MALTESE, SUBLANG_DEFAULT),
[MAKEINDEX('m','v')] = MAKELANGID(LANG_DIVEHI, SUBLANG_DEFAULT),
[MAKEINDEX('m','y')] = MAKELANGID(LANG_MALAY, SUBLANG_DEFAULT),
[MAKEINDEX('n','g')] = MAKELANGID(LANG_ENGLISH, SUBLANG_CUSTOM_UNSPECIFIED),
[MAKEINDEX('n','l')] = MAKELANGID(LANG_DUTCH, SUBLANG_DEFAULT),
[MAKEINDEX('n','o')] = MAKELANGID(LANG_NORWEGIAN, SUBLANG_DEFAULT),
[MAKEINDEX('n','p')] = MAKELANGID(LANG_NEPALI, SUBLANG_DEFAULT),
[MAKEINDEX('p','h')] = MAKELANGID(LANG_FILIPINO, SUBLANG_DEFAULT),
[MAKEINDEX('p','k')] = MAKELANGID(LANG_URDU, SUBLANG_DEFAULT),
[MAKEINDEX('p','l')] = MAKELANGID(LANG_POLISH, SUBLANG_DEFAULT),
[MAKEINDEX('p','t')] = MAKELANGID(LANG_PORTUGUESE, SUBLANG_DEFAULT),
[MAKEINDEX('r','o')] = MAKELANGID(LANG_ROMANIAN, SUBLANG_DEFAULT),
[MAKEINDEX('r','s')] = MAKELANGID(LANG_SERBIAN, SUBLANG_SERBIAN_LATIN),
[MAKEINDEX('r','u')] = MAKELANGID(LANG_RUSSIAN, SUBLANG_DEFAULT),
[MAKEINDEX('s','e')] = MAKELANGID(LANG_SWEDISH, SUBLANG_DEFAULT),
[MAKEINDEX('s','i')] = MAKELANGID(LANG_SLOVENIAN, SUBLANG_DEFAULT),
[MAKEINDEX('s','k')] = MAKELANGID(LANG_SLOVAK, SUBLANG_DEFAULT),
[MAKEINDEX('s','n')] = MAKELANGID(LANG_WOLOF, SUBLANG_DEFAULT),
[MAKEINDEX('s','y')] = MAKELANGID(LANG_SYRIAC, SUBLANG_DEFAULT),
[MAKEINDEX('t','g')] = MAKELANGID(LANG_FRENCH, SUBLANG_CUSTOM_UNSPECIFIED),
[MAKEINDEX('t','h')] = MAKELANGID(LANG_THAI, SUBLANG_DEFAULT),
[MAKEINDEX('t','j')] = MAKELANGID(LANG_TAJIK, SUBLANG_DEFAULT),
[MAKEINDEX('t','m')] = MAKELANGID(LANG_TURKMEN, SUBLANG_DEFAULT),
[MAKEINDEX('t','r')] = MAKELANGID(LANG_TURKISH, SUBLANG_DEFAULT),
[MAKEINDEX('t','w')] = MAKELANGID(LANG_CHINESE, SUBLANG_CUSTOM_UNSPECIFIED),
[MAKEINDEX('t','z')] = MAKELANGID(LANG_SWAHILI, SUBLANG_CUSTOM_UNSPECIFIED),
[MAKEINDEX('u','a')] = MAKELANGID(LANG_UKRAINIAN, SUBLANG_DEFAULT),
[MAKEINDEX('u','s')] = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),
[MAKEINDEX('u','z')] = MAKELANGID(LANG_UZBEK, 2),
[MAKEINDEX('v','n')] = MAKELANGID(LANG_VIETNAMESE, SUBLANG_DEFAULT),
[MAKEINDEX('z','a')] = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_SOUTH_AFRICA),
};
LANGID langid;
if (layout_len == 2 && (langid = langids[MAKEINDEX(layout[0], layout[1])])) return langid;
if (layout_len == 3 && !memcmp(layout, "ara", layout_len)) return MAKELANGID(LANG_ARABIC, SUBLANG_DEFAULT);
if (layout_len == 3 && !memcmp(layout, "epo", layout_len)) return MAKELANGID(LANG_NEUTRAL, SUBLANG_CUSTOM_DEFAULT);
if (layout_len == 3 && !memcmp(layout, "mao", layout_len)) return MAKELANGID(LANG_MAORI, SUBLANG_DEFAULT);
if (layout_len == 4 && !memcmp(layout, "brai", layout_len)) return MAKELANGID(LANG_NEUTRAL, SUBLANG_CUSTOM_DEFAULT);
if (layout_len == 5 && !memcmp(layout, "latam", layout_len)) return MAKELANGID(LANG_SPANISH, SUBLANG_CUSTOM_UNSPECIFIED);
#undef MAKEINDEX
FIXME("Unknown layout language %s\n", debugstr_a(layout));
return MAKELANGID(LANG_NEUTRAL, SUBLANG_CUSTOM_UNSPECIFIED);
};
static HKL get_layout_hkl(struct layout *layout, LCID locale)
{
if (!layout->layout_id) return (HKL)(UINT_PTR)MAKELONG(locale, layout->lang);
else return (HKL)(UINT_PTR)MAKELONG(locale, 0xf000 | layout->layout_id);
}
static void add_xkb_layout(const char *xkb_layout, struct xkb_keymap *xkb_keymap,
xkb_layout_index_t xkb_group, LANGID lang)
{
static WORD next_layout_id = 1;
unsigned int mod, keyc, len, names_len, min_keycode, max_keycode;
struct xkb_state *xkb_state = xkb_state_new(xkb_keymap);
xkb_mod_mask_t shift_mask, control_mask, altgr_mask, capslock_mask;
VSC_LPWSTR *names_entry, *names_ext_entry;
VSC_VK *vsc2vk_e0_entry, *vsc2vk_e1_entry;
VK_TO_WCHARS8 *vk2wchars_entry;
struct layout *layout;
const USHORT *scan2vk;
WCHAR *names_str;
WORD index = 0;
char *ptr;
min_keycode = xkb_keymap_min_keycode(xkb_keymap);
max_keycode = xkb_keymap_max_keycode(xkb_keymap);
TRACE("xkb_layout=%s xkb_keymap=%p xkb_group=%u lang=%04x\n", xkb_layout, xkb_keymap, xkb_group, lang);
LIST_FOR_EACH_ENTRY(layout, &xkb_layouts, struct layout, entry)
if (layout->lang == lang) index++;
for (names_len = 0, keyc = min_keycode; keyc <= max_keycode; keyc++)
{
const xkb_keysym_t *keysym;
if (!xkb_keymap_key_get_syms_by_level(xkb_keymap, keyc, xkb_group, 0, &keysym)) continue;
names_len += xkb_keysym_get_name(*keysym, NULL, 0) + 1;
}
names_len *= sizeof(WCHAR);
len = strlen(xkb_layout) + 1;
if (!(layout = calloc(1, sizeof(*layout) + names_len + len)))
{
ERR("Failed to allocate memory for Xkb layout entry\n");
return;
}
layout->ref = 1;
ptr = (char *)(layout + 1);
layout->xkb_layout = strcpy(ptr, xkb_layout);
ptr += len;
layout->xkb_group = xkb_group;
layout->lang = lang;
layout->index = index;
if (index) layout->layout_id = next_layout_id++;
layout->key_names_str = names_str = (void *)ptr;
switch (lang)
{
case MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT): scan2vk = scan2vk_azerty; break;
case MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT): scan2vk = scan2vk_qwertz; break;
case MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN_SWISS): scan2vk = scan2vk_qwertz; break;
default: scan2vk = scan2vk_qwerty; break;
}
if (strstr(xkb_layout, "dvorak")) scan2vk = scan2vk_dvorak;
layout->tables.pKeyNames = layout->key_names;
layout->tables.pKeyNamesExt = layout->key_names_ext;
layout->tables.bMaxVSCtoVK = 0xff;
layout->tables.pusVSCtoVK = layout->vsc2vk;
layout->tables.pVSCtoVK_E0 = layout->vsc2vk_e0;
layout->tables.pVSCtoVK_E1 = layout->vsc2vk_e1;
layout->tables.pCharModifiers = &layout->modifiers;
layout->tables.pVkToWcharTable = layout->vk_to_wchar_table;
layout->tables.fLocaleFlags = MAKELONG(KLLF_ALTGR, KBD_VERSION);
layout->vk_to_wchar_table[0].pVkToWchars = (VK_TO_WCHARS1 *)layout->vk_to_wchars8;
layout->vk_to_wchar_table[0].cbSize = sizeof(*layout->vk_to_wchars8);
layout->vk_to_wchar_table[0].nModifications = 8;
layout->vk2bit[0].Vk = VK_SHIFT;
layout->vk2bit[0].ModBits = KBDSHIFT;
layout->vk2bit[1].Vk = VK_CONTROL;
layout->vk2bit[1].ModBits = KBDCTRL;
layout->vk2bit[2].Vk = VK_MENU;
layout->vk2bit[2].ModBits = KBDALT;
layout->modifiers.pVkToBit = layout->vk2bit;
for (mod = 0; mod <= (KBDSHIFT | KBDCTRL | KBDALT); ++mod)
{
BYTE num = 0;
if (mod & KBDSHIFT) num |= 1 << 0;
if (mod & KBDCTRL) num |= 1 << 1;
if (mod & KBDALT) num |= 1 << 2;
layout->modifiers.ModNumber[mod] = num;
}
layout->modifiers.wMaxModBits = 7;
names_entry = layout->tables.pKeyNames;
names_ext_entry = layout->tables.pKeyNamesExt;
vsc2vk_e0_entry = layout->tables.pVSCtoVK_E0;
vsc2vk_e1_entry = layout->tables.pVSCtoVK_E1;
vk2wchars_entry = layout->vk_to_wchars8;
for (keyc = min_keycode; keyc <= max_keycode; keyc++)
{
WORD scan = key2scan(keyc - 8);
const xkb_keysym_t *keysym;
VSC_LPWSTR *entry;
char name[256];
if (!xkb_keymap_key_get_syms_by_level(xkb_keymap, keyc, xkb_group, 0, &keysym)) continue;
len = xkb_keysym_get_name(*keysym, name, sizeof(name));
if (!(scan & 0xff) || !len) continue;
if (!(scan & 0x300)) entry = names_entry++;
else entry = names_ext_entry++;
entry->vsc = (BYTE)scan;
entry->pwsz = names_str;
names_str += ntdll_umbstowcs(name, len + 1, entry->pwsz, len + 1);
TRACE("keyc %#04x, scan %#04x -> name %s\n", keyc, scan, debugstr_w(entry->pwsz));
}
for (keyc = min_keycode; keyc <= max_keycode; keyc++)
{
WORD scan = key2scan(keyc - 8), vkey = scan2vk[scan];
VSC_VK *entry = NULL;
if (!(scan & 0xff) || !vkey) continue;
if (scan & 0x100) entry = vsc2vk_e0_entry++;
else if (scan & 0x200) entry = vsc2vk_e1_entry++;
else layout->tables.pusVSCtoVK[scan & 0xff] = vkey;
if (entry)
{
entry->Vsc = scan & 0xff;
entry->Vk = vkey;
}
TRACE("keyc %#04x, scan %#05x -> vkey %#06x\n", keyc, scan, vkey);
}
shift_mask = 1 << xkb_keymap_mod_get_index(xkb_keymap, XKB_MOD_NAME_SHIFT);
control_mask = 1 << xkb_keymap_mod_get_index(xkb_keymap, XKB_MOD_NAME_CTRL);
capslock_mask = 1 << xkb_keymap_mod_get_index(xkb_keymap, XKB_MOD_NAME_CAPS);
altgr_mask = 1 << xkb_keymap_mod_get_index(xkb_keymap, "Mod5");
for (keyc = min_keycode; keyc <= max_keycode; keyc++)
{
WORD scan = key2scan(keyc - 8), vkey = scan2vk[scan];
VK_TO_WCHARS8 vkey2wch = {.VirtualKey = vkey}, caps_vkey2wch = vkey2wch;
BOOL found = FALSE, caps_found = FALSE;
uint32_t caps_ret, shift_ret;
unsigned int mod;
for (mod = 0; mod < 8; ++mod)
{
xkb_mod_mask_t mod_mask = 0;
uint32_t ret;
if (mod & (1 << 0)) mod_mask |= shift_mask;
if (mod & (1 << 1)) mod_mask |= control_mask;
/* Windows uses VK_CTRL + VK_MENU for AltGr, we cannot combine Ctrl and Alt */
if (mod & (1 << 2)) mod_mask = (mod_mask & ~control_mask) | altgr_mask;
xkb_state_update_mask(xkb_state, 0, 0, mod_mask, 0, 0, xkb_group);
if (mod_mask & control_mask) vkey2wch.wch[mod] = WCH_NONE; /* on Windows CTRL+key behave specifically */
else if (!(ret = xkb_state_key_get_utf32(xkb_state, keyc))) vkey2wch.wch[mod] = WCH_NONE;
else vkey2wch.wch[mod] = ret;
if (vkey2wch.wch[mod] != WCH_NONE) found = TRUE;
xkb_state_update_mask(xkb_state, 0, 0, mod_mask | capslock_mask, 0, 0, xkb_group);
if (mod_mask & control_mask) caps_vkey2wch.wch[mod] = WCH_NONE; /* on Windows CTRL+key behave specifically */
else if (!(ret = xkb_state_key_get_utf32(xkb_state, keyc))) caps_vkey2wch.wch[mod] = WCH_NONE;
else if (ret == vkey2wch.wch[mod]) caps_vkey2wch.wch[mod] = WCH_NONE;
else caps_vkey2wch.wch[mod] = ret;
if (caps_vkey2wch.wch[mod] != WCH_NONE) caps_found = TRUE;
}
if (!found) continue;
if (caps_found)
{
TRACE("vkey %#06x + CAPS -> %s\n", caps_vkey2wch.VirtualKey, debugstr_wn(caps_vkey2wch.wch, 8));
caps_vkey2wch.Attributes = SGCAPS;
*vk2wchars_entry++ = caps_vkey2wch;
}
else
{
xkb_state_update_mask(xkb_state, 0, 0, capslock_mask, 0, 0, xkb_group);
caps_ret = xkb_state_key_get_utf32(xkb_state, keyc);
xkb_state_update_mask(xkb_state, 0, 0, shift_mask, 0, 0, xkb_group);
shift_ret = xkb_state_key_get_utf32(xkb_state, keyc);
if (caps_ret && caps_ret == shift_ret) vkey2wch.Attributes |= CAPLOK;
}
TRACE("vkey %#06x -> %s\n", vkey2wch.VirtualKey, debugstr_wn(vkey2wch.wch, 8));
*vk2wchars_entry++ = vkey2wch;
}
xkb_state_unref(xkb_state);
TRACE("Created layout entry=%p index=%04x lang=%04x id=%04x\n", layout, layout->index, layout->lang, layout->layout_id);
list_add_tail(&xkb_layouts, &layout->entry);
}
static void set_current_xkb_group(xkb_layout_index_t xkb_group)
{
struct wayland_keyboard *keyboard = &process_wayland.keyboard;
LCID locale = LOWORD(NtUserGetKeyboardLayout(0));
struct layout *layout;
HKL hkl;
pthread_mutex_lock(&xkb_layouts_mutex);
LIST_FOR_EACH_ENTRY(layout, &xkb_layouts, struct layout, entry)
if (layout->xkb_group == xkb_group) break;
if (&layout->entry != &xkb_layouts)
hkl = get_layout_hkl(layout, locale);
else
{
ERR("Failed to find Xkb Layout for group %d\n", xkb_group);
hkl = keyboard_hkl;
}
pthread_mutex_unlock(&xkb_layouts_mutex);
if (hkl == keyboard_hkl) return;
keyboard_hkl = hkl;
TRACE("Changing keyboard layout to %p\n", hkl);
NtUserPostMessage(keyboard->focused_hwnd, WM_INPUTLANGCHANGEREQUEST, 0 /*FIXME*/,
(LPARAM)keyboard_hkl);
}
static BOOL find_xkb_layout_variant(const char *name, const char **layout, const char **variant)
{
struct rxkb_layout *iter;
for (iter = rxkb_layout_first(rxkb_context); iter; iter = rxkb_layout_next(iter))
{
if (!strcmp(name, rxkb_layout_get_description(iter)))
{
*layout = rxkb_layout_get_name(iter);
*variant = rxkb_layout_get_variant(iter);
return TRUE;
}
}
return FALSE;
}
static BOOL get_async_key_state(BYTE state[256])
{
BOOL ret;
SERVER_START_REQ(get_key_state)
{
req->async = 1;
req->key = -1;
wine_server_set_reply(req, state, 256);
ret = !wine_server_call(req);
}
SERVER_END_REQ;
return ret;
}
static void release_all_keys(HWND hwnd)
{
BYTE state[256];
int vkey;
INPUT input = {.type = INPUT_KEYBOARD};
get_async_key_state(state);
for (vkey = 1; vkey < 256; vkey++)
{
/* Skip mouse buttons. */
if (vkey < 7 && vkey != VK_CANCEL) continue;
/* Skip left/right-agnostic modifier vkeys. */
if (vkey == VK_SHIFT || vkey == VK_CONTROL || vkey == VK_MENU) continue;
if (state[vkey] & 0x80)
{
UINT scan = NtUserMapVirtualKeyEx(vkey, MAPVK_VK_TO_VSC_EX,
keyboard_hkl);
input.ki.wVk = vkey;
input.ki.wScan = scan & 0xff;
input.ki.dwFlags = KEYEVENTF_KEYUP;
if (scan & ~0xff) input.ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
__wine_send_input(hwnd, &input, NULL);
}
}
}
/**********************************************************************
* Keyboard handling
*/
static HWND wayland_keyboard_get_focused_hwnd(void)
{
struct wayland_keyboard *keyboard = &process_wayland.keyboard;
HWND hwnd;
pthread_mutex_lock(&keyboard->mutex);
hwnd = keyboard->focused_hwnd;
pthread_mutex_unlock(&keyboard->mutex);
return hwnd;
}
static void keyboard_handle_keymap(void *data, struct wl_keyboard *wl_keyboard,
uint32_t format, int fd, uint32_t size)
{
struct wayland_keyboard *keyboard = &process_wayland.keyboard;
struct xkb_keymap *xkb_keymap = NULL;
xkb_layout_index_t xkb_group;
struct xkb_state *xkb_state;
struct layout *entry, *next;
char *keymap_str;
TRACE("format=%d fd=%d size=%d\n", format, fd, size);
if ((keymap_str = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0)) != MAP_FAILED)
{
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1)
FIXME("Unsupported keymap format %#x\n", format);
else
{
xkb_keymap = xkb_keymap_new_from_string(keyboard->xkb_context, keymap_str,
XKB_KEYMAP_FORMAT_TEXT_V1, 0);
}
munmap(keymap_str, size);
}
close(fd);
if (!xkb_keymap)
{
ERR("Failed to load Xkb keymap\n");
return;
}
pthread_mutex_lock(&xkb_layouts_mutex);
LIST_FOR_EACH_ENTRY_SAFE(entry, next, &xkb_layouts, struct layout, entry)
{
list_remove(&entry->entry);
xkb_layout_release(entry);
}
for (xkb_group = 0; xkb_group < xkb_keymap_num_layouts(xkb_keymap); xkb_group++)
{
const char *layout_name = xkb_keymap_layout_get_name(xkb_keymap, xkb_group);
const char *layout, *variant = NULL;
int layout_len, variant_len = 0;
char buffer[1024];
LANGID lang;
if (!find_xkb_layout_variant(layout_name, &layout, &variant)) layout = "us";
if (variant) variant_len = strlen(variant);
layout_len = strlen(layout);
TRACE("Found layout %u name %s -> %s:%s\n", xkb_group, layout_name, layout, variant);
lang = langid_from_xkb_layout(layout, layout_len);
snprintf(buffer, ARRAY_SIZE(buffer), "%.*s:%.*s", layout_len, layout, variant_len, variant);
add_xkb_layout(buffer, xkb_keymap, xkb_group, lang);
}
pthread_mutex_unlock(&xkb_layouts_mutex);
if ((xkb_state = xkb_state_new(xkb_keymap)))
{
pthread_mutex_lock(&keyboard->mutex);
xkb_state_unref(keyboard->xkb_state);
keyboard->xkb_state = xkb_state;
pthread_mutex_unlock(&keyboard->mutex);
set_current_xkb_group(0);
}
xkb_keymap_unref(xkb_keymap);
}
static void keyboard_handle_enter(void *data, struct wl_keyboard *wl_keyboard,
uint32_t serial, struct wl_surface *wl_surface,
struct wl_array *keys)
{
struct wayland_keyboard *keyboard = &process_wayland.keyboard;
struct wayland_surface *surface;
HWND hwnd;
if (!wl_surface) return;
/* The wl_surface user data remains valid and immutable for the whole
* lifetime of the object, so it's safe to access without locking. */
hwnd = wl_surface_get_user_data(wl_surface);
TRACE("serial=%u hwnd=%p\n", serial, hwnd);
pthread_mutex_lock(&keyboard->mutex);
keyboard->focused_hwnd = hwnd;
pthread_mutex_unlock(&keyboard->mutex);
NtUserPostMessage(keyboard->focused_hwnd, WM_INPUTLANGCHANGEREQUEST, 0 /*FIXME*/,
(LPARAM)keyboard_hkl);
if ((surface = wayland_surface_lock_hwnd(hwnd)))
{
/* TODO: Drop the internal message and call NtUserSetForegroundWindow
* directly once it's updated to not explicitly deactivate the old
* foreground window when both the old and new foreground windows
* are in the same non-current thread. */
if (surface->window.managed)
NtUserPostMessage(hwnd, WM_WAYLAND_SET_FOREGROUND, 0, 0);
pthread_mutex_unlock(&surface->mutex);
}
}
static void keyboard_handle_leave(void *data, struct wl_keyboard *wl_keyboard,
uint32_t serial, struct wl_surface *wl_surface)
{
struct wayland_keyboard *keyboard = &process_wayland.keyboard;
HWND hwnd;
if (!wl_surface) return;
/* The wl_surface user data remains valid and immutable for the whole
* lifetime of the object, so it's safe to access without locking. */
hwnd = wl_surface_get_user_data(wl_surface);
TRACE("serial=%u hwnd=%p\n", serial, hwnd);
pthread_mutex_lock(&keyboard->mutex);
if (keyboard->focused_hwnd == hwnd)
keyboard->focused_hwnd = NULL;
pthread_mutex_unlock(&keyboard->mutex);
/* The spec for the leave event tells us to treat all keys as released,
* and for any key repetition to stop. */
release_all_keys(hwnd);
/* FIXME: update foreground window as well */
}
static void send_right_control(HWND hwnd, uint32_t state)
{
INPUT input = {0};
input.type = INPUT_KEYBOARD;
input.ki.wScan = key2scan(KEY_RIGHTCTRL);
input.ki.wVk = VK_RCONTROL;
input.ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
if (state == WL_KEYBOARD_KEY_STATE_RELEASED) input.ki.dwFlags |= KEYEVENTF_KEYUP;
__wine_send_input(hwnd, &input, NULL);
}
static void keyboard_handle_key(void *data, struct wl_keyboard *wl_keyboard,
uint32_t serial, uint32_t time, uint32_t key,
uint32_t state)
{
UINT scan = key2scan(key);
INPUT input = {0};
HWND hwnd;
if (!(hwnd = wayland_keyboard_get_focused_hwnd())) return;
TRACE_(key)("serial=%u hwnd=%p key=%d scan=%#x state=%#x\n", serial, hwnd, key, scan, state);
/* NOTE: Windows normally sends VK_CONTROL + VK_MENU only if the layout has KLLF_ALTGR */
if (key == KEY_RIGHTALT) send_right_control(hwnd, state);
input.type = INPUT_KEYBOARD;
input.ki.wScan = scan & 0xff;
input.ki.wVk = NtUserMapVirtualKeyEx(scan, MAPVK_VSC_TO_VK_EX, keyboard_hkl);
if (scan & ~0xff) input.ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
if (state == WL_KEYBOARD_KEY_STATE_RELEASED) input.ki.dwFlags |= KEYEVENTF_KEYUP;
__wine_send_input(hwnd, &input, NULL);
}
static void keyboard_handle_modifiers(void *data, struct wl_keyboard *wl_keyboard,
uint32_t serial, uint32_t mods_depressed,
uint32_t mods_latched, uint32_t mods_locked,
uint32_t xkb_group)
{
struct wayland_keyboard *keyboard = &process_wayland.keyboard;
if (!wayland_keyboard_get_focused_hwnd()) return;
TRACE("serial=%u mods_depressed=%#x mods_latched=%#x mods_locked=%#x xkb_group=%d stub!\n",
serial, mods_depressed, mods_latched, mods_locked, xkb_group);
pthread_mutex_lock(&keyboard->mutex);
xkb_state_update_mask(keyboard->xkb_state, mods_depressed, mods_latched,
mods_locked, 0, 0, xkb_group);
pthread_mutex_unlock(&keyboard->mutex);
set_current_xkb_group(xkb_group);
/* FIXME: Sync wine modifier state with XKB modifier state. */
}
static void keyboard_handle_repeat_info(void *data, struct wl_keyboard *wl_keyboard,
int rate, int delay)
{
UINT speed;
TRACE("rate=%d delay=%d\n", rate, delay);
/* Handle non-negative rate values, ignore invalid (negative) values. A
* rate of 0 disables repeat. */
if (rate >= 80) speed = 31;
else if (rate >= 5) speed = rate * 400 / 1000 - 1;
else speed = 0;
delay = max(0, min(3, round(delay / 250.0) - 1));
NtUserSystemParametersInfo(SPI_SETKEYBOARDSPEED, speed, NULL, 0);
NtUserSystemParametersInfo(SPI_SETKEYBOARDDELAY, delay, NULL, 0);
NtUserCallOneParam(rate > 0, NtUserCallOneParam_SetKeyboardAutoRepeat);
}
static const struct wl_keyboard_listener keyboard_listener = {
keyboard_handle_keymap,
keyboard_handle_enter,
keyboard_handle_leave,
keyboard_handle_key,
keyboard_handle_modifiers,
keyboard_handle_repeat_info,
};
/***********************************************************************
* wayland_keyboard_init
*/
void wayland_keyboard_init(struct wl_keyboard *wl_keyboard)
{
struct wayland_keyboard *keyboard = &process_wayland.keyboard;
struct xkb_context *xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
if (!(rxkb_context = rxkb_context_new(RXKB_CONTEXT_NO_FLAGS))
|| !rxkb_context_parse_default_ruleset(rxkb_context))
{
ERR("Failed to parse default Xkb ruleset\n");
return;
}
if (!xkb_context)
{
ERR("Failed to create XKB context\n");
return;
}
NtUserCallOneParam(TRUE, NtUserCallOneParam_SetKeyboardAutoRepeat);
pthread_mutex_lock(&keyboard->mutex);
keyboard->wl_keyboard = wl_keyboard;
keyboard->xkb_context = xkb_context;
pthread_mutex_unlock(&keyboard->mutex);
wl_keyboard_add_listener(keyboard->wl_keyboard, &keyboard_listener, NULL);
}
/***********************************************************************
* wayland_keyboard_deinit
*/
void wayland_keyboard_deinit(void)
{
struct wayland_keyboard *keyboard = &process_wayland.keyboard;
pthread_mutex_lock(&keyboard->mutex);
if (keyboard->wl_keyboard)
{
wl_keyboard_destroy(keyboard->wl_keyboard);
keyboard->wl_keyboard = NULL;
}
if (keyboard->xkb_context)
{
xkb_context_unref(keyboard->xkb_context);
keyboard->xkb_context = NULL;
}
if (keyboard->xkb_state)
{
xkb_state_unref(keyboard->xkb_state);
keyboard->xkb_state = NULL;
}
pthread_mutex_unlock(&keyboard->mutex);
if (rxkb_context)
{
rxkb_context_unref(rxkb_context);
rxkb_context = NULL;
}
}
/***********************************************************************
* KbdLayerDescriptor (WAYLANDDRV.@)
*/
const KBDTABLES *WAYLAND_KbdLayerDescriptor(HKL hkl)
{
struct layout *layout;
TRACE("hkl=%p\n", hkl);
pthread_mutex_lock(&xkb_layouts_mutex);
LIST_FOR_EACH_ENTRY(layout, &xkb_layouts, struct layout, entry)
if (hkl == get_layout_hkl(layout, LOWORD(hkl))) break;
if (&layout->entry == &xkb_layouts) layout = NULL;
else xkb_layout_addref(layout);
pthread_mutex_unlock(&xkb_layouts_mutex);
if (!layout)
{
WARN("Failed to find Xkb layout for HKL %p\n", hkl);
return NULL;
}
TRACE("Found layout entry %p, hkl %04x%04x id %04x\n",
layout, layout->index, layout->lang, layout->layout_id);
return &layout->tables;
}
/***********************************************************************
* ReleaseKbdTables (WAYLANDDRV.@)
*/
void WAYLAND_ReleaseKbdTables(const KBDTABLES *tables)
{
struct layout *layout = CONTAINING_RECORD(tables, struct layout, tables);
xkb_layout_release(layout);
}
Reference in a new issue View git blame Copy permalink