ReactOS 0.4.15-dev-8227-g32d615f
input.c File Reference
#include <user32.h>
#include <strsafe.h>
Include dependency graph for input.c:

Go to the source code of this file.

Classes

struct  tagIMEHOTKEYENTRY
 

Macros

#define FE_JAPANESE   (1 << 0)
 
#define FE_CHINESE_TRADITIONAL   (1 << 1)
 
#define FE_CHINESE_SIMPLIFIED   (1 << 2)
 
#define FE_KOREAN   (1 << 3)
 
#define MOD_ALL_MODS   (MOD_ALT | MOD_CONTROL | MOD_SHIFT | MOD_WIN)
 
#define ENGLISH_US   MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US)
 

Typedefs

typedef struct tagIMEHOTKEYENTRY IMEHOTKEYENTRY
 
typedef struct tagIMEHOTKEYENTRYPIMEHOTKEYENTRY
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (user32)
 
VOID FASTCALL IntSetFeKeyboardFlags (LANGID LangID, PBYTE pbFlags)
 
DWORD FASTCALL CliReadRegistryValue (HANDLE hKey, LPCWSTR pszName)
 
BOOL APIENTRY CliImmSetHotKeyWorker (DWORD dwHotKeyId, UINT uModifiers, UINT uVirtualKey, HKL hKL, DWORD dwAction)
 
VOID IntLoadPreloadKeyboardLayouts (VOID)
 
BOOL APIENTRY CliSaveImeHotKey (DWORD dwID, UINT uModifiers, UINT uVirtualKey, HKL hKL, BOOL bDelete)
 
BOOL WINAPI CliImmSetHotKey (DWORD dwID, UINT uModifiers, UINT uVirtualKey, HKL hKL)
 
BOOL FASTCALL CliSetSingleHotKey (LPCWSTR pszSubKey, HANDLE hKey)
 
BOOL FASTCALL CliGetImeHotKeysFromRegistry (VOID)
 
VOID APIENTRY CliGetPreloadKeyboardLayouts (PBYTE pbFlags)
 
VOID APIENTRY CliSetDefaultImeHotKeys (PIMEHOTKEYENTRY pEntries, UINT nCount, BOOL bCheck)
 
VOID APIENTRY CliImmInitializeHotKeys (DWORD dwAction, HKL hKL)
 
BOOL WINAPI DragDetect (HWND hWnd, POINT pt)
 
BOOL WINAPI EnableWindow (HWND hWnd, BOOL bEnable)
 
SHORT WINAPI DECLSPEC_HOTPATCH GetAsyncKeyState (int vKey)
 
HKL WINAPI GetKeyboardLayout (DWORD idThread)
 
UINT WINAPI GetKBCodePage (VOID)
 
int WINAPI GetKeyNameTextA (LONG lParam, LPSTR lpString, int nSize)
 
int WINAPI GetKeyNameTextW (LONG lParam, LPWSTR lpString, int nSize)
 
SHORT WINAPI DECLSPEC_HOTPATCH GetKeyState (int nVirtKey)
 
BOOL WINAPI GetKeyboardLayoutNameA (LPSTR pwszKLID)
 
BOOL WINAPI GetKeyboardLayoutNameW (LPWSTR pwszKLID)
 
int WINAPI GetKeyboardType (int nTypeFlag)
 
BOOL WINAPI GetLastInputInfo (PLASTINPUTINFO plii)
 
HKL WINAPI LoadKeyboardLayoutA (LPCSTR pszKLID, UINT Flags)
 
static BOOL IsValidKLID (_In_ LPCWSTR pwszKLID)
 
VOID GetSystemLibraryPath (LPWSTR pszPath, INT cchPath, LPCWSTR pszFileName)
 
HKL APIENTRY IntLoadKeyboardLayout (_In_ HKL hklUnload, _In_z_ LPCWSTR pwszKLID, _In_ LANGID wLangID, _In_ UINT Flags, _In_ BOOL unknown5)
 
HKL WINAPI LoadKeyboardLayoutW (LPCWSTR pwszKLID, UINT Flags)
 
HKL WINAPI LoadKeyboardLayoutEx (HKL hklUnload, LPCWSTR pwszKLID, UINT Flags)
 
BOOL WINAPI UnloadKeyboardLayout (HKL hKL)
 
UINT WINAPI MapVirtualKeyA (UINT uCode, UINT uMapType)
 
UINT WINAPI MapVirtualKeyExA (UINT uCode, UINT uMapType, HKL dwhkl)
 
UINT WINAPI MapVirtualKeyExW (UINT uCode, UINT uMapType, HKL dwhkl)
 
UINT WINAPI MapVirtualKeyW (UINT uCode, UINT uMapType)
 
DWORD WINAPI OemKeyScan (WORD wOemChar)
 
BOOL WINAPI SetDoubleClickTime (UINT uInterval)
 
BOOL WINAPI SwapMouseButton (BOOL fSwap)
 
int WINAPI ToAscii (UINT uVirtKey, UINT uScanCode, CONST BYTE *lpKeyState, LPWORD lpChar, UINT uFlags)
 
int WINAPI ToAsciiEx (UINT uVirtKey, UINT uScanCode, CONST BYTE *lpKeyState, LPWORD lpChar, UINT uFlags, HKL dwhkl)
 
int WINAPI ToUnicode (UINT wVirtKey, UINT wScanCode, CONST BYTE *lpKeyState, LPWSTR pwszBuff, int cchBuff, UINT wFlags)
 
int WINAPI ToUnicodeEx (UINT wVirtKey, UINT wScanCode, CONST BYTE *lpKeyState, LPWSTR pwszBuff, int cchBuff, UINT wFlags, HKL dwhkl)
 
SHORT WINAPI VkKeyScanA (CHAR ch)
 
SHORT WINAPI VkKeyScanExA (CHAR ch, HKL dwhkl)
 
SHORT WINAPI VkKeyScanExW (WCHAR ch, HKL dwhkl)
 
SHORT WINAPI VkKeyScanW (WCHAR ch)
 
VOID WINAPI keybd_event (BYTE bVk, BYTE bScan, DWORD dwFlags, ULONG_PTR dwExtraInfo)
 
VOID WINAPI mouse_event (DWORD dwFlags, DWORD dx, DWORD dy, DWORD dwData, ULONG_PTR dwExtraInfo)
 

Variables

IMEHOTKEYENTRY DefaultHotKeyTableJ []
 
IMEHOTKEYENTRY DefaultHotKeyTableT []
 
IMEHOTKEYENTRY DefaultHotKeyTableC []
 

Macro Definition Documentation

◆ ENGLISH_US

Definition at line 719 of file input.c.

◆ FE_CHINESE_SIMPLIFIED

#define FE_CHINESE_SIMPLIFIED   (1 << 2)

Definition at line 65 of file input.c.

◆ FE_CHINESE_TRADITIONAL

#define FE_CHINESE_TRADITIONAL   (1 << 1)

Definition at line 64 of file input.c.

◆ FE_JAPANESE

#define FE_JAPANESE   (1 << 0)

Definition at line 63 of file input.c.

◆ FE_KOREAN

#define FE_KOREAN   (1 << 3)

Definition at line 66 of file input.c.

◆ MOD_ALL_MODS

#define MOD_ALL_MODS   (MOD_ALT | MOD_CONTROL | MOD_SHIFT | MOD_WIN)

Typedef Documentation

◆ IMEHOTKEYENTRY

◆ PIMEHOTKEYENTRY

Function Documentation

◆ CliGetImeHotKeysFromRegistry()

BOOL FASTCALL CliGetImeHotKeysFromRegistry ( VOID  )

Definition at line 337 of file input.c.

338{
339 HKEY hKey;
340 LONG error;
341 BOOL ret = FALSE;
342 DWORD dwIndex, cchKeyName;
343 WCHAR szKeyName[16];
344
346 L"Control Panel\\Input Method\\Hot Keys",
347 0,
348 KEY_READ,
349 &hKey);
350 if (error != ERROR_SUCCESS)
351 return ret;
352
353 for (dwIndex = 0; dwIndex < 1000; ++dwIndex)
354 {
355 cchKeyName = _countof(szKeyName);
356 error = RegEnumKeyExW(hKey, dwIndex, szKeyName, &cchKeyName, NULL, NULL, NULL, NULL);
357 if (error != ERROR_SUCCESS)
358 break;
359
360 szKeyName[_countof(szKeyName) - 1] = 0; /* Avoid stack overrun */
361
362 if (CliSetSingleHotKey(szKeyName, hKey))
363 ret = TRUE;
364 }
365
367 return ret;
368}
#define RegCloseKey(hKey)
Definition: registry.h:49
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
LONG WINAPI RegEnumKeyExW(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPWSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPWSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
Definition: reg.c:2504
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
FxAutoRegKey hKey
#define error(str)
Definition: mkdosfs.c:1605
#define KEY_READ
Definition: nt_native.h:1023
#define L(x)
Definition: ntvdm.h:50
long LONG
Definition: pedump.c:60
#define _countof(array)
Definition: sndvol32.h:70
int ret
BOOL FASTCALL CliSetSingleHotKey(LPCWSTR pszSubKey, HANDLE hKey)
Definition: input.c:312
#define HKEY_CURRENT_USER
Definition: winreg.h:11
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by CliImmInitializeHotKeys().

◆ CliGetPreloadKeyboardLayouts()

VOID APIENTRY CliGetPreloadKeyboardLayouts ( PBYTE  pbFlags)

Definition at line 370 of file input.c.

371{
372 WCHAR szValueName[33], szValue[16];
373 UNICODE_STRING ustrValue;
374 DWORD dwKL, cbValue, dwType;
375 UINT iNumber;
376 HKEY hKey;
377 LONG error;
378
379 error = RegOpenKeyExW(HKEY_CURRENT_USER, L"Keyboard Layout\\Preload", 0, KEY_READ, &hKey);
380 if (error != ERROR_SUCCESS)
381 return;
382
383 for (iNumber = 1; iNumber < 1000; ++iNumber)
384 {
385 _ultow(iNumber, szValueName, 10);
386
387 cbValue = sizeof(szValue);
388 error = RegQueryValueExW(hKey, szValueName, NULL, &dwType, (LPBYTE)szValue, &cbValue);
389 if (error != ERROR_SUCCESS)
390 break;
391
392 if (dwType != REG_SZ)
393 continue;
394
395 szValue[_countof(szValue) - 1] = 0; /* Avoid stack overrun */
396
397 RtlInitUnicodeString(&ustrValue, szValue);
398 RtlUnicodeStringToInteger(&ustrValue, 16, &dwKL);
399
400 IntSetFeKeyboardFlags(LOWORD(dwKL), pbFlags);
401 }
402
404}
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
_CRTIMP wchar_t *__cdecl _ultow(_In_ unsigned long _Value, _Pre_notnull_ _Post_z_ wchar_t *_Dest, _In_ int _Radix)
#define REG_SZ
Definition: layer.c:22
unsigned int UINT
Definition: ndis.h:50
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToInteger(PUNICODE_STRING String, ULONG Base, PULONG Value)
#define LOWORD(l)
Definition: pedump.c:82
unsigned char * LPBYTE
Definition: typedefs.h:53
VOID FASTCALL IntSetFeKeyboardFlags(LANGID LangID, PBYTE pbFlags)
Definition: input.c:70

Referenced by CliImmInitializeHotKeys().

◆ CliImmInitializeHotKeys()

VOID APIENTRY CliImmInitializeHotKeys ( DWORD  dwAction,
HKL  hKL 
)

Definition at line 425 of file input.c.

426{
427 UINT nCount;
428 LPHKL pList;
429 UINT iIndex;
431 BYTE bFlags = 0;
432 BOOL bCheck;
433
435
437
438 if (dwAction == SETIMEHOTKEY_INITIALIZE)
439 {
442
444 }
445 else
446 {
448 if (!nCount)
449 return;
450
451 pList = RtlAllocateHeap(RtlGetProcessHeap(), 0, nCount * sizeof(HKL));
452 if (!pList)
453 return;
454
456
457 for (iIndex = 0; iIndex < nCount; ++iIndex)
458 {
459 LangID = LOWORD(pList[iIndex]);
461 }
462
463 RtlFreeHeap(RtlGetProcessHeap(), 0, pList);
464 }
465
466 if (bFlags & FE_JAPANESE)
468
469 if (bFlags & FE_CHINESE_TRADITIONAL)
471
472 if (bFlags & FE_CHINESE_SIMPLIFIED)
474}
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:590
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:608
LCID WINAPI GetUserDefaultLCID(void)
Definition: locale.c:1210
FxChildList * pList
HKL FAR * LPHKL
Definition: imm.h:24
UINT NTAPI NtUserGetKeyboardLayoutList(ULONG nItems, HKL *pHklBuff)
Definition: kbdlayout.c:1075
BOOL NTAPI NtUserSetImeHotKey(DWORD dwHotKeyId, UINT uModifiers, UINT uVirtualKey, HKL hKL, DWORD dwAction)
Definition: ime.c:451
USHORT LANGID
Definition: mui.h:9
UINT_PTR HKL
Definition: msctf.idl:143
#define LANGIDFROMLCID(l)
Definition: nls.h:18
@ SETIMEHOTKEY_INITIALIZE
Definition: undocuser.h:403
_Must_inspect_result_ _In_ WDFUSBDEVICE _In_opt_ WDFREQUEST _In_opt_ PWDF_REQUEST_SEND_OPTIONS _Out_writes_opt_ NumCharacters PUSHORT _Inout_ PUSHORT _In_ UCHAR _In_opt_ USHORT LangID
Definition: wdfusb.h:1083
#define FE_JAPANESE
Definition: input.c:63
VOID APIENTRY CliGetPreloadKeyboardLayouts(PBYTE pbFlags)
Definition: input.c:370
IMEHOTKEYENTRY DefaultHotKeyTableT[]
Definition: input.c:49
IMEHOTKEYENTRY DefaultHotKeyTableC[]
Definition: input.c:56
#define FE_CHINESE_SIMPLIFIED
Definition: input.c:65
#define FE_CHINESE_TRADITIONAL
Definition: input.c:64
BOOL FASTCALL CliGetImeHotKeysFromRegistry(VOID)
Definition: input.c:337
IMEHOTKEYENTRY DefaultHotKeyTableJ[]
Definition: input.c:43
VOID APIENTRY CliSetDefaultImeHotKeys(PIMEHOTKEYENTRY pEntries, UINT nCount, BOOL bCheck)
Definition: input.c:406
unsigned char BYTE
Definition: xxhash.c:193

Referenced by IntLoadKeyboardLayout(), UnloadKeyboardLayout(), and UpdatePerUserSystemParameters().

◆ CliImmSetHotKey()

BOOL WINAPI CliImmSetHotKey ( DWORD  dwID,
UINT  uModifiers,
UINT  uVirtualKey,
HKL  hKL 
)

Definition at line 288 of file input.c.

289{
290 BOOL ret;
291
292 if (uVirtualKey == 0) // Delete?
293 {
294 ret = CliSaveImeHotKey(dwID, uModifiers, uVirtualKey, hKL, TRUE);
295 if (ret)
296 CliImmSetHotKeyWorker(dwID, uModifiers, uVirtualKey, hKL, SETIMEHOTKEY_DELETE);
297 return ret;
298 }
299
300 // Add
301 ret = CliImmSetHotKeyWorker(dwID, uModifiers, uVirtualKey, hKL, SETIMEHOTKEY_ADD);
302 if (ret)
303 {
304 ret = CliSaveImeHotKey(dwID, uModifiers, uVirtualKey, hKL, FALSE);
305 if (!ret) // Failure?
306 CliImmSetHotKeyWorker(dwID, uModifiers, uVirtualKey, hKL, SETIMEHOTKEY_DELETE);
307 }
308
309 return ret;
310}
@ SETIMEHOTKEY_ADD
Definition: undocuser.h:402
@ SETIMEHOTKEY_DELETE
Definition: undocuser.h:401
BOOL APIENTRY CliImmSetHotKeyWorker(DWORD dwHotKeyId, UINT uModifiers, UINT uVirtualKey, HKL hKL, DWORD dwAction)
Definition: input.c:111
BOOL APIENTRY CliSaveImeHotKey(DWORD dwID, UINT uModifiers, UINT uVirtualKey, HKL hKL, BOOL bDelete)
Definition: input.c:210

◆ CliImmSetHotKeyWorker()

BOOL APIENTRY CliImmSetHotKeyWorker ( DWORD  dwHotKeyId,
UINT  uModifiers,
UINT  uVirtualKey,
HKL  hKL,
DWORD  dwAction 
)

Definition at line 111 of file input.c.

112{
113 if (dwAction == SETIMEHOTKEY_ADD)
114 {
115 if (IME_HOTKEY_DSWITCH_FIRST <= dwHotKeyId && dwHotKeyId <= IME_HOTKEY_DSWITCH_LAST)
116 {
117 if (!hKL)
118 goto Failure;
119 }
120 else
121 {
122 if (hKL)
123 goto Failure;
124
125 if (IME_KHOTKEY_SHAPE_TOGGLE <= dwHotKeyId &&
127 {
128 // The Korean cannot set the IME hotkeys
129 goto Failure;
130 }
131 }
132
133#define MOD_ALL_MODS (MOD_ALT | MOD_CONTROL | MOD_SHIFT | MOD_WIN)
134 if ((uModifiers & MOD_ALL_MODS) && !(uModifiers & (MOD_LEFT | MOD_RIGHT)))
135 goto Failure;
136#undef MOD_ALL_MODS
137 }
138
139 return NtUserSetImeHotKey(dwHotKeyId, uModifiers, uVirtualKey, hKL, dwAction);
140
141Failure:
143 return FALSE;
144}
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define SetLastError(x)
Definition: compat.h:752
#define MOD_LEFT
Definition: imm.h:188
#define IME_THOTKEY_IME_NONIME_TOGGLE
Definition: imm.h:207
#define IME_KHOTKEY_SHAPE_TOGGLE
Definition: imm.h:203
#define IME_HOTKEY_DSWITCH_LAST
Definition: imm.h:213
#define IME_HOTKEY_DSWITCH_FIRST
Definition: imm.h:212
#define MOD_RIGHT
Definition: imm.h:189
#define MOD_ALL_MODS

Referenced by CliImmSetHotKey(), CliSetDefaultImeHotKeys(), and CliSetSingleHotKey().

◆ CliReadRegistryValue()

DWORD FASTCALL CliReadRegistryValue ( HANDLE  hKey,
LPCWSTR  pszName 
)

Definition at line 97 of file input.c.

98{
99 DWORD dwValue, cbValue;
100 LONG error;
101
102 cbValue = sizeof(dwValue);
103 error = RegQueryValueExW(hKey, pszName, NULL, NULL, (LPBYTE)&dwValue, &cbValue);
104 if (error != ERROR_SUCCESS || cbValue < sizeof(DWORD))
105 return 0;
106
107 return dwValue;
108}

Referenced by CliSetSingleHotKey().

◆ CliSaveImeHotKey()

BOOL APIENTRY CliSaveImeHotKey ( DWORD  dwID,
UINT  uModifiers,
UINT  uVirtualKey,
HKL  hKL,
BOOL  bDelete 
)

Definition at line 210 of file input.c.

211{
213 LONG error;
214 HKEY hControlPanel = NULL, hInputMethod = NULL, hHotKeys = NULL, hKey = NULL;
215 BOOL ret = FALSE, bRevertOnFailure = FALSE;
216
217 if (bDelete)
218 {
220 L"Control Panel\\Input Method\\Hot Keys\\%08lX", dwID);
222 return (error == ERROR_SUCCESS);
223 }
224
225 // Open "Control Panel"
227 NULL, &hControlPanel, NULL);
228 if (error == ERROR_SUCCESS)
229 {
230 // Open "Input Method"
231 error = RegCreateKeyExW(hControlPanel, L"Input Method", 0, NULL, 0, KEY_ALL_ACCESS,
232 NULL, &hInputMethod, NULL);
233 if (error == ERROR_SUCCESS)
234 {
235 // Open "Hot Keys"
236 error = RegCreateKeyExW(hInputMethod, L"Hot Keys", 0, NULL, 0, KEY_ALL_ACCESS,
237 NULL, &hHotKeys, NULL);
238 if (error == ERROR_SUCCESS)
239 {
240 // Open "Key"
241 StringCchPrintfW(szName, _countof(szName), L"%08lX", dwID);
242 error = RegCreateKeyExW(hHotKeys, szName, 0, NULL, 0, KEY_ALL_ACCESS,
243 NULL, &hKey, NULL);
244 if (error == ERROR_SUCCESS)
245 {
246 bRevertOnFailure = TRUE;
247
248 // Set "Virtual Key"
249 error = RegSetValueExW(hKey, L"Virtual Key", 0, REG_BINARY,
250 (LPBYTE)&uVirtualKey, sizeof(uVirtualKey));
251 if (error == ERROR_SUCCESS)
252 {
253 // Set "Key Modifiers"
254 error = RegSetValueExW(hKey, L"Key Modifiers", 0, REG_BINARY,
255 (LPBYTE)&uModifiers, sizeof(uModifiers));
256 if (error == ERROR_SUCCESS)
257 {
258 // Set "Target IME"
259 error = RegSetValueExW(hKey, L"Target IME", 0, REG_BINARY,
260 (LPBYTE)&hKL, sizeof(hKL));
261 if (error == ERROR_SUCCESS)
262 {
263 // Success!
264 ret = TRUE;
265 bRevertOnFailure = FALSE;
266 }
267 }
268 }
270 }
271 RegCloseKey(hHotKeys);
272 }
273 RegCloseKey(hInputMethod);
274 }
275 RegCloseKey(hControlPanel);
276 }
277
278 if (bRevertOnFailure)
279 CliSaveImeHotKey(dwID, uVirtualKey, uModifiers, hKL, TRUE);
280
281 return ret;
282}
LONG WINAPI RegCreateKeyExW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD Reserved, _In_opt_ LPWSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_opt_ LPDWORD lpdwDisposition)
Definition: reg.c:1096
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4882
LONG WINAPI RegDeleteKeyW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey)
Definition: reg.c:1239
#define MAX_PATH
Definition: compat.h:34
#define REG_BINARY
Definition: nt_native.h:1496
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
static const WCHAR szName[]
Definition: powrprof.c:45
STRSAFEAPI StringCchPrintfW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszFormat,...)
Definition: strsafe.h:530

Referenced by CliImmSetHotKey(), and CliSaveImeHotKey().

◆ CliSetDefaultImeHotKeys()

VOID APIENTRY CliSetDefaultImeHotKeys ( PIMEHOTKEYENTRY  pEntries,
UINT  nCount,
BOOL  bCheck 
)

Definition at line 406 of file input.c.

407{
408 UINT uVirtualKey, uModifiers;
409 HKL hKL;
410
411 while (nCount-- > 0)
412 {
413 if (!bCheck || !NtUserGetImeHotKey(pEntries->dwHotKeyId, &uModifiers, &uVirtualKey, &hKL))
414 {
416 pEntries->uModifiers,
417 pEntries->uVirtualKey,
418 pEntries->hKL,
420 }
421 ++pEntries;
422 }
423}
BOOL NTAPI NtUserGetImeHotKey(DWORD dwHotKeyId, LPUINT lpuModifiers, LPUINT lpuVirtualKey, LPHKL lphKL)
Definition: ime.c:406
UINT uVirtualKey
Definition: input.c:37
DWORD dwHotKeyId
Definition: input.c:36
UINT uModifiers
Definition: input.c:38

Referenced by CliImmInitializeHotKeys().

◆ CliSetSingleHotKey()

BOOL FASTCALL CliSetSingleHotKey ( LPCWSTR  pszSubKey,
HANDLE  hKey 
)

Definition at line 312 of file input.c.

313{
314 LONG error;
315 HKEY hSubKey;
316 DWORD dwHotKeyId = 0;
317 UINT uModifiers = 0, uVirtualKey = 0;
318 HKL hKL = NULL;
319 UNICODE_STRING ustrName;
320
321 error = RegOpenKeyExW(hKey, pszSubKey, 0, KEY_READ, &hSubKey);
322 if (error != ERROR_SUCCESS)
323 return FALSE;
324
325 RtlInitUnicodeString(&ustrName, pszSubKey);
326 RtlUnicodeStringToInteger(&ustrName, 16, &dwHotKeyId);
327
328 uModifiers = CliReadRegistryValue(hSubKey, L"Key Modifiers");
329 hKL = (HKL)(ULONG_PTR)CliReadRegistryValue(hSubKey, L"Target IME");
330 uVirtualKey = CliReadRegistryValue(hSubKey, L"Virtual Key");
331
332 RegCloseKey(hSubKey);
333
334 return CliImmSetHotKeyWorker(dwHotKeyId, uModifiers, uVirtualKey, hKL, SETIMEHOTKEY_ADD);
335}
uint32_t ULONG_PTR
Definition: typedefs.h:65
DWORD FASTCALL CliReadRegistryValue(HANDLE hKey, LPCWSTR pszName)
Definition: input.c:97

Referenced by CliGetImeHotKeysFromRegistry().

◆ DragDetect()

BOOL WINAPI DragDetect ( HWND  hWnd,
POINT  pt 
)

Definition at line 481 of file input.c.

484{
485 return NtUserDragDetect(hWnd, pt);
486#if 0
487 MSG msg;
488 RECT rect;
489 POINT tmp;
492
493 rect.left = pt.x - dx;
494 rect.right = pt.x + dx;
495 rect.top = pt.y - dy;
496 rect.bottom = pt.y + dy;
497
499
500 for (;;)
501 {
502 while (
505 )
506 {
507 if (msg.message == WM_LBUTTONUP)
508 {
510 return FALSE;
511 }
512 if (msg.message == WM_MOUSEMOVE)
513 {
514 tmp.x = LOWORD(msg.lParam);
515 tmp.y = HIWORD(msg.lParam);
516 if (!PtInRect(&rect, tmp))
517 {
519 return TRUE;
520 }
521 }
522 if (msg.message == WM_KEYDOWN)
523 {
524 if (msg.wParam == VK_ESCAPE)
525 {
527 return TRUE;
528 }
529 }
530 }
531 WaitMessage();
532 }
533 return 0;
534#endif
535}
#define msg(x)
Definition: auth_time.c:54
HWND hWnd
Definition: settings.c:17
#define pt(x, y)
Definition: drawing.c:79
BOOL NTAPI NtUserDragDetect(HWND hWnd, POINT pt)
Definition: message.c:2159
GLint dy
Definition: linetemp.h:97
GLint dx
Definition: linetemp.h:97
& rect
Definition: startmenu.cpp:1413
long y
Definition: polytest.cpp:48
long x
Definition: polytest.cpp:48
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
uint32_t ULONG
Definition: typedefs.h:59
#define HIWORD(l)
Definition: typedefs.h:247
HWND WINAPI SetCapture(_In_ HWND hWnd)
#define WM_MOUSEFIRST
Definition: winuser.h:1774
#define SM_CXDRAG
Definition: winuser.h:1028
#define WM_MOUSELAST
Definition: winuser.h:1801
BOOL WINAPI ReleaseCapture(void)
Definition: message.c:2890
#define WM_KEYFIRST
Definition: winuser.h:1714
#define WM_MOUSEMOVE
Definition: winuser.h:1775
BOOL WINAPI PtInRect(_In_ LPCRECT, _In_ POINT)
BOOL WINAPI PeekMessageW(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT, _In_ UINT)
#define PM_REMOVE
Definition: winuser.h:1196
BOOL WINAPI WaitMessage(void)
Definition: ntwrapper.h:350
#define WM_LBUTTONUP
Definition: winuser.h:1777
#define WM_KEYDOWN
Definition: winuser.h:1715
#define SM_CYDRAG
Definition: winuser.h:1029
#define WM_KEYLAST
Definition: winuser.h:1728
#define VK_ESCAPE
Definition: winuser.h:2214
int WINAPI GetSystemMetrics(_In_ int)

◆ EnableWindow()

BOOL WINAPI EnableWindow ( HWND  hWnd,
BOOL  bEnable 
)

Definition at line 541 of file input.c.

542{
544}
EXTINLINE BOOL NtUserxEnableWindow(HWND hWnd, BOOL bEnable)
Definition: ntwrapper.h:681
_In_ BOOL bEnable
Definition: winddi.h:3426

◆ GetAsyncKeyState()

SHORT WINAPI DECLSPEC_HOTPATCH GetAsyncKeyState ( int  vKey)

Definition at line 552 of file input.c.

553{
554 if (vKey < 0 || vKey > 256)
555 return 0;
556 return (SHORT)NtUserGetAsyncKeyState((DWORD)vKey);
557}
SHORT NTAPI NtUserGetAsyncKeyState(INT Key)
Definition: keyboard.c:634
short SHORT
Definition: pedump.c:59

◆ GetKBCodePage()

UINT WINAPI GetKBCodePage ( VOID  )

Definition at line 574 of file input.c.

575{
576 return GetOEMCP();
577}
UINT WINAPI GetOEMCP(void)
Definition: locale.c:2059

◆ GetKeyboardLayout()

HKL WINAPI GetKeyboardLayout ( DWORD  idThread)

Definition at line 564 of file input.c.

565{
566 return NtUserxGetKeyboardLayout(idThread);
567}
EXTINLINE HKL NtUserxGetKeyboardLayout(DWORD idThread)
Definition: ntwrapper.h:626

◆ GetKeyboardLayoutNameA()

BOOL WINAPI GetKeyboardLayoutNameA ( LPSTR  pwszKLID)

Definition at line 634 of file input.c.

635{
637
639 return FALSE;
640
641 if (!WideCharToMultiByte(CP_ACP, 0, buf, -1, pwszKLID, KL_NAMELENGTH, NULL, NULL))
642 return FALSE;
643
644 return TRUE;
645}
#define CP_ACP
Definition: compat.h:109
#define WideCharToMultiByte
Definition: compat.h:111
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
BOOL WINAPI GetKeyboardLayoutNameW(_Out_writes_(KL_NAMELENGTH) LPWSTR)
#define KL_NAMELENGTH
Definition: winuser.h:122

◆ GetKeyboardLayoutNameW()

BOOL WINAPI GetKeyboardLayoutNameW ( LPWSTR  pwszKLID)

Definition at line 651 of file input.c.

652{
654
655 RtlInitEmptyUnicodeString(&Name,
656 pwszKLID,
657 KL_NAMELENGTH * sizeof(WCHAR));
658
660}
struct NameRec_ * Name
Definition: cdprocs.h:460
BOOL NTAPI NtUserGetKeyboardLayoutName(_Inout_ PUNICODE_STRING pustrName)
Definition: kbdlayout.c:1129

◆ GetKeyboardType()

int WINAPI GetKeyboardType ( int  nTypeFlag)

Definition at line 666 of file input.c.

667{
668 return NtUserxGetKeyboardType(nTypeFlag);
669}
EXTINLINE INT NtUserxGetKeyboardType(INT nTypeFlag)
Definition: ntwrapper.h:631

◆ GetKeyNameTextA()

int WINAPI GetKeyNameTextA ( LONG  lParam,
LPSTR  lpString,
int  nSize 
)

Definition at line 584 of file input.c.

587{
588 LPWSTR pwszBuf;
589 UINT cchBuf = 0;
590 int iRet = 0;
591 BOOL defChar = FALSE;
592
593 pwszBuf = HeapAlloc(GetProcessHeap(), 0, nSize * sizeof(WCHAR));
594 if (!pwszBuf)
595 return 0;
596
597 cchBuf = NtUserGetKeyNameText(lParam, pwszBuf, nSize);
598
599 iRet = WideCharToMultiByte(CP_ACP, 0,
600 pwszBuf, cchBuf,
601 lpString, nSize, ".", &defChar); // FIXME: do we need defChar?
602 lpString[iRet] = 0;
603 HeapFree(GetProcessHeap(), 0, pwszBuf);
604
605 return iRet;
606}
LPARAM lParam
Definition: combotst.c:139
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
DWORD NTAPI NtUserGetKeyNameText(LONG lParam, LPWSTR lpString, int nSize)
Definition: keyboard.c:1584
*nSize LPSTR _Inout_ LPDWORD nSize
Definition: winbase.h:2084
WCHAR * LPWSTR
Definition: xmlstorage.h:184

◆ GetKeyNameTextW()

int WINAPI GetKeyNameTextW ( LONG  lParam,
LPWSTR  lpString,
int  nSize 
)

Definition at line 612 of file input.c.

615{
616 return NtUserGetKeyNameText(lParam, lpString, nSize);
617}

◆ GetKeyState()

SHORT WINAPI DECLSPEC_HOTPATCH GetKeyState ( int  nVirtKey)

Definition at line 625 of file input.c.

626{
627 return (SHORT)NtUserGetKeyState((DWORD)nVirtKey);
628}
SHORT NTAPI NtUserGetKeyState(INT VirtKey)
Definition: msgqueue.c:2556

◆ GetLastInputInfo()

BOOL WINAPI GetLastInputInfo ( PLASTINPUTINFO  plii)

Definition at line 675 of file input.c.

676{
677 TRACE("%p\n", plii);
678
679 if (plii->cbSize != sizeof (*plii))
680 {
682 return FALSE;
683 }
684
685 plii->dwTime = gpsi->dwLastRITEventTickCount;
686 return TRUE;
687}
PSERVERINFO gpsi
Definition: imm.c:18
#define TRACE(s)
Definition: solgame.cpp:4
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList

◆ GetSystemLibraryPath()

VOID GetSystemLibraryPath ( LPWSTR  pszPath,
INT  cchPath,
LPCWSTR  pszFileName 
)

Definition at line 712 of file input.c.

713{
714 WCHAR szSysDir[MAX_PATH];
715 GetSystemDirectoryW(szSysDir, _countof(szSysDir));
716 StringCchPrintfW(pszPath, cchPath, L"%s\\%s", szSysDir, pszFileName);
717}
UINT WINAPI GetSystemDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2313
WORD WORD PSZ PSZ pszFileName
Definition: vdmdbg.h:44

Referenced by IntLoadKeyboardLayout().

◆ IntLoadKeyboardLayout()

HKL APIENTRY IntLoadKeyboardLayout ( _In_ HKL  hklUnload,
_In_z_ LPCWSTR  pwszKLID,
_In_ LANGID  wLangID,
_In_ UINT  Flags,
_In_ BOOL  unknown5 
)

Definition at line 728 of file input.c.

734{
735 DWORD dwKLID, dwHKL, dwType, dwSize;
736 UNICODE_STRING ustrKLID;
737 WCHAR wszRegKey[256] = L"SYSTEM\\CurrentControlSet\\Control\\Keyboard Layouts\\";
738 WCHAR wszLayoutId[10], wszNewKLID[KL_NAMELENGTH], szImeFileName[80];
739 HKL hNewKL;
740 HKEY hKey;
741 BOOL bIsIME;
742 WORD wLow, wHigh;
743
744 if (!IsValidKLID(pwszKLID))
745 {
746 ERR("pwszKLID: %s\n", debugstr_w(pwszKLID));
748 }
749
750 dwKLID = wcstoul(pwszKLID, NULL, 16);
751 bIsIME = IS_IME_HKL(UlongToHandle(dwKLID));
752
753 wLow = LOWORD(dwKLID);
754 wHigh = HIWORD(dwKLID);
755
757 {
758 /* Check substitutes key */
759 if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Keyboard Layout\\Substitutes", 0,
761 {
762 dwSize = sizeof(wszNewKLID);
763 if (RegQueryValueExW(hKey, pwszKLID, NULL, &dwType, (LPBYTE)wszNewKLID,
764 &dwSize) == ERROR_SUCCESS &&
765 dwType == REG_SZ)
766 {
767 /* Use new KLID value */
768 pwszKLID = wszNewKLID;
769 dwKLID = wcstoul(pwszKLID, NULL, 16);
770 wHigh = LOWORD(dwKLID);
771 }
772
773 /* Close the key now */
775 }
776 }
777
778 /* Append KLID at the end of registry key */
779 StringCbCatW(wszRegKey, sizeof(wszRegKey), pwszKLID);
780
781 /* Open layout registry key for read */
783 {
784 dwSize = sizeof(wszLayoutId);
785 if (RegQueryValueExW(hKey, L"Layout Id", NULL, &dwType, (LPBYTE)wszLayoutId,
786 &dwSize) == ERROR_SUCCESS && dwType == REG_SZ)
787 {
788 /* If Layout Id is specified, use this value | f000 as HIWORD */
789 wHigh = (0xF000 | wcstoul(wszLayoutId, NULL, 16));
790 }
791
792 if (bIsIME)
793 {
794 /* Check "IME File" value */
795 dwSize = sizeof(szImeFileName);
796 if (RegQueryValueExW(hKey, L"IME File", NULL, &dwType, (LPBYTE)szImeFileName,
798 {
799 bIsIME = FALSE;
800 wHigh = 0;
801 ERR("0x%X\n", dwKLID);
802 }
803 else
804 {
806 szImeFileName[_countof(szImeFileName) - 1] = UNICODE_NULL;
807 GetSystemLibraryPath(szPath, _countof(szPath), szImeFileName);
808
809 /* We don't allow the invalid "IME File" values due to security reason */
810 if (dwType != REG_SZ || szImeFileName[0] == 0 ||
811 wcscspn(szImeFileName, L":\\/") != wcslen(szImeFileName) ||
812 GetFileAttributesW(szPath) == INVALID_FILE_ATTRIBUTES) /* Does not exist? */
813 {
814 bIsIME = FALSE;
815 wHigh = 0;
816 ERR("'%s'\n", debugstr_w(szPath));
817 }
818 }
819 }
820
821 /* Close the key now */
823 }
824 else
825 {
826 ERR("Could not find keyboard layout %S.\n", pwszKLID);
827 return NULL;
828 }
829
830 if (wHigh == 0)
831 wHigh = wLow;
832
833 dwHKL = MAKELONG(wLow, wHigh);
834
835 RtlInitUnicodeString(&ustrKLID, pwszKLID);
836 hNewKL = NtUserLoadKeyboardLayoutEx(NULL, 0, NULL, hklUnload, &ustrKLID, dwHKL, Flags);
838 return hNewKL;
839}
#define UlongToHandle(ul)
Definition: basetsd.h:97
#define ERR(fmt,...)
Definition: debug.h:113
DWORD WINAPI GetFileAttributesW(LPCWSTR lpFileName)
Definition: fileinfo.c:652
unsigned short WORD
Definition: ntddk_ex.h:93
#define IS_IME_HKL(hKL)
Definition: imm32_undoc.h:20
_Check_return_ unsigned long __cdecl wcstoul(_In_z_ const wchar_t *_Str, _Out_opt_ _Deref_post_z_ wchar_t **_EndPtr, _In_ int _Radix)
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
HKL NTAPI NtUserLoadKeyboardLayoutEx(IN HANDLE hFile, IN DWORD offTable, IN PVOID pTables, IN HKL hOldKL, IN PUNICODE_STRING puszKLID, IN DWORD dwNewKL, IN UINT Flags)
Definition: kbdlayout.c:1198
#define debugstr_w
Definition: kernel32.h:32
LPCWSTR szPath
Definition: env.c:37
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define UNICODE_NULL
_Check_return_ _CRTIMP size_t __cdecl wcscspn(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_Control)
STRSAFEAPI StringCbCatW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:342
#define MAKELONG(a, b)
Definition: typedefs.h:249
#define INVALID_FILE_ATTRIBUTES
Definition: vfdcmd.c:23
VOID APIENTRY CliImmInitializeHotKeys(DWORD dwAction, HKL hKL)
Definition: input.c:425
#define ENGLISH_US
Definition: input.c:719
VOID GetSystemLibraryPath(LPWSTR pszPath, INT cchPath, LPCWSTR pszFileName)
Definition: input.c:712
static BOOL IsValidKLID(_In_ LPCWSTR pwszKLID)
Definition: input.c:707
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define KLF_SUBSTITUTE_OK
Definition: winuser.h:112
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170

Referenced by LoadKeyboardLayoutEx(), and LoadKeyboardLayoutW().

◆ IntLoadPreloadKeyboardLayouts()

VOID IntLoadPreloadKeyboardLayouts ( VOID  )

Definition at line 148 of file input.c.

149{
150 UINT nNumber, uFlags;
151 DWORD cbValue, dwType;
152 WCHAR szNumber[32], szValue[KL_NAMELENGTH];
153 HKEY hPreloadKey;
154 BOOL bOK = FALSE;
155 HKL hKL, hDefaultKL = NULL;
156
158 L"Keyboard Layout\\Preload",
159 &hPreloadKey) != ERROR_SUCCESS)
160 {
161 return;
162 }
163
164 for (nNumber = 1; nNumber <= 1000; ++nNumber)
165 {
166 _ultow(nNumber, szNumber, 10);
167
168 cbValue = sizeof(szValue);
169 if (RegQueryValueExW(hPreloadKey,
170 szNumber,
171 NULL,
172 &dwType,
173 (LPBYTE)szValue,
174 &cbValue) != ERROR_SUCCESS)
175 {
176 break;
177 }
178
179 if (dwType != REG_SZ)
180 continue;
181
182 if (nNumber == 1) /* The first entry is for default keyboard layout */
183 uFlags = KLF_SUBSTITUTE_OK | KLF_ACTIVATE | KLF_RESET;
184 else
186
187 hKL = LoadKeyboardLayoutW(szValue, uFlags);
188 if (hKL)
189 {
190 bOK = TRUE;
191 if (nNumber == 1) /* The first entry */
192 hDefaultKL = hKL;
193 }
194 }
195
196 RegCloseKey(hPreloadKey);
197
198 if (hDefaultKL)
199 SystemParametersInfoW(SPI_SETDEFAULTINPUTLANG, 0, &hDefaultKL, 0);
200
201 if (!bOK)
202 {
203 /* Fallback to English (US) */
204 LoadKeyboardLayoutW(L"00000409", KLF_SUBSTITUTE_OK | KLF_ACTIVATE | KLF_RESET);
205 }
206}
LONG WINAPI RegOpenKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3268
UINT uFlags
Definition: api.c:59
HKL WINAPI LoadKeyboardLayoutW(LPCWSTR pwszKLID, UINT Flags)
Definition: input.c:845
#define KLF_REPLACELANG
Definition: winuser.h:115
#define KLF_ACTIVATE
Definition: winuser.h:111
BOOL WINAPI SystemParametersInfoW(_In_ UINT uiAction, _In_ UINT uiParam, _Inout_opt_ PVOID pvParam, _In_ UINT fWinIni)
#define KLF_NOTELLSHELL
Definition: winuser.h:116

Referenced by UpdatePerUserSystemParameters().

◆ IntSetFeKeyboardFlags()

VOID FASTCALL IntSetFeKeyboardFlags ( LANGID  LangID,
PBYTE  pbFlags 
)

Definition at line 70 of file input.c.

71{
72 switch (LangID)
73 {
75 *pbFlags |= FE_JAPANESE;
76 break;
77
80 *pbFlags |= FE_CHINESE_TRADITIONAL;
81 break;
82
85 *pbFlags |= FE_CHINESE_SIMPLIFIED;
86 break;
87
89 *pbFlags |= FE_KOREAN;
90 break;
91
92 default:
93 break;
94 }
95}
#define MAKELANGID(p, s)
Definition: nls.h:15
#define SUBLANG_CHINESE_SINGAPORE
Definition: nls.h:211
#define SUBLANG_CHINESE_TRADITIONAL
Definition: nls.h:208
#define SUBLANG_CHINESE_SIMPLIFIED
Definition: nls.h:209
#define SUBLANG_DEFAULT
Definition: nls.h:168
#define SUBLANG_CHINESE_HONGKONG
Definition: nls.h:210
#define LANG_CHINESE
Definition: nls.h:42
#define LANG_JAPANESE
Definition: nls.h:76
#define LANG_KOREAN
Definition: nls.h:84
#define SUBLANG_KOREAN
Definition: nls.h:280
#define FE_KOREAN
Definition: input.c:66

Referenced by CliGetPreloadKeyboardLayouts(), and CliImmInitializeHotKeys().

◆ IsValidKLID()

static BOOL IsValidKLID ( _In_ LPCWSTR  pwszKLID)
inlinestatic

Definition at line 707 of file input.c.

708{
709 return (pwszKLID != NULL) && (wcsspn(pwszKLID, L"0123456789ABCDEFabcdef") == (KL_NAMELENGTH - 1));
710}
_Check_return_ _CRTIMP size_t __cdecl wcsspn(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_Control)

Referenced by IntLoadKeyboardLayout().

◆ keybd_event()

VOID WINAPI keybd_event ( BYTE  bVk,
BYTE  bScan,
DWORD  dwFlags,
ULONG_PTR  dwExtraInfo 
)

Definition at line 1099 of file input.c.

1104{
1105 INPUT Input;
1106
1107 Input.type = INPUT_KEYBOARD;
1108 Input.ki.wVk = bVk;
1109 Input.ki.wScan = bScan;
1110 Input.ki.dwFlags = dwFlags;
1111 Input.ki.time = 0;
1112 Input.ki.dwExtraInfo = dwExtraInfo;
1113
1114 NtUserSendInput(1, &Input, sizeof(INPUT));
1115}
UINT NTAPI NtUserSendInput(UINT nInputs, LPINPUT pInput, INT cbSize)
Definition: input.c:708
@ Input
Definition: arc.h:84
#define INPUT_KEYBOARD
Definition: winable.h:10
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
BOOL bScan
Definition: wlanconf.c:23

◆ LoadKeyboardLayoutA()

HKL WINAPI LoadKeyboardLayoutA ( LPCSTR  pszKLID,
UINT  Flags 
)

Definition at line 693 of file input.c.

695{
696 WCHAR wszKLID[16];
697
698 if (!MultiByteToWideChar(CP_ACP, 0, pszKLID, -1,
699 wszKLID, sizeof(wszKLID)/sizeof(wszKLID[0])))
700 {
701 return FALSE;
702 }
703
704 return LoadKeyboardLayoutW(wszKLID, Flags);
705}
#define MultiByteToWideChar
Definition: compat.h:110

◆ LoadKeyboardLayoutEx()

HKL WINAPI LoadKeyboardLayoutEx ( HKL  hklUnload,
LPCWSTR  pwszKLID,
UINT  Flags 
)

Definition at line 856 of file input.c.

859{
860 FIXME("(%p, %s, 0x%X)", hklUnload, debugstr_w(pwszKLID), Flags);
861 if (!hklUnload)
862 return NULL;
863 return IntLoadKeyboardLayout(hklUnload, pwszKLID, 0, Flags, FALSE);
864}
#define FIXME(fmt,...)
Definition: debug.h:114
HKL APIENTRY IntLoadKeyboardLayout(_In_ HKL hklUnload, _In_z_ LPCWSTR pwszKLID, _In_ LANGID wLangID, _In_ UINT Flags, _In_ BOOL unknown5)
Definition: input.c:728

◆ LoadKeyboardLayoutW()

HKL WINAPI LoadKeyboardLayoutW ( LPCWSTR  pwszKLID,
UINT  Flags 
)

Definition at line 845 of file input.c.

847{
848 TRACE("(%s, 0x%X)\n", debugstr_w(pwszKLID), Flags);
849 return IntLoadKeyboardLayout(NULL, pwszKLID, 0, Flags, FALSE);
850}

Referenced by IntLoadPreloadKeyboardLayouts(), and LoadKeyboardLayoutA().

◆ MapVirtualKeyA()

UINT WINAPI MapVirtualKeyA ( UINT  uCode,
UINT  uMapType 
)

Definition at line 882 of file input.c.

884{
885 return MapVirtualKeyExA(uCode, uMapType, GetKeyboardLayout(0));
886}
HKL WINAPI GetKeyboardLayout(_In_ DWORD)
UINT WINAPI MapVirtualKeyExA(_In_ UINT, _In_ UINT, _In_opt_ HKL)

◆ MapVirtualKeyExA()

UINT WINAPI MapVirtualKeyExA ( UINT  uCode,
UINT  uMapType,
HKL  dwhkl 
)

Definition at line 892 of file input.c.

895{
896 return MapVirtualKeyExW(uCode, uMapType, dwhkl);
897}
UINT WINAPI MapVirtualKeyExW(UINT uCode, UINT uMapType, HKL dwhkl)
Definition: input.c:904

◆ MapVirtualKeyExW()

UINT WINAPI MapVirtualKeyExW ( UINT  uCode,
UINT  uMapType,
HKL  dwhkl 
)

Definition at line 904 of file input.c.

907{
908 return NtUserMapVirtualKeyEx(uCode, uMapType, 0, dwhkl);
909}
UINT NTAPI NtUserMapVirtualKeyEx(UINT keyCode, UINT transType, DWORD keyboardId, HKL dwhkl)
Definition: keyboard.c:1439

Referenced by MapVirtualKeyExA(), and MapVirtualKeyW().

◆ MapVirtualKeyW()

UINT WINAPI MapVirtualKeyW ( UINT  uCode,
UINT  uMapType 
)

Definition at line 916 of file input.c.

918{
919 return MapVirtualKeyExW(uCode, uMapType, GetKeyboardLayout(0));
920}

◆ mouse_event()

VOID WINAPI mouse_event ( DWORD  dwFlags,
DWORD  dx,
DWORD  dy,
DWORD  dwData,
ULONG_PTR  dwExtraInfo 
)

Definition at line 1123 of file input.c.

1129{
1130 INPUT Input;
1131
1132 Input.type = INPUT_MOUSE;
1133 Input.mi.dx = dx;
1134 Input.mi.dy = dy;
1135 Input.mi.mouseData = dwData;
1136 Input.mi.dwFlags = dwFlags;
1137 Input.mi.time = 0;
1138 Input.mi.dwExtraInfo = dwExtraInfo;
1139
1140 NtUserSendInput(1, &Input, sizeof(INPUT));
1141}
static HANDLE ULONG_PTR dwData
Definition: file.c:35
#define INPUT_MOUSE
Definition: winable.h:9

◆ OemKeyScan()

DWORD WINAPI OemKeyScan ( WORD  wOemChar)

Definition at line 927 of file input.c.

928{
929 WCHAR p;
930 SHORT Vk;
931 UINT Scan;
932
933 MultiByteToWideChar(CP_OEMCP, 0, (PCSTR)&wOemChar, 1, &p, 1);
934 Vk = VkKeyScanW(p);
935 Scan = MapVirtualKeyW((Vk & 0x00ff), 0);
936 if (!Scan) return -1;
937 /*
938 Page 450-1, MS W2k SuperBible by SAMS. Return, low word has the
939 scan code and high word has the shift state.
940 */
941 return ((Vk & 0xff00) << 8) | Scan;
942}
GLfloat GLfloat p
Definition: glext.h:8902
const char * PCSTR
Definition: typedefs.h:52
#define CP_OEMCP
Definition: winnls.h:231
UINT WINAPI MapVirtualKeyW(_In_ UINT, _In_ UINT)
SHORT WINAPI VkKeyScanW(_In_ WCHAR)

◆ SetDoubleClickTime()

BOOL WINAPI SetDoubleClickTime ( UINT  uInterval)

Definition at line 949 of file input.c.

950{
952 uInterval,
953 NULL,
954 0);
955}
BOOL NTAPI NtUserSystemParametersInfo(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
Definition: sysparams.c:2168
#define SPI_SETDOUBLECLICKTIME
Definition: winuser.h:1381

◆ SwapMouseButton()

BOOL WINAPI SwapMouseButton ( BOOL  fSwap)

Definition at line 963 of file input.c.

965{
966 return NtUserxSwapMouseButton(fSwap);
967}
EXTINLINE BOOL NtUserxSwapMouseButton(BOOL fSwap)
Definition: ntwrapper.h:596

◆ ToAscii()

int WINAPI ToAscii ( UINT  uVirtKey,
UINT  uScanCode,
CONST BYTE lpKeyState,
LPWORD  lpChar,
UINT  uFlags 
)

Definition at line 974 of file input.c.

979{
980 return ToAsciiEx(uVirtKey, uScanCode, lpKeyState, lpChar, uFlags, 0);
981}
int WINAPI ToAsciiEx(_In_ UINT, _In_ UINT, _In_reads_opt_(256) CONST BYTE *, _Out_ LPWORD, _In_ UINT, _In_opt_ HKL)

◆ ToAsciiEx()

int WINAPI ToAsciiEx ( UINT  uVirtKey,
UINT  uScanCode,
CONST BYTE lpKeyState,
LPWORD  lpChar,
UINT  uFlags,
HKL  dwhkl 
)

Definition at line 988 of file input.c.

994{
995 WCHAR UniChars[2];
996 int Ret, CharCount;
997
998 Ret = ToUnicodeEx(uVirtKey, uScanCode, lpKeyState, UniChars, 2, uFlags, dwhkl);
999 CharCount = (Ret < 0 ? 1 : Ret);
1000 WideCharToMultiByte(CP_ACP, 0, UniChars, CharCount, (LPSTR)lpChar, 2, NULL, NULL);
1001
1002 return Ret;
1003}
int WINAPI ToUnicodeEx(_In_ UINT wVirtKey, _In_ UINT wScanCode, _In_reads_bytes_(256) CONST BYTE *lpKeyState, _Out_writes_(cchBuff) LPWSTR pwszBuff, _In_ int cchBuff, _In_ UINT wFlags, _In_opt_ HKL dwhkl)
char * LPSTR
Definition: xmlstorage.h:182

◆ ToUnicode()

int WINAPI ToUnicode ( UINT  wVirtKey,
UINT  wScanCode,
CONST BYTE lpKeyState,
LPWSTR  pwszBuff,
int  cchBuff,
UINT  wFlags 
)

Definition at line 1010 of file input.c.

1016{
1017 return ToUnicodeEx(wVirtKey, wScanCode, lpKeyState, pwszBuff, cchBuff,
1018 wFlags, 0);
1019}
_In_ DWORD _Out_ _In_ WORD wFlags
Definition: wincon.h:531

◆ ToUnicodeEx()

int WINAPI ToUnicodeEx ( UINT  wVirtKey,
UINT  wScanCode,
CONST BYTE lpKeyState,
LPWSTR  pwszBuff,
int  cchBuff,
UINT  wFlags,
HKL  dwhkl 
)

Definition at line 1026 of file input.c.

1033{
1034 return NtUserToUnicodeEx(wVirtKey, wScanCode, (PBYTE)lpKeyState, pwszBuff, cchBuff,
1035 wFlags, dwhkl);
1036}
INT NTAPI NtUserToUnicodeEx(UINT wVirtKey, UINT wScanCode, PBYTE lpKeyState, LPWSTR pwszBuff, int cchBuff, UINT wFlags, HKL dwhkl)
BYTE * PBYTE
Definition: pedump.c:66

◆ UnloadKeyboardLayout()

BOOL WINAPI UnloadKeyboardLayout ( HKL  hKL)

Definition at line 869 of file input.c.

870{
872 return FALSE;
873
875 return TRUE;
876}
BOOL NTAPI NtUserUnloadKeyboardLayout(HKL hKl)
Definition: kbdlayout.c:1288

◆ VkKeyScanA()

SHORT WINAPI VkKeyScanA ( CHAR  ch)

Definition at line 1044 of file input.c.

1045{
1046 WCHAR wChar;
1047
1048 if (IsDBCSLeadByte(ch))
1049 return -1;
1050
1051 MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wChar, 1);
1052 return VkKeyScanW(wChar);
1053}
BOOL WINAPI IsDBCSLeadByte(BYTE testchar)
Definition: locale.c:2123

◆ VkKeyScanExA()

SHORT WINAPI VkKeyScanExA ( CHAR  ch,
HKL  dwhkl 
)

Definition at line 1060 of file input.c.

1062{
1063 WCHAR wChar;
1064
1065 if (IsDBCSLeadByte(ch))
1066 return -1;
1067
1068 MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wChar, 1);
1069 return VkKeyScanExW(wChar, dwhkl);
1070}
SHORT WINAPI VkKeyScanExW(WCHAR ch, HKL dwhkl)
Definition: input.c:1077

◆ VkKeyScanExW()

SHORT WINAPI VkKeyScanExW ( WCHAR  ch,
HKL  dwhkl 
)

Definition at line 1077 of file input.c.

1079{
1080 return (SHORT)NtUserVkKeyScanEx(ch, dwhkl, TRUE);
1081}
DWORD NTAPI NtUserVkKeyScanEx(WCHAR wChar, HKL KeyboardLayout, BOOL bUsehHK)
Definition: keyboard.c:1709

Referenced by VkKeyScanExA().

◆ VkKeyScanW()

SHORT WINAPI VkKeyScanW ( WCHAR  ch)

Definition at line 1088 of file input.c.

1089{
1090 return (SHORT)NtUserVkKeyScanEx(ch, 0, FALSE);
1091}

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( user32  )

Variable Documentation

◆ DefaultHotKeyTableC

IMEHOTKEYENTRY DefaultHotKeyTableC[]
Initial value:
=
{
}
#define IME_CHOTKEY_IME_NONIME_TOGGLE
Definition: imm.h:195
#define MOD_SHIFT
Definition: imm.h:186
#define MOD_CONTROL
Definition: imm.h:185
#define IME_CHOTKEY_SHAPE_TOGGLE
Definition: imm.h:196
#define VK_SPACE
Definition: winuser.h:2219

Definition at line 56 of file input.c.

Referenced by CliImmInitializeHotKeys().

◆ DefaultHotKeyTableJ

IMEHOTKEYENTRY DefaultHotKeyTableJ[]
Initial value:
=
{
}
#define IME_JHOTKEY_CLOSE_OPEN
Definition: imm.h:200
#define MOD_IGNORE_ALL_MODIFIER
Definition: imm.h:192
#define VK_KANJI
Definition: winuser.h:2213

Definition at line 43 of file input.c.

Referenced by CliImmInitializeHotKeys().

◆ DefaultHotKeyTableT

IMEHOTKEYENTRY DefaultHotKeyTableT[]
Initial value:

Definition at line 49 of file input.c.

Referenced by CliImmInitializeHotKeys().