system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-11-05 18:01:34 +00:00
Code Issues Projects Releases Packages Wiki Activity
wine/dlls/win32u/input.c
Gabriel Ivăncescu 19d2dc0dfc win32u: Don't clip captured mouse pointer if it's done by the system. 
We have similar checks in X11DRV_SetCapture for example, where this would
have been moved before the merge to win32u.

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=55231
Signed-off-by: Gabriel Ivăncescu <gabrielopcode@gmail.com>
2023-07-31 18:19:10 +09:00

2640 lines
83 KiB
C
Raw Blame History

/*
* USER Input processing
*
* Copyright 1993 Bob Amstadt
* Copyright 1993 David Metcalfe
* Copyright 1996 Albrecht Kleine
* Copyright 1996 Frans van Dorsselaer
* Copyright 1997 David Faure
* Copyright 1998 Morten Welinder
* Copyright 1998 Ulrich Weigand
* Copyright 2001 Eric Pouech
* Copyright 2002 Alexandre Julliard
*
* 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 "ntstatus.h"
#define WIN32_NO_STATUS
#include "win32u_private.h"
#include "ntuser_private.h"
#include "wine/server.h"
#include "wine/debug.h"
#include "kbd.h"
WINE_DEFAULT_DEBUG_CHANNEL(win);
WINE_DECLARE_DEBUG_CHANNEL(keyboard);
static const WCHAR keyboard_layouts_keyW[] =
{
'\\','R','e','g','i','s','t','r','y',
'\\','M','a','c','h','i','n','e',
'\\','S','y','s','t','e','m',
'\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t',
'\\','C','o','n','t','r','o','l',
'\\','K','e','y','b','o','a','r','d',' ','L','a','y','o','u','t','s'
};
static const WCHAR escW[] = {'E','s','c',0};
static const WCHAR backspaceW[] = {'B','a','c','k','s','p','a','c','e',0};
static const WCHAR tabW[] = {'T','a','b',0};
static const WCHAR enterW[] = {'E','n','t','e','r',0};
static const WCHAR ctrlW[] = {'C','t','r','l',0};
static const WCHAR shiftW[] = {'S','h','i','f','t',0};
static const WCHAR right_shiftW[] = {'R','i','g','h','t',' ','S','h','i','f','t',0};
static const WCHAR num_mulW[] = {'N','u','m',' ','*',0};
static const WCHAR altW[] = {'A','l','t',0};
static const WCHAR spaceW[] = {'S','p','a','c','e',0};
static const WCHAR caps_lockW[] = {'C','a','p','s',' ','L','o','c','k',0};
static const WCHAR f1W[] = {'F','1',0};
static const WCHAR f2W[] = {'F','2',0};
static const WCHAR f3W[] = {'F','3',0};
static const WCHAR f4W[] = {'F','4',0};
static const WCHAR f5W[] = {'F','5',0};
static const WCHAR f6W[] = {'F','6',0};
static const WCHAR f7W[] = {'F','7',0};
static const WCHAR f8W[] = {'F','8',0};
static const WCHAR f9W[] = {'F','9',0};
static const WCHAR f10W[] = {'F','1','0',0};
static const WCHAR pauseW[] = {'P','a','u','s','e',0};
static const WCHAR scroll_lockW[] = {'S','c','r','o','l','l',' ','L','o','c','k',0};
static const WCHAR num_7W[] = {'N','u','m',' ','7',0};
static const WCHAR num_8W[] = {'N','u','m',' ','8',0};
static const WCHAR num_9W[] = {'N','u','m',' ','9',0};
static const WCHAR num_minusW[] = {'N','u','m',' ','-',0};
static const WCHAR num_4W[] = {'N','u','m',' ','4',0};
static const WCHAR num_5W[] = {'N','u','m',' ','5',0};
static const WCHAR num_6W[] = {'N','u','m',' ','6',0};
static const WCHAR num_plusW[] = {'N','u','m',' ','+',0};
static const WCHAR num_1W[] = {'N','u','m',' ','1',0};
static const WCHAR num_2W[] = {'N','u','m',' ','2',0};
static const WCHAR num_3W[] = {'N','u','m',' ','3',0};
static const WCHAR num_0W[] = {'N','u','m',' ','0',0};
static const WCHAR num_delW[] = {'N','u','m',' ','D','e','l',0};
static const WCHAR sys_reqW[] = {'S','y','s',' ','R','e','q',0};
static const WCHAR f11W[] = {'F','1','1',0};
static const WCHAR f12W[] = {'F','1','2',0};
static const WCHAR f13W[] = {'F','1','3',0};
static const WCHAR f14W[] = {'F','1','4',0};
static const WCHAR f15W[] = {'F','1','5',0};
static const WCHAR f16W[] = {'F','1','6',0};
static const WCHAR f17W[] = {'F','1','7',0};
static const WCHAR f18W[] = {'F','1','8',0};
static const WCHAR f19W[] = {'F','1','9',0};
static const WCHAR f20W[] = {'F','2','0',0};
static const WCHAR f21W[] = {'F','2','1',0};
static const WCHAR f22W[] = {'F','2','2',0};
static const WCHAR f23W[] = {'F','2','3',0};
static const WCHAR f24W[] = {'F','2','4',0};
static const WCHAR num_enterW[] = {'N','u','m',' ','E','n','t','e','r',0};
static const WCHAR right_ctrlW[] = {'R','i','g','h','t',' ','C','t','r','l',0};
static const WCHAR num_divW[] = {'N','u','m',' ','/',0};
static const WCHAR prnt_scrnW[] = {'P','r','n','t',' ','S','c','r','n',0};
static const WCHAR right_altW[] = {'R','i','g','h','t',' ','A','l','t',0};
static const WCHAR num_lockW[] = {'N','u','m',' ','L','o','c','k',0};
static const WCHAR breakW[] = {'B','r','e','a','k',0};
static const WCHAR homeW[] = {'H','o','m','e',0};
static const WCHAR upW[] = {'U','p',0};
static const WCHAR page_upW[] = {'P','a','g','e',' ','U','p',0};
static const WCHAR leftW[] = {'L','e','f','t',0};
static const WCHAR rightW[] = {'R','i','g','h','t',0};
static const WCHAR endW[] = {'E','n','d',0};
static const WCHAR downW[] = {'D','o','w','n',0};
static const WCHAR page_downW[] = {'P','a','g','e',' ','D','o','w','n',0};
static const WCHAR insertW[] = {'I','n','s','e','r','t',0};
static const WCHAR deleteW[] = {'D','e','l','e','t','e',0};
static const WCHAR zerozeroW[] = {'<','0','0','>',0};
static const WCHAR helpW[] = {'H','e','l','p',0};
static const WCHAR left_windowsW[] = {'L','e','f','t',' ','W','i','n','d','o','w','s',0};
static const WCHAR right_windowsW[] = {'R','i','g','h','t',' ','W','i','n','d','o','w','s',0};
static const WCHAR applicationW[] = {'A','p','p','l','i','c','a','t','i','o','n',0};
static const VK_TO_BIT vk_to_bit[] =
{
{.Vk = VK_SHIFT, .ModBits = KBDSHIFT},
{.Vk = VK_CONTROL, .ModBits = KBDCTRL},
{.Vk = VK_MENU, .ModBits = KBDALT},
{0},
};
static const MODIFIERS modifiers =
{
.pVkToBit = (VK_TO_BIT *)vk_to_bit,
.wMaxModBits = 7,
.ModNumber = {0, 1, 2, 3, 0, 1, 0, 0},
};
static const VK_TO_WCHARS2 vk_to_wchars2[] =
{
{.VirtualKey = VK_OEM_3, .wch = {'`', '~'}},
{.VirtualKey = '1', .wch = {'1', '!'}},
{.VirtualKey = '3', .wch = {'3', '#'}},
{.VirtualKey = '4', .wch = {'4', '$'}},
{.VirtualKey = '5', .wch = {'5', '%'}},
{.VirtualKey = '7', .wch = {'7', '&'}},
{.VirtualKey = '8', .wch = {'8', '*'}},
{.VirtualKey = '9', .wch = {'9', '('}},
{.VirtualKey = '0', .wch = {'0', ')'}},
{.VirtualKey = VK_OEM_PLUS, .wch = {'=', '+'}},
{.VirtualKey = 'Q', .wch = {'q', 'Q'}, .Attributes = CAPLOK},
{.VirtualKey = 'W', .wch = {'w', 'W'}, .Attributes = CAPLOK},
{.VirtualKey = 'E', .wch = {'e', 'E'}, .Attributes = CAPLOK},
{.VirtualKey = 'R', .wch = {'r', 'R'}, .Attributes = CAPLOK},
{.VirtualKey = 'T', .wch = {'t', 'T'}, .Attributes = CAPLOK},
{.VirtualKey = 'Y', .wch = {'y', 'Y'}, .Attributes = CAPLOK},
{.VirtualKey = 'U', .wch = {'u', 'U'}, .Attributes = CAPLOK},
{.VirtualKey = 'I', .wch = {'i', 'I'}, .Attributes = CAPLOK},
{.VirtualKey = 'O', .wch = {'o', 'O'}, .Attributes = CAPLOK},
{.VirtualKey = 'P', .wch = {'p', 'P'}, .Attributes = CAPLOK},
{.VirtualKey = 'A', .wch = {'a', 'A'}, .Attributes = CAPLOK},
{.VirtualKey = 'S', .wch = {'s', 'S'}, .Attributes = CAPLOK},
{.VirtualKey = 'D', .wch = {'d', 'D'}, .Attributes = CAPLOK},
{.VirtualKey = 'F', .wch = {'f', 'F'}, .Attributes = CAPLOK},
{.VirtualKey = 'G', .wch = {'g', 'G'}, .Attributes = CAPLOK},
{.VirtualKey = 'H', .wch = {'h', 'H'}, .Attributes = CAPLOK},
{.VirtualKey = 'J', .wch = {'j', 'J'}, .Attributes = CAPLOK},
{.VirtualKey = 'K', .wch = {'k', 'K'}, .Attributes = CAPLOK},
{.VirtualKey = 'L', .wch = {'l', 'L'}, .Attributes = CAPLOK},
{.VirtualKey = VK_OEM_1, .wch = {';', ':'}},
{.VirtualKey = VK_OEM_7, .wch = {'\'', '\"'}},
{.VirtualKey = 'Z', .wch = {'z', 'Z'}, .Attributes = CAPLOK},
{.VirtualKey = 'X', .wch = {'x', 'X'}, .Attributes = CAPLOK},
{.VirtualKey = 'C', .wch = {'c', 'C'}, .Attributes = CAPLOK},
{.VirtualKey = 'V', .wch = {'v', 'V'}, .Attributes = CAPLOK},
{.VirtualKey = 'B', .wch = {'b', 'B'}, .Attributes = CAPLOK},
{.VirtualKey = 'N', .wch = {'n', 'N'}, .Attributes = CAPLOK},
{.VirtualKey = 'M', .wch = {'m', 'M'}, .Attributes = CAPLOK},
{.VirtualKey = VK_OEM_COMMA, .wch = {',', '<'}},
{.VirtualKey = VK_OEM_PERIOD, .wch = {'.', '>'}},
{.VirtualKey = VK_OEM_2, .wch = {'/', '?'}},
{.VirtualKey = VK_DECIMAL, .wch = {'.', '.'}},
{.VirtualKey = VK_TAB, .wch = {'\t', '\t'}},
{.VirtualKey = VK_ADD, .wch = {'+', '+'}},
{.VirtualKey = VK_DIVIDE, .wch = {'/', '/'}},
{.VirtualKey = VK_MULTIPLY, .wch = {'*', '*'}},
{.VirtualKey = VK_SUBTRACT, .wch = {'-', '-'}},
{0},
};
static const VK_TO_WCHARS3 vk_to_wchars3[] =
{
{.VirtualKey = VK_OEM_4, .wch = {'[', '{', '\x001b'}},
{.VirtualKey = VK_OEM_6, .wch = {']', '}', '\x001d'}},
{.VirtualKey = VK_OEM_5, .wch = {'\\', '|', '\x001c'}},
{.VirtualKey = VK_OEM_102, .wch = {'\\', '|', '\x001c'}},
{.VirtualKey = VK_BACK, .wch = {'\b', '\b', '\x007f'}},
{.VirtualKey = VK_ESCAPE, .wch = {'\x001b', '\x001b', '\x001b'}},
{.VirtualKey = VK_RETURN, .wch = {'\r', '\r', '\n'}},
{.VirtualKey = VK_SPACE, .wch = {' ', ' ', ' '}},
{.VirtualKey = VK_CANCEL, .wch = {'\x0003', '\x0003', '\x0003'}},
{0},
};
static const VK_TO_WCHARS4 vk_to_wchars4[] =
{
{.VirtualKey = '2', .wch = {'2', '@', WCH_NONE, '\x0000'}},
{.VirtualKey = '6', .wch = {'6', '^', WCH_NONE, '\x001e'}},
{.VirtualKey = VK_OEM_MINUS, .wch = {'-', '_', WCH_NONE, '\x001f'}},
{0},
};
static const VK_TO_WCHARS1 vk_to_wchars1[] =
{
{.VirtualKey = VK_NUMPAD0, .wch = {'0'}},
{.VirtualKey = VK_NUMPAD1, .wch = {'1'}},
{.VirtualKey = VK_NUMPAD2, .wch = {'2'}},
{.VirtualKey = VK_NUMPAD3, .wch = {'3'}},
{.VirtualKey = VK_NUMPAD4, .wch = {'4'}},
{.VirtualKey = VK_NUMPAD5, .wch = {'5'}},
{.VirtualKey = VK_NUMPAD6, .wch = {'6'}},
{.VirtualKey = VK_NUMPAD7, .wch = {'7'}},
{.VirtualKey = VK_NUMPAD8, .wch = {'8'}},
{.VirtualKey = VK_NUMPAD9, .wch = {'9'}},
{0},
};
static const VK_TO_WCHAR_TABLE vk_to_wchar_table[] =
{
{.pVkToWchars = (VK_TO_WCHARS1 *)vk_to_wchars3, .nModifications = 3, .cbSize = sizeof(vk_to_wchars3[0])},
{.pVkToWchars = (VK_TO_WCHARS1 *)vk_to_wchars4, .nModifications = 4, .cbSize = sizeof(vk_to_wchars4[0])},
{.pVkToWchars = (VK_TO_WCHARS1 *)vk_to_wchars2, .nModifications = 2, .cbSize = sizeof(vk_to_wchars2[0])},
{.pVkToWchars = (VK_TO_WCHARS1 *)vk_to_wchars1, .nModifications = 1, .cbSize = sizeof(vk_to_wchars1[0])},
{0},
};
static const VSC_LPWSTR key_names[] =
{
{.vsc = 0x01, .pwsz = (WCHAR *)escW},
{.vsc = 0x0e, .pwsz = (WCHAR *)backspaceW},
{.vsc = 0x0f, .pwsz = (WCHAR *)tabW},
{.vsc = 0x1c, .pwsz = (WCHAR *)enterW},
{.vsc = 0x1d, .pwsz = (WCHAR *)ctrlW},
{.vsc = 0x2a, .pwsz = (WCHAR *)shiftW},
{.vsc = 0x36, .pwsz = (WCHAR *)right_shiftW},
{.vsc = 0x37, .pwsz = (WCHAR *)num_mulW},
{.vsc = 0x38, .pwsz = (WCHAR *)altW},
{.vsc = 0x39, .pwsz = (WCHAR *)spaceW},
{.vsc = 0x3a, .pwsz = (WCHAR *)caps_lockW},
{.vsc = 0x3b, .pwsz = (WCHAR *)f1W},
{.vsc = 0x3c, .pwsz = (WCHAR *)f2W},
{.vsc = 0x3d, .pwsz = (WCHAR *)f3W},
{.vsc = 0x3e, .pwsz = (WCHAR *)f4W},
{.vsc = 0x3f, .pwsz = (WCHAR *)f5W},
{.vsc = 0x40, .pwsz = (WCHAR *)f6W},
{.vsc = 0x41, .pwsz = (WCHAR *)f7W},
{.vsc = 0x42, .pwsz = (WCHAR *)f8W},
{.vsc = 0x43, .pwsz = (WCHAR *)f9W},
{.vsc = 0x44, .pwsz = (WCHAR *)f10W},
{.vsc = 0x45, .pwsz = (WCHAR *)pauseW},
{.vsc = 0x46, .pwsz = (WCHAR *)scroll_lockW},
{.vsc = 0x47, .pwsz = (WCHAR *)num_7W},
{.vsc = 0x48, .pwsz = (WCHAR *)num_8W},
{.vsc = 0x49, .pwsz = (WCHAR *)num_9W},
{.vsc = 0x4a, .pwsz = (WCHAR *)num_minusW},
{.vsc = 0x4b, .pwsz = (WCHAR *)num_4W},
{.vsc = 0x4c, .pwsz = (WCHAR *)num_5W},
{.vsc = 0x4d, .pwsz = (WCHAR *)num_6W},
{.vsc = 0x4e, .pwsz = (WCHAR *)num_plusW},
{.vsc = 0x4f, .pwsz = (WCHAR *)num_1W},
{.vsc = 0x50, .pwsz = (WCHAR *)num_2W},
{.vsc = 0x51, .pwsz = (WCHAR *)num_3W},
{.vsc = 0x52, .pwsz = (WCHAR *)num_0W},
{.vsc = 0x53, .pwsz = (WCHAR *)num_delW},
{.vsc = 0x54, .pwsz = (WCHAR *)sys_reqW},
{.vsc = 0x57, .pwsz = (WCHAR *)f11W},
{.vsc = 0x58, .pwsz = (WCHAR *)f12W},
{.vsc = 0x7c, .pwsz = (WCHAR *)f13W},
{.vsc = 0x7d, .pwsz = (WCHAR *)f14W},
{.vsc = 0x7e, .pwsz = (WCHAR *)f15W},
{.vsc = 0x7f, .pwsz = (WCHAR *)f16W},
{.vsc = 0x80, .pwsz = (WCHAR *)f17W},
{.vsc = 0x81, .pwsz = (WCHAR *)f18W},
{.vsc = 0x82, .pwsz = (WCHAR *)f19W},
{.vsc = 0x83, .pwsz = (WCHAR *)f20W},
{.vsc = 0x84, .pwsz = (WCHAR *)f21W},
{.vsc = 0x85, .pwsz = (WCHAR *)f22W},
{.vsc = 0x86, .pwsz = (WCHAR *)f23W},
{.vsc = 0x87, .pwsz = (WCHAR *)f24W},
{0},
};
static const VSC_LPWSTR key_names_ext[] =
{
{.vsc = 0x1c, .pwsz = (WCHAR *)num_enterW},
{.vsc = 0x1d, .pwsz = (WCHAR *)right_ctrlW},
{.vsc = 0x35, .pwsz = (WCHAR *)num_divW},
{.vsc = 0x37, .pwsz = (WCHAR *)prnt_scrnW},
{.vsc = 0x38, .pwsz = (WCHAR *)right_altW},
{.vsc = 0x45, .pwsz = (WCHAR *)num_lockW},
{.vsc = 0x46, .pwsz = (WCHAR *)breakW},
{.vsc = 0x47, .pwsz = (WCHAR *)homeW},
{.vsc = 0x48, .pwsz = (WCHAR *)upW},
{.vsc = 0x49, .pwsz = (WCHAR *)page_upW},
{.vsc = 0x4b, .pwsz = (WCHAR *)leftW},
{.vsc = 0x4d, .pwsz = (WCHAR *)rightW},
{.vsc = 0x4f, .pwsz = (WCHAR *)endW},
{.vsc = 0x50, .pwsz = (WCHAR *)downW},
{.vsc = 0x51, .pwsz = (WCHAR *)page_downW},
{.vsc = 0x52, .pwsz = (WCHAR *)insertW},
{.vsc = 0x53, .pwsz = (WCHAR *)deleteW},
{.vsc = 0x54, .pwsz = (WCHAR *)zerozeroW},
{.vsc = 0x56, .pwsz = (WCHAR *)helpW},
{.vsc = 0x5b, .pwsz = (WCHAR *)left_windowsW},
{.vsc = 0x5c, .pwsz = (WCHAR *)right_windowsW},
{.vsc = 0x5d, .pwsz = (WCHAR *)applicationW},
{0},
};
static const USHORT vsc_to_vk[] =
{
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, 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
};
static const VSC_VK vsc_to_vk_e0[] =
{
{0x10, X10 | KBDEXT},
{0x19, X19 | KBDEXT},
{0x1d, X1D | KBDEXT},
{0x20, X20 | KBDEXT},
{0x21, X21 | KBDEXT},
{0x22, X22 | KBDEXT},
{0x24, X24 | KBDEXT},
{0x2e, X2E | KBDEXT},
{0x30, X30 | KBDEXT},
{0x32, X32 | KBDEXT},
{0x35, X35 | KBDEXT},
{0x37, X37 | KBDEXT},
{0x38, X38 | KBDEXT},
{0x47, X47 | KBDEXT},
{0x48, X48 | KBDEXT},
{0x49, X49 | KBDEXT},
{0x4b, X4B | KBDEXT},
{0x4d, X4D | KBDEXT},
{0x4f, X4F | KBDEXT},
{0x50, X50 | KBDEXT},
{0x51, X51 | KBDEXT},
{0x52, X52 | KBDEXT},
{0x53, X53 | KBDEXT},
{0x5b, X5B | KBDEXT},
{0x5c, X5C | KBDEXT},
{0x5d, X5D | KBDEXT},
{0x5f, X5F | KBDEXT},
{0x65, X65 | KBDEXT},
{0x66, X66 | KBDEXT},
{0x67, X67 | KBDEXT},
{0x68, X68 | KBDEXT},
{0x69, X69 | KBDEXT},
{0x6a, X6A | KBDEXT},
{0x6b, X6B | KBDEXT},
{0x6c, X6C | KBDEXT},
{0x6d, X6D | KBDEXT},
{0x1c, X1C | KBDEXT},
{0x46, X46 | KBDEXT},
{0},
};
static const VSC_VK vsc_to_vk_e1[] =
{
{0x1d, Y1D},
{0},
};
static const KBDTABLES kbdus_tables =
{
.pCharModifiers = (MODIFIERS *)&modifiers,
.pVkToWcharTable = (VK_TO_WCHAR_TABLE *)vk_to_wchar_table,
.pKeyNames = (VSC_LPWSTR *)key_names,
.pKeyNamesExt = (VSC_LPWSTR *)key_names_ext,
.pusVSCtoVK = (USHORT *)vsc_to_vk,
.bMaxVSCtoVK = ARRAY_SIZE(vsc_to_vk),
.pVSCtoVK_E0 = (VSC_VK *)vsc_to_vk_e0,
.pVSCtoVK_E1 = (VSC_VK *)vsc_to_vk_e1,
.fLocaleFlags = MAKELONG(0, KBD_VERSION),
};
static LONG clipping_cursor; /* clipping thread counter */
LONG global_key_state_counter = 0;
BOOL grab_pointer = TRUE;
BOOL grab_fullscreen = FALSE;
static void kbd_tables_init_vsc2vk( const KBDTABLES *tables, BYTE vsc2vk[0x300] )
{
const VSC_VK *entry;
WORD vsc;
memset( vsc2vk, 0, 0x300 );
for (vsc = 0; tables->pusVSCtoVK && vsc <= tables->bMaxVSCtoVK; ++vsc)
{
if (tables->pusVSCtoVK[vsc] == VK__none_) continue;
vsc2vk[vsc] = (BYTE)tables->pusVSCtoVK[vsc];
}
for (entry = tables->pVSCtoVK_E0; entry && entry->Vsc; entry++)
{
if (entry->Vk == VK__none_) continue;
vsc2vk[entry->Vsc + 0x100] = (BYTE)entry->Vk;
}
for (entry = tables->pVSCtoVK_E1; entry && entry->Vsc; entry++)
{
if (entry->Vk == VK__none_) continue;
vsc2vk[entry->Vsc + 0x200] = (BYTE)entry->Vk;
}
}
#define NEXT_ENTRY(t, e) ((void *)&(e)->wch[(t)->nModifications])
static void kbd_tables_init_vk2char( const KBDTABLES *tables, BYTE vk2char[0x100] )
{
const VK_TO_WCHAR_TABLE *table;
const VK_TO_WCHARS1 *entry;
memset( vk2char, 0, 0x100 );
for (table = tables->pVkToWcharTable; table->pVkToWchars; table++)
{
for (entry = table->pVkToWchars; entry->VirtualKey; entry = NEXT_ENTRY(table, entry))
{
if (entry->VirtualKey & ~0xff) continue;
vk2char[entry->VirtualKey] = entry->wch[0];
}
}
}
static UINT kbd_tables_get_mod_bits( const KBDTABLES *tables, UINT mod )
{
const MODIFIERS *mods = tables->pCharModifiers;
WORD bits;
for (bits = 0; bits <= mods->wMaxModBits; ++bits)
if (mods->ModNumber[bits] == mod) return bits;
return -1;
}
static UINT kbd_tables_get_mod_num( const KBDTABLES *tables, const BYTE *state, BOOL caps )
{
const MODIFIERS *mods = tables->pCharModifiers;
const VK_TO_BIT *entry;
WORD bits = 0;
for (entry = mods->pVkToBit; entry->Vk; ++entry)
if (state[entry->Vk] & 0x80) bits |= entry->ModBits;
if (caps) bits |= KBDSHIFT;
if (bits > mods->wMaxModBits) return -1;
return mods->ModNumber[bits];
}
static WORD kbd_tables_wchar_to_vkey( const KBDTABLES *tables, WCHAR wch )
{
const VK_TO_WCHAR_TABLE *table;
const VK_TO_WCHARS1 *entry;
WORD bits;
BYTE mod;
if (wch == '\x001b') return VK_ESCAPE;
for (table = tables->pVkToWcharTable; table->pVkToWchars; table++)
{
for (entry = table->pVkToWchars; entry->VirtualKey; entry = NEXT_ENTRY(table, entry))
{
for (mod = 0; mod < table->nModifications; ++mod)
{
if (entry->wch[mod] == WCH_NONE || entry->wch[mod] != wch) continue;
bits = kbd_tables_get_mod_bits( tables, mod );
return (bits << 8) | entry->VirtualKey;
}
}
}
if (wch >= 0x0001 && wch <= 0x001a) return (0x200) | ('A' + wch - 1); /* CTRL + A-Z */
return wch >= 0x0080 ? -1 : 0;
}
static WCHAR kbd_tables_vkey_to_wchar( const KBDTABLES *tables, UINT vkey, const BYTE *state )
{
UINT mod, caps_mod, alt, ctrl, caps;
const VK_TO_WCHAR_TABLE *table;
const VK_TO_WCHARS1 *entry;
alt = state[VK_MENU] & 0x80;
ctrl = state[VK_CONTROL] & 0x80;
caps = state[VK_CAPITAL] & 1;
if (ctrl && alt) return WCH_NONE;
if (!ctrl && vkey == VK_ESCAPE) return VK_ESCAPE;
mod = caps_mod = kbd_tables_get_mod_num( tables, state, FALSE );
if (caps) caps_mod = kbd_tables_get_mod_num( tables, state, TRUE );
for (table = tables->pVkToWcharTable; table->pVkToWchars; table++)
{
if (table->nModifications <= mod) continue;
for (entry = table->pVkToWchars; entry->VirtualKey; entry = NEXT_ENTRY(table, entry))
{
if (entry->VirtualKey != vkey) continue;
if ((entry->Attributes & CAPLOK) && table->nModifications > caps_mod) return entry->wch[caps_mod];
return entry->wch[mod];
}
}
if (ctrl && vkey >= 'A' && vkey <= 'Z') return vkey - 'A' + 1;
return WCH_NONE;
}
#undef NEXT_ENTRY
/*******************************************************************
* NtUserGetForegroundWindow (win32u.@)
*/
HWND WINAPI NtUserGetForegroundWindow(void)
{
HWND ret = 0;
SERVER_START_REQ( get_thread_input )
{
req->tid = 0;
if (!wine_server_call_err( req )) ret = wine_server_ptr_handle( reply->foreground );
}
SERVER_END_REQ;
return ret;
}
/* see GetActiveWindow */
HWND get_active_window(void)
{
GUITHREADINFO info;
info.cbSize = sizeof(info);
return NtUserGetGUIThreadInfo( GetCurrentThreadId(), &info ) ? info.hwndActive : 0;
}
/* see GetCapture */
HWND get_capture(void)
{
GUITHREADINFO info;
info.cbSize = sizeof(info);
return NtUserGetGUIThreadInfo( GetCurrentThreadId(), &info ) ? info.hwndCapture : 0;
}
/* see GetFocus */
HWND get_focus(void)
{
GUITHREADINFO info;
info.cbSize = sizeof(info);
return NtUserGetGUIThreadInfo( GetCurrentThreadId(), &info ) ? info.hwndFocus : 0;
}
/**********************************************************************
* NtUserAttachThreadInput (win32u.@)
*/
BOOL WINAPI NtUserAttachThreadInput( DWORD from, DWORD to, BOOL attach )
{
BOOL ret;
SERVER_START_REQ( attach_thread_input )
{
req->tid_from = from;
req->tid_to = to;
req->attach = attach;
ret = !wine_server_call_err( req );
}
SERVER_END_REQ;
return ret;
}
/***********************************************************************
* __wine_send_input (win32u.@)
*
* Internal SendInput function to allow the graphics driver to inject real events.
*/
BOOL WINAPI __wine_send_input( HWND hwnd, const INPUT *input, const RAWINPUT *rawinput )
{
return set_ntstatus( send_hardware_message( hwnd, input, rawinput, 0 ));
}
/***********************************************************************
* update_mouse_coords
*
* Helper for NtUserSendInput.
*/
static void update_mouse_coords( INPUT *input )
{
if (!(input->mi.dwFlags & MOUSEEVENTF_MOVE)) return;
if (input->mi.dwFlags & MOUSEEVENTF_ABSOLUTE)
{
RECT rc;
if (input->mi.dwFlags & MOUSEEVENTF_VIRTUALDESK)
rc = get_virtual_screen_rect( 0 );
else
rc = get_primary_monitor_rect( 0 );
input->mi.dx = rc.left + ((input->mi.dx * (rc.right - rc.left)) >> 16);
input->mi.dy = rc.top + ((input->mi.dy * (rc.bottom - rc.top)) >> 16);
}
else
{
int accel[3];
/* dx and dy can be negative numbers for relative movements */
NtUserSystemParametersInfo( SPI_GETMOUSE, 0, accel, 0 );
if (!accel[2]) return;
if (abs( input->mi.dx ) > accel[0])
{
input->mi.dx *= 2;
if (abs( input->mi.dx ) > accel[1] && accel[2] == 2) input->mi.dx *= 2;
}
if (abs(input->mi.dy) > accel[0])
{
input->mi.dy *= 2;
if (abs( input->mi.dy ) > accel[1] && accel[2] == 2) input->mi.dy *= 2;
}
}
}
/***********************************************************************
* NtUserSendInput (win32u.@)
*/
UINT WINAPI NtUserSendInput( UINT count, INPUT *inputs, int size )
{
UINT i;
NTSTATUS status = STATUS_SUCCESS;
if (size != sizeof(INPUT))
{
RtlSetLastWin32Error( ERROR_INVALID_PARAMETER );
return 0;
}
if (!count)
{
RtlSetLastWin32Error( ERROR_INVALID_PARAMETER );
return 0;
}
if (!inputs)
{
RtlSetLastWin32Error( ERROR_NOACCESS );
return 0;
}
for (i = 0; i < count; i++)
{
INPUT input = inputs[i];
switch (input.type)
{
case INPUT_MOUSE:
/* we need to update the coordinates to what the server expects */
update_mouse_coords( &input );
/* fallthrough */
case INPUT_KEYBOARD:
status = send_hardware_message( 0, &input, NULL, SEND_HWMSG_INJECTED );
break;
case INPUT_HARDWARE:
RtlSetLastWin32Error( ERROR_CALL_NOT_IMPLEMENTED );
return 0;
}
if (status)
{
RtlSetLastWin32Error( RtlNtStatusToDosError(status) );
break;
}
}
return i;
}
/***********************************************************************
* NtUserSetCursorPos (win32u.@)
*/
BOOL WINAPI NtUserSetCursorPos( INT x, INT y )
{
POINT pt = { x, y };
BOOL ret;
INT prev_x, prev_y, new_x, new_y;
UINT dpi;
if ((dpi = get_thread_dpi()))
{
HMONITOR monitor = monitor_from_point( pt, MONITOR_DEFAULTTOPRIMARY, get_thread_dpi() );
pt = map_dpi_point( pt, dpi, get_monitor_dpi( monitor ));
}
SERVER_START_REQ( set_cursor )
{
req->flags = SET_CURSOR_POS;
req->x = pt.x;
req->y = pt.y;
if ((ret = !wine_server_call( req )))
{
prev_x = reply->prev_x;
prev_y = reply->prev_y;
new_x = reply->new_x;
new_y = reply->new_y;
}
}
SERVER_END_REQ;
if (ret && (prev_x != new_x || prev_y != new_y)) user_driver->pSetCursorPos( new_x, new_y );
return ret;
}
/***********************************************************************
* get_cursor_pos
*/
BOOL get_cursor_pos( POINT *pt )
{
BOOL ret;
DWORD last_change;
UINT dpi;
if (!pt) return FALSE;
SERVER_START_REQ( set_cursor )
{
if ((ret = !wine_server_call( req )))
{
pt->x = reply->new_x;
pt->y = reply->new_y;
last_change = reply->last_change;
}
}
SERVER_END_REQ;
/* query new position from graphics driver if we haven't updated recently */
if (ret && NtGetTickCount() - last_change > 100) ret = user_driver->pGetCursorPos( pt );
if (ret && (dpi = get_thread_dpi()))
{
HMONITOR monitor = monitor_from_point( *pt, MONITOR_DEFAULTTOPRIMARY, 0 );
*pt = map_dpi_point( *pt, get_monitor_dpi( monitor ), dpi );
}
return ret;
}
/***********************************************************************
* NtUserGetCursorInfo (win32u.@)
*/
BOOL WINAPI NtUserGetCursorInfo( CURSORINFO *info )
{
BOOL ret;
if (!info) return FALSE;
SERVER_START_REQ( get_thread_input )
{
req->tid = 0;
if ((ret = !wine_server_call( req )))
{
info->hCursor = wine_server_ptr_handle( reply->cursor );
info->flags = reply->show_count >= 0 ? CURSOR_SHOWING : 0;
}
}
SERVER_END_REQ;
get_cursor_pos( &info->ptScreenPos );
return ret;
}
static void check_for_events( UINT flags )
{
if (!user_driver->pProcessEvents( flags ))
flush_window_surfaces( TRUE );
}
/**********************************************************************
* GetAsyncKeyState (win32u.@)
*/
SHORT WINAPI NtUserGetAsyncKeyState( INT key )
{
struct user_key_state_info *key_state_info = get_user_thread_info()->key_state;
INT counter = global_key_state_counter;
BYTE prev_key_state;
SHORT ret;
if (key < 0 || key >= 256) return 0;
check_for_events( QS_INPUT );
if (key_state_info && !(key_state_info->state[key] & 0xc0) &&
key_state_info->counter == counter && NtGetTickCount() - key_state_info->time < 50)
{
/* use cached value */
return 0;
}
else if (!key_state_info)
{
key_state_info = calloc( 1, sizeof(*key_state_info) );
get_user_thread_info()->key_state = key_state_info;
}
ret = 0;
SERVER_START_REQ( get_key_state )
{
req->async = 1;
req->key = key;
if (key_state_info)
{
prev_key_state = key_state_info->state[key];
wine_server_set_reply( req, key_state_info->state, sizeof(key_state_info->state) );
}
if (!wine_server_call( req ))
{
if (reply->state & 0x40) ret |= 0x0001;
if (reply->state & 0x80) ret |= 0x8000;
if (key_state_info)
{
/* force refreshing the key state cache - some multithreaded programs
* (like Adobe Photoshop CS5) expect that changes to the async key state
* are also immediately available in other threads. */
if (prev_key_state != key_state_info->state[key])
counter = InterlockedIncrement( &global_key_state_counter );
key_state_info->time = NtGetTickCount();
key_state_info->counter = counter;
}
}
}
SERVER_END_REQ;
return ret;
}
/***********************************************************************
* NtUserGetQueueStatus (win32u.@)
*/
DWORD WINAPI NtUserGetQueueStatus( UINT flags )
{
DWORD ret;
if (flags & ~(QS_ALLINPUT | QS_ALLPOSTMESSAGE | QS_SMRESULT))
{
RtlSetLastWin32Error( ERROR_INVALID_FLAGS );
return 0;
}
check_for_events( flags );
SERVER_START_REQ( get_queue_status )
{
req->clear_bits = flags;
wine_server_call( req );
ret = MAKELONG( reply->changed_bits & flags, reply->wake_bits & flags );
}
SERVER_END_REQ;
return ret;
}
/***********************************************************************
* get_input_state
*/
DWORD get_input_state(void)
{
DWORD ret;
check_for_events( QS_INPUT );
SERVER_START_REQ( get_queue_status )
{
req->clear_bits = 0;
wine_server_call( req );
ret = reply->wake_bits & (QS_KEY | QS_MOUSEBUTTON);
}
SERVER_END_REQ;
return ret;
}
/***********************************************************************
* get_locale_kbd_layout
*/
static HKL get_locale_kbd_layout(void)
{
LCID layout;
LANGID langid;
/* FIXME:
*
* layout = main_key_tab[kbd_layout].lcid;
*
* Winword uses return value of GetKeyboardLayout as a codepage
* to translate ANSI keyboard messages to unicode. But we have
* a problem with it: for instance Polish keyboard layout is
* identical to the US one, and therefore instead of the Polish
* locale id we return the US one.
*/
NtQueryDefaultLocale( TRUE, &layout );
/*
* Microsoft Office expects this value to be something specific
* for Japanese and Korean Windows with an IME the value is 0xe001
* We should probably check to see if an IME exists and if so then
* set this word properly.
*/
langid = PRIMARYLANGID( LANGIDFROMLCID( layout ) );
if (langid == LANG_CHINESE || langid == LANG_JAPANESE || langid == LANG_KOREAN)
layout = MAKELONG( layout, 0xe001 ); /* IME */
else
layout = MAKELONG( layout, layout );
return ULongToHandle( layout );
}
/***********************************************************************
* NtUserGetKeyboardLayout (win32u.@)
*
* Device handle for keyboard layout defaulted to
* the language id. This is the way Windows default works.
*/
HKL WINAPI NtUserGetKeyboardLayout( DWORD thread_id )
{
struct user_thread_info *thread = get_user_thread_info();
HKL layout = thread->kbd_layout;
if (thread_id && thread_id != GetCurrentThreadId())
FIXME( "couldn't return keyboard layout for thread %04x\n", (int)thread_id );
if (!layout) return get_locale_kbd_layout();
return layout;
}
/**********************************************************************
* NtUserGetKeyState (win32u.@)
*
* An application calls the GetKeyState function in response to a
* keyboard-input message. This function retrieves the state of the key
* at the time the input message was generated.
*/
SHORT WINAPI NtUserGetKeyState( INT vkey )
{
SHORT retval = 0;
SERVER_START_REQ( get_key_state )
{
req->key = vkey;
if (!wine_server_call( req )) retval = (signed char)(reply->state & 0x81);
}
SERVER_END_REQ;
TRACE("key (0x%x) -> %x\n", vkey, retval);
return retval;
}
/**********************************************************************
* NtUserGetKeyboardState (win32u.@)
*/
BOOL WINAPI NtUserGetKeyboardState( BYTE *state )
{
BOOL ret;
UINT i;
TRACE("(%p)\n", state);
memset( state, 0, 256 );
SERVER_START_REQ( get_key_state )
{
req->key = -1;
wine_server_set_reply( req, state, 256 );
ret = !wine_server_call_err( req );
for (i = 0; i < 256; i++) state[i] &= 0x81;
}
SERVER_END_REQ;
return ret;
}
/**********************************************************************
* NtUserSetKeyboardState (win32u.@)
*/
BOOL WINAPI NtUserSetKeyboardState( BYTE *state )
{
BOOL ret;
SERVER_START_REQ( set_key_state )
{
wine_server_add_data( req, state, 256 );
ret = !wine_server_call_err( req );
}
SERVER_END_REQ;
return ret;
}
/******************************************************************************
* NtUserVkKeyScanEx (win32u.@)
*/
WORD WINAPI NtUserVkKeyScanEx( WCHAR chr, HKL layout )
{
const KBDTABLES *kbd_tables = &kbdus_tables;
SHORT ret;
TRACE_(keyboard)( "chr %s, layout %p\n", debugstr_wn(&chr, 1), layout );
if ((ret = user_driver->pVkKeyScanEx( chr, layout )) != -256) return ret;
ret = kbd_tables_wchar_to_vkey( kbd_tables, chr );
TRACE_(keyboard)( "ret %04x\n", ret );
return ret;
}
/******************************************************************************
* NtUserMapVirtualKeyEx (win32u.@)
*/
UINT WINAPI NtUserMapVirtualKeyEx( UINT code, UINT type, HKL layout )
{
const KBDTABLES *kbd_tables = &kbdus_tables;
BYTE vsc2vk[0x300], vk2char[0x100];
UINT ret;
TRACE_(keyboard)( "code %u, type %u, layout %p.\n", code, type, layout );
if ((ret = user_driver->pMapVirtualKeyEx( code, type, layout )) != -1) return ret;
kbd_tables_init_vsc2vk( kbd_tables, vsc2vk );
kbd_tables_init_vk2char( kbd_tables, vk2char );
switch (type)
{
case MAPVK_VK_TO_VSC_EX:
case MAPVK_VK_TO_VSC:
switch (code)
{
case VK_SHIFT: code = VK_LSHIFT; break;
case VK_CONTROL: code = VK_LCONTROL; break;
case VK_MENU: code = VK_LMENU; break;
case VK_NUMPAD0: code = VK_INSERT; break;
case VK_NUMPAD1: code = VK_END; break;
case VK_NUMPAD2: code = VK_DOWN; break;
case VK_NUMPAD3: code = VK_NEXT; break;
case VK_NUMPAD4: code = VK_LEFT; break;
case VK_NUMPAD5: code = VK_CLEAR; break;
case VK_NUMPAD6: code = VK_RIGHT; break;
case VK_NUMPAD7: code = VK_HOME; break;
case VK_NUMPAD8: code = VK_UP; break;
case VK_NUMPAD9: code = VK_PRIOR; break;
case VK_DECIMAL: code = VK_DELETE; break;
}
for (ret = 0; ret < ARRAY_SIZE(vsc2vk); ++ret) if (vsc2vk[ret] == code) break;
if (ret >= ARRAY_SIZE(vsc2vk)) ret = 0;
if (type == MAPVK_VK_TO_VSC)
{
if (ret >= 0x200) ret = 0;
else ret &= 0xff;
}
else if (ret >= 0x100) ret += 0xdf00;
break;
case MAPVK_VSC_TO_VK:
case MAPVK_VSC_TO_VK_EX:
if (code & 0xe000) code -= 0xdf00;
if (code >= ARRAY_SIZE(vsc2vk)) ret = 0;
else ret = vsc2vk[code];
if (type == MAPVK_VSC_TO_VK)
{
switch (ret)
{
case VK_LSHIFT: case VK_RSHIFT: ret = VK_SHIFT; break;
case VK_LCONTROL: case VK_RCONTROL: ret = VK_CONTROL; break;
case VK_LMENU: case VK_RMENU: ret = VK_MENU; break;
}
}
break;
case MAPVK_VK_TO_CHAR:
if (code >= ARRAY_SIZE(vk2char)) ret = 0;
else if (code >= 'A' && code <= 'Z') ret = code;
else ret = vk2char[code];
break;
default:
FIXME_(keyboard)( "unknown type %d\n", type );
return 0;
}
TRACE_(keyboard)( "returning 0x%04x\n", ret );
return ret;
}
/****************************************************************************
* NtUserGetKeyNameText (win32u.@)
*/
INT WINAPI NtUserGetKeyNameText( LONG lparam, WCHAR *buffer, INT size )
{
INT code = ((lparam >> 16) & 0x1ff), vkey, len;
const KBDTABLES *kbd_tables = &kbdus_tables;
VSC_LPWSTR *key_name;
BYTE vsc2vk[0x300];
TRACE_(keyboard)( "lparam %#x, buffer %p, size %d.\n", (int)lparam, buffer, size );
if (!buffer || !size) return 0;
if ((len = user_driver->pGetKeyNameText( lparam, buffer, size )) >= 0) return len;
kbd_tables_init_vsc2vk( kbd_tables, vsc2vk );
if (lparam & 0x2000000)
{
switch ((vkey = vsc2vk[code]))
{
case VK_RSHIFT:
case VK_RCONTROL:
case VK_RMENU:
for (code = 0; code < ARRAY_SIZE(vsc2vk); ++code)
if (vsc2vk[code] == (vkey - 1)) break;
break;
}
}
if (code < 0x100) key_name = kbd_tables->pKeyNames;
else key_name = kbd_tables->pKeyNamesExt;
while (key_name->vsc && key_name->vsc != (BYTE)code) key_name++;
if (key_name->vsc == (BYTE)code)
{
len = min( size - 1, wcslen( key_name->pwsz ) );
memcpy( buffer, key_name->pwsz, len * sizeof(WCHAR) );
}
else if (size > 1)
{
HKL hkl = NtUserGetKeyboardLayout( 0 );
vkey = NtUserMapVirtualKeyEx( code & 0xff, MAPVK_VSC_TO_VK, hkl );
buffer[0] = NtUserMapVirtualKeyEx( vkey, MAPVK_VK_TO_CHAR, hkl );
len = 1;
}
buffer[len] = 0;
TRACE_(keyboard)( "ret %d, str %s.\n", len, debugstr_w(buffer) );
return len;
}
/****************************************************************************
* NtUserToUnicodeEx (win32u.@)
*/
INT WINAPI NtUserToUnicodeEx( UINT virt, UINT scan, const BYTE *state,
WCHAR *str, int size, UINT flags, HKL layout )
{
const KBDTABLES *kbd_tables = &kbdus_tables;
WCHAR buffer[2] = {0};
INT len;
TRACE_(keyboard)( "virt %#x, scan %#x, state %p, str %p, size %d, flags %#x, layout %p.\n",
virt, scan, state, str, size, flags, layout );
if (!state) return 0;
if ((len = user_driver->pToUnicodeEx( virt, scan, state, str, size, flags, layout )) >= -1)
return len;
if (scan & 0x8000) buffer[0] = 0; /* key up */
else buffer[0] = kbd_tables_vkey_to_wchar( kbd_tables, virt, state );
if (buffer[0] != WCH_NONE) len = 1;
else buffer[0] = len = 0;
lstrcpynW( str, buffer, size );
TRACE_(keyboard)( "ret %d, str %s.\n", len, debugstr_w(str) );
return len;
}
/**********************************************************************
* NtUserActivateKeyboardLayout (win32u.@)
*/
HKL WINAPI NtUserActivateKeyboardLayout( HKL layout, UINT flags )
{
struct user_thread_info *info = get_user_thread_info();
HKL old_layout;
LCID locale;
HWND focus;
TRACE_(keyboard)( "layout %p, flags %x\n", layout, flags );
if (flags) FIXME_(keyboard)( "flags %x not supported\n", flags );
if (layout == (HKL)HKL_NEXT || layout == (HKL)HKL_PREV)
{
RtlSetLastWin32Error( ERROR_CALL_NOT_IMPLEMENTED );
FIXME_(keyboard)( "HKL_NEXT and HKL_PREV not supported\n" );
return 0;
}
if (LOWORD(layout) != MAKELANGID(LANG_INVARIANT, SUBLANG_DEFAULT) &&
(NtQueryDefaultLocale( TRUE, &locale ) || LOWORD(layout) != locale))
{
RtlSetLastWin32Error( ERROR_CALL_NOT_IMPLEMENTED );
FIXME_(keyboard)( "Changing user locale is not supported\n" );
return 0;
}
if (!user_driver->pActivateKeyboardLayout( layout, flags ))
return 0;
old_layout = info->kbd_layout;
if (old_layout != layout)
{
HWND ime_hwnd = get_default_ime_window( 0 );
const NLS_LOCALE_DATA *data;
CHARSETINFO cs = {0};
if (ime_hwnd) send_message( ime_hwnd, WM_IME_INTERNAL, IME_INTERNAL_HKL_DEACTIVATE, HandleToUlong(old_layout) );
if (HIWORD(layout) & 0x8000)
FIXME( "Aliased keyboard layout not yet implemented\n" );
else if (!(data = get_locale_data( HIWORD(layout) )))
WARN( "Failed to find locale data for %04x\n", HIWORD(layout) );
else
translate_charset_info( ULongToPtr(data->idefaultansicodepage), &cs, TCI_SRCCODEPAGE );
info->kbd_layout = layout;
info->kbd_layout_id = 0;
if (ime_hwnd) send_message( ime_hwnd, WM_IME_INTERNAL, IME_INTERNAL_HKL_ACTIVATE, HandleToUlong(layout) );
if ((focus = get_focus()) && get_window_thread( focus, NULL ) == GetCurrentThreadId())
send_message( focus, WM_INPUTLANGCHANGE, cs.ciCharset, (LPARAM)layout );
}
if (!old_layout) return get_locale_kbd_layout();
return old_layout;
}
/***********************************************************************
* NtUserGetKeyboardLayoutList (win32u.@)
*
* Return number of values available if either input parm is
* 0, per MS documentation.
*/
UINT WINAPI NtUserGetKeyboardLayoutList( INT size, HKL *layouts )
{
char buffer[4096];
KEY_NODE_INFORMATION *key_info = (KEY_NODE_INFORMATION *)buffer;
KEY_VALUE_PARTIAL_INFORMATION *value_info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
DWORD count, tmp, i = 0;
HKEY hkey, subkey;
HKL layout;
TRACE_(keyboard)( "size %d, layouts %p.\n", size, layouts );
if ((count = user_driver->pGetKeyboardLayoutList( size, layouts )) != ~0) return count;
layout = get_locale_kbd_layout();
count = 0;
count++;
if (size && layouts)
{
layouts[count - 1] = layout;
if (count == size) return count;
}
if ((hkey = reg_open_key( NULL, keyboard_layouts_keyW, sizeof(keyboard_layouts_keyW) )))
{
while (!NtEnumerateKey( hkey, i++, KeyNodeInformation, key_info,
sizeof(buffer) - sizeof(WCHAR), &tmp ))
{
if (!(subkey = reg_open_key( hkey, key_info->Name, key_info->NameLength ))) continue;
key_info->Name[key_info->NameLength / sizeof(WCHAR)] = 0;
tmp = wcstoul( key_info->Name, NULL, 16 );
if (query_reg_ascii_value( subkey, "Layout Id", value_info, sizeof(buffer) ) &&
value_info->Type == REG_SZ)
tmp = 0xf000 | (wcstoul( (const WCHAR *)value_info->Data, NULL, 16 ) & 0xfff);
NtClose( subkey );
tmp = MAKELONG( LOWORD( layout ), LOWORD( tmp ) );
if (layout == UlongToHandle( tmp )) continue;
count++;
if (size && layouts)
{
layouts[count - 1] = UlongToHandle( tmp );
if (count == size) break;
}
}
NtClose( hkey );
}
return count;
}
/****************************************************************************
* NtUserGetKeyboardLayoutName (win32u.@)
*/
BOOL WINAPI NtUserGetKeyboardLayoutName( WCHAR *name )
{
struct user_thread_info *info = get_user_thread_info();
char buffer[4096];
KEY_NODE_INFORMATION *key = (KEY_NODE_INFORMATION *)buffer;
KEY_VALUE_PARTIAL_INFORMATION *value = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
WCHAR klid[KL_NAMELENGTH];
UINT id;
ULONG len, i = 0;
HKEY hkey, subkey;
HKL layout;
TRACE_(keyboard)( "name %p\n", name );
if (!name)
{
RtlSetLastWin32Error( ERROR_NOACCESS );
return FALSE;
}
if (info->kbd_layout_id)
{
sprintf( buffer, "%08X", info->kbd_layout_id );
asciiz_to_unicode( name, buffer );
return TRUE;
}
layout = NtUserGetKeyboardLayout( 0 );
id = HandleToUlong( layout );
if (HIWORD( id ) == LOWORD( id )) id = LOWORD( id );
sprintf( buffer, "%08X", id );
asciiz_to_unicode( name, buffer );
if ((hkey = reg_open_key( NULL, keyboard_layouts_keyW, sizeof(keyboard_layouts_keyW) )))
{
while (!NtEnumerateKey( hkey, i++, KeyNodeInformation, key,
sizeof(buffer) - sizeof(WCHAR), &len ))
{
if (!(subkey = reg_open_key( hkey, key->Name, key->NameLength ))) continue;
memcpy( klid, key->Name, key->NameLength );
klid[key->NameLength / sizeof(WCHAR)] = 0;
if (query_reg_ascii_value( subkey, "Layout Id", value, sizeof(buffer) ) &&
value->Type == REG_SZ)
id = 0xf000 | (wcstoul( (const WCHAR *)value->Data, NULL, 16 ) & 0xfff);
else
id = wcstoul( klid, NULL, 16 );
NtClose( subkey );
if (HIWORD( layout ) == id)
{
lstrcpynW( name, klid, KL_NAMELENGTH );
break;
}
}
NtClose( hkey );
}
info->kbd_layout_id = wcstoul( name, NULL, 16 );
TRACE_(keyboard)( "ret %s\n", debugstr_w( name ) );
return TRUE;
}
/***********************************************************************
* NtUserRegisterHotKey (win32u.@)
*/
BOOL WINAPI NtUserRegisterHotKey( HWND hwnd, INT id, UINT modifiers, UINT vk )
{
BOOL ret;
int replaced = 0;
TRACE_(keyboard)( "(%p,%d,0x%08x,%X)\n", hwnd, id, modifiers, vk );
if ((!hwnd || is_current_thread_window( hwnd )) &&
!user_driver->pRegisterHotKey( hwnd, modifiers, vk ))
return FALSE;
SERVER_START_REQ( register_hotkey )
{
req->window = wine_server_user_handle( hwnd );
req->id = id;
req->flags = modifiers;
req->vkey = vk;
if ((ret = !wine_server_call_err( req )))
{
replaced = reply->replaced;
modifiers = reply->flags;
vk = reply->vkey;
}
}
SERVER_END_REQ;
if (ret && replaced)
user_driver->pUnregisterHotKey(hwnd, modifiers, vk);
return ret;
}
/***********************************************************************
* NtUserUnregisterHotKey (win32u.@)
*/
BOOL WINAPI NtUserUnregisterHotKey( HWND hwnd, INT id )
{
BOOL ret;
UINT modifiers, vk;
TRACE_(keyboard)("(%p,%d)\n",hwnd,id);
SERVER_START_REQ( unregister_hotkey )
{
req->window = wine_server_user_handle( hwnd );
req->id = id;
if ((ret = !wine_server_call_err( req )))
{
modifiers = reply->flags;
vk = reply->vkey;
}
}
SERVER_END_REQ;
if (ret)
user_driver->pUnregisterHotKey(hwnd, modifiers, vk);
return ret;
}
/***********************************************************************
* NtUserGetMouseMovePointsEx (win32u.@)
*/
int WINAPI NtUserGetMouseMovePointsEx( UINT size, MOUSEMOVEPOINT *ptin, MOUSEMOVEPOINT *ptout,
int count, DWORD resolution )
{
cursor_pos_t *pos, positions[64];
int copied;
unsigned int i;
TRACE( "%d, %p, %p, %d, %d\n", size, ptin, ptout, count, (int)resolution );
if ((size != sizeof(MOUSEMOVEPOINT)) || (count < 0) || (count > ARRAY_SIZE( positions )))
{
RtlSetLastWin32Error( ERROR_INVALID_PARAMETER );
return -1;
}
if (!ptin || (!ptout && count))
{
RtlSetLastWin32Error( ERROR_NOACCESS );
return -1;
}
if (resolution != GMMP_USE_DISPLAY_POINTS)
{
FIXME( "only GMMP_USE_DISPLAY_POINTS is supported for now\n" );
RtlSetLastWin32Error( ERROR_POINT_NOT_FOUND );
return -1;
}
SERVER_START_REQ( get_cursor_history )
{
wine_server_set_reply( req, &positions, sizeof(positions) );
if (wine_server_call_err( req )) return -1;
}
SERVER_END_REQ;
for (i = 0; i < ARRAY_SIZE( positions ); i++)
{
pos = &positions[i];
if (ptin->x == pos->x && ptin->y == pos->y && (!ptin->time || ptin->time == pos->time))
break;
}
if (i == ARRAY_SIZE( positions ))
{
RtlSetLastWin32Error( ERROR_POINT_NOT_FOUND );
return -1;
}
for (copied = 0; copied < count && i < ARRAY_SIZE( positions ); copied++, i++)
{
pos = &positions[i];
ptout[copied].x = pos->x;
ptout[copied].y = pos->y;
ptout[copied].time = pos->time;
ptout[copied].dwExtraInfo = pos->info;
}
return copied;
}
static WORD get_key_state(void)
{
WORD ret = 0;
if (get_system_metrics( SM_SWAPBUTTON ))
{
if (NtUserGetAsyncKeyState(VK_RBUTTON) & 0x80) ret |= MK_LBUTTON;
if (NtUserGetAsyncKeyState(VK_LBUTTON) & 0x80) ret |= MK_RBUTTON;
}
else
{
if (NtUserGetAsyncKeyState(VK_LBUTTON) & 0x80) ret |= MK_LBUTTON;
if (NtUserGetAsyncKeyState(VK_RBUTTON) & 0x80) ret |= MK_RBUTTON;
}
if (NtUserGetAsyncKeyState(VK_MBUTTON) & 0x80) ret |= MK_MBUTTON;
if (NtUserGetAsyncKeyState(VK_SHIFT) & 0x80) ret |= MK_SHIFT;
if (NtUserGetAsyncKeyState(VK_CONTROL) & 0x80) ret |= MK_CONTROL;
if (NtUserGetAsyncKeyState(VK_XBUTTON1) & 0x80) ret |= MK_XBUTTON1;
if (NtUserGetAsyncKeyState(VK_XBUTTON2) & 0x80) ret |= MK_XBUTTON2;
return ret;
}
struct tracking_list
{
TRACKMOUSEEVENT info;
POINT pos; /* center of hover rectangle */
};
/* FIXME: move tracking stuff into per-thread data */
static struct tracking_list tracking_info;
static void check_mouse_leave( HWND hwnd, int hittest )
{
if (tracking_info.info.hwndTrack != hwnd)
{
if (tracking_info.info.dwFlags & TME_NONCLIENT)
NtUserPostMessage( tracking_info.info.hwndTrack, WM_NCMOUSELEAVE, 0, 0 );
else
NtUserPostMessage( tracking_info.info.hwndTrack, WM_MOUSELEAVE, 0, 0 );
tracking_info.info.dwFlags &= ~TME_LEAVE;
}
else
{
if (hittest == HTCLIENT)
{
if (tracking_info.info.dwFlags & TME_NONCLIENT)
{
NtUserPostMessage( tracking_info.info.hwndTrack, WM_NCMOUSELEAVE, 0, 0 );
tracking_info.info.dwFlags &= ~TME_LEAVE;
}
}
else
{
if (!(tracking_info.info.dwFlags & TME_NONCLIENT))
{
NtUserPostMessage( tracking_info.info.hwndTrack, WM_MOUSELEAVE, 0, 0 );
tracking_info.info.dwFlags &= ~TME_LEAVE;
}
}
}
}
void update_mouse_tracking_info( HWND hwnd )
{
int hover_width = 0, hover_height = 0, hittest;
POINT pos;
TRACE( "hwnd %p\n", hwnd );
get_cursor_pos( &pos );
hwnd = window_from_point( hwnd, pos, &hittest );
TRACE( "point %s hwnd %p hittest %d\n", wine_dbgstr_point(&pos), hwnd, hittest );
NtUserSystemParametersInfo( SPI_GETMOUSEHOVERWIDTH, 0, &hover_width, 0 );
NtUserSystemParametersInfo( SPI_GETMOUSEHOVERHEIGHT, 0, &hover_height, 0 );
TRACE( "tracked pos %s, current pos %s, hover width %d, hover height %d\n",
wine_dbgstr_point(&tracking_info.pos), wine_dbgstr_point(&pos),
hover_width, hover_height );
if (tracking_info.info.dwFlags & TME_LEAVE)
check_mouse_leave( hwnd, hittest );
if (tracking_info.info.hwndTrack != hwnd)
tracking_info.info.dwFlags &= ~TME_HOVER;
if (tracking_info.info.dwFlags & TME_HOVER)
{
/* has the cursor moved outside the rectangle centered around pos? */
if ((abs( pos.x - tracking_info.pos.x ) > (hover_width / 2)) ||
(abs( pos.y - tracking_info.pos.y ) > (hover_height / 2)))
{
tracking_info.pos = pos;
}
else
{
if (hittest == HTCLIENT)
{
screen_to_client(hwnd, &pos);
TRACE( "client cursor pos %s\n", wine_dbgstr_point(&pos) );
NtUserPostMessage( tracking_info.info.hwndTrack, WM_MOUSEHOVER,
get_key_state(), MAKELPARAM( pos.x, pos.y ) );
}
else
{
if (tracking_info.info.dwFlags & TME_NONCLIENT)
NtUserPostMessage( tracking_info.info.hwndTrack, WM_NCMOUSEHOVER,
hittest, MAKELPARAM( pos.x, pos.y ) );
}
/* stop tracking mouse hover */
tracking_info.info.dwFlags &= ~TME_HOVER;
}
}
/* stop the timer if the tracking list is empty */
if (!(tracking_info.info.dwFlags & (TME_HOVER | TME_LEAVE)))
{
kill_system_timer( tracking_info.info.hwndTrack, SYSTEM_TIMER_TRACK_MOUSE );
tracking_info.info.hwndTrack = 0;
tracking_info.info.dwFlags = 0;
tracking_info.info.dwHoverTime = 0;
}
}
/***********************************************************************
* NtUserTrackMouseEvent (win32u.@)
*/
BOOL WINAPI NtUserTrackMouseEvent( TRACKMOUSEEVENT *info )
{
DWORD hover_time;
int hittest;
HWND hwnd;
POINT pos;
TRACE( "size %u, flags %#x, hwnd %p, time %u\n",
(int)info->cbSize, (int)info->dwFlags, info->hwndTrack, (int)info->dwHoverTime );
if (info->cbSize != sizeof(TRACKMOUSEEVENT))
{
WARN( "wrong size %u\n", (int)info->cbSize );
RtlSetLastWin32Error( ERROR_INVALID_PARAMETER );
return FALSE;
}
if (info->dwFlags & TME_QUERY)
{
*info = tracking_info.info;
info->cbSize = sizeof(TRACKMOUSEEVENT);
return TRUE;
}
if (!is_window( info->hwndTrack ))
{
RtlSetLastWin32Error( ERROR_INVALID_WINDOW_HANDLE );
return FALSE;
}
hover_time = (info->dwFlags & TME_HOVER) ? info->dwHoverTime : HOVER_DEFAULT;
if (hover_time == HOVER_DEFAULT || hover_time == 0)
NtUserSystemParametersInfo( SPI_GETMOUSEHOVERTIME, 0, &hover_time, 0 );
get_cursor_pos( &pos );
hwnd = window_from_point( info->hwndTrack, pos, &hittest );
TRACE( "point %s hwnd %p hittest %d\n", wine_dbgstr_point(&pos), hwnd, hittest );
if (info->dwFlags & ~(TME_CANCEL | TME_HOVER | TME_LEAVE | TME_NONCLIENT))
FIXME( "ignoring flags %#x\n", (int)info->dwFlags & ~(TME_CANCEL | TME_HOVER | TME_LEAVE | TME_NONCLIENT) );
if (info->dwFlags & TME_CANCEL)
{
if (tracking_info.info.hwndTrack == info->hwndTrack)
{
tracking_info.info.dwFlags &= ~(info->dwFlags & ~TME_CANCEL);
/* if we aren't tracking on hover or leave remove this entry */
if (!(tracking_info.info.dwFlags & (TME_HOVER | TME_LEAVE)))
{
kill_system_timer( tracking_info.info.hwndTrack, SYSTEM_TIMER_TRACK_MOUSE );
tracking_info.info.hwndTrack = 0;
tracking_info.info.dwFlags = 0;
tracking_info.info.dwHoverTime = 0;
}
}
}
else
{
/* In our implementation, it's possible that another window will receive
* WM_MOUSEMOVE and call TrackMouseEvent before TrackMouseEventProc is
* called. In such a situation, post the WM_MOUSELEAVE now. */
if ((tracking_info.info.dwFlags & TME_LEAVE) && tracking_info.info.hwndTrack != NULL)
check_mouse_leave(hwnd, hittest);
kill_system_timer( tracking_info.info.hwndTrack, SYSTEM_TIMER_TRACK_MOUSE );
tracking_info.info.hwndTrack = 0;
tracking_info.info.dwFlags = 0;
tracking_info.info.dwHoverTime = 0;
if (info->hwndTrack == hwnd)
{
/* Adding new mouse event to the tracking list */
tracking_info.info = *info;
tracking_info.info.dwHoverTime = hover_time;
/* Initialize HoverInfo variables even if not hover tracking */
tracking_info.pos = pos;
NtUserSetSystemTimer( tracking_info.info.hwndTrack, SYSTEM_TIMER_TRACK_MOUSE, hover_time );
}
}
return TRUE;
}
/**********************************************************************
* set_capture_window
*/
BOOL set_capture_window( HWND hwnd, UINT gui_flags, HWND *prev_ret )
{
HWND previous = 0;
UINT flags = 0;
BOOL ret;
if (gui_flags & GUI_INMENUMODE) flags |= CAPTURE_MENU;
if (gui_flags & GUI_INMOVESIZE) flags |= CAPTURE_MOVESIZE;
SERVER_START_REQ( set_capture_window )
{
req->handle = wine_server_user_handle( hwnd );
req->flags = flags;
if ((ret = !wine_server_call_err( req )))
{
previous = wine_server_ptr_handle( reply->previous );
hwnd = wine_server_ptr_handle( reply->full_handle );
}
}
SERVER_END_REQ;
if (ret)
{
user_driver->pSetCapture( hwnd, gui_flags );
if (previous)
send_message( previous, WM_CAPTURECHANGED, 0, (LPARAM)hwnd );
if (prev_ret) *prev_ret = previous;
}
return ret;
}
/**********************************************************************
* NtUserSetCapture (win32u.@)
*/
HWND WINAPI NtUserSetCapture( HWND hwnd )
{
HWND previous = 0;
set_capture_window( hwnd, 0, &previous );
return previous;
}
/**********************************************************************
* release_capture
*/
BOOL release_capture(void)
{
BOOL ret = set_capture_window( 0, 0, NULL );
/* Somebody may have missed some mouse movements */
if (ret)
{
INPUT input = { .type = INPUT_MOUSE };
input.mi.dwFlags = MOUSEEVENTF_MOVE;
NtUserSendInput( 1, &input, sizeof(input) );
}
return ret;
}
/*****************************************************************
* set_focus_window
*
* Change the focus window, sending the WM_SETFOCUS and WM_KILLFOCUS messages
*/
static HWND set_focus_window( HWND hwnd )
{
HWND previous = 0, ime_hwnd;
BOOL ret;
SERVER_START_REQ( set_focus_window )
{
req->handle = wine_server_user_handle( hwnd );
if ((ret = !wine_server_call_err( req )))
previous = wine_server_ptr_handle( reply->previous );
}
SERVER_END_REQ;
if (!ret) return 0;
if (previous == hwnd) return previous;
if (previous)
{
send_message( previous, WM_KILLFOCUS, (WPARAM)hwnd, 0 );
ime_hwnd = get_default_ime_window( previous );
if (ime_hwnd)
send_message( ime_hwnd, WM_IME_INTERNAL, IME_INTERNAL_DEACTIVATE,
HandleToUlong(previous) );
if (hwnd != get_focus()) return previous; /* changed by the message */
}
if (is_window(hwnd))
{
user_driver->pSetFocus(hwnd);
ime_hwnd = get_default_ime_window( hwnd );
if (ime_hwnd)
send_message( ime_hwnd, WM_IME_INTERNAL, IME_INTERNAL_ACTIVATE,
HandleToUlong(hwnd) );
if (previous)
NtUserNotifyWinEvent( EVENT_OBJECT_FOCUS, hwnd, OBJID_CLIENT, 0 );
send_message( hwnd, WM_SETFOCUS, (WPARAM)previous, 0 );
}
return previous;
}
/*******************************************************************
* set_active_window
*/
static BOOL set_active_window( HWND hwnd, HWND *prev, BOOL mouse, BOOL focus )
{
HWND previous = get_active_window();
BOOL ret;
DWORD old_thread, new_thread;
CBTACTIVATESTRUCT cbt;
if (previous == hwnd)
{
if (prev) *prev = hwnd;
goto done;
}
/* call CBT hook chain */
cbt.fMouse = mouse;
cbt.hWndActive = previous;
if (call_hooks( WH_CBT, HCBT_ACTIVATE, (WPARAM)hwnd, (LPARAM)&cbt, sizeof(cbt) )) return FALSE;
if (is_window( previous ))
{
send_message( previous, WM_NCACTIVATE, FALSE, (LPARAM)hwnd );
send_message( previous, WM_ACTIVATE,
MAKEWPARAM( WA_INACTIVE, is_iconic(previous) ), (LPARAM)hwnd );
}
SERVER_START_REQ( set_active_window )
{
req->handle = wine_server_user_handle( hwnd );
if ((ret = !wine_server_call_err( req )))
previous = wine_server_ptr_handle( reply->previous );
}
SERVER_END_REQ;
if (!ret) return FALSE;
if (prev) *prev = previous;
if (previous == hwnd) goto done;
if (hwnd)
{
/* send palette messages */
if (send_message( hwnd, WM_QUERYNEWPALETTE, 0, 0 ))
send_message_timeout( HWND_BROADCAST, WM_PALETTEISCHANGING, (WPARAM)hwnd, 0,
SMTO_ABORTIFHUNG, 2000, FALSE );
if (!is_window(hwnd)) return FALSE;
}
old_thread = previous ? get_window_thread( previous, NULL ) : 0;
new_thread = hwnd ? get_window_thread( hwnd, NULL ) : 0;
if (old_thread != new_thread)
{
HWND *list, *phwnd;
if ((list = list_window_children( NULL, get_desktop_window(), NULL, 0 )))
{
if (old_thread)
{
for (phwnd = list; *phwnd; phwnd++)
{
if (get_window_thread( *phwnd, NULL ) == old_thread)
send_message( *phwnd, WM_ACTIVATEAPP, 0, new_thread );
}
}
if (new_thread)
{
for (phwnd = list; *phwnd; phwnd++)
{
if (get_window_thread( *phwnd, NULL ) == new_thread)
send_message( *phwnd, WM_ACTIVATEAPP, 1, old_thread );
}
}
free( list );
}
}
if (is_window(hwnd))
{
send_message( hwnd, WM_NCACTIVATE, hwnd == NtUserGetForegroundWindow(), (LPARAM)previous );
send_message( hwnd, WM_ACTIVATE,
MAKEWPARAM( mouse ? WA_CLICKACTIVE : WA_ACTIVE, is_iconic(hwnd) ),
(LPARAM)previous );
if (NtUserGetAncestor( hwnd, GA_PARENT ) == get_desktop_window())
NtUserPostMessage( get_desktop_window(), WM_PARENTNOTIFY, WM_NCACTIVATE, (LPARAM)hwnd );
}
/* now change focus if necessary */
if (focus)
{
GUITHREADINFO info;
info.cbSize = sizeof(info);
NtUserGetGUIThreadInfo( GetCurrentThreadId(), &info );
/* Do not change focus if the window is no more active */
if (hwnd == info.hwndActive)
{
if (!info.hwndFocus || !hwnd || NtUserGetAncestor( info.hwndFocus, GA_ROOT ) != hwnd)
set_focus_window( hwnd );
}
}
done:
if (hwnd) clip_fullscreen_window( hwnd, FALSE );
return TRUE;
}
/**********************************************************************
* NtUserSetActiveWindow (win32u.@)
*/
HWND WINAPI NtUserSetActiveWindow( HWND hwnd )
{
HWND prev;
TRACE( "%p\n", hwnd );
if (hwnd)
{
LONG style;
hwnd = get_full_window_handle( hwnd );
if (!is_window( hwnd ))
{
RtlSetLastWin32Error( ERROR_INVALID_WINDOW_HANDLE );
return 0;
}
style = get_window_long( hwnd, GWL_STYLE );
if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD)
return get_active_window(); /* Windows doesn't seem to return an error here */
}
if (!set_active_window( hwnd, &prev, FALSE, TRUE )) return 0;
return prev;
}
/*****************************************************************
* NtUserSetFocus (win32u.@)
*/
HWND WINAPI NtUserSetFocus( HWND hwnd )
{
HWND hwndTop = hwnd;
HWND previous = get_focus();
TRACE( "%p prev %p\n", hwnd, previous );
if (hwnd)
{
/* Check if we can set the focus to this window */
hwnd = get_full_window_handle( hwnd );
if (!is_window( hwnd ))
{
RtlSetLastWin32Error( ERROR_INVALID_WINDOW_HANDLE );
return 0;
}
if (hwnd == previous) return previous; /* nothing to do */
for (;;)
{
HWND parent;
LONG style = get_window_long( hwndTop, GWL_STYLE );
if (style & (WS_MINIMIZE | WS_DISABLED)) return 0;
if (!(style & WS_CHILD)) break;
parent = NtUserGetAncestor( hwndTop, GA_PARENT );
if (!parent || parent == get_desktop_window())
{
if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return 0;
break;
}
if (parent == get_hwnd_message_parent()) return 0;
hwndTop = parent;
}
/* call hooks */
if (call_hooks( WH_CBT, HCBT_SETFOCUS, (WPARAM)hwnd, (LPARAM)previous, 0 )) return 0;
/* activate hwndTop if needed. */
if (hwndTop != get_active_window())
{
if (!set_active_window( hwndTop, NULL, FALSE, FALSE )) return 0;
if (!is_window( hwnd )) return 0; /* Abort if window destroyed */
/* Do not change focus if the window is no longer active */
if (hwndTop != get_active_window()) return 0;
}
}
else /* NULL hwnd passed in */
{
if (!previous) return 0; /* nothing to do */
if (call_hooks( WH_CBT, HCBT_SETFOCUS, 0, (LPARAM)previous, 0 )) return 0;
}
/* change focus and send messages */
return set_focus_window( hwnd );
}
/*******************************************************************
* set_foreground_window
*/
BOOL set_foreground_window( HWND hwnd, BOOL mouse )
{
BOOL ret, send_msg_old = FALSE, send_msg_new = FALSE;
HWND previous = 0;
if (mouse) hwnd = get_full_window_handle( hwnd );
SERVER_START_REQ( set_foreground_window )
{
req->handle = wine_server_user_handle( hwnd );
if ((ret = !wine_server_call_err( req )))
{
previous = wine_server_ptr_handle( reply->previous );
send_msg_old = reply->send_msg_old;
send_msg_new = reply->send_msg_new;
}
}
SERVER_END_REQ;
if (ret && previous != hwnd)
{
if (send_msg_old) /* old window belongs to other thread */
NtUserMessageCall( previous, WM_WINE_SETACTIVEWINDOW, 0, 0,
0, NtUserSendNotifyMessage, FALSE );
else if (send_msg_new) /* old window belongs to us but new one to other thread */
ret = set_active_window( 0, NULL, mouse, TRUE );
if (send_msg_new) /* new window belongs to other thread */
NtUserMessageCall( hwnd, WM_WINE_SETACTIVEWINDOW, (WPARAM)hwnd, 0,
0, NtUserSendNotifyMessage, FALSE );
else /* new window belongs to us */
ret = set_active_window( hwnd, NULL, mouse, TRUE );
}
return ret;
}
static struct
{
HBITMAP bitmap;
unsigned int timeout;
} caret = {0, 500};
static void display_caret( HWND hwnd, const RECT *r )
{
HDC dc, mem_dc;
/* do not use DCX_CACHE here, since coördinates are in logical units */
if (!(dc = NtUserGetDCEx( hwnd, 0, DCX_USESTYLE )))
return;
mem_dc = NtGdiCreateCompatibleDC(dc);
if (mem_dc)
{
HBITMAP prev_bitmap;
prev_bitmap = NtGdiSelectBitmap( mem_dc, caret.bitmap );
NtGdiBitBlt( dc, r->left, r->top, r->right-r->left, r->bottom-r->top, mem_dc, 0, 0, SRCINVERT, 0, 0 );
NtGdiSelectBitmap( mem_dc, prev_bitmap );
NtGdiDeleteObjectApp( mem_dc );
}
NtUserReleaseDC( hwnd, dc );
}
static unsigned int get_caret_registry_timeout(void)
{
char value_buffer[FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data[11 * sizeof(WCHAR)])];
KEY_VALUE_PARTIAL_INFORMATION *value = (void *)value_buffer;
unsigned int ret = 500;
HKEY key;
if (!(key = reg_open_hkcu_key( "Control Panel\\Desktop" )))
return ret;
if (query_reg_ascii_value( key, "CursorBlinkRate", value, sizeof(value_buffer) ))
ret = wcstoul( (WCHAR *)value->Data, NULL, 10 );
NtClose( key );
return ret;
}
/*****************************************************************
* NtUserCreateCaret (win32u.@)
*/
BOOL WINAPI NtUserCreateCaret( HWND hwnd, HBITMAP bitmap, int width, int height )
{
HBITMAP caret_bitmap = 0;
int old_state = 0;
int hidden = 0;
HWND prev = 0;
BOOL ret;
RECT r;
TRACE( "hwnd %p, bitmap %p, width %d, height %d\n", hwnd, bitmap, width, height );
if (!hwnd) return FALSE;
if (bitmap && bitmap != (HBITMAP)1)
{
BITMAP bitmap_data;
if (!NtGdiExtGetObjectW( bitmap, sizeof(bitmap_data), &bitmap_data )) return FALSE;
width = bitmap_data.bmWidth;
height = bitmap_data.bmHeight;
caret_bitmap = NtGdiCreateBitmap( bitmap_data.bmWidth, bitmap_data.bmHeight,
bitmap_data.bmPlanes, bitmap_data.bmBitsPixel, NULL );
if (caret_bitmap)
{
size_t size = bitmap_data.bmWidthBytes * bitmap_data.bmHeight;
BYTE *bits = malloc( size );
NtGdiGetBitmapBits( bitmap, size, bits );
NtGdiSetBitmapBits( caret_bitmap, size, bits );
free( bits );
}
}
else
{
HDC dc;
if (!width) width = get_system_metrics( SM_CXBORDER );
if (!height) height = get_system_metrics( SM_CYBORDER );
/* create the uniform bitmap on the fly */
dc = NtUserGetDCEx( hwnd, 0, DCX_USESTYLE );
if (dc)
{
HDC mem_dc = NtGdiCreateCompatibleDC( dc );
if (mem_dc)
{
if ((caret_bitmap = NtGdiCreateCompatibleBitmap( mem_dc, width, height )))
{
HBITMAP prev_bitmap = NtGdiSelectBitmap( mem_dc, caret_bitmap );
SetRect( &r, 0, 0, width, height );
fill_rect( mem_dc, &r, GetStockObject( bitmap ? GRAY_BRUSH : WHITE_BRUSH ));
NtGdiSelectBitmap( mem_dc, prev_bitmap );
}
NtGdiDeleteObjectApp( mem_dc );
}
NtUserReleaseDC( hwnd, dc );
}
}
if (!caret_bitmap) return FALSE;
SERVER_START_REQ( set_caret_window )
{
req->handle = wine_server_user_handle( hwnd );
req->width = width;
req->height = height;
if ((ret = !wine_server_call_err( req )))
{
prev = wine_server_ptr_handle( reply->previous );
r.left = reply->old_rect.left;
r.top = reply->old_rect.top;
r.right = reply->old_rect.right;
r.bottom = reply->old_rect.bottom;
old_state = reply->old_state;
hidden = reply->old_hide;
}
}
SERVER_END_REQ;
if (!ret) return FALSE;
if (prev && !hidden) /* hide the previous one */
{
/* FIXME: won't work if prev belongs to a different process */
kill_system_timer( prev, SYSTEM_TIMER_CARET );
if (old_state) display_caret( prev, &r );
}
if (caret.bitmap) NtGdiDeleteObjectApp( caret.bitmap );
caret.bitmap = caret_bitmap;
caret.timeout = get_caret_registry_timeout();
return TRUE;
}
/*******************************************************************
* destroy_caret
*/
BOOL destroy_caret(void)
{
int old_state = 0;
int hidden = 0;
HWND prev = 0;
BOOL ret;
RECT r;
SERVER_START_REQ( set_caret_window )
{
req->handle = 0;
req->width = 0;
req->height = 0;
if ((ret = !wine_server_call_err( req )))
{
prev = wine_server_ptr_handle( reply->previous );
r.left = reply->old_rect.left;
r.top = reply->old_rect.top;
r.right = reply->old_rect.right;
r.bottom = reply->old_rect.bottom;
old_state = reply->old_state;
hidden = reply->old_hide;
}
}
SERVER_END_REQ;
if (ret && prev && !hidden)
{
/* FIXME: won't work if prev belongs to a different process */
kill_system_timer( prev, SYSTEM_TIMER_CARET );
if (old_state) display_caret( prev, &r );
}
if (caret.bitmap) NtGdiDeleteObjectApp( caret.bitmap );
caret.bitmap = 0;
return ret;
}
/*****************************************************************
* NtUserGetCaretBlinkTime (win32u.@)
*/
UINT WINAPI NtUserGetCaretBlinkTime(void)
{
return caret.timeout;
}
/*******************************************************************
* set_caret_blink_time
*/
BOOL set_caret_blink_time( unsigned int time )
{
TRACE( "time %u\n", time );
caret.timeout = time;
/* FIXME: update the timer */
return TRUE;
}
/*****************************************************************
* NtUserGetCaretPos (win32u.@)
*/
BOOL WINAPI NtUserGetCaretPos( POINT *pt )
{
BOOL ret;
SERVER_START_REQ( set_caret_info )
{
req->flags = 0; /* don't set anything */
req->handle = 0;
req->x = 0;
req->y = 0;
req->hide = 0;
req->state = 0;
if ((ret = !wine_server_call_err( req )))
{
pt->x = reply->old_rect.left;
pt->y = reply->old_rect.top;
}
}
SERVER_END_REQ;
return ret;
}
/*******************************************************************
* set_caret_pos
*/
BOOL set_caret_pos( int x, int y )
{
int old_state = 0;
int hidden = 0;
HWND hwnd = 0;
BOOL ret;
RECT r;
TRACE( "(%d, %d)\n", x, y );
SERVER_START_REQ( set_caret_info )
{
req->flags = SET_CARET_POS|SET_CARET_STATE;
req->handle = 0;
req->x = x;
req->y = y;
req->hide = 0;
req->state = CARET_STATE_ON_IF_MOVED;
if ((ret = !wine_server_call_err( req )))
{
hwnd = wine_server_ptr_handle( reply->full_handle );
r.left = reply->old_rect.left;
r.top = reply->old_rect.top;
r.right = reply->old_rect.right;
r.bottom = reply->old_rect.bottom;
old_state = reply->old_state;
hidden = reply->old_hide;
}
}
SERVER_END_REQ;
if (ret && !hidden && (x != r.left || y != r.top))
{
if (old_state) display_caret( hwnd, &r );
r.right += x - r.left;
r.bottom += y - r.top;
r.left = x;
r.top = y;
display_caret( hwnd, &r );
NtUserSetSystemTimer( hwnd, SYSTEM_TIMER_CARET, caret.timeout );
}
return ret;
}
/*****************************************************************
* NtUserShowCaret (win32u.@)
*/
BOOL WINAPI NtUserShowCaret( HWND hwnd )
{
int hidden = 0;
BOOL ret;
RECT r;
SERVER_START_REQ( set_caret_info )
{
req->flags = SET_CARET_HIDE | SET_CARET_STATE;
req->handle = wine_server_user_handle( hwnd );
req->x = 0;
req->y = 0;
req->hide = -1;
req->state = CARET_STATE_ON;
if ((ret = !wine_server_call_err( req )))
{
hwnd = wine_server_ptr_handle( reply->full_handle );
r.left = reply->old_rect.left;
r.top = reply->old_rect.top;
r.right = reply->old_rect.right;
r.bottom = reply->old_rect.bottom;
hidden = reply->old_hide;
}
}
SERVER_END_REQ;
if (ret && hidden == 1) /* hidden was 1 so it's now 0 */
{
display_caret( hwnd, &r );
NtUserSetSystemTimer( hwnd, SYSTEM_TIMER_CARET, caret.timeout );
}
return ret;
}
/*****************************************************************
* NtUserHideCaret (win32u.@)
*/
BOOL WINAPI NtUserHideCaret( HWND hwnd )
{
int old_state = 0;
int hidden = 0;
BOOL ret;
RECT r;
SERVER_START_REQ( set_caret_info )
{
req->flags = SET_CARET_HIDE | SET_CARET_STATE;
req->handle = wine_server_user_handle( hwnd );
req->x = 0;
req->y = 0;
req->hide = 1;
req->state = CARET_STATE_OFF;
if ((ret = !wine_server_call_err( req )))
{
hwnd = wine_server_ptr_handle( reply->full_handle );
r.left = reply->old_rect.left;
r.top = reply->old_rect.top;
r.right = reply->old_rect.right;
r.bottom = reply->old_rect.bottom;
old_state = reply->old_state;
hidden = reply->old_hide;
}
}
SERVER_END_REQ;
if (ret && !hidden)
{
if (old_state) display_caret( hwnd, &r );
kill_system_timer( hwnd, SYSTEM_TIMER_CARET );
}
return ret;
}
void toggle_caret( HWND hwnd )
{
BOOL ret;
RECT r;
int hidden = 0;
SERVER_START_REQ( set_caret_info )
{
req->flags = SET_CARET_STATE;
req->handle = wine_server_user_handle( hwnd );
req->x = 0;
req->y = 0;
req->hide = 0;
req->state = CARET_STATE_TOGGLE;
if ((ret = !wine_server_call( req )))
{
hwnd = wine_server_ptr_handle( reply->full_handle );
r.left = reply->old_rect.left;
r.top = reply->old_rect.top;
r.right = reply->old_rect.right;
r.bottom = reply->old_rect.bottom;
hidden = reply->old_hide;
}
}
SERVER_END_REQ;
if (ret && !hidden) display_caret( hwnd, &r );
}
/**********************************************************************
* NtUserEnableMouseInPointer (win32u.@)
*/
BOOL WINAPI NtUserEnableMouseInPointer( BOOL enable )
{
FIXME( "enable %u stub!\n", enable );
RtlSetLastWin32Error( ERROR_CALL_NOT_IMPLEMENTED );
return FALSE;
}
/**********************************************************************
* NtUserIsMouseInPointerEnabled (win32u.@)
*/
BOOL WINAPI NtUserIsMouseInPointerEnabled(void)
{
FIXME( "stub!\n" );
RtlSetLastWin32Error( ERROR_CALL_NOT_IMPLEMENTED );
return FALSE;
}
static BOOL is_captured_by_system(void)
{
GUITHREADINFO info;
info.cbSize = sizeof(info);
return NtUserGetGUIThreadInfo( GetCurrentThreadId(), &info ) && info.hwndCapture && (info.flags & (GUI_INMOVESIZE | GUI_INMENUMODE));
}
/***********************************************************************
* clip_fullscreen_window
*
* Turn on clipping if the active window is fullscreen.
*/
BOOL clip_fullscreen_window( HWND hwnd, BOOL reset )
{
struct user_thread_info *thread_info = get_user_thread_info();
MONITORINFO monitor_info = {.cbSize = sizeof(MONITORINFO)};
RECT rect;
HMONITOR monitor;
DWORD style;
BOOL ret;
if (hwnd == NtUserGetDesktopWindow()) return FALSE;
if (hwnd != NtUserGetForegroundWindow()) return FALSE;
style = NtUserGetWindowLongW( hwnd, GWL_STYLE );
if (!(style & WS_VISIBLE)) return FALSE;
if ((style & (WS_POPUP | WS_CHILD)) == WS_CHILD) return FALSE;
/* maximized windows don't count as full screen */
if ((style & WS_MAXIMIZE) && (style & WS_CAPTION) == WS_CAPTION) return FALSE;
if (!NtUserGetWindowRect( hwnd, &rect )) return FALSE;
if (!NtUserIsWindowRectFullScreen( &rect )) return FALSE;
if (is_captured_by_system()) return FALSE;
if (NtGetTickCount() - thread_info->clipping_reset < 1000) return FALSE;
if (!reset && clipping_cursor && thread_info->clipping_cursor) return FALSE; /* already clipping */
if (!(monitor = NtUserMonitorFromWindow( hwnd, MONITOR_DEFAULTTONEAREST ))) return FALSE;
if (!NtUserGetMonitorInfo( monitor, &monitor_info )) return FALSE;
if (!grab_fullscreen)
{
RECT virtual_rect = NtUserGetVirtualScreenRect();
if (!EqualRect( &monitor_info.rcMonitor, &virtual_rect )) return FALSE;
if (is_virtual_desktop()) return FALSE;
}
TRACE( "win %p clipping fullscreen\n", hwnd );
SERVER_START_REQ( set_cursor )
{
req->flags = SET_CURSOR_CLIP | SET_CURSOR_FSCLIP;
req->clip.left = monitor_info.rcMonitor.left;
req->clip.top = monitor_info.rcMonitor.top;
req->clip.right = monitor_info.rcMonitor.right;
req->clip.bottom = monitor_info.rcMonitor.bottom;
ret = !wine_server_call( req );
}
SERVER_END_REQ;
return ret;
}
/**********************************************************************
* NtUserGetPointerInfoList (win32u.@)
*/
BOOL WINAPI NtUserGetPointerInfoList( UINT32 id, POINTER_INPUT_TYPE type, UINT_PTR unk0, UINT_PTR unk1, SIZE_T size,
UINT32 *entry_count, UINT32 *pointer_count, void *pointer_info )
{
FIXME( "id %#x, type %#x, unk0 %#zx, unk1 %#zx, size %#zx, entry_count %p, pointer_count %p, pointer_info %p stub!\n",
id, (int)type, (size_t)unk0, (size_t)unk1, (size_t)size, entry_count, pointer_count, pointer_info );
RtlSetLastWin32Error( ERROR_CALL_NOT_IMPLEMENTED );
return FALSE;
}
BOOL get_clip_cursor( RECT *rect )
{
UINT dpi;
BOOL ret;
if (!rect) return FALSE;
SERVER_START_REQ( set_cursor )
{
req->flags = 0;
if ((ret = !wine_server_call( req )))
{
rect->left = reply->new_clip.left;
rect->top = reply->new_clip.top;
rect->right = reply->new_clip.right;
rect->bottom = reply->new_clip.bottom;
}
}
SERVER_END_REQ;
if (ret && (dpi = get_thread_dpi()))
{
HMONITOR monitor = monitor_from_rect( rect, MONITOR_DEFAULTTOPRIMARY, 0 );
*rect = map_dpi_rect( *rect, get_monitor_dpi( monitor ), dpi );
}
return ret;
}
BOOL process_wine_clipcursor( HWND hwnd, UINT flags, BOOL reset )
{
struct user_thread_info *thread_info = get_user_thread_info();
RECT rect, virtual_rect = NtUserGetVirtualScreenRect();
BOOL was_clipping, empty = !!(flags & SET_CURSOR_NOCLIP);
TRACE( "hwnd %p, flags %#x, reset %u\n", hwnd, flags, reset );
if ((was_clipping = thread_info->clipping_cursor)) InterlockedDecrement( &clipping_cursor );
thread_info->clipping_cursor = FALSE;
if (reset)
{
thread_info->clipping_reset = NtGetTickCount();
return user_driver->pClipCursor( NULL, TRUE );
}
if (!grab_pointer) return TRUE;
/* we are clipping if the clip rectangle is smaller than the screen */
get_clip_cursor( &rect );
intersect_rect( &rect, &rect, &virtual_rect );
if (EqualRect( &rect, &virtual_rect )) empty = TRUE;
if (empty && !(flags & SET_CURSOR_FSCLIP))
{
/* if currently clipping, check if we should switch to fullscreen clipping */
if (was_clipping && clip_fullscreen_window( hwnd, TRUE )) return TRUE;
return user_driver->pClipCursor( NULL, FALSE );
}
if (!user_driver->pClipCursor( &rect, FALSE )) return FALSE;
InterlockedIncrement( &clipping_cursor );
thread_info->clipping_cursor = TRUE;
return TRUE;
}
/***********************************************************************
* NtUserClipCursor (win32u.@)
*/
BOOL WINAPI NtUserClipCursor( const RECT *rect )
{
UINT dpi;
BOOL ret;
RECT new_rect;
TRACE( "Clipping to %s\n", wine_dbgstr_rect(rect) );
if (rect)
{
if (rect->left > rect->right || rect->top > rect->bottom) return FALSE;
if ((dpi = get_thread_dpi()))
{
HMONITOR monitor = monitor_from_rect( rect, MONITOR_DEFAULTTOPRIMARY, dpi );
new_rect = map_dpi_rect( *rect, dpi, get_monitor_dpi( monitor ));
rect = &new_rect;
}
}
SERVER_START_REQ( set_cursor )
{
if (rect)
{
req->flags = SET_CURSOR_CLIP;
req->clip.left = rect->left;
req->clip.top = rect->top;
req->clip.right = rect->right;
req->clip.bottom = rect->bottom;
}
else req->flags = SET_CURSOR_NOCLIP;
ret = !wine_server_call( req );
}
SERVER_END_REQ;
return ret;
}
Reference in a new issue View git blame Copy permalink