?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
include/mscvpdb.h: Use flexible array members for the rest of structures.
[wine.git] / dlls / wow64win / user.c
blob2f41820abbd53ccccaee1ae711f14c3f27227480
1 /*
2 * WoW64 User functions
3 *
4 * Copyright 2021 Jacek Caban for CodeWeavers
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdarg.h>
22
23 #include "ntstatus.h"
24 #define WIN32_NO_STATUS
25 #include "windef.h"
26 #include "winbase.h"
27 #include "ntuser.h"
28 #include "shellapi.h"
29 #include "wow64win_private.h"
30 #include "wine/debug.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(wow);
33
34 typedef struct
35 {
36 DWORD cbSize;
37 DWORD fMask;
38 DWORD dwStyle;
39 UINT cyMax;
40 ULONG hbrBack;
41 DWORD dwContextHelpID;
42 ULONG dwMenuData;
43 } MENUINFO32;
44
45 typedef struct
46 {
47 UINT cbSize;
48 UINT fMask;
49 UINT fType;
50 UINT fState;
51 UINT wID;
52 UINT32 hSubMenu;
53 UINT32 hbmpChecked;
54 UINT32 hbmpUnchecked;
55 UINT32 dwItemData;
56 UINT32 dwTypeData;
57 UINT cch;
58 UINT32 hbmpItem;
59 } MENUITEMINFOW32;
60
61 typedef struct
62 {
63 UINT32 hwnd;
64 UINT message;
65 UINT32 wParam;
66 UINT32 lParam;
67 DWORD time;
68 POINT pt;
69 } MSG32;
70
71 typedef struct
72 {
73 DWORD dwType;
74 DWORD dwSize;
75 UINT32 hDevice;
76 UINT32 wParam;
77 } RAWINPUTHEADER32;
78
79 typedef struct
80 {
81 USHORT usUsagePage;
82 USHORT usUsage;
83 DWORD dwFlags;
84 UINT32 hwndTarget;
85 } RAWINPUTDEVICE32;
86
87 typedef struct
88 {
89 UINT32 hDevice;
90 DWORD dwType;
91 } RAWINPUTDEVICELIST32;
92
93 typedef struct
94 {
95 LONG dx;
96 LONG dy;
97 DWORD mouseData;
98 DWORD dwFlags;
99 DWORD time;
100 ULONG dwExtraInfo;
101 } MOUSEINPUT32;
102
103 typedef struct
104 {
105 WORD wVk;
106 WORD wScan;
107 DWORD dwFlags;
108 DWORD time;
109 ULONG dwExtraInfo;
110 } KEYBDINPUT32;
111
112 typedef struct
113 {
114 DWORD type;
115 union
116 {
117 MOUSEINPUT32 mi;
118 KEYBDINPUT32 ki;
119 HARDWAREINPUT hi;
120 } DUMMYUNIONNAME;
121 } INPUT32;
122
123 typedef struct
124 {
125 int x;
126 int y;
127 DWORD time;
128 ULONG dwExtraInfo;
129 } MOUSEMOVEPOINT32;
130
131 typedef struct
132 {
133 UINT32 hdc;
134 BOOL fErase;
135 RECT rcPaint;
136 BOOL fRestore;
137 BOOL fIncUpdate;
138 BYTE rgbReserved[32];
139 } PAINTSTRUCT32;
140
141 typedef struct
142 {
143 ULONG lpCreateParams;
144 ULONG hInstance;
145 ULONG hMenu;
146 ULONG hwndParent;
147 INT cy;
148 INT cx;
149 INT y;
150 INT x;
151 LONG style;
152 ULONG lpszName;
153 ULONG lpszClass;
154 DWORD dwExStyle;
155 } CREATESTRUCT32;
156
157 typedef struct
158 {
159 ULONG szClass;
160 ULONG szTitle;
161 ULONG hOwner;
162 INT x;
163 INT y;
164 INT cx;
165 INT cy;
166 DWORD style;
167 ULONG lParam;
168 } MDICREATESTRUCT32;
169
170 typedef struct
171 {
172 ULONG hmenuIn;
173 ULONG hmenuNext;
174 ULONG hwndNext;
175 } MDINEXTMENU32;
176
177 typedef struct
178 {
179 LONG lResult;
180 LONG lParam;
181 LONG wParam;
182 DWORD message;
183 ULONG hwnd;
184 } CWPRETSTRUCT32;
185
186 typedef struct
187 {
188 ULONG hwnd;
189 ULONG hwndInsertAfter;
190 INT x;
191 INT y;
192 INT cx;
193 INT cy;
194 UINT flags;
195 } WINDOWPOS32;
196
197 typedef struct
198 {
199 RECT rgrc[3];
200 ULONG lppos;
201 } NCCALCSIZE_PARAMS32;
202
203 typedef struct
204 {
205 UINT CtlType;
206 UINT CtlID;
207 ULONG hwndItem;
208 UINT itemID1;
209 ULONG itemData1;
210 UINT itemID2;
211 ULONG itemData2;
212 DWORD dwLocaleId;
213 } COMPAREITEMSTRUCT32;
214
215 typedef struct
216 {
217 ULONG dwData;
218 DWORD cbData;
219 ULONG lpData;
220 } COPYDATASTRUCT32;
221
222 typedef struct
223 {
224 UINT cbSize;
225 INT iContextType;
226 INT iCtrlId;
227 ULONG hItemHandle;
228 DWORD dwContextId;
229 POINT MousePos;
230 } HELPINFO32;
231
232 typedef struct
233 {
234 UINT CtlType;
235 UINT CtlID;
236 UINT itemID;
237 UINT itemWidth;
238 UINT itemHeight;
239 ULONG itemData;
240 } MEASUREITEMSTRUCT32;
241
242 typedef struct
243 {
244 UINT CtlType;
245 UINT CtlID;
246 UINT itemID;
247 UINT itemAction;
248 UINT itemState;
249 ULONG hwndItem;
250 ULONG hDC;
251 RECT rcItem;
252 ULONG itemData;
253 } DRAWITEMSTRUCT32;
254
255 typedef struct
256 {
257 DWORD cbSize;
258 RECT rcItem;
259 RECT rcButton;
260 DWORD stateButton;
261 ULONG hwndCombo;
262 ULONG hwndItem;
263 ULONG hwndList;
264 } COMBOBOXINFO32;
265
266 typedef struct
267 {
268 ULONG lParam;
269 ULONG wParam;
270 UINT message;
271 ULONG hwnd;
272 } CWPSTRUCT32;
273
274 typedef struct
275 {
276 POINT pt;
277 ULONG hwnd;
278 UINT wHitTestCode;
279 ULONG dwExtraInfo;
280 DWORD mouseData;
281 } MOUSEHOOKSTRUCTEX32;
282
283 typedef struct
284 {
285 POINT pt;
286 DWORD mouseData;
287 DWORD flags;
288 DWORD time;
289 ULONG dwExtraInfo;
290 } MSLLHOOKSTRUCT32;
291
292 typedef struct
293 {
294 DWORD vkCode;
295 DWORD scanCode;
296 DWORD flags;
297 DWORD time;
298 ULONG dwExtraInfo;
299 } KBDLLHOOKSTRUCT32;
300
301 typedef struct
302 {
303 UINT message;
304 UINT paramL;
305 UINT paramH;
306 DWORD time;
307 ULONG hwnd;
308 } EVENTMSG32;
309
310 typedef struct
311 {
312 BOOL fMouse;
313 ULONG hWndActive;
314 } CBTACTIVATESTRUCT32;
315
316 typedef struct
317 {
318 UINT CtlType;
319 UINT CtlID;
320 UINT itemID;
321 ULONG hwndItem;
322 ULONG itemData;
323 } DELETEITEMSTRUCT32;
324
325 typedef struct
326 {
327 UINT cbSize;
328 UINT style;
329 ULONG lpfnWndProc;
330 INT cbClsExtra;
331 INT cbWndExtra;
332 ULONG hInstance;
333 ULONG hIcon;
334 ULONG hCursor;
335 ULONG hbrBackground;
336 ULONG lpszMenuName;
337 ULONG lpszClassName;
338 ULONG hIconSm;
339 } WNDCLASSEXW32;
340
341 struct client_menu_name32
342 {
343 ULONG nameA;
344 ULONG nameW;
345 ULONG nameUS;
346 };
347
348 struct win_proc_params32
349 {
350 ULONG func;
351 ULONG hwnd;
352 UINT msg;
353 ULONG wparam;
354 ULONG lparam;
355 BOOL ansi;
356 BOOL ansi_dst;
357 enum wm_char_mapping mapping;
358 ULONG dpi_context;
359 ULONG procA;
360 ULONG procW;
361 };
362
363 struct win_hook_params32
364 {
365 ULONG proc;
366 ULONG handle;
367 DWORD pid;
368 DWORD tid;
369 int id;
370 int code;
371 ULONG wparam;
372 ULONG lparam;
373 BOOL prev_unicode;
374 BOOL next_unicode;
375 WCHAR module[1];
376 };
377
378 struct win_event_hook_params32
379 {
380 DWORD event;
381 ULONG hwnd;
382 LONG object_id;
383 LONG child_id;
384 ULONG handle;
385 DWORD tid;
386 DWORD time;
387 ULONG proc;
388 WCHAR module[MAX_PATH];
389 };
390
391 struct draw_text_params32
392 {
393 ULONG hdc;
394 int count;
395 RECT rect;
396 UINT flags;
397 WCHAR str[1];
398 };
399
400 struct unpack_dde_message_params32
401 {
402 ULONG hwnd;
403 UINT message;
404 LONG wparam;
405 LONG lparam;
406 char data[1];
407 };
408
409 static MSG *msg_32to64( MSG *msg, const MSG32 *msg32 )
410 {
411 if (!msg32) return NULL;
412
413 msg->hwnd = LongToHandle( msg32->hwnd );
414 msg->message = msg32->message;
415 msg->wParam = msg32->wParam;
416 msg->lParam = msg32->lParam;
417 msg->time = msg32->time;
418 msg->pt = msg32->pt;
419 return msg;
420 }
421
422 static MSG32 *msg_64to32( const MSG *msg64, MSG32 *msg32 )
423 {
424 MSG32 msg;
425
426 if (!msg32) return NULL;
427
428 msg.hwnd = HandleToLong( msg64->hwnd );
429 msg.message = msg64->message;
430 msg.wParam = msg64->wParam;
431 msg.lParam = msg64->lParam;
432 msg.time = msg64->time;
433 msg.pt = msg64->pt;
434 memcpy( msg32, &msg, sizeof(msg) );
435 return msg32;
436 }
437
438 static struct client_menu_name *client_menu_name_32to64( struct client_menu_name *name,
439 const struct client_menu_name32 *name32 )
440 {
441 if (!name32) return NULL;
442 name->nameA = UlongToPtr( name32->nameA );
443 name->nameW = UlongToPtr( name32->nameW );
444 name->nameUS = UlongToPtr( name32->nameUS );
445 return name;
446 }
447
448 static struct client_menu_name32 *client_menu_name_64to32( const struct client_menu_name *name64,
449 struct client_menu_name32 *name32 )
450 {
451 if (name32)
452 {
453 struct client_menu_name32 name;
454 name.nameA = PtrToUlong( name64->nameA );
455 name.nameW = PtrToUlong( name64->nameW );
456 name.nameUS = PtrToUlong( name64->nameUS );
457 memcpy( name32, &name, sizeof(name) );
458 }
459 return name32;
460 }
461
462 static void win_proc_params_64to32( const struct win_proc_params *src, struct win_proc_params32 *dst )
463 {
464 struct win_proc_params32 params;
465
466 params.func = PtrToUlong( src->func );
467 params.hwnd = HandleToUlong( src->hwnd );
468 params.msg = src->msg;
469 params.wparam = src->wparam;
470 params.lparam = src->lparam;
471 params.ansi = src->ansi;
472 params.ansi_dst = src->ansi_dst;
473 params.mapping = src->mapping;
474 params.dpi_context = src->dpi_context;
475 params.procA = PtrToUlong( src->procA );
476 params.procW = PtrToUlong( src->procW );
477 memcpy( dst, &params, sizeof(params) );
478 }
479
480 static void createstruct_32to64( const CREATESTRUCT32 *from, CREATESTRUCTW *to )
481
482 {
483 to->lpCreateParams = UlongToPtr( from->lpCreateParams );
484 to->hInstance = UlongToPtr( from->hInstance );
485 to->hMenu = LongToHandle( from->hMenu );
486 to->hwndParent = LongToHandle( from->hwndParent );
487 to->cy = from->cy;
488 to->cx = from->cx;
489 to->y = from->y;
490 to->x = from->x;
491 to->style = from->style;
492 to->dwExStyle = from->dwExStyle;
493 to->lpszName = UlongToPtr( from->lpszName );
494 to->lpszClass = UlongToPtr( from->lpszClass );
495 }
496
497 static void createstruct_64to32( const CREATESTRUCTW *from, CREATESTRUCT32 *to )
498 {
499 CREATESTRUCT32 cs;
500
501 cs.lpCreateParams = PtrToUlong( from->lpCreateParams );
502 cs.hInstance = PtrToUlong( from->hInstance );
503 cs.hMenu = HandleToUlong( from->hMenu );
504 cs.hwndParent = HandleToUlong( from->hwndParent );
505 cs.cy = from->cy;
506 cs.cx = from->cx;
507 cs.y = from->y;
508 cs.x = from->x;
509 cs.style = from->style;
510 cs.lpszName = PtrToUlong( from->lpszName );
511 cs.lpszClass = PtrToUlong( from->lpszClass );
512 cs.dwExStyle = from->dwExStyle;
513 memcpy( to, &cs, sizeof(cs) );
514 }
515
516 static void winpos_32to64( WINDOWPOS *dst, const WINDOWPOS32 *src )
517 {
518 dst->hwnd = LongToHandle( src->hwnd );
519 dst->hwndInsertAfter = LongToHandle( src->hwndInsertAfter );
520 dst->x = src->x;
521 dst->y = src->y;
522 dst->cx = src->cx;
523 dst->cy = src->cy;
524 dst->flags = src->flags;
525 }
526
527 static void winpos_64to32( const WINDOWPOS *src, WINDOWPOS32 *dst )
528 {
529 WINDOWPOS32 wp;
530
531 wp.hwnd = HandleToUlong( src->hwnd );
532 wp.hwndInsertAfter = HandleToUlong( src->hwndInsertAfter );
533 wp.x = src->x;
534 wp.y = src->y;
535 wp.cx = src->cx;
536 wp.cy = src->cy;
537 wp.flags = src->flags;
538 memcpy( dst, &wp, sizeof(wp) );
539 }
540
541 static PAINTSTRUCT *paintstruct_32to64( PAINTSTRUCT *ps, const PAINTSTRUCT32 *ps32 )
542 {
543 if (!ps32) return NULL;
544 ps->hdc = ULongToHandle( ps32->hdc );
545 ps->fErase = ps32->fErase;
546 ps->rcPaint = ps32->rcPaint;
547 ps->fRestore = ps32->fRestore;
548 ps->fIncUpdate = ps32->fIncUpdate;
549 return ps;
550 }
551
552 static MOUSEHOOKSTRUCTEX32 *mousehookstruct_64to32( const MOUSEHOOKSTRUCTEX *hook64,
553 MOUSEHOOKSTRUCTEX32 *hook32 )
554 {
555 MOUSEHOOKSTRUCTEX32 hook;
556
557 if (!hook64) return NULL;
558
559 hook.pt = hook64->pt;
560 hook.hwnd = HandleToUlong( hook64->hwnd );
561 hook.wHitTestCode = hook64->wHitTestCode;
562 hook.dwExtraInfo = hook64->dwExtraInfo;
563 hook.mouseData = hook64->mouseData;
564 memcpy( hook32, &hook, sizeof(hook) );
565 return hook32;
566 }
567
568 static NTSTATUS dispatch_callback( ULONG id, void *args, ULONG len )
569 {
570 void *ret_ptr;
571 ULONG ret_len;
572 NTSTATUS status = Wow64KiUserCallbackDispatcher( id, args, len, &ret_ptr, &ret_len );
573 return NtCallbackReturn( ret_ptr, ret_len, status );
574 }
575
576 static NTSTATUS WINAPI wow64_NtUserCallEnumDisplayMonitor( void *arg, ULONG size )
577 {
578 struct enum_display_monitor_params *params = arg;
579 struct
580 {
581 ULONG proc;
582 ULONG monitor;
583 ULONG hdc;
584 RECT rect;
585 ULONG lparam;
586 } params32;
587
588 params32.proc = PtrToUlong( params->proc );
589 params32.monitor = HandleToUlong( params->monitor );
590 params32.hdc = HandleToUlong( params->hdc );
591 params32.rect = params->rect;
592 params32.lparam = params->lparam;
593 return dispatch_callback( NtUserCallEnumDisplayMonitor, &params32, sizeof(params32) );
594 }
595
596 static NTSTATUS WINAPI wow64_NtUserCallSendAsyncCallback( void *arg, ULONG size )
597 {
598 struct send_async_params *params = arg;
599 struct
600 {
601 ULONG callback;
602 ULONG hwnd;
603 UINT msg;
604 ULONG data;
605 ULONG result;
606 } params32;
607
608 params32.callback = PtrToUlong( params->callback );
609 params32.hwnd = HandleToUlong( params->hwnd );
610 params32.msg = params->msg;
611 params32.data = params->data;
612 params32.result = params->result;
613 return dispatch_callback( NtUserCallSendAsyncCallback, &params32, sizeof(params32) );
614 }
615
616 static NTSTATUS WINAPI wow64_NtUserCallWinEventHook( void *arg, ULONG size )
617 {
618 struct win_event_hook_params *params = arg;
619 struct win_event_hook_params32 params32;
620
621 params32.event = params->event;
622 params32.hwnd = HandleToUlong( params->hwnd );
623 params32.object_id = params->object_id;
624 params32.child_id = params->child_id;
625 params32.handle = HandleToUlong( params->handle );
626 params32.tid = params->tid;
627 params32.time = params->time;
628 params32.proc = PtrToUlong( params->proc );
629
630 size -= FIELD_OFFSET( struct win_event_hook_params, module );
631 if (size) memcpy( params32.module, params->module, size );
632 return dispatch_callback( NtUserCallWinEventHook, &params32,
633 FIELD_OFFSET( struct win_event_hook_params32, module ) + size);
634 }
635
636 static size_t packed_message_64to32( UINT message, WPARAM wparam,
637 const void *params64, void *params32, size_t size )
638 {
639 if (!size) return 0;
640
641 switch (message)
642 {
643 case WM_NCCREATE:
644 case WM_CREATE:
645 {
646 CREATESTRUCT32 *cs32 = params32;
647 const CREATESTRUCTW *cs64 = params64;
648
649 createstruct_64to32( cs64, cs32 );
650 size -= sizeof(*cs64);
651 if (size) memmove( cs32 + 1, cs64 + 1, size );
652 return sizeof(*cs32) + size;
653 }
654
655 case WM_NCCALCSIZE:
656 if (wparam)
657 {
658 NCCALCSIZE_PARAMS32 ncp32;
659 const NCCALCSIZE_PARAMS *ncp64 = params64;
660
661 ncp32.rgrc[0] = ncp64->rgrc[0];
662 ncp32.rgrc[1] = ncp64->rgrc[1];
663 ncp32.rgrc[2] = ncp64->rgrc[2];
664 winpos_64to32( (const WINDOWPOS *)(ncp64 + 1),
665 (WINDOWPOS32 *)((const char *)params32 + sizeof(ncp32)) );
666 memcpy( params32, &ncp32, sizeof(ncp32) );
667 return sizeof(ncp32) + sizeof(WINDOWPOS32);
668 }
669 break;
670
671 case WM_DRAWITEM:
672 {
673 DRAWITEMSTRUCT32 dis32;
674 const DRAWITEMSTRUCT *dis64 = params64;
675
676 dis32.CtlType = dis64->CtlType;
677 dis32.CtlID = dis64->CtlID;
678 dis32.itemID = dis64->itemID;
679 dis32.itemAction = dis64->itemAction;
680 dis32.itemState = dis64->itemState;
681 dis32.hwndItem = HandleToLong( dis64->hwndItem );
682 dis32.hDC = HandleToUlong( dis64->hDC );
683 dis32.itemData = dis64->itemData;
684 dis32.rcItem.left = dis64->rcItem.left;
685 dis32.rcItem.top = dis64->rcItem.top;
686 dis32.rcItem.right = dis64->rcItem.right;
687 dis32.rcItem.bottom = dis64->rcItem.bottom;
688 memcpy( params32, &dis32, sizeof(dis32) );
689 return sizeof(dis32);
690 }
691
692 case WM_MEASUREITEM:
693 {
694 MEASUREITEMSTRUCT32 mis32;
695 const MEASUREITEMSTRUCT *mis64 = params64;
696
697 mis32.CtlType = mis64->CtlType;
698 mis32.CtlID = mis64->CtlID;
699 mis32.itemID = mis64->itemID;
700 mis32.itemWidth = mis64->itemWidth;
701 mis32.itemHeight = mis64->itemHeight;
702 mis32.itemData = mis64->itemData;
703 memcpy( params32, &mis32, sizeof(mis32) );
704 return sizeof(mis32);
705 }
706
707 case WM_DELETEITEM:
708 {
709 DELETEITEMSTRUCT32 dis32;
710 const DELETEITEMSTRUCT *dis64 = params64;
711
712 dis32.CtlType = dis64->CtlType;
713 dis32.CtlID = dis64->CtlID;
714 dis32.itemID = dis64->itemID;
715 dis32.hwndItem = HandleToLong( dis64->hwndItem );
716 dis32.itemData = dis64->itemData;
717 memcpy( params32, &dis32, sizeof(dis32) );
718 return sizeof(dis32);
719 }
720
721 case WM_COMPAREITEM:
722 {
723 COMPAREITEMSTRUCT32 cis32;
724 const COMPAREITEMSTRUCT *cis64 = params64;
725
726 cis32.CtlType = cis64->CtlType;
727 cis32.CtlID = cis64->CtlID;
728 cis32.hwndItem = HandleToLong( cis64->hwndItem );
729 cis32.itemID1 = cis64->itemID1;
730 cis32.itemData1 = cis64->itemData1;
731 cis32.itemID2 = cis64->itemID2;
732 cis32.itemData2 = cis64->itemData2;
733 cis32.dwLocaleId = cis64->dwLocaleId;
734 memcpy( params32, &cis32, sizeof(cis32) );
735 return sizeof(cis32);
736 }
737
738 case WM_WINDOWPOSCHANGING:
739 case WM_WINDOWPOSCHANGED:
740 winpos_64to32( params64, params32 );
741 return sizeof(WINDOWPOS32);
742
743 case WM_COPYDATA:
744 {
745 COPYDATASTRUCT32 cds32;
746 const COPYDATASTRUCT *cds64 = params64;
747
748 cds32.dwData = cds64->dwData;
749 cds32.cbData = cds64->cbData;
750 cds32.lpData = PtrToUlong( cds64->lpData );
751 memcpy( params32, &cds32, sizeof(cds32) );
752 size -= sizeof(cds32);
753 if (size) memmove( (char *)params32 + sizeof(cds32), cds64 + 1, size );
754 return sizeof(cds32) + size;
755 }
756 case WM_HELP:
757 {
758 HELPINFO32 hi32;
759 const HELPINFO *hi64 = params64;
760
761 hi32.cbSize = sizeof(hi32);
762 hi32.iContextType = hi64->iContextType;
763 hi32.iCtrlId = hi64->iCtrlId;
764 hi32.hItemHandle = HandleToLong( hi64->hItemHandle );
765 hi32.dwContextId = hi64->dwContextId;
766 hi32.MousePos = hi64->MousePos;
767 memcpy( params32, &hi32, sizeof(hi32) );
768 return sizeof(hi32);
769 }
770
771 case WM_GETDLGCODE:
772 msg_64to32( params64, params32 );
773 return sizeof(MSG32);
774
775 case WM_NEXTMENU:
776 {
777 MDINEXTMENU32 *next32 = params32;
778 const MDINEXTMENU *next64 = params64;
779
780 next32->hmenuIn = HandleToLong( next64->hmenuIn );
781 next32->hmenuNext = HandleToLong( next64->hmenuNext );
782 next32->hwndNext = HandleToLong( next64->hwndNext );
783 return sizeof(*next32);
784 }
785
786 case WM_MDICREATE:
787 {
788 MDICREATESTRUCT32 mcs32;
789 const MDICREATESTRUCTW *mcs64 = params64;
790
791 mcs32.szClass = PtrToUlong( mcs64->szClass );
792 mcs32.szTitle = PtrToUlong( mcs64->szTitle );
793 mcs32.hOwner = HandleToLong( mcs64->hOwner );
794 mcs32.x = mcs64->x;
795 mcs32.y = mcs64->y;
796 mcs32.cx = mcs64->cx;
797 mcs32.cy = mcs64->cy;
798 mcs32.style = mcs64->style;
799 mcs32.lParam = mcs64->lParam;
800 size -= sizeof(*mcs64);
801 if (size) memmove( (char *)params32 + sizeof(mcs32), mcs64 + 1, size );
802 memcpy( params32, &mcs32, sizeof(mcs32) );
803 return sizeof(mcs32) + size;
804 }
805
806 case CB_GETCOMBOBOXINFO:
807 {
808 COMBOBOXINFO32 ci32;
809 const COMBOBOXINFO *ci64 = params64;
810
811 ci32.cbSize = sizeof(ci32);
812 ci32.rcItem = ci64->rcItem;
813 ci32.rcButton = ci64->rcButton;
814 ci32.stateButton = ci64->stateButton;
815 ci32.hwndCombo = HandleToLong( ci64->hwndCombo );
816 ci32.hwndItem = HandleToLong( ci64->hwndItem );
817 ci32.hwndList = HandleToLong( ci64->hwndList );
818 memcpy( params32, &ci32, sizeof(ci32) );
819 return sizeof(ci32);
820 }
821 }
822
823 memmove( params32, params64, size );
824 return size;
825 }
826
827 static size_t packed_result_32to64( UINT message, WPARAM wparam, const void *params32,
828 size_t size, void *params64 )
829 {
830 if (!size) return 0;
831
832 switch (message)
833 {
834 case WM_NCCREATE:
835 case WM_CREATE:
836 if (size >= sizeof(CREATESTRUCT32))
837 {
838 const CREATESTRUCT32 *cs32 = params32;
839 CREATESTRUCTW *cs64 = params64;
840
841 cs64->lpCreateParams = UlongToPtr( cs32->lpCreateParams );
842 cs64->hInstance = UlongToPtr( cs32->hInstance );
843 cs64->hMenu = LongToHandle( cs32->hMenu );
844 cs64->hwndParent = LongToHandle( cs32->hwndParent );
845 cs64->cy = cs32->cy;
846 cs64->cx = cs32->cx;
847 cs64->y = cs32->y;
848 cs64->x = cs32->x;
849 cs64->style = cs32->style;
850 cs64->dwExStyle = cs32->dwExStyle;
851 return sizeof(*cs64);
852 }
853 break;
854
855 case WM_NCCALCSIZE:
856 if (wparam)
857 {
858 const NCCALCSIZE_PARAMS32 *ncp32 = params32;
859 NCCALCSIZE_PARAMS *ncp64 = params64;
860
861 ncp64->rgrc[0] = ncp32->rgrc[0];
862 ncp64->rgrc[1] = ncp32->rgrc[1];
863 ncp64->rgrc[2] = ncp32->rgrc[2];
864 winpos_32to64( (WINDOWPOS *)(ncp64 + 1), (const WINDOWPOS32 *)(ncp32 + 1) );
865 return sizeof(*ncp64) + sizeof(WINDOWPOS);
866 }
867 break;
868
869 case WM_MEASUREITEM:
870 {
871 const MEASUREITEMSTRUCT32 *mis32 = params32;
872 MEASUREITEMSTRUCT *mis64 = params64;
873
874 mis64->CtlType = mis32->CtlType;
875 mis64->CtlID = mis32->CtlID;
876 mis64->itemID = mis32->itemID;
877 mis64->itemWidth = mis32->itemWidth;
878 mis64->itemHeight = mis32->itemHeight;
879 mis64->itemData = mis32->itemData;
880 return sizeof(*mis64);
881 }
882
883 case WM_WINDOWPOSCHANGING:
884 case WM_WINDOWPOSCHANGED:
885 winpos_32to64( params64, params32 );
886 return sizeof(WINDOWPOS);
887
888 case WM_NEXTMENU:
889 {
890 const MDINEXTMENU32 *next32 = params32;
891 MDINEXTMENU *next64 = params64;
892
893 next64->hmenuIn = LongToHandle( next32->hmenuIn );
894 next64->hmenuNext = LongToHandle( next32->hmenuNext );
895 next64->hwndNext = LongToHandle( next32->hwndNext );
896 return sizeof(*next64);
897 }
898
899 case CB_GETCOMBOBOXINFO:
900 {
901 const COMBOBOXINFO32 *ci32 = params32;
902 COMBOBOXINFO *ci64 = params64;
903
904 ci64->cbSize = sizeof(*ci32);
905 ci64->rcItem = ci32->rcItem;
906 ci64->rcButton = ci32->rcButton;
907 ci64->stateButton = ci32->stateButton;
908 ci64->hwndCombo = LongToHandle( ci32->hwndCombo );
909 ci64->hwndItem = LongToHandle( ci32->hwndItem );
910 ci64->hwndList = LongToHandle( ci32->hwndList );
911 return sizeof(*ci64);
912 }
913
914 case WM_GETTEXT:
915 case WM_ASKCBFORMATNAME:
916 case WM_GETMINMAXINFO:
917 case WM_STYLECHANGING:
918 case SBM_SETSCROLLINFO:
919 case SBM_GETSCROLLINFO:
920 case SBM_GETSCROLLBARINFO:
921 case EM_GETSEL:
922 case SBM_GETRANGE:
923 case CB_GETEDITSEL:
924 case EM_SETRECT:
925 case EM_GETRECT:
926 case EM_SETRECTNP:
927 case LB_GETITEMRECT:
928 case CB_GETDROPPEDCONTROLRECT:
929 case EM_GETLINE:
930 case CB_GETLBTEXT:
931 case LB_GETTEXT:
932 case LB_GETSELITEMS:
933 case WM_SIZING:
934 case WM_MOVING:
935 case WM_MDIGETACTIVE:
936 break;
937
938 default:
939 return 0;
940 }
941
942 if (size) memcpy( params64, params32, size );
943 return size;
944 }
945
946 static NTSTATUS WINAPI wow64_NtUserCallWinProc( void *arg, ULONG size )
947 {
948 struct win_proc_params *params = arg;
949 struct win_proc_params32 *params32 = arg;
950 size_t lparam_size = 0, offset32 = sizeof(*params32);
951 LRESULT result = 0;
952 void *ret_ptr;
953 ULONG ret_len;
954 NTSTATUS status;
955
956 win_proc_params_64to32( params, params32 );
957 if (size > sizeof(*params))
958 {
959 const size_t offset64 = (sizeof(*params) + 15) & ~15;
960 offset32 = (offset32 + 15) & ~15;
961 lparam_size = packed_message_64to32( params32->msg, params32->wparam,
962 (char *)params + offset64,
963 (char *)params32 + offset32,
964 size - offset64 );
965 }
966
967 status = Wow64KiUserCallbackDispatcher( NtUserCallWinProc, params32,
968 offset32 + lparam_size,
969 &ret_ptr, &ret_len );
970
971 if (ret_len >= sizeof(LONG))
972 {
973 LRESULT *result_ptr = arg;
974 result = *(LONG *)ret_ptr;
975 ret_len = packed_result_32to64( params32->msg, params32->wparam, (LONG *)ret_ptr + 1,
976 ret_len - sizeof(LONG), result_ptr + 1 );
977 *result_ptr = result;
978 return NtCallbackReturn( result_ptr, sizeof(*result_ptr) + ret_len, status );
979 }
980
981 return NtCallbackReturn( &result, sizeof(result), status );
982 }
983
984 static UINT hook_lparam_64to32( int id, int code, const void *lp, size_t size, void *lp32 )
985 {
986 if (!size) return 0;
987
988 switch (id)
989 {
990 case WH_SYSMSGFILTER:
991 case WH_MSGFILTER:
992 case WH_GETMESSAGE:
993 msg_64to32( lp, lp32 );
994 return sizeof(MSG32);
995
996 case WH_CBT:
997 switch (code)
998 {
999 case HCBT_CREATEWND:
1000 return packed_message_64to32( WM_CREATE, 0, lp, lp32, size );
1001
1002 case HCBT_ACTIVATE:
1003 {
1004 const CBTACTIVATESTRUCT *cbt = lp;
1005 CBTACTIVATESTRUCT32 cbt32;
1006 cbt32.fMouse = cbt->fMouse;
1007 cbt32.hWndActive = HandleToUlong( cbt->hWndActive );
1008 memcpy( lp32, &cbt32, sizeof(cbt32) );
1009 return sizeof(cbt32);
1010 }
1011
1012 case HCBT_CLICKSKIPPED:
1013 mousehookstruct_64to32( lp, lp32 );
1014 return sizeof(MOUSEHOOKSTRUCTEX32);
1015 }
1016 break;
1017
1018 case WH_CALLWNDPROC:
1019 {
1020 const CWPSTRUCT *cwp = lp;
1021 CWPSTRUCT32 cwp32;
1022 cwp32.lParam = cwp->lParam;
1023 cwp32.wParam = cwp->wParam;
1024 cwp32.message = cwp->message;
1025 cwp32.hwnd = HandleToUlong( cwp->hwnd );
1026 memcpy( lp32, &cwp32, sizeof(cwp32) );
1027 if (size > sizeof(*cwp))
1028 {
1029 const size_t offset64 = (sizeof(*cwp) + 15) & ~15;
1030 const size_t offset32 = (sizeof(cwp32) + 15) & ~15;
1031 size = packed_message_64to32( cwp32.message, cwp32.wParam,
1032 (const char *)lp + offset64,
1033 (char *)lp32 + offset32, size - offset64 );
1034 return offset32 + size;
1035 }
1036 return sizeof(cwp32);
1037 }
1038
1039 case WH_CALLWNDPROCRET:
1040 {
1041 const CWPRETSTRUCT *cwpret = lp;
1042 CWPRETSTRUCT32 cwpret32;
1043 cwpret32.lResult = cwpret->lResult;
1044 cwpret32.lParam = cwpret->lParam;
1045 cwpret32.wParam = cwpret->wParam;
1046 cwpret32.message = cwpret->message;
1047 cwpret32.hwnd = HandleToUlong( cwpret->hwnd );
1048 memcpy( lp32, &cwpret32, sizeof(cwpret32) );
1049 if (size > sizeof(*cwpret))
1050 {
1051 const size_t offset64 = (sizeof(*cwpret) + 15) & ~15;
1052 const size_t offset32 = (sizeof(cwpret32) + 15) & ~15;
1053 size = packed_message_64to32( cwpret32.message, cwpret32.wParam,
1054 (const char *)lp + offset64,
1055 (char *)lp32 + offset32, size - offset64 );
1056 return offset32 + size;
1057 }
1058 return sizeof(cwpret32);
1059 }
1060
1061 case WH_MOUSE:
1062 mousehookstruct_64to32( lp, lp32 );
1063 return sizeof(MOUSEHOOKSTRUCTEX32);
1064
1065 case WH_MOUSE_LL:
1066 {
1067 const MSLLHOOKSTRUCT *hook = lp;
1068 MSLLHOOKSTRUCT32 hook32;
1069 hook32.pt = hook->pt;
1070 hook32.mouseData = hook->mouseData;
1071 hook32.flags = hook->flags;
1072 hook32.time = hook->time;
1073 hook32.dwExtraInfo = hook->dwExtraInfo;
1074 memcpy( lp32, &hook32, sizeof(hook32) );
1075 return sizeof(hook32);
1076 }
1077
1078 case WH_KEYBOARD_LL:
1079 {
1080 const KBDLLHOOKSTRUCT *hook = lp;
1081 KBDLLHOOKSTRUCT32 hook32;
1082 hook32.vkCode = hook->vkCode;
1083 hook32.scanCode = hook->scanCode;
1084 hook32.flags = hook->flags;
1085 hook32.time = hook->time;
1086 hook32.dwExtraInfo = hook->dwExtraInfo;
1087 memcpy( lp32, &hook32, sizeof(hook32) );
1088 return sizeof(hook32);
1089 }
1090
1091 case WH_JOURNALRECORD:
1092 {
1093 const EVENTMSG *event = lp;
1094 EVENTMSG32 event32;
1095
1096 event32.message = event->message;
1097 event32.paramL = event->paramL;
1098 event32.paramH = event->paramH;
1099 event32.time = event->time;
1100 event32.hwnd = HandleToUlong( event->hwnd );
1101 memcpy( lp32, &event32, sizeof(event32) );
1102 return sizeof(event32);
1103 }
1104 }
1105
1106 memmove( lp32, lp, size );
1107 return size;
1108 }
1109
1110 static NTSTATUS WINAPI wow64_NtUserCallWindowsHook( void *arg, ULONG size )
1111 {
1112 struct win_hook_params *params = arg;
1113 struct win_hook_params32 params32;
1114 UINT module_len, size32, offset;
1115 void *ret_ptr;
1116 LRESULT *result_ptr = arg;
1117 ULONG ret_len, ret_size = 0;
1118 NTSTATUS status;
1119
1120 module_len = wcslen( params->module );
1121 size32 = FIELD_OFFSET( struct win_hook_params32, module[module_len + 1] );
1122 offset = FIELD_OFFSET( struct win_hook_params, module[module_len + 1] );
1123
1124 params32.proc = PtrToUlong( params->proc );
1125 params32.handle = HandleToUlong( params->handle );
1126 params32.pid = params->pid;
1127 params32.tid = params->tid;
1128 params32.id = params->id;
1129 params32.code = params->code;
1130 params32.wparam = params->wparam;
1131 params32.lparam = params->lparam;
1132 params32.prev_unicode = params->prev_unicode;
1133 params32.next_unicode = params->next_unicode;
1134 memcpy( arg, &params32, FIELD_OFFSET( struct win_hook_params32, module ));
1135 memmove( ((struct win_hook_params32 *)arg)->module, params->module,
1136 (module_len + 1) * sizeof(WCHAR) );
1137
1138 if (size > offset)
1139 {
1140 size32 = (size32 + 15) & ~15;
1141 offset = (offset + 15) & ~15;
1142 size32 += hook_lparam_64to32( params32.id, params32.code, (char *)params + offset,
1143 size - offset, (char *)arg + size32 );
1144 }
1145
1146 status = Wow64KiUserCallbackDispatcher( NtUserCallWindowsHook, arg, size32, &ret_ptr, &ret_len );
1147 if (status || ret_len < sizeof(LONG)) return status;
1148
1149 switch (params32.id)
1150 {
1151 case WH_SYSMSGFILTER:
1152 case WH_MSGFILTER:
1153 case WH_GETMESSAGE:
1154 if (ret_len == sizeof(MSG32) + sizeof(LONG))
1155 {
1156 msg_32to64( (MSG *)(result_ptr + 1), (MSG32 *)((LONG *)ret_ptr + 1) );
1157 ret_size = sizeof(MSG);
1158 }
1159 break;
1160 }
1161 *result_ptr = *(LONG *)ret_ptr;
1162 return NtCallbackReturn( result_ptr, sizeof(*result_ptr) + ret_size, status );
1163 }
1164
1165 static NTSTATUS WINAPI wow64_NtUserCopyImage( void *arg, ULONG size )
1166 {
1167 struct copy_image_params *params = arg;
1168 void *ret_ptr;
1169 ULONG ret_len;
1170 NTSTATUS status;
1171 struct
1172 {
1173 ULONG hwnd;
1174 UINT type;
1175 INT dx;
1176 INT dy;
1177 UINT flags;
1178 } params32;
1179
1180 params32.hwnd = HandleToUlong( params->hwnd );
1181 params32.type = params->type;
1182 params32.dx = params->dx;
1183 params32.dy = params->dy;
1184 params32.flags = params->flags;
1185 status = Wow64KiUserCallbackDispatcher( NtUserCopyImage, &params32, sizeof(params32),
1186 &ret_ptr, &ret_len );
1187 if (!status && ret_len == sizeof(ULONG))
1188 {
1189 HANDLE handle = ULongToHandle( *(ULONG *)ret_ptr );
1190 return NtCallbackReturn( &handle, sizeof(handle), status );
1191 }
1192 return status;
1193 }
1194
1195 static NTSTATUS WINAPI wow64_NtUserDrawNonClientButton( void *arg, ULONG size )
1196 {
1197 struct draw_non_client_button_params *params = arg;
1198 struct
1199 {
1200 ULONG hwnd;
1201 ULONG hdc;
1202 enum NONCLIENT_BUTTON_TYPE type;
1203 RECT rect;
1204 BOOL down;
1205 BOOL grayed;
1206 } params32;
1207
1208 params32.hwnd = HandleToUlong( params->hwnd );
1209 params32.hdc = HandleToUlong( params->hdc );
1210 params32.type = params->type;
1211 params32.rect = params->rect;
1212 params32.down = params->down;
1213 params32.grayed = params->grayed;
1214 return dispatch_callback( NtUserDrawNonClientButton, &params32, sizeof(params32) );
1215 }
1216
1217 static NTSTATUS WINAPI wow64_NtUserDrawScrollBar( void *arg, ULONG size )
1218 {
1219 struct draw_scroll_bar_params *params = arg;
1220 struct
1221 {
1222 ULONG hwnd;
1223 ULONG hdc;
1224 INT bar;
1225 UINT hit_test;
1226 struct
1227 {
1228 ULONG win;
1229 INT bar;
1230 INT thumb_pos;
1231 INT thumb_val;
1232 BOOL vertical;
1233 enum SCROLL_HITTEST hit_test;
1234 } tracking_info;
1235 BOOL arrows;
1236 BOOL interior;
1237 RECT rect;
1238 UINT enable_flags;
1239 INT arrow_size;
1240 INT thumb_pos;
1241 INT thumb_size;
1242 BOOL vertical;
1243 } params32;
1244
1245 params32.hwnd = HandleToUlong( params->hwnd );
1246 params32.hdc = HandleToUlong( params->hdc );
1247 params32.bar = params->bar;
1248 params32.hit_test = params->hit_test;
1249 params32.tracking_info.win = HandleToUlong( params->tracking_info.win );
1250 params32.tracking_info.bar = params->tracking_info.bar;
1251 params32.tracking_info.thumb_pos = params->tracking_info.thumb_pos;
1252 params32.tracking_info.thumb_val = params->tracking_info.thumb_val;
1253 params32.tracking_info.vertical = params->tracking_info.vertical;
1254 params32.tracking_info.hit_test = params->tracking_info.hit_test;
1255 params32.arrows = params->arrows;
1256 params32.interior = params->interior;
1257 params32.rect = params->rect;
1258 params32.enable_flags = params->enable_flags;
1259 params32.arrow_size = params->arrow_size;
1260 params32.thumb_pos = params->thumb_pos;
1261 params32.thumb_size = params->thumb_size;
1262 params32.vertical = params->vertical;
1263 return dispatch_callback( NtUserDrawScrollBar, &params32, sizeof(params32) );
1264 }
1265
1266 static NTSTATUS WINAPI wow64_NtUserDrawText( void *arg, ULONG size )
1267 {
1268 struct draw_text_params *params = arg;
1269 struct draw_text_params32 *params32;
1270 ULONG offset = offsetof( struct draw_text_params, str ) - offsetof( struct draw_text_params32, str );
1271
1272 params32 = (struct draw_text_params32 *)((char *)params + offset);
1273 params32->flags = params->flags;
1274 params32->rect = params->rect;
1275 params32->count = params->count;
1276 params32->hdc = HandleToUlong( params->hdc );
1277 return dispatch_callback( NtUserDrawText, params32, size - offset );
1278 }
1279
1280 static NTSTATUS WINAPI wow64_NtUserFreeCachedClipboardData( void *arg, ULONG size )
1281 {
1282 struct free_cached_data_params *params = arg;
1283 struct
1284 {
1285 UINT format;
1286 ULONG handle;
1287 } params32;
1288
1289 params32.format = params->format;
1290 params32.handle = HandleToUlong( params->handle );
1291 return dispatch_callback( NtUserFreeCachedClipboardData, &params32, sizeof(params32) );
1292 }
1293
1294 static NTSTATUS WINAPI wow64_NtUserImmProcessKey( void *arg, ULONG size )
1295 {
1296 struct imm_process_key_params *params = arg;
1297 struct
1298 {
1299 ULONG hwnd;
1300 ULONG hkl;
1301 UINT vkey;
1302 ULONG key_data;
1303 } params32;
1304
1305 params32.hwnd = HandleToUlong( params->hwnd );
1306 params32.hkl = HandleToUlong( params->hkl );
1307 params32.vkey = params->vkey;
1308 params32.key_data = params->key_data;
1309 return dispatch_callback( NtUserImmProcessKey, &params32, sizeof(params32) );
1310 }
1311
1312 static NTSTATUS WINAPI wow64_NtUserImmTranslateMessage( void *arg, ULONG size )
1313 {
1314 struct imm_translate_message_params *params = arg;
1315 struct
1316 {
1317 LONG hwnd;
1318 UINT msg;
1319 LONG wparam;
1320 LONG key_data;
1321 } params32;
1322
1323 params32.hwnd = HandleToLong( params->hwnd );
1324 params32.msg = params->msg;
1325 params32.wparam = params->wparam;
1326 params32.key_data = params->key_data;
1327 return dispatch_callback( NtUserImmTranslateMessage, &params32, sizeof(params32) );
1328 }
1329
1330 static NTSTATUS WINAPI wow64_NtUserInitBuiltinClasses( void *arg, ULONG size )
1331 {
1332 return dispatch_callback( NtUserInitBuiltinClasses, arg, size );
1333 }
1334
1335 static NTSTATUS WINAPI wow64_NtUserLoadDriver( void *arg, ULONG size )
1336 {
1337 return dispatch_callback( NtUserLoadDriver, arg, size );
1338 }
1339
1340 static NTSTATUS WINAPI wow64_NtUserLoadImage( void *arg, ULONG size )
1341 {
1342 struct load_image_params *params = arg;
1343 void *ret_ptr;
1344 ULONG ret_len;
1345 NTSTATUS status;
1346 struct
1347 {
1348 ULONG hinst;
1349 ULONG name;
1350 UINT type;
1351 INT dx;
1352 INT dy;
1353 UINT flags;
1354 } params32;
1355
1356 params32.hinst = PtrToUlong( params->hinst );
1357 params32.name = PtrToUlong( params->name );
1358 params32.type = params->type;
1359 params32.dx = params->dx;
1360 params32.dy = params->dy;
1361 params32.flags = params->flags;
1362 status = Wow64KiUserCallbackDispatcher( NtUserLoadImage, &params32, sizeof(params32),
1363 &ret_ptr, &ret_len );
1364 if (!status && ret_len == sizeof(ULONG))
1365 {
1366 HANDLE handle = ULongToHandle( *(ULONG *)ret_ptr );
1367 return NtCallbackReturn( &handle, sizeof(handle), status );
1368 }
1369 return status;
1370 }
1371
1372 static NTSTATUS WINAPI wow64_NtUserLoadSysMenu( void *arg, ULONG size )
1373 {
1374 void *ret_ptr;
1375 ULONG ret_len;
1376 NTSTATUS status;
1377
1378 status = Wow64KiUserCallbackDispatcher( NtUserLoadSysMenu, arg, size, &ret_ptr, &ret_len );
1379 if (!status && ret_len == sizeof(ULONG))
1380 {
1381 HMENU menu = ULongToHandle( *(ULONG *)ret_ptr );
1382 return NtCallbackReturn( &menu, sizeof(menu), status );
1383 }
1384 return status;
1385 }
1386
1387 static NTSTATUS WINAPI wow64_NtUserPostDDEMessage( void *arg, ULONG size )
1388 {
1389 struct post_dde_message_params *params = arg;
1390 struct
1391 {
1392 ULONG hwnd;
1393 UINT msg;
1394 LONG wparam;
1395 LONG lparam;
1396 DWORD dest_tid;
1397 DWORD type;
1398 } params32;
1399
1400 params32.hwnd = HandleToUlong( params->hwnd );
1401 params32.msg = params->msg;
1402 params32.wparam = params->wparam;
1403 params32.lparam = params->lparam;
1404 params32.dest_tid = params->dest_tid;
1405 params32.type = params->type;
1406 return dispatch_callback( NtUserPostDDEMessage, &params32, sizeof(params32) );
1407 }
1408
1409 static NTSTATUS WINAPI wow64_NtUserRenderSynthesizedFormat( void *arg, ULONG size )
1410 {
1411 return dispatch_callback( NtUserRenderSynthesizedFormat, arg, size );
1412 }
1413
1414 static NTSTATUS WINAPI wow64_NtUserUnpackDDEMessage( void *arg, ULONG size )
1415 {
1416 struct unpack_dde_message_params *params = arg;
1417 struct unpack_dde_message_params32 *params32;
1418 struct unpack_dde_message_result result;
1419 struct
1420 {
1421 LONG wparam;
1422 LONG lparam;
1423 } *result32;
1424 ULONG ret_len;
1425 NTSTATUS status;
1426
1427 size -= FIELD_OFFSET( struct unpack_dde_message_params, data );
1428 if (!(params32 = Wow64AllocateTemp( FIELD_OFFSET( struct unpack_dde_message_params32, data[size] ))))
1429 return STATUS_NO_MEMORY;
1430
1431 params32->hwnd = HandleToUlong( params->hwnd );
1432 params32->message = params->message;
1433 params32->wparam = params->wparam;
1434 params32->lparam = params->lparam;
1435 if (size) memcpy( params32->data, params->data, size );
1436 size = FIELD_OFFSET( struct unpack_dde_message_params32, data[size] );
1437
1438 status = Wow64KiUserCallbackDispatcher( NtUserUnpackDDEMessage, params32, size, (void **)&result32, &ret_len );
1439 if (!status && ret_len == sizeof(*result32))
1440 {
1441 result.wparam = result32->wparam;
1442 result.lparam = result32->lparam;
1443 return NtCallbackReturn( &result, sizeof(result), status );
1444 }
1445 return status;
1446 }
1447
1448 static NTSTATUS WINAPI wow64_NtUserCallFreeIcon( void *arg, ULONG size )
1449 {
1450 return dispatch_callback( NtUserCallFreeIcon, arg, size );
1451 }
1452
1453 static NTSTATUS WINAPI wow64_NtUserThunkLock( void *arg, ULONG size )
1454 {
1455 return dispatch_callback( NtUserThunkLock, arg, size );
1456 }
1457
1458 static NTSTATUS WINAPI wow64_NtUserCallVulkanDebugReportCallback( void *arg, ULONG size )
1459 {
1460 FIXME( "\n" );
1461 return 0;
1462 }
1463
1464 static NTSTATUS WINAPI wow64_NtUserCallVulkanDebugUtilsCallback( void *arg, ULONG size )
1465 {
1466 FIXME( "\n" );
1467 return 0;
1468 }
1469
1470 static NTSTATUS WINAPI wow64_NtUserCallOpenGLDebugMessageCallback( void *arg, ULONG size )
1471 {
1472 FIXME( "\n" );
1473 return 0;
1474 }
1475
1476 static NTSTATUS WINAPI wow64_NtUserDriverCallbackFirst0( void *arg, ULONG size )
1477 {
1478 return dispatch_callback( NtUserDriverCallbackFirst + 0, arg, size );
1479 }
1480
1481 static NTSTATUS WINAPI wow64_NtUserDriverCallbackFirst1( void *arg, ULONG size )
1482 {
1483 return dispatch_callback( NtUserDriverCallbackFirst + 1, arg, size );
1484 }
1485
1486 static NTSTATUS WINAPI wow64_NtUserDriverCallbackFirst2( void *arg, ULONG size )
1487 {
1488 return dispatch_callback( NtUserDriverCallbackFirst + 2, arg, size );
1489 }
1490
1491 static NTSTATUS WINAPI wow64_NtUserDriverCallbackFirst3( void *arg, ULONG size )
1492 {
1493 return dispatch_callback( NtUserDriverCallbackFirst + 3, arg, size );
1494 }
1495
1496 static NTSTATUS WINAPI wow64_NtUserDriverCallbackFirst4( void *arg, ULONG size )
1497 {
1498 return dispatch_callback( NtUserDriverCallbackFirst + 4, arg, size );
1499 }
1500
1501 static NTSTATUS WINAPI wow64_NtUserDriverCallbackFirst5( void *arg, ULONG size )
1502 {
1503 return dispatch_callback( NtUserDriverCallbackFirst + 5, arg, size );
1504 }
1505
1506 static NTSTATUS WINAPI wow64_NtUserDriverCallbackFirst6( void *arg, ULONG size )
1507 {
1508 return dispatch_callback( NtUserDriverCallbackFirst + 6, arg, size );
1509 }
1510
1511 static NTSTATUS WINAPI wow64_NtUserDriverCallbackFirst7( void *arg, ULONG size )
1512 {
1513 return dispatch_callback( NtUserDriverCallbackFirst + 7, arg, size );
1514 }
1515
1516 static NTSTATUS WINAPI wow64_NtUserDriverCallbackFirst8( void *arg, ULONG size )
1517 {
1518 return dispatch_callback( NtUserDriverCallbackFirst + 8, arg, size );
1519 }
1520
1521 static NTSTATUS WINAPI wow64_NtUserDriverCallbackFirst9( void *arg, ULONG size )
1522 {
1523 return dispatch_callback( NtUserDriverCallbackFirst + 9, arg, size );
1524 }
1525
1526 user_callback user_callbacks[] =
1527 {
1528 /* user32 callbacks */
1529 wow64_NtUserCallEnumDisplayMonitor,
1530 wow64_NtUserCallSendAsyncCallback,
1531 wow64_NtUserCallWinEventHook,
1532 wow64_NtUserCallWinProc,
1533 wow64_NtUserCallWindowsHook,
1534 wow64_NtUserCopyImage,
1535 wow64_NtUserDrawNonClientButton,
1536 wow64_NtUserDrawScrollBar,
1537 wow64_NtUserDrawText,
1538 wow64_NtUserFreeCachedClipboardData,
1539 wow64_NtUserImmProcessKey,
1540 wow64_NtUserImmTranslateMessage,
1541 wow64_NtUserInitBuiltinClasses,
1542 wow64_NtUserLoadDriver,
1543 wow64_NtUserLoadImage,
1544 wow64_NtUserLoadSysMenu,
1545 wow64_NtUserPostDDEMessage,
1546 wow64_NtUserRenderSynthesizedFormat,
1547 wow64_NtUserUnpackDDEMessage,
1548 /* win16 hooks */
1549 wow64_NtUserCallFreeIcon,
1550 wow64_NtUserThunkLock,
1551 /* Vulkan support */
1552 wow64_NtUserCallVulkanDebugReportCallback,
1553 wow64_NtUserCallVulkanDebugUtilsCallback,
1554 /* OpenGL support */
1555 wow64_NtUserCallOpenGLDebugMessageCallback,
1556 /* Driver-specific callbacks */
1557 wow64_NtUserDriverCallbackFirst0,
1558 wow64_NtUserDriverCallbackFirst1,
1559 wow64_NtUserDriverCallbackFirst2,
1560 wow64_NtUserDriverCallbackFirst3,
1561 wow64_NtUserDriverCallbackFirst4,
1562 wow64_NtUserDriverCallbackFirst5,
1563 wow64_NtUserDriverCallbackFirst6,
1564 wow64_NtUserDriverCallbackFirst7,
1565 wow64_NtUserDriverCallbackFirst8,
1566 wow64_NtUserDriverCallbackFirst9,
1567 };
1568
1569 C_ASSERT( ARRAYSIZE(user_callbacks) == NtUserCallCount );
1570
1571 NTSTATUS WINAPI wow64_NtUserActivateKeyboardLayout( UINT *args )
1572 {
1573 HKL layout = get_handle( &args );
1574 UINT flags = get_ulong( &args );
1575
1576 return HandleToUlong( NtUserActivateKeyboardLayout( layout, flags ));
1577 }
1578
1579 NTSTATUS WINAPI wow64_NtUserAddClipboardFormatListener( UINT *args )
1580 {
1581 HWND hwnd = get_handle( &args );
1582
1583 return NtUserAddClipboardFormatListener( hwnd );
1584 }
1585
1586 NTSTATUS WINAPI wow64_NtUserAssociateInputContext( UINT *args )
1587 {
1588 HWND hwnd = get_handle( &args );
1589 HIMC ctx = get_handle( &args );
1590 ULONG flags = get_ulong( &args );
1591
1592 return NtUserAssociateInputContext( hwnd, ctx, flags );
1593 }
1594
1595 NTSTATUS WINAPI wow64_NtUserAttachThreadInput( UINT *args )
1596 {
1597 DWORD from = get_ulong( &args );
1598 DWORD to = get_ulong( &args );
1599 BOOL attach = get_ulong( &args );
1600
1601 return NtUserAttachThreadInput( from, to, attach );
1602 }
1603
1604 NTSTATUS WINAPI wow64_NtUserBeginPaint( UINT *args )
1605 {
1606 HWND hwnd = get_handle( &args );
1607 PAINTSTRUCT32 *ps32 = get_ptr( &args );
1608
1609 PAINTSTRUCT ps;
1610 HDC ret;
1611
1612 ret = NtUserBeginPaint( hwnd, ps32 ? & ps : NULL );
1613 if (ret && ps32)
1614 {
1615 ps32->hdc = HandleToUlong( ps.hdc );
1616 ps32->fErase = ps.fErase;
1617 ps32->rcPaint = ps.rcPaint;
1618 }
1619 return HandleToUlong( ret );
1620 }
1621
1622 NTSTATUS WINAPI wow64_NtUserBuildHimcList( UINT *args )
1623 {
1624 ULONG thread_id = get_ulong( &args );
1625 ULONG count = get_ulong( &args );
1626 UINT32 *buffer32 = get_ptr( &args );
1627 UINT *size = get_ptr( &args );
1628
1629 HIMC *buffer = NULL;
1630 ULONG i;
1631 NTSTATUS status;
1632
1633 if (buffer32 && !(buffer = Wow64AllocateTemp( count * sizeof(*buffer) )))
1634 return STATUS_NO_MEMORY;
1635
1636 if ((status = NtUserBuildHimcList( thread_id, count, buffer, size ))) return status;
1637
1638 for (i = 0; i < *size; i++) buffer32[i] = HandleToUlong( buffer[i] );
1639 return status;
1640 }
1641
1642 NTSTATUS WINAPI wow64_NtUserBuildHwndList( UINT *args )
1643 {
1644 HDESK desktop = get_handle( &args );
1645 ULONG unk2 = get_ulong( &args );
1646 ULONG unk3 = get_ulong( &args );
1647 ULONG unk4 = get_ulong( &args );
1648 ULONG thread_id = get_ulong( &args );
1649 ULONG count = get_ulong( &args );
1650 UINT32 *buffer32 = get_ptr( &args );
1651 ULONG *size = get_ptr( &args );
1652
1653 HWND *buffer;
1654 ULONG i;
1655 NTSTATUS status;
1656
1657 if (!(buffer = Wow64AllocateTemp( count * sizeof(*buffer) ))) return STATUS_NO_MEMORY;
1658
1659 if ((status = NtUserBuildHwndList( desktop, unk2, unk3, unk4, thread_id, count, buffer, size )))
1660 return status;
1661
1662 for (i = 0; i < *size; i++)
1663 buffer32[i] = HandleToUlong( buffer[i] );
1664 return status;
1665 }
1666
1667 NTSTATUS WINAPI wow64_NtUserCallHwnd( UINT *args )
1668 {
1669 HWND hwnd = get_handle( &args );
1670 DWORD code = get_ulong( &args );
1671
1672 return NtUserCallHwnd( hwnd, code );
1673 }
1674
1675 NTSTATUS WINAPI wow64_NtUserCallHwndParam( UINT *args )
1676 {
1677 HWND hwnd = get_handle( &args );
1678 DWORD_PTR param = get_ulong( &args );
1679 DWORD code = get_ulong( &args );
1680
1681 switch (code)
1682 {
1683 case NtUserCallHwndParam_GetScrollInfo:
1684 {
1685 struct
1686 {
1687 int bar;
1688 ULONG info;
1689 } *info32 = UlongToPtr( param );
1690 struct get_scroll_info_params info;
1691
1692 info.bar = info32->bar;
1693 info.info = UlongToPtr( info32->info );
1694 return NtUserCallHwndParam( hwnd, (UINT_PTR)&info, code );
1695 }
1696
1697 case NtUserCallHwndParam_GetWindowRects:
1698 {
1699 struct
1700 {
1701 ULONG rect;
1702 BOOL client;
1703 UINT dpi;
1704 } *params32 = UlongToPtr( param );
1705 struct get_window_rects_params params;
1706
1707 params.rect = UlongToPtr( params32->rect );
1708 params.client = params32->client;
1709 params.dpi = params32->dpi;
1710 return NtUserCallHwndParam( hwnd, (UINT_PTR)&params, code );
1711 }
1712
1713 case NtUserCallHwndParam_MapWindowPoints:
1714 {
1715 struct
1716 {
1717 ULONG hwnd_to;
1718 ULONG points;
1719 UINT count;
1720 UINT dpi;
1721 } *params32 = UlongToPtr( param );
1722 struct map_window_points_params params;
1723
1724 params.hwnd_to = LongToHandle( params32->hwnd_to );
1725 params.points = UlongToPtr( params32->points );
1726 params.count = params32->count;
1727 params.dpi = params32->dpi;
1728 return NtUserCallHwndParam( hwnd, (UINT_PTR)&params, code );
1729 }
1730
1731 case NtUserCallHwndParam_SendHardwareInput:
1732 {
1733 struct
1734 {
1735 UINT flags;
1736 ULONG input;
1737 ULONG lparam;
1738 } *params32 = UlongToPtr( param );
1739 struct send_hardware_input_params params;
1740
1741 params.flags = params32->flags;
1742 params.input = UlongToPtr( params32->input );
1743 params.lparam = params32->lparam;
1744 return NtUserCallHwndParam( hwnd, (UINT_PTR)&params, code );
1745 }
1746
1747 default:
1748 return NtUserCallHwndParam( hwnd, param, code );
1749 }
1750 }
1751
1752 NTSTATUS WINAPI wow64_NtUserCallMsgFilter( UINT *args )
1753 {
1754 MSG32 *msg32 = get_ptr( &args );
1755 INT code = get_ulong( &args );
1756 MSG msg;
1757 BOOL ret;
1758
1759 ret = NtUserCallMsgFilter( msg_32to64( &msg, msg32 ), code );
1760 msg_64to32( &msg, msg32 );
1761 return ret;
1762 }
1763
1764 NTSTATUS WINAPI wow64_NtUserCallNextHookEx( UINT *args )
1765 {
1766 HHOOK hhook = get_handle( &args );
1767 INT code = get_ulong( &args );
1768 WPARAM wparam = get_ulong( &args );
1769 LPARAM lparam = get_ulong( &args );
1770
1771 return NtUserCallNextHookEx( hhook, code, wparam, lparam );
1772 }
1773
1774 NTSTATUS WINAPI wow64_NtUserCallNoParam( UINT *args )
1775 {
1776 ULONG code = get_ulong( &args );
1777
1778 return NtUserCallNoParam( code );
1779 }
1780
1781 NTSTATUS WINAPI wow64_NtUserCallOneParam( UINT *args )
1782 {
1783 ULONG_PTR arg = get_ulong( &args );
1784 ULONG code = get_ulong( &args );
1785
1786 return NtUserCallOneParam( arg, code );
1787 }
1788
1789 NTSTATUS WINAPI wow64_NtUserCallTwoParam( UINT *args )
1790 {
1791 ULONG_PTR arg1 = get_ulong( &args );
1792 ULONG_PTR arg2 = get_ulong( &args );
1793 ULONG code = get_ulong( &args );
1794
1795 switch (code)
1796 {
1797 case NtUserCallTwoParam_GetMenuInfo:
1798 {
1799 MENUINFO32 *info32 = UlongToPtr( arg2 );
1800 MENUINFO info;
1801
1802 if (!info32 || info32->cbSize != sizeof(*info32))
1803 {
1804 set_last_error32( ERROR_INVALID_PARAMETER );
1805 return FALSE;
1806 }
1807
1808 info.cbSize = sizeof(info);
1809 info.fMask = info32->fMask;
1810 if (!NtUserCallTwoParam( arg1, (UINT_PTR)&info, code )) return FALSE;
1811 if (info.fMask & MIM_BACKGROUND) info32->hbrBack = HandleToUlong( info.hbrBack );
1812 if (info.fMask & MIM_HELPID) info32->dwContextHelpID = info.dwContextHelpID;
1813 if (info.fMask & MIM_MAXHEIGHT) info32->cyMax = info.cyMax;
1814 if (info.fMask & MIM_MENUDATA) info32->dwMenuData = info.dwMenuData;
1815 if (info.fMask & MIM_STYLE) info32->dwStyle = info.dwStyle;
1816 return TRUE;
1817 }
1818
1819 default:
1820 return NtUserCallTwoParam( arg1, arg2, code );
1821 }
1822 }
1823
1824 NTSTATUS WINAPI wow64_NtUserChangeClipboardChain( UINT *args )
1825 {
1826 HWND hwnd = get_handle( &args );
1827 HWND next = get_handle( &args );
1828
1829 return NtUserChangeClipboardChain( hwnd, next );
1830 }
1831
1832 NTSTATUS WINAPI wow64_NtUserChangeDisplaySettings( UINT *args )
1833 {
1834 UNICODE_STRING32 *devname32 = get_ptr( &args );
1835 DEVMODEW *devmode = get_ptr( &args );
1836 HWND hwnd = get_handle( &args );
1837 DWORD flags = get_ulong( &args );
1838 void *lparam = get_ptr( &args );
1839
1840 UNICODE_STRING devname;
1841
1842 return NtUserChangeDisplaySettings( unicode_str_32to64( &devname, devname32 ),
1843 devmode, hwnd, flags, lparam );
1844 }
1845
1846 NTSTATUS WINAPI wow64_NtUserCheckMenuItem( UINT *args )
1847 {
1848 HMENU handle = get_handle( &args );
1849 UINT id = get_ulong( &args );
1850 UINT flags = get_ulong( &args );
1851
1852 return NtUserCheckMenuItem( handle, id, flags );
1853 }
1854
1855 NTSTATUS WINAPI wow64_NtUserChildWindowFromPointEx( UINT *args )
1856 {
1857 HWND parent = get_handle( &args );
1858 LONG x = get_ulong( &args );
1859 LONG y = get_ulong( &args );
1860 UINT flags = get_ulong( &args );
1861
1862 return HandleToUlong( NtUserChildWindowFromPointEx( parent, x, y, flags ));
1863 }
1864
1865 NTSTATUS WINAPI wow64_NtUserClipCursor( UINT *args )
1866 {
1867 const RECT *rect = get_ptr( &args );
1868
1869 return NtUserClipCursor( rect );
1870 }
1871
1872 NTSTATUS WINAPI wow64_NtUserCloseClipboard( UINT *args )
1873 {
1874 return NtUserCloseClipboard();
1875 }
1876
1877 NTSTATUS WINAPI wow64_NtUserCloseDesktop( UINT *args )
1878 {
1879 HDESK handle = get_handle( &args );
1880
1881 return NtUserCloseDesktop( handle );
1882 }
1883
1884 NTSTATUS WINAPI wow64_NtUserCloseWindowStation( UINT *args )
1885 {
1886 HWINSTA handle = get_handle( &args );
1887
1888 return NtUserCloseWindowStation( handle );
1889 }
1890
1891 NTSTATUS WINAPI wow64_NtUserCopyAcceleratorTable( UINT *args )
1892 {
1893 HACCEL src = get_handle( &args );
1894 ACCEL *dst = get_ptr( &args );
1895 INT count = get_ulong( &args );
1896
1897 return NtUserCopyAcceleratorTable( src, dst, count );
1898 }
1899
1900 NTSTATUS WINAPI wow64_NtUserCountClipboardFormats( UINT *args )
1901 {
1902 return NtUserCountClipboardFormats();
1903 }
1904
1905 NTSTATUS WINAPI wow64_NtUserCreateAcceleratorTable( UINT *args )
1906 {
1907 ACCEL *table = get_ptr( &args );
1908 INT count = get_ulong( &args );
1909
1910 return HandleToUlong( NtUserCreateAcceleratorTable( table, count ));
1911 }
1912
1913 NTSTATUS WINAPI wow64_NtUserCreateCaret( UINT *args )
1914 {
1915 HWND hwnd = get_handle( &args );
1916 HBITMAP bitmap = get_handle( &args );
1917 int width = get_ulong( &args );
1918 int height = get_ulong( &args );
1919
1920 return NtUserCreateCaret( hwnd, bitmap, width, height );
1921 }
1922
1923 NTSTATUS WINAPI wow64_NtUserCreateDesktopEx( UINT *args )
1924 {
1925 OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
1926 UNICODE_STRING32 *device32 = get_ptr( &args );
1927 DEVMODEW *devmode = get_ptr( &args );
1928 DWORD flags = get_ulong( &args );
1929 ACCESS_MASK access = get_ulong( &args );
1930 ULONG heap_size = get_ulong( &args );
1931
1932 struct object_attr64 attr;
1933 UNICODE_STRING device;
1934 HANDLE ret;
1935
1936 ret = NtUserCreateDesktopEx( objattr_32to64( &attr, attr32 ),
1937 unicode_str_32to64( &device, device32 ),
1938 devmode, flags, access, heap_size );
1939 return HandleToUlong( ret );
1940 }
1941
1942 NTSTATUS WINAPI wow64_NtUserCreateInputContext( UINT *args )
1943 {
1944 UINT_PTR client_ptr = get_ulong( &args );
1945
1946 return HandleToUlong( NtUserCreateInputContext( client_ptr ));
1947 }
1948
1949 NTSTATUS WINAPI wow64_NtUserCreateWindowEx( UINT *args )
1950 {
1951 DWORD ex_style = get_ulong( &args );
1952 UNICODE_STRING32 *class_name32 = get_ptr( &args );
1953 UNICODE_STRING32 *version32 = get_ptr( &args );
1954 UNICODE_STRING32 *window_name32 = get_ptr( &args );
1955 DWORD style = get_ulong( &args );
1956 int x = get_ulong( &args );
1957 int y = get_ulong( &args );
1958 int width = get_ulong( &args );
1959 int height = get_ulong( &args );
1960 HWND parent = get_handle( &args );
1961 HMENU menu = get_handle( &args );
1962 HINSTANCE instance = get_ptr( &args );
1963 void *params = get_ptr( &args );
1964 DWORD flags = get_ulong( &args );
1965 HINSTANCE client_instance = get_ptr( &args );
1966 DWORD unk = get_ulong( &args );
1967 BOOL ansi = get_ulong( &args );
1968
1969 UNICODE_STRING class_name, version, window_name;
1970 HWND ret;
1971
1972 ret = NtUserCreateWindowEx( ex_style,
1973 unicode_str_32to64( &class_name, class_name32),
1974 unicode_str_32to64( &version, version32 ),
1975 unicode_str_32to64( &window_name, window_name32 ),
1976 style, x, y, width, height, parent, menu,
1977 instance, params, flags, client_instance, unk, ansi );
1978 return HandleToUlong( ret );
1979 }
1980
1981 NTSTATUS WINAPI wow64_NtUserCreateWindowStation( UINT *args )
1982 {
1983 OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
1984 ACCESS_MASK access = get_ulong( &args );
1985 ULONG arg3 = get_ulong( &args );
1986 ULONG arg4 = get_ulong( &args );
1987 ULONG arg5 = get_ulong( &args );
1988 ULONG arg6 = get_ulong( &args );
1989 ULONG arg7 = get_ulong( &args );
1990
1991 struct object_attr64 attr;
1992
1993 return HandleToUlong( NtUserCreateWindowStation( objattr_32to64( &attr, attr32 ), access,
1994 arg3, arg4, arg5, arg6, arg7 ));
1995 }
1996
1997 NTSTATUS WINAPI wow64_NtUserDeferWindowPosAndBand( UINT *args )
1998 {
1999 HDWP hdwp = get_handle( &args );
2000 HWND hwnd = get_handle( &args );
2001 HWND after = get_handle( &args );
2002 INT x = get_ulong( &args );
2003 INT y = get_ulong( &args );
2004 INT cx = get_ulong( &args );
2005 INT cy = get_ulong( &args );
2006 UINT flags = get_ulong( &args );
2007 UINT unk1 = get_ulong( &args );
2008 UINT unk2 = get_ulong( &args );
2009
2010 HDWP ret = NtUserDeferWindowPosAndBand( hdwp, hwnd, after, x, y, cx, cy, flags, unk1, unk2 );
2011 return HandleToUlong( ret );
2012 }
2013
2014 NTSTATUS WINAPI wow64_NtUserDeleteMenu( UINT *args )
2015 {
2016 HMENU menu = get_handle( &args );
2017 UINT id = get_ulong( &args );
2018 UINT flags = get_ulong( &args );
2019
2020 return NtUserDeleteMenu( menu, id, flags );
2021 }
2022
2023 NTSTATUS WINAPI wow64_NtUserDestroyAcceleratorTable( UINT *args )
2024 {
2025 HACCEL handle = get_handle( &args );
2026
2027 return NtUserDestroyAcceleratorTable( handle );
2028 }
2029
2030 NTSTATUS WINAPI wow64_NtUserDestroyCursor( UINT *args )
2031 {
2032 HCURSOR cursor = get_handle( &args );
2033 ULONG arg = get_ulong( &args );
2034
2035 return NtUserDestroyCursor( cursor, arg );
2036 }
2037
2038 NTSTATUS WINAPI wow64_NtUserDestroyInputContext( UINT *args )
2039 {
2040 HIMC handle = get_handle( &args );
2041
2042 return NtUserDestroyInputContext( handle );
2043 }
2044
2045 NTSTATUS WINAPI wow64_NtUserDestroyMenu( UINT *args )
2046 {
2047 HMENU handle = get_handle( &args );
2048
2049 return NtUserDestroyMenu( handle );
2050 }
2051
2052 NTSTATUS WINAPI wow64_NtUserDestroyWindow( UINT *args )
2053 {
2054 HWND hwnd = get_handle( &args );
2055
2056 return NtUserDestroyWindow( hwnd );
2057 }
2058
2059 NTSTATUS WINAPI wow64_NtUserDisableThreadIme( UINT *args )
2060 {
2061 DWORD thread_id = get_ulong( &args );
2062
2063 return NtUserDisableThreadIme( thread_id );
2064 }
2065
2066 NTSTATUS WINAPI wow64_NtUserDispatchMessage( UINT *args )
2067 {
2068 const MSG32 *msg32 = get_ptr( &args );
2069 MSG msg;
2070
2071 return NtUserDispatchMessage( msg_32to64( &msg, msg32 ));
2072 }
2073
2074 NTSTATUS WINAPI wow64_NtUserDragDetect( UINT *args )
2075 {
2076 HWND hwnd = get_handle( &args );
2077 int x = get_ulong( &args );
2078 int y = get_ulong( &args );
2079
2080 return NtUserDragDetect( hwnd, x, y );
2081 }
2082
2083 NTSTATUS WINAPI wow64_NtUserDragObject( UINT *args )
2084 {
2085 HWND parent = get_handle( &args );
2086 HWND hwnd = get_handle( &args );
2087 UINT fmt = get_ulong( &args );
2088 ULONG_PTR data = get_ulong( &args );
2089 HCURSOR hcursor = get_handle( &args );
2090
2091 return NtUserDragObject( parent, hwnd, fmt, data, hcursor );
2092 }
2093
2094 NTSTATUS WINAPI wow64_NtUserDrawCaptionTemp( UINT *args )
2095 {
2096 HWND hwnd = get_handle( &args );
2097 HDC hdc = get_handle( &args );
2098 const RECT *rect = get_ptr( &args );
2099 HFONT font = get_handle( &args );
2100 HICON icon = get_handle( &args );
2101 const WCHAR *str = get_ptr( &args );
2102 UINT flags = get_ulong( &args );
2103
2104 return NtUserDrawCaptionTemp( hwnd, hdc, rect, font, icon, str, flags );
2105 }
2106
2107 NTSTATUS WINAPI wow64_NtUserDrawIconEx( UINT *args )
2108 {
2109 HDC hdc = get_handle( &args );
2110 int x0 = get_ulong( &args );
2111 int y0 = get_ulong( &args );
2112 HICON icon = get_handle( &args );
2113 int width = get_ulong( &args );
2114 int height = get_ulong( &args );
2115 UINT istep = get_ulong( &args );
2116 HBRUSH hbr = get_handle( &args );
2117 UINT flags = get_ulong( &args );
2118
2119 return NtUserDrawIconEx( hdc, x0, y0, icon, width, height, istep, hbr, flags );
2120 }
2121
2122 NTSTATUS WINAPI wow64_NtUserDrawMenuBarTemp( UINT *args )
2123 {
2124 HWND hwnd = get_handle( &args );
2125 HDC hdc = get_handle( &args );
2126 RECT *rect = get_ptr( &args );
2127 HMENU handle = get_handle( &args );
2128 HFONT font = get_handle( &args );
2129
2130 return NtUserDrawMenuBarTemp( hwnd, hdc, rect, handle, font );
2131 }
2132
2133 NTSTATUS WINAPI wow64_NtUserEmptyClipboard( UINT *args )
2134 {
2135 return NtUserEmptyClipboard();
2136 }
2137
2138 NTSTATUS WINAPI wow64_NtUserEnableMenuItem( UINT *args )
2139 {
2140 HMENU handle = get_handle( &args );
2141 UINT id = get_ulong( &args );
2142 UINT flags = get_ulong( &args );
2143
2144 return NtUserEnableMenuItem( handle, id, flags );
2145 }
2146
2147 NTSTATUS WINAPI wow64_NtUserEnableMouseInPointer( UINT *args )
2148 {
2149 UINT enable = get_ulong( &args );
2150
2151 return NtUserEnableMouseInPointer( enable );
2152 }
2153
2154 NTSTATUS WINAPI wow64_NtUserEnableScrollBar( UINT *args )
2155 {
2156 HWND hwnd = get_handle( &args );
2157 UINT bar = get_ulong( &args );
2158 UINT flags = get_ulong( &args );
2159
2160 return NtUserEnableScrollBar( hwnd, bar, flags );
2161 }
2162
2163 NTSTATUS WINAPI wow64_NtUserEndDeferWindowPosEx( UINT *args )
2164 {
2165 HDWP hdwp = get_handle( &args );
2166 BOOL async = get_ulong( &args );
2167
2168 return NtUserEndDeferWindowPosEx( hdwp, async );
2169 }
2170
2171 NTSTATUS WINAPI wow64_NtUserEndMenu( UINT *args )
2172 {
2173 return NtUserEndMenu();
2174 }
2175
2176 NTSTATUS WINAPI wow64_NtUserEndPaint( UINT *args )
2177 {
2178 HWND hwnd = get_handle( &args );
2179 const PAINTSTRUCT32 *ps32 = get_ptr( &args );
2180 PAINTSTRUCT ps;
2181
2182 return NtUserEndPaint( hwnd, paintstruct_32to64( &ps, ps32 ));
2183 }
2184
2185 NTSTATUS WINAPI wow64_NtUserEnumDisplayDevices( UINT *args )
2186 {
2187 UNICODE_STRING32 *device32 = get_ptr( &args );
2188 DWORD index = get_ulong( &args );
2189 DISPLAY_DEVICEW *info = get_ptr( &args );
2190 DWORD flags = get_ulong( &args );
2191
2192 UNICODE_STRING device;
2193
2194 return NtUserEnumDisplayDevices( unicode_str_32to64( &device, device32 ), index, info, flags );
2195 }
2196
2197 NTSTATUS WINAPI wow64_NtUserEnumDisplayMonitors( UINT *args )
2198 {
2199 HDC hdc = get_handle( &args );
2200 RECT *rect = get_ptr( &args );
2201 MONITORENUMPROC proc = get_ptr( &args );
2202 LPARAM lp = get_ulong( &args );
2203
2204 return NtUserEnumDisplayMonitors( hdc, rect, proc, lp );
2205 }
2206
2207 NTSTATUS WINAPI wow64_NtUserEnumDisplaySettings( UINT *args )
2208 {
2209 UNICODE_STRING32 *device32 = get_ptr( &args );
2210 DWORD mode = get_ulong( &args );
2211 DEVMODEW *dev_mode = get_ptr( &args );
2212 DWORD flags = get_ulong( &args );
2213
2214 UNICODE_STRING device;
2215
2216 return NtUserEnumDisplaySettings( unicode_str_32to64( &device, device32 ),
2217 mode, dev_mode, flags );
2218 }
2219
2220 NTSTATUS WINAPI wow64_NtUserExcludeUpdateRgn( UINT *args )
2221 {
2222 HDC hdc = get_handle( &args );
2223 HWND hwnd = get_handle( &args );
2224
2225 return NtUserExcludeUpdateRgn( hdc, hwnd );
2226 }
2227
2228 NTSTATUS WINAPI wow64_NtUserFindExistingCursorIcon( UINT *args )
2229 {
2230 UNICODE_STRING32 *module32 = get_ptr( &args );
2231 UNICODE_STRING32 *res_name32 = get_ptr( &args );
2232 void *desc = get_ptr( &args );
2233
2234 UNICODE_STRING module;
2235 UNICODE_STRING res_name;
2236 HICON ret;
2237
2238 ret = NtUserFindExistingCursorIcon( unicode_str_32to64( &module, module32 ),
2239 unicode_str_32to64( &res_name, res_name32 ), desc );
2240 return HandleToUlong( ret );
2241 }
2242
2243 NTSTATUS WINAPI wow64_NtUserFindWindowEx( UINT *args )
2244 {
2245 HWND parent = get_handle( &args );
2246 HWND child = get_handle( &args );
2247 UNICODE_STRING32 *class32 = get_ptr( &args );
2248 UNICODE_STRING32 *title32 = get_ptr( &args );
2249 ULONG unk = get_ulong( &args );
2250
2251 UNICODE_STRING class, title;
2252 HWND ret;
2253
2254 ret = NtUserFindWindowEx( parent, child, unicode_str_32to64( &class, class32 ),
2255 unicode_str_32to64( &title, title32 ), unk );
2256 return HandleToUlong( ret );
2257 }
2258
2259 NTSTATUS WINAPI wow64_NtUserFlashWindowEx( UINT *args )
2260 {
2261 struct
2262 {
2263 UINT cbSize;
2264 ULONG hwnd;
2265 DWORD dwFlags;
2266 UINT uCount;
2267 DWORD dwTimeout;
2268 } *info32 = get_ptr( &args );
2269
2270 FLASHWINFO info;
2271
2272 if (!info32)
2273 {
2274 set_last_error32( ERROR_NOACCESS );
2275 return FALSE;
2276 }
2277
2278 if (info32->cbSize != sizeof(*info32))
2279 {
2280 set_last_error32( ERROR_INVALID_PARAMETER );
2281 return FALSE;
2282 }
2283
2284 info.cbSize = sizeof(info);
2285 info.hwnd = LongToHandle( info32->hwnd );
2286 info.dwFlags = info32->dwFlags;
2287 info.uCount = info32->uCount;
2288 info.dwTimeout = info32->dwTimeout;
2289 return NtUserFlashWindowEx( &info );
2290 }
2291
2292 NTSTATUS WINAPI wow64_NtUserGetAncestor( UINT *args )
2293 {
2294 HWND hwnd = get_handle( &args );
2295 UINT type = get_ulong( &args );
2296
2297 return HandleToUlong( NtUserGetAncestor( hwnd, type ));
2298 }
2299
2300 NTSTATUS WINAPI wow64_NtUserGetAsyncKeyState( UINT *args )
2301 {
2302 INT key = get_ulong( &args );
2303
2304 return NtUserGetAsyncKeyState( key );
2305 }
2306
2307 NTSTATUS WINAPI wow64_NtUserGetAtomName( UINT *args )
2308 {
2309 ATOM atom = get_ulong( &args );
2310 UNICODE_STRING32 *str32 = get_ptr( &args );
2311
2312 UNICODE_STRING str;
2313
2314 return NtUserGetAtomName( atom, unicode_str_32to64( &str, str32 ));
2315 }
2316
2317 NTSTATUS WINAPI wow64_NtUserGetCaretBlinkTime( UINT *args )
2318 {
2319 return NtUserGetCaretBlinkTime();
2320 }
2321
2322 NTSTATUS WINAPI wow64_NtUserGetCaretPos( UINT *args )
2323 {
2324 POINT *pt = get_ptr( &args );
2325
2326 return NtUserGetCaretPos( pt );
2327 }
2328
2329 NTSTATUS WINAPI wow64_NtUserGetClassInfoEx( UINT *args )
2330 {
2331 HINSTANCE instance = get_ptr( &args );
2332 UNICODE_STRING32 *name32 = get_ptr( &args );
2333 WNDCLASSEXW32 *wc32 = get_ptr( &args );
2334 struct client_menu_name32 *client_name32 = get_ptr( &args );
2335 BOOL ansi = get_ulong( &args );
2336
2337 struct client_menu_name client_name;
2338 UNICODE_STRING name;
2339 WNDCLASSEXW wc;
2340 ATOM ret;
2341
2342 wc.cbSize = sizeof(wc);
2343 if (!(ret = NtUserGetClassInfoEx( instance, unicode_str_32to64( &name, name32 ), &wc,
2344 &client_name, ansi )))
2345 return 0;
2346
2347 wc32->style = wc.style;
2348 wc32->lpfnWndProc = PtrToUlong( wc.lpfnWndProc );
2349 wc32->cbClsExtra = wc.cbClsExtra;
2350 wc32->cbWndExtra = wc.cbWndExtra;
2351 wc32->hInstance = PtrToUlong( wc.hInstance );
2352 wc32->hIcon = HandleToUlong( wc.hIcon );
2353 wc32->hCursor = HandleToUlong( wc.hCursor );
2354 wc32->hbrBackground = HandleToUlong( wc.hbrBackground );
2355 wc32->lpszMenuName = PtrToUlong( wc.lpszMenuName );
2356 wc32->lpszClassName = PtrToUlong( wc.lpszClassName );
2357 wc32->hIconSm = HandleToUlong( wc.hIconSm );
2358 client_menu_name_64to32( &client_name, client_name32 );
2359 return ret;
2360 }
2361
2362 NTSTATUS WINAPI wow64_NtUserGetClassName( UINT *args )
2363 {
2364 HWND hwnd = get_handle( &args );
2365 BOOL real = get_ulong( &args );
2366 UNICODE_STRING32 *str32 = get_ptr( &args );
2367
2368 UNICODE_STRING str;
2369
2370 return NtUserGetClassName( hwnd, real, unicode_str_32to64( &str, str32 ));
2371 }
2372
2373 NTSTATUS WINAPI wow64_NtUserGetClipboardData( UINT *args )
2374 {
2375 UINT format = get_ulong( &args );
2376 struct
2377 {
2378 UINT32 data;
2379 UINT32 size;
2380 UINT32 data_size;
2381 UINT seqno;
2382 BOOL data_only;
2383 } *params32 = get_ptr( &args );
2384
2385 struct get_clipboard_params params;
2386 HANDLE ret;
2387
2388 params.data = UlongToPtr( params32->data );
2389 params.size = params32->size;
2390 params.data_size = params32->data_size;
2391 params.data_only = params32->data_only;
2392
2393 ret = NtUserGetClipboardData( format, &params );
2394
2395 params32->size = params.size;
2396 params32->data_size = params.data_size;
2397 params32->seqno = params.seqno;
2398 return HandleToUlong( ret );
2399 }
2400
2401 NTSTATUS WINAPI wow64_NtUserGetClipboardFormatName( UINT *args )
2402 {
2403 UINT format = get_ulong( &args );
2404 WCHAR *buffer = get_ptr( &args );
2405 INT maxlen = get_ulong( &args );
2406
2407 return NtUserGetClipboardFormatName( format, buffer, maxlen );
2408 }
2409
2410 NTSTATUS WINAPI wow64_NtUserGetClipboardOwner( UINT *args )
2411 {
2412 return HandleToUlong( NtUserGetClipboardOwner() );
2413 }
2414
2415 NTSTATUS WINAPI wow64_NtUserGetClipboardSequenceNumber( UINT *args )
2416 {
2417 return NtUserGetClipboardSequenceNumber();
2418 }
2419
2420 NTSTATUS WINAPI wow64_NtUserGetClipboardViewer( UINT *args )
2421 {
2422 return HandleToUlong( NtUserGetClipboardViewer() );
2423 }
2424
2425 NTSTATUS WINAPI wow64_NtUserGetCursor( UINT *args )
2426 {
2427 return HandleToUlong( NtUserGetCursor() );
2428 }
2429
2430 NTSTATUS WINAPI wow64_NtUserGetCursorFrameInfo( UINT *args )
2431 {
2432 HCURSOR cursor = get_ptr( &args );
2433 DWORD istep = get_ulong( &args );
2434 DWORD *rate_jiffies = get_ptr( &args );
2435 DWORD *num_steps = get_ptr( &args );
2436
2437 return HandleToUlong( NtUserGetCursorFrameInfo( cursor, istep, rate_jiffies, num_steps ));
2438 }
2439
2440 NTSTATUS WINAPI wow64_NtUserGetCursorInfo( UINT *args )
2441 {
2442 struct
2443 {
2444 DWORD cbSize;
2445 DWORD flags;
2446 ULONG hCursor;
2447 POINT ptScreenPos;
2448 } *info32 = get_ptr( &args );
2449 CURSORINFO info;
2450
2451 if (!info32) return FALSE;
2452 info.cbSize = sizeof(info);
2453 if (!NtUserGetCursorInfo( &info )) return FALSE;
2454 info32->flags = info.flags;
2455 info32->hCursor = HandleToUlong( info.hCursor );
2456 info32->ptScreenPos = info.ptScreenPos;
2457 return TRUE;
2458 }
2459
2460 NTSTATUS WINAPI wow64_NtUserGetDC( UINT *args )
2461 {
2462 HWND hwnd = get_handle( &args );
2463
2464 return HandleToUlong( NtUserGetDC( hwnd ));
2465 }
2466
2467 NTSTATUS WINAPI wow64_NtUserGetDCEx( UINT *args )
2468 {
2469 HWND hwnd = get_handle( &args );
2470 HRGN clip_rgn = get_handle( &args );
2471 DWORD flags = get_ulong( &args );
2472
2473 return HandleToUlong( NtUserGetDCEx( hwnd, clip_rgn, flags ));
2474 }
2475
2476 NTSTATUS WINAPI wow64_NtUserGetDisplayConfigBufferSizes( UINT *args )
2477 {
2478 UINT32 flags = get_ulong( &args );
2479 UINT32 *num_path_info = get_ptr( &args );
2480 UINT32 *num_mode_info = get_ptr( &args );
2481
2482 return NtUserGetDisplayConfigBufferSizes( flags, num_path_info, num_mode_info );
2483 }
2484
2485 NTSTATUS WINAPI wow64_NtUserGetDoubleClickTime( UINT *args )
2486 {
2487 return NtUserGetDoubleClickTime();
2488 }
2489
2490 NTSTATUS WINAPI wow64_NtUserGetDpiForMonitor( UINT *args )
2491 {
2492 HMONITOR monitor = get_handle( &args );
2493 UINT type = get_ulong( &args );
2494 UINT *x = get_ptr( &args );
2495 UINT *y = get_ptr( &args );
2496
2497 return NtUserGetDpiForMonitor( monitor, type, x, y );
2498 }
2499
2500 NTSTATUS WINAPI wow64_NtUserGetForegroundWindow( UINT *args )
2501 {
2502 return HandleToUlong( NtUserGetForegroundWindow() );
2503 }
2504
2505 NTSTATUS WINAPI wow64_NtUserGetGUIThreadInfo( UINT *args )
2506 {
2507 DWORD id = get_ulong( &args );
2508 struct
2509 {
2510 DWORD cbSize;
2511 DWORD flags;
2512 ULONG hwndActive;
2513 ULONG hwndFocus;
2514 ULONG hwndCapture;
2515 ULONG hwndMenuOwner;
2516 ULONG hwndMoveSize;
2517 ULONG hwndCaret;
2518 RECT rcCaret;
2519 } *info32 = get_ptr( &args );
2520 GUITHREADINFO info;
2521
2522 if (info32->cbSize != sizeof(*info32))
2523 {
2524 set_last_error32( ERROR_INVALID_PARAMETER );
2525 return FALSE;
2526 }
2527
2528 info.cbSize = sizeof(info);
2529 if (!NtUserGetGUIThreadInfo( id, &info )) return FALSE;
2530 info32->flags = info.flags;
2531 info32->hwndActive = HandleToUlong( info.hwndActive );
2532 info32->hwndFocus = HandleToUlong( info.hwndFocus );
2533 info32->hwndCapture = HandleToUlong( info.hwndCapture );
2534 info32->hwndMenuOwner = HandleToUlong( info.hwndMenuOwner );
2535 info32->hwndMoveSize = HandleToUlong( info.hwndMoveSize );
2536 info32->hwndCaret = HandleToUlong( info.hwndCaret );
2537 info32->rcCaret = info.rcCaret;
2538 return TRUE;
2539 }
2540
2541 NTSTATUS WINAPI wow64_NtUserGetIconInfo( UINT *args )
2542 {
2543 HICON icon = get_handle( &args );
2544 struct
2545 {
2546 BOOL fIcon;
2547 DWORD xHotspot;
2548 DWORD yHotspot;
2549 UINT32 hbmMask;
2550 UINT32 hbmColor;
2551 } *info32 = get_ptr( &args );
2552 UNICODE_STRING32 *module32 = get_ptr( &args );
2553 UNICODE_STRING32 *res_name32 = get_ptr( &args );
2554 DWORD *bpp = get_ptr( &args );
2555 LONG unk = get_ulong( &args );
2556
2557 ICONINFO info;
2558 UNICODE_STRING module, res_name;
2559
2560 if (!NtUserGetIconInfo( icon, &info, unicode_str_32to64( &module, module32 ),
2561 unicode_str_32to64( &res_name, res_name32 ), bpp, unk ))
2562 return FALSE;
2563
2564 info32->fIcon = info.fIcon;
2565 info32->xHotspot = info.xHotspot;
2566 info32->yHotspot = info.yHotspot;
2567 info32->hbmMask = HandleToUlong( info.hbmMask );
2568 info32->hbmColor = HandleToUlong( info.hbmColor );
2569 if (module32)
2570 {
2571 module32->Buffer = PtrToUlong( module.Buffer );
2572 module32->Length = module.Length;
2573 }
2574 if (res_name32)
2575 {
2576 res_name32->Buffer = PtrToUlong( res_name.Buffer );
2577 res_name32->Length = res_name.Length;
2578 }
2579 return TRUE;
2580 }
2581
2582 NTSTATUS WINAPI wow64_NtUserGetIconSize( UINT *args )
2583 {
2584 HICON handle = get_handle( &args );
2585 UINT step = get_ulong( &args );
2586 LONG *width = get_ptr( &args );
2587 LONG *height = get_ptr( &args );
2588
2589 return NtUserGetIconSize( handle, step, width, height );
2590 }
2591
2592 NTSTATUS WINAPI wow64_NtUserGetInternalWindowPos( UINT *args )
2593 {
2594 HWND hwnd = get_handle( &args );
2595 RECT *rect = get_ptr( &args );
2596 POINT *pt = get_ptr( &args );
2597
2598 return NtUserGetInternalWindowPos( hwnd, rect, pt );
2599 }
2600
2601 NTSTATUS WINAPI wow64_NtUserGetKeyNameText( UINT *args )
2602 {
2603 LONG lparam = get_ulong( &args );
2604 WCHAR *buffer = get_ptr( &args );
2605 INT size = get_ulong( &args );
2606
2607 return NtUserGetKeyNameText( lparam, buffer, size );
2608 }
2609
2610 NTSTATUS WINAPI wow64_NtUserGetKeyState( UINT *args )
2611 {
2612 INT vkey = get_ulong( &args );
2613
2614 return NtUserGetKeyState( vkey );
2615 }
2616
2617 NTSTATUS WINAPI wow64_NtUserGetKeyboardLayout( UINT *args )
2618 {
2619 DWORD tid = get_ulong( &args );
2620
2621 return HandleToUlong( NtUserGetKeyboardLayout( tid ));
2622 }
2623
2624 NTSTATUS WINAPI wow64_NtUserGetKeyboardLayoutList( UINT *args )
2625 {
2626 INT size = get_ulong( &args );
2627 UINT32 *layouts32 = get_ptr( &args );
2628 HKL *layouts = NULL;
2629 UINT ret, i;
2630
2631 if (layouts32 && size && !(layouts = Wow64AllocateTemp( size * sizeof(*layouts) )))
2632 return 0;
2633
2634 ret = NtUserGetKeyboardLayoutList( size, layouts );
2635 if (layouts)
2636 for (i = 0; i < ret; i++) layouts32[i] = HandleToUlong( layouts[i] );
2637 return ret;
2638 }
2639
2640 NTSTATUS WINAPI wow64_NtUserGetKeyboardLayoutName( UINT *args )
2641 {
2642 WCHAR *name = get_ptr( &args );
2643
2644 return NtUserGetKeyboardLayoutName( name );
2645 }
2646
2647 NTSTATUS WINAPI wow64_NtUserGetKeyboardState( UINT *args )
2648 {
2649 BYTE *state = get_ptr( &args );
2650
2651 return NtUserGetKeyboardState( state );
2652 }
2653
2654 NTSTATUS WINAPI wow64_NtUserGetLayeredWindowAttributes( UINT *args )
2655 {
2656 HWND hwnd = get_handle( &args );
2657 COLORREF *key = get_ptr( &args );
2658 BYTE *alpha = get_ptr( &args );
2659 DWORD *flags = get_ptr( &args );
2660
2661 return NtUserGetLayeredWindowAttributes( hwnd, key, alpha, flags );
2662 }
2663
2664 NTSTATUS WINAPI wow64_NtUserGetMenuBarInfo( UINT *args )
2665 {
2666 HWND hwnd = get_handle( &args );
2667 LONG id = get_ulong( &args );
2668 LONG item = get_ulong( &args );
2669 struct
2670 {
2671 DWORD cbSize;
2672 RECT rcBar;
2673 ULONG hMenu;
2674 ULONG hwndMenu;
2675 BOOL fBarFocused:1;
2676 BOOL fFocused:1;
2677 } *info32 = get_ptr( &args );
2678
2679 MENUBARINFO info;
2680
2681 if (info32->cbSize != sizeof(*info32))
2682 {
2683 set_last_error32( ERROR_INVALID_PARAMETER );
2684 return FALSE;
2685 }
2686
2687 info.cbSize = sizeof(info);
2688 if (!NtUserGetMenuBarInfo( hwnd, id, item, &info )) return FALSE;
2689 info32->rcBar = info.rcBar;
2690 info32->hMenu = HandleToUlong( info.hMenu );
2691 info32->hwndMenu = HandleToUlong( info.hwndMenu );
2692 info32->fBarFocused = info.fBarFocused;
2693 info32->fFocused = info.fFocused;
2694 return TRUE;
2695 }
2696
2697 NTSTATUS WINAPI wow64_NtUserGetMenuItemRect( UINT *args )
2698 {
2699 HWND hwnd = get_handle( &args );
2700 HMENU handle = get_handle( &args );
2701 UINT item = get_ulong( &args );
2702 RECT *rect = get_ptr( &args );
2703
2704 return NtUserGetMenuItemRect( hwnd, handle, item, rect );
2705 }
2706
2707 NTSTATUS WINAPI wow64_NtUserGetMessage( UINT *args )
2708 {
2709 MSG32 *msg32 = get_ptr( &args );
2710 HWND hwnd = get_handle( &args );
2711 UINT first = get_ulong( &args );
2712 UINT last = get_ulong( &args );
2713 MSG msg;
2714 int ret;
2715
2716 ret = NtUserGetMessage( &msg, hwnd, first, last );
2717 if (ret != -1) msg_64to32( &msg, msg32 );
2718 return ret;
2719 }
2720
2721 NTSTATUS WINAPI wow64_NtUserGetMouseMovePointsEx( UINT *args )
2722 {
2723 UINT size = get_ulong( &args );
2724 MOUSEMOVEPOINT32 *ptin32 = get_ptr( &args );
2725 MOUSEMOVEPOINT32 *ptout32 = get_ptr( &args );
2726 int count = get_ulong( &args );
2727 DWORD resolution = get_ulong( &args );
2728
2729 MOUSEMOVEPOINT ptin[64], ptout[64];
2730 int ret, i;
2731
2732 if (size != sizeof(MOUSEMOVEPOINT32) || count < 0 || count > ARRAYSIZE( ptin ))
2733 {
2734 set_last_error32( ERROR_INVALID_PARAMETER );
2735 return -1;
2736 }
2737
2738 if (!ptin32 || (!ptout32 && count))
2739 {
2740 set_last_error32( ERROR_NOACCESS );
2741 return -1;
2742 }
2743
2744 for (i = 0; i < count; i++)
2745 {
2746 ptin[i].x = ptin32[i].x;
2747 ptin[i].y = ptin32[i].y;
2748 ptin[i].time = ptin32[i].time;
2749 ptin[i].dwExtraInfo = ptin32[i].dwExtraInfo;
2750 }
2751
2752 ret = NtUserGetMouseMovePointsEx( sizeof(MOUSEMOVEPOINT), ptin, ptout, count, resolution );
2753
2754 for (i = 0; i < ret; i++)
2755 {
2756 ptout32[i].x = ptout[i].x;
2757 ptout32[i].y = ptout[i].y;
2758 ptout32[i].time = ptout[i].time;
2759 ptout32[i].dwExtraInfo = ptout[i].dwExtraInfo;
2760 }
2761
2762 return ret;
2763 }
2764
2765 NTSTATUS WINAPI wow64_NtUserGetObjectInformation( UINT *args )
2766 {
2767 HANDLE handle = get_handle( &args );
2768 INT index = get_ulong( &args );
2769 void *info = get_ptr( &args );
2770 DWORD len = get_ulong( &args );
2771 DWORD *needed = get_ptr( &args );
2772
2773 return NtUserGetObjectInformation( handle, index, info, len, needed );
2774 }
2775
2776 NTSTATUS WINAPI wow64_NtUserGetOpenClipboardWindow( UINT *args )
2777 {
2778 return HandleToUlong( NtUserGetOpenClipboardWindow() );
2779 }
2780
2781 NTSTATUS WINAPI wow64_NtUserGetPointerInfoList( UINT *args )
2782 {
2783 UINT id = get_ulong( &args );
2784 UINT type = get_ulong( &args );
2785 UINT unk0 = get_ulong( &args );
2786 UINT unk1 = get_ulong( &args );
2787 UINT size = get_ulong( &args );
2788 void *entry_count = get_ptr( &args );
2789 void *pointer_count = get_ptr( &args );
2790 void *pointer_info = get_ptr( &args );
2791
2792 return NtUserGetPointerInfoList( id, type, unk0, unk1, size, entry_count, pointer_count, pointer_info );
2793 }
2794
2795 NTSTATUS WINAPI wow64_NtUserGetPriorityClipboardFormat( UINT *args )
2796 {
2797 UINT *list = get_ptr( &args );
2798 INT count = get_ulong( &args );
2799
2800 return NtUserGetPriorityClipboardFormat( list, count );
2801 }
2802
2803 NTSTATUS WINAPI wow64_NtUserGetProcessDpiAwarenessContext( UINT *args )
2804 {
2805 HANDLE process = get_handle( &args );
2806
2807 return NtUserGetProcessDpiAwarenessContext( process );
2808 }
2809
2810 NTSTATUS WINAPI wow64_NtUserGetProcessWindowStation( UINT *args )
2811 {
2812 return HandleToUlong( NtUserGetProcessWindowStation() );
2813 }
2814
2815 NTSTATUS WINAPI wow64_NtUserGetProp( UINT *args )
2816 {
2817 HWND hwnd = get_handle( &args );
2818 const WCHAR *str = get_ptr( &args );
2819
2820 return HandleToUlong( NtUserGetProp( hwnd, str ));
2821 }
2822
2823 NTSTATUS WINAPI wow64_NtUserGetQueueStatus( UINT *args )
2824 {
2825 UINT flags = get_ulong( &args );
2826
2827 return NtUserGetQueueStatus( flags );
2828 }
2829
2830 NTSTATUS WINAPI wow64_NtUserGetRawInputBuffer( UINT *args )
2831 {
2832 RAWINPUT *data = get_ptr( &args );
2833 UINT *data_size = get_ptr( &args );
2834 UINT header_size = get_ulong( &args );
2835
2836 if (header_size != sizeof(RAWINPUTHEADER32))
2837 {
2838 set_last_error32( ERROR_INVALID_PARAMETER );
2839 return ~0u;
2840 }
2841
2842 /* RAWINPUT has different sizes on 32-bit and 64-bit, but no translation is
2843 * done. The function actually returns different structures depending on
2844 * whether it's operating under WoW64 or not. */
2845 return NtUserGetRawInputBuffer( data, data_size, sizeof(RAWINPUTHEADER) );
2846 }
2847
2848 NTSTATUS WINAPI wow64_NtUserGetRawInputData( UINT *args )
2849 {
2850 HRAWINPUT handle = get_handle( &args );
2851 UINT command = get_ulong( &args );
2852 void *data = get_ptr( &args );
2853 UINT *data_size = get_ptr( &args );
2854 UINT header_size = get_ulong( &args );
2855
2856 if (header_size != sizeof(RAWINPUTHEADER32))
2857 {
2858 set_last_error32( ERROR_INVALID_PARAMETER );
2859 return ~0u;
2860 }
2861
2862 switch (command)
2863 {
2864 case RID_INPUT:
2865 if (data)
2866 {
2867 UINT data_size64, body_size, ret;
2868 RAWINPUTHEADER32 *data32 = data;
2869 RAWINPUTHEADER *data64 = NULL;
2870
2871 data_size64 = *data_size + sizeof(RAWINPUTHEADER);
2872 if (!(data64 = Wow64AllocateTemp( data_size64 )))
2873 {
2874 set_last_error32( STATUS_NO_MEMORY );
2875 return ~0u;
2876 }
2877
2878 ret = NtUserGetRawInputData( handle, command, data64, &data_size64, sizeof(RAWINPUTHEADER) );
2879 if (ret == ~0u) return ret;
2880
2881 body_size = ret - sizeof(RAWINPUTHEADER);
2882 if (*data_size < sizeof(RAWINPUTHEADER32) + body_size)
2883 {
2884 set_last_error32( ERROR_INSUFFICIENT_BUFFER );
2885 return ~0u;
2886 }
2887
2888 data32->dwType = data64->dwType;
2889 data32->dwSize = sizeof(RAWINPUTHEADER32) + body_size;
2890 data32->hDevice = (UINT_PTR)data64->hDevice;
2891 data32->wParam = data64->wParam;
2892 memcpy( data32 + 1, data64 + 1, body_size );
2893 return sizeof(RAWINPUTHEADER32) + body_size;
2894 }
2895 else
2896 {
2897 UINT data_size64, ret;
2898
2899 ret = NtUserGetRawInputData( handle, command, NULL, &data_size64, sizeof(RAWINPUTHEADER) );
2900 if (ret == ~0u) return ret;
2901 *data_size = data_size64 - sizeof(RAWINPUTHEADER) + sizeof(RAWINPUTHEADER32);
2902 return 0;
2903 }
2904
2905 case RID_HEADER:
2906 {
2907 UINT data_size64 = sizeof(RAWINPUTHEADER);
2908 RAWINPUTHEADER32 *data32 = data;
2909 RAWINPUTHEADER data64;
2910 UINT ret;
2911
2912 if (!data)
2913 {
2914 *data_size = sizeof(RAWINPUTHEADER32);
2915 return 0;
2916 }
2917
2918 if (*data_size < sizeof(RAWINPUTHEADER32))
2919 {
2920 set_last_error32( ERROR_INSUFFICIENT_BUFFER );
2921 return ~0u;
2922 }
2923
2924 ret = NtUserGetRawInputData( handle, command, &data64, &data_size64, sizeof(RAWINPUTHEADER) );
2925 if (ret == ~0u) return ret;
2926 data32->dwType = data64.dwType;
2927 data32->dwSize = data64.dwSize - sizeof(RAWINPUTHEADER) + sizeof(RAWINPUTHEADER32);
2928 data32->hDevice = (UINT_PTR)data64.hDevice;
2929 data32->wParam = data64.wParam;
2930 return sizeof(RAWINPUTHEADER32);
2931 }
2932
2933 default:
2934 set_last_error32( ERROR_INVALID_PARAMETER );
2935 return ~0u;
2936 }
2937 }
2938
2939 NTSTATUS WINAPI wow64_NtUserGetRawInputDeviceInfo( UINT *args )
2940 {
2941 HANDLE handle = get_handle( &args );
2942 UINT command = get_ulong( &args );
2943 void *data = get_ptr( &args );
2944 UINT *data_size = get_ptr( &args );
2945
2946 return NtUserGetRawInputDeviceInfo( handle, command, data, data_size );
2947 }
2948
2949 NTSTATUS WINAPI wow64_NtUserGetRawInputDeviceList( UINT *args )
2950 {
2951 RAWINPUTDEVICELIST32 *devices32 = get_ptr( &args );
2952 UINT *count = get_ptr( &args );
2953 UINT size = get_ulong( &args );
2954
2955 if (size != sizeof(RAWINPUTDEVICELIST32))
2956 {
2957 set_last_error32( ERROR_INVALID_PARAMETER );
2958 return ~0u;
2959 }
2960
2961 if (devices32)
2962 {
2963 RAWINPUTDEVICELIST *devices64;
2964 unsigned int ret, i;
2965
2966 if (!(devices64 = Wow64AllocateTemp( (*count) * sizeof(*devices64) )))
2967 {
2968 set_last_error32( ERROR_NOT_ENOUGH_MEMORY );
2969 return ~0u;
2970 }
2971
2972 ret = NtUserGetRawInputDeviceList( devices64, count, sizeof(RAWINPUTDEVICELIST) );
2973 if (ret == ~0u) return ret;
2974
2975 for (i = 0; i < *count; ++i)
2976 {
2977 devices32[i].hDevice = (UINT_PTR)devices64[i].hDevice;
2978 devices32[i].dwType = devices64[i].dwType;
2979 }
2980 return ret;
2981 }
2982 else
2983 {
2984 return NtUserGetRawInputDeviceList( NULL, count, sizeof(RAWINPUTDEVICELIST) );
2985 }
2986 }
2987
2988 NTSTATUS WINAPI wow64_NtUserRealChildWindowFromPoint( UINT *args )
2989 {
2990 HWND parent = get_handle( &args );
2991 LONG x = get_ulong( &args );
2992 LONG y = get_ulong( &args );
2993
2994 return HandleToUlong( NtUserRealChildWindowFromPoint( parent, x, y ));
2995 }
2996
2997 NTSTATUS WINAPI wow64_NtUserRegisterClassExWOW( UINT *args )
2998 {
2999 const WNDCLASSEXW32 *wc32 = get_ptr( &args );
3000 UNICODE_STRING32 *name32 = get_ptr( &args );
3001 UNICODE_STRING32 *version32 = get_ptr( &args );
3002 struct client_menu_name32 *client_name32 = get_ptr( &args );
3003 DWORD fnid = get_ulong( &args );
3004 DWORD flags = get_ulong( &args );
3005 DWORD *wow = get_ptr( &args );
3006
3007 struct client_menu_name client_name;
3008 UNICODE_STRING name, version;
3009 WNDCLASSEXW wc;
3010
3011 if (wc32->cbSize != sizeof(*wc32))
3012 {
3013 set_last_error32( ERROR_INVALID_PARAMETER );
3014 return 0;
3015 }
3016
3017 wc.cbSize = sizeof(wc);
3018 wc.style = wc32->style;
3019 wc.lpfnWndProc = UlongToPtr( wc32->lpfnWndProc );
3020 wc.cbClsExtra = wc32->cbClsExtra;
3021 wc.cbWndExtra = wc32->cbWndExtra;
3022 wc.hInstance = UlongToPtr( wc32->hInstance );
3023 wc.hIcon = LongToHandle( wc32->hIcon );
3024 wc.hCursor = LongToHandle( wc32->hCursor );
3025 wc.hbrBackground = UlongToHandle( wc32->hbrBackground );
3026 wc.lpszMenuName = UlongToPtr( wc32->lpszMenuName );
3027 wc.lpszClassName = UlongToPtr( wc32->lpszClassName );
3028 wc.hIconSm = LongToHandle( wc32->hIconSm );
3029
3030 return NtUserRegisterClassExWOW( &wc,
3031 unicode_str_32to64( &name, name32 ),
3032 unicode_str_32to64( &version, version32 ),
3033 client_menu_name_32to64( &client_name, client_name32 ),
3034 fnid, flags, wow );
3035 }
3036
3037 NTSTATUS WINAPI wow64_NtUserGetRegisteredRawInputDevices( UINT *args )
3038 {
3039 RAWINPUTDEVICE32 *devices32 = get_ptr( &args );
3040 UINT *count = get_ptr( &args );
3041 UINT size = get_ulong( &args );
3042
3043 if (size != sizeof(RAWINPUTDEVICE32))
3044 {
3045 set_last_error32( ERROR_INVALID_PARAMETER );
3046 return ~0u;
3047 }
3048
3049 if (devices32)
3050 {
3051 RAWINPUTDEVICE *devices64;
3052 unsigned int ret, i;
3053
3054 if (!(devices64 = Wow64AllocateTemp( (*count) * sizeof(*devices64) )))
3055 {
3056 set_last_error32( ERROR_NOT_ENOUGH_MEMORY );
3057 return ~0u;
3058 }
3059
3060 ret = NtUserGetRegisteredRawInputDevices( devices64, count, sizeof(RAWINPUTDEVICE) );
3061 if (ret == ~0u) return ret;
3062
3063 for (i = 0; i < *count; ++i)
3064 {
3065 devices32[i].usUsagePage = devices64[i].usUsagePage;
3066 devices32[i].usUsage = devices64[i].usUsage;
3067 devices32[i].dwFlags = devices64[i].dwFlags;
3068 devices32[i].hwndTarget = (ULONG_PTR)devices64[i].hwndTarget;
3069 }
3070 return ret;
3071 }
3072 else
3073 {
3074 return NtUserGetRegisteredRawInputDevices( NULL, count, sizeof(RAWINPUTDEVICE) );
3075 }
3076 }
3077
3078 NTSTATUS WINAPI wow64_NtUserGetScrollBarInfo( UINT *args )
3079 {
3080 HWND hwnd = get_handle( &args );
3081 LONG id = get_ulong( &args );
3082 SCROLLBARINFO *info = get_ptr( &args );
3083
3084 return NtUserGetScrollBarInfo( hwnd, id, info );
3085 }
3086
3087 NTSTATUS WINAPI wow64_NtUserGetSystemDpiForProcess( UINT *args )
3088 {
3089 HANDLE process = get_handle( &args );
3090
3091 return NtUserGetSystemDpiForProcess( process );
3092 }
3093
3094 NTSTATUS WINAPI wow64_NtUserGetSystemMenu( UINT *args )
3095 {
3096 HWND hwnd = get_handle( &args );
3097 BOOL revert = get_ulong( &args );
3098
3099 return HandleToUlong( NtUserGetSystemMenu( hwnd, revert ));
3100 }
3101
3102 NTSTATUS WINAPI wow64_NtUserGetThreadDesktop( UINT *args )
3103 {
3104 DWORD thread = get_ulong( &args );
3105
3106 return HandleToUlong( NtUserGetThreadDesktop( thread ));
3107 }
3108
3109 NTSTATUS WINAPI wow64_NtUserGetTitleBarInfo( UINT *args )
3110 {
3111 HWND hwnd = get_handle( &args );
3112 TITLEBARINFO *info = get_ptr( &args );
3113
3114 return NtUserGetTitleBarInfo( hwnd, info );
3115 }
3116
3117 NTSTATUS WINAPI wow64_NtUserGetUpdateRect( UINT *args )
3118 {
3119 HWND hwnd = get_handle( &args );
3120 RECT *rect = get_ptr( &args );
3121 BOOL erase = get_ulong( &args );
3122
3123 return NtUserGetUpdateRect( hwnd, rect, erase );
3124 }
3125
3126 NTSTATUS WINAPI wow64_NtUserGetUpdateRgn( UINT *args )
3127 {
3128 HWND hwnd = get_handle( &args );
3129 HRGN hrgn = get_handle( &args );
3130 BOOL erase = get_ulong( &args );
3131
3132 return NtUserGetUpdateRgn( hwnd, hrgn, erase );
3133 }
3134
3135 NTSTATUS WINAPI wow64_NtUserGetUpdatedClipboardFormats( UINT *args )
3136 {
3137 UINT *formats = get_ptr( &args );
3138 UINT size = get_ulong( &args );
3139 UINT *out_size = get_ptr( &args );
3140
3141 return NtUserGetUpdatedClipboardFormats( formats, size, out_size );
3142 }
3143
3144 NTSTATUS WINAPI wow64_NtUserGetWindowDC( UINT *args )
3145 {
3146 HWND hwnd = get_handle( &args );
3147
3148 return HandleToUlong( NtUserGetWindowDC( hwnd ));
3149 }
3150
3151 NTSTATUS WINAPI wow64_NtUserGetWindowPlacement( UINT *args )
3152 {
3153 HWND hwnd = get_handle( &args );
3154 WINDOWPLACEMENT *placement = get_ptr( &args );
3155
3156 return NtUserGetWindowPlacement( hwnd, placement );
3157 }
3158
3159 NTSTATUS WINAPI wow64_NtUserGetWindowRgnEx( UINT *args )
3160 {
3161 HWND hwnd = get_handle( &args );
3162 HRGN hrgn = get_handle( &args );
3163 UINT unk = get_ulong( &args );
3164
3165 return NtUserGetWindowRgnEx( hwnd, hrgn, unk );
3166 }
3167
3168 NTSTATUS WINAPI wow64_NtUserHideCaret( UINT *args )
3169 {
3170 HWND hwnd = get_handle( &args );
3171
3172 return NtUserHideCaret( hwnd );
3173 }
3174
3175 NTSTATUS WINAPI wow64_NtUserHiliteMenuItem( UINT *args )
3176 {
3177 HWND hwnd = get_handle( &args );
3178 HMENU handle = get_handle( &args );
3179 UINT item = get_ulong( &args );
3180 UINT hilite = get_ulong( &args );
3181
3182 return NtUserHiliteMenuItem( hwnd, handle, item, hilite );
3183 }
3184
3185 struct user_client_procs32
3186 {
3187 ULONG pButtonWndProc;
3188 ULONG pComboWndProc;
3189 ULONG pDefWindowProc;
3190 ULONG pDefDlgProc;
3191 ULONG pEditWndProc;
3192 ULONG pListBoxWndProc;
3193 ULONG pMDIClientWndProc;
3194 ULONG pScrollBarWndProc;
3195 ULONG pStaticWndProc;
3196 ULONG pImeWndProc;
3197 ULONG pDesktopWndProc;
3198 ULONG pIconTitleWndProc;
3199 ULONG pPopupMenuWndProc;
3200 ULONG pMessageWndProc;
3201 };
3202
3203 static struct user_client_procs *user_client_procs_32to64( struct user_client_procs *procs,
3204 const struct user_client_procs32 *procs32 )
3205 {
3206 if (!procs32) return NULL;
3207
3208 procs->pButtonWndProc = UlongToPtr( procs32->pButtonWndProc );
3209 procs->pComboWndProc = UlongToPtr( procs32->pComboWndProc );
3210 procs->pDefWindowProc = UlongToPtr( procs32->pDefWindowProc );
3211 procs->pDefDlgProc = UlongToPtr( procs32->pDefDlgProc );
3212 procs->pEditWndProc = UlongToPtr( procs32->pEditWndProc );
3213 procs->pListBoxWndProc = UlongToPtr( procs32->pListBoxWndProc );
3214 procs->pMDIClientWndProc = UlongToPtr( procs32->pMDIClientWndProc );
3215 procs->pScrollBarWndProc = UlongToPtr( procs32->pScrollBarWndProc );
3216 procs->pStaticWndProc = UlongToPtr( procs32->pStaticWndProc );
3217 procs->pImeWndProc = UlongToPtr( procs32->pImeWndProc );
3218 procs->pDesktopWndProc = UlongToPtr( procs32->pDesktopWndProc );
3219 procs->pIconTitleWndProc = UlongToPtr( procs32->pIconTitleWndProc );
3220 procs->pPopupMenuWndProc = UlongToPtr( procs32->pPopupMenuWndProc );
3221 procs->pMessageWndProc = UlongToPtr( procs32->pMessageWndProc );
3222 return procs;
3223 }
3224
3225 NTSTATUS WINAPI wow64_NtUserInitializeClientPfnArrays( UINT *args )
3226 {
3227 const struct user_client_procs32 *procsA32 = get_ptr( &args );
3228 const struct user_client_procs32 *procsW32 = get_ptr( &args );
3229 void *workers = get_ptr( &args );
3230 HINSTANCE user_module = get_ptr( &args );
3231
3232 struct user_client_procs procsA, procsW;
3233 return NtUserInitializeClientPfnArrays( user_client_procs_32to64( &procsA, procsA32 ),
3234 user_client_procs_32to64( &procsW, procsW32 ),
3235 workers, user_module );
3236 }
3237
3238 NTSTATUS WINAPI wow64_NtUserInternalGetWindowIcon( UINT *args )
3239 {
3240 HWND hwnd = get_handle( &args );
3241 UINT type = get_ulong( &args );
3242
3243 return HandleToUlong( NtUserInternalGetWindowIcon( hwnd, type ));
3244 }
3245
3246 NTSTATUS WINAPI wow64_NtUserInternalGetWindowText( UINT *args )
3247 {
3248 HWND hwnd = get_handle( &args );
3249 WCHAR *text = get_ptr( &args );
3250 INT count = get_ulong( &args );
3251
3252 return NtUserInternalGetWindowText( hwnd, text, count );
3253 }
3254
3255 NTSTATUS WINAPI wow64_NtUserInvalidateRect( UINT *args )
3256 {
3257 HWND hwnd = get_handle( &args );
3258 const RECT *rect = get_ptr( &args );
3259 BOOL erase = get_ulong( &args );
3260
3261 return NtUserInvalidateRect( hwnd, rect, erase );
3262 }
3263
3264 NTSTATUS WINAPI wow64_NtUserInvalidateRgn( UINT *args )
3265 {
3266 HWND hwnd = get_handle( &args );
3267 HRGN hrgn = get_handle( &args );
3268 BOOL erase = get_ulong( &args );
3269
3270 return NtUserInvalidateRgn( hwnd, hrgn, erase );
3271 }
3272
3273 NTSTATUS WINAPI wow64_NtUserIsClipboardFormatAvailable( UINT *args )
3274 {
3275 UINT format = get_ulong( &args );
3276
3277 return NtUserIsClipboardFormatAvailable( format );
3278 }
3279
3280 NTSTATUS WINAPI wow64_NtUserIsMouseInPointerEnabled( UINT *args )
3281 {
3282 return NtUserIsMouseInPointerEnabled();
3283 }
3284
3285 NTSTATUS WINAPI wow64_NtUserKillTimer( UINT *args )
3286 {
3287 HWND hwnd = get_handle( &args );
3288 UINT_PTR id = get_ulong( &args );
3289
3290 return NtUserKillTimer( hwnd, id );
3291 }
3292
3293 NTSTATUS WINAPI wow64_NtUserLockWindowUpdate( UINT *args )
3294 {
3295 HWND hwnd = get_handle( &args );
3296
3297 return NtUserLockWindowUpdate( hwnd );
3298 }
3299
3300 NTSTATUS WINAPI wow64_NtUserLogicalToPerMonitorDPIPhysicalPoint( UINT *args )
3301 {
3302 HWND hwnd = get_handle( &args );
3303 POINT *pt = get_ptr( &args );
3304
3305 return NtUserLogicalToPerMonitorDPIPhysicalPoint( hwnd, pt );
3306 }
3307
3308 NTSTATUS WINAPI wow64_NtUserMapVirtualKeyEx( UINT *args )
3309 {
3310 UINT code = get_ulong( &args );
3311 UINT type = get_ulong( &args );
3312 HKL layout = get_handle( &args );
3313
3314 return NtUserMapVirtualKeyEx( code, type, layout );
3315 }
3316
3317 NTSTATUS WINAPI wow64_NtUserMenuItemFromPoint( UINT *args )
3318 {
3319 HWND hwnd = get_handle( &args );
3320 HMENU handle = get_handle( &args );
3321 int x = get_ulong( &args );
3322 int y = get_ulong( &args );
3323
3324 return NtUserMenuItemFromPoint( hwnd, handle, x, y );
3325 }
3326
3327 static LRESULT message_call_32to64( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam,
3328 void *result_info, DWORD type, BOOL ansi )
3329 {
3330 LRESULT ret = 0;
3331
3332 switch (msg)
3333 {
3334 case WM_NCCREATE:
3335 case WM_CREATE:
3336 if (lparam)
3337 {
3338 CREATESTRUCT32 *cs32 = (void *)lparam;
3339 CREATESTRUCTW cs;
3340
3341 createstruct_32to64( cs32, &cs );
3342 ret = NtUserMessageCall( hwnd, msg, wparam, (LPARAM)&cs, result_info, type, ansi );
3343 cs32->lpCreateParams = PtrToUlong( cs.lpCreateParams );
3344 cs32->hInstance = PtrToUlong( cs.hInstance );
3345 cs32->hMenu = HandleToLong( cs.hMenu );
3346 cs32->hwndParent = HandleToLong( cs.hwndParent );
3347 cs32->cy = cs.cy;
3348 cs32->cx = cs.cx;
3349 cs32->y = cs.y;
3350 cs32->x = cs.x;
3351 cs32->style = cs.style;
3352 cs32->dwExStyle = cs.dwExStyle;
3353 return ret;
3354 }
3355 return NtUserMessageCall( hwnd, msg, wparam, lparam, result_info, type, ansi );
3356
3357 case WM_MDICREATE:
3358 {
3359 MDICREATESTRUCT32 *cs32 = (void *)lparam;
3360 MDICREATESTRUCTW cs;
3361
3362 cs.szClass = UlongToPtr( cs32->szClass );
3363 cs.szTitle = UlongToPtr( cs32->szTitle );
3364 cs.hOwner = LongToHandle( cs32->hOwner );
3365 cs.x = cs32->x;
3366 cs.y = cs32->y;
3367 cs.cx = cs32->cx;
3368 cs.cy = cs32->cy;
3369 cs.style = cs32->style;
3370 cs.lParam = cs32->lParam;
3371
3372 return NtUserMessageCall( hwnd, msg, wparam, (LPARAM)&cs, result_info, type, ansi );
3373 }
3374
3375 case WM_WINDOWPOSCHANGING:
3376 case WM_WINDOWPOSCHANGED:
3377 {
3378 WINDOWPOS32 *winpos32 = (void *)lparam;
3379 WINDOWPOS winpos;
3380
3381 winpos_32to64( &winpos, winpos32 );
3382 ret = NtUserMessageCall( hwnd, msg, wparam, (LPARAM)&winpos, result_info, type, ansi );
3383 winpos_64to32( &winpos, winpos32 );
3384 return ret;
3385 }
3386
3387 case WM_NCCALCSIZE:
3388 if (wparam)
3389 {
3390 NCCALCSIZE_PARAMS32 *params32 = (void *)lparam;
3391 NCCALCSIZE_PARAMS params;
3392 WINDOWPOS winpos;
3393
3394 params.rgrc[0] = params32->rgrc[0];
3395 params.rgrc[1] = params32->rgrc[1];
3396 params.rgrc[2] = params32->rgrc[2];
3397 params.lppos = &winpos;
3398 winpos_32to64( &winpos, UlongToPtr( params32->lppos ));
3399 ret = NtUserMessageCall( hwnd, msg, wparam, (LPARAM)&params, result_info, type, ansi );
3400 params32->rgrc[0] = params.rgrc[0];
3401 params32->rgrc[1] = params.rgrc[1];
3402 params32->rgrc[2] = params.rgrc[2];
3403 winpos_64to32( &winpos, UlongToPtr( params32->lppos ));
3404 return ret;
3405 }
3406 return NtUserMessageCall( hwnd, msg, wparam, lparam, result_info, type, ansi );
3407
3408 case WM_COMPAREITEM:
3409 {
3410 COMPAREITEMSTRUCT32 *cis32 = (void *)lparam;
3411 COMPAREITEMSTRUCT cis;
3412
3413 cis.CtlType = cis32->CtlType;
3414 cis.CtlID = cis32->CtlID;
3415 cis.hwndItem = LongToHandle( cis32->hwndItem );
3416 cis.itemID1 = cis32->itemID1;
3417 cis.itemData1 = cis32->itemData1;
3418 cis.itemID2 = cis32->itemID2;
3419 cis.itemData2 = cis32->itemData2;
3420 cis.dwLocaleId = cis32->dwLocaleId;
3421 return NtUserMessageCall( hwnd, msg, wparam, (LPARAM)&cis, result_info, type, ansi );
3422 }
3423
3424 case WM_DELETEITEM:
3425 {
3426 DELETEITEMSTRUCT32 *dis32 = (void *)lparam;
3427 DELETEITEMSTRUCT dis;
3428
3429 dis.CtlType = dis32->CtlType;
3430 dis.CtlID = dis32->CtlID;
3431 dis.itemID = dis32->itemID;
3432 dis.hwndItem = LongToHandle( dis32->hwndItem );
3433 dis.itemData = dis32->itemData;
3434 return NtUserMessageCall( hwnd, msg, wparam, (LPARAM)&dis, result_info, type, ansi );
3435 }
3436
3437 case WM_MEASUREITEM:
3438 {
3439 MEASUREITEMSTRUCT32 *mis32 = (void *)lparam;
3440 MEASUREITEMSTRUCT mis;
3441
3442 mis.CtlType = mis32->CtlType;
3443 mis.CtlID = mis32->CtlID;
3444 mis.itemID = mis32->itemID;
3445 mis.itemWidth = mis32->itemWidth;
3446 mis.itemHeight = mis32->itemHeight;
3447 mis.itemData = mis32->itemData;
3448 ret = NtUserMessageCall( hwnd, msg, wparam, (LPARAM)&mis, result_info, type, ansi );
3449 mis32->CtlType = mis.CtlType;
3450 mis32->CtlID = mis.CtlID;
3451 mis32->itemID = mis.itemID;
3452 mis32->itemWidth = mis.itemWidth;
3453 mis32->itemHeight = mis.itemHeight;
3454 mis32->itemData = mis.itemData;
3455 return ret;
3456 }
3457
3458 case WM_DRAWITEM:
3459 {
3460 DRAWITEMSTRUCT32 *dis32 = (void *)lparam;
3461 DRAWITEMSTRUCT dis;
3462
3463 dis.CtlType = dis32->CtlType;
3464 dis.CtlID = dis32->CtlID;
3465 dis.itemID = dis32->itemID;
3466 dis.itemAction = dis32->itemAction;
3467 dis.itemState = dis32->itemState;
3468 dis.hwndItem = LongToHandle( dis32->hwndItem );
3469 dis.hDC = LongToHandle( dis32->hDC );
3470 dis.itemData = dis32->itemData;
3471 dis.rcItem.left = dis32->rcItem.left;
3472 dis.rcItem.top = dis32->rcItem.top;
3473 dis.rcItem.right = dis32->rcItem.right;
3474 dis.rcItem.bottom = dis32->rcItem.bottom;
3475 return NtUserMessageCall( hwnd, msg, wparam, (LPARAM)&dis, result_info, type, ansi );
3476 }
3477
3478 case WM_COPYDATA:
3479 {
3480 COPYDATASTRUCT32 *cds32 = (void *)lparam;
3481 COPYDATASTRUCT cds;
3482
3483 cds.dwData = cds32->dwData;
3484 cds.cbData = cds32->cbData;
3485 cds.lpData = UlongToPtr( cds32->lpData );
3486 return NtUserMessageCall( hwnd, msg, wparam, (LPARAM)&cds, result_info, type, ansi );
3487 }
3488
3489 case WM_HELP:
3490 {
3491 HELPINFO32 *hi32 = (void *)lparam;
3492 HELPINFO hi64;
3493
3494 hi64.cbSize = sizeof(hi64);
3495 hi64.iContextType = hi32->iContextType;
3496 hi64.iCtrlId = hi32->iCtrlId;
3497 hi64.hItemHandle = LongToHandle( hi32->hItemHandle );
3498 hi64.dwContextId = hi32->dwContextId;
3499 hi64.MousePos = hi32->MousePos;
3500 return NtUserMessageCall( hwnd, msg, wparam, (LPARAM)&hi64, result_info, type, ansi );
3501 }
3502
3503 case WM_GETDLGCODE:
3504 if (lparam)
3505 {
3506 MSG32 *msg32 = (MSG32 *)lparam;
3507 MSG msg64;
3508
3509 return NtUserMessageCall( hwnd, msg, wparam, (LPARAM)msg_32to64( &msg64, msg32 ),
3510 result_info, type, ansi );
3511 }
3512 return NtUserMessageCall( hwnd, msg, wparam, lparam, result_info, type, ansi );
3513
3514 case WM_NEXTMENU:
3515 {
3516 MDINEXTMENU32 *next32 = (void *)lparam;
3517 MDINEXTMENU next;
3518
3519 next.hmenuIn = LongToHandle( next32->hmenuIn );
3520 next.hmenuNext = LongToHandle( next32->hmenuNext );
3521 next.hwndNext = LongToHandle( next32->hwndNext );
3522 ret = NtUserMessageCall( hwnd, msg, wparam, (LPARAM)&next, result_info, type, ansi );
3523 next32->hmenuIn = HandleToLong( next.hmenuIn );
3524 next32->hmenuNext = HandleToLong( next.hmenuNext );
3525 next32->hwndNext = HandleToLong( next.hwndNext );
3526 return ret;
3527 }
3528
3529 case WM_PAINTCLIPBOARD:
3530 {
3531 PAINTSTRUCT ps;
3532
3533 paintstruct_32to64( &ps, (PAINTSTRUCT32 *)lparam );
3534 return NtUserMessageCall( hwnd, msg, wparam, (LPARAM)&ps, result_info, type, ansi );
3535 }
3536
3537 case CB_GETCOMBOBOXINFO:
3538 {
3539 COMBOBOXINFO32 *ci32 = (COMBOBOXINFO32 *)lparam;
3540 COMBOBOXINFO ci;
3541
3542 ci.cbSize = ci32->cbSize;
3543 ci.rcItem = ci32->rcItem;
3544 ci.rcButton = ci32->rcButton;
3545 ci.stateButton = ci32->stateButton;
3546 ci.hwndCombo = LongToHandle( ci32->hwndCombo );
3547 ci.hwndItem = LongToHandle( ci32->hwndItem );
3548 ci.hwndList = LongToHandle( ci32->hwndList );
3549 ret = NtUserMessageCall( hwnd, msg, wparam, (LPARAM)&ci, result_info, type, ansi );
3550 ci32->cbSize = ci.cbSize;
3551 ci32->rcItem = ci.rcItem;
3552 ci32->rcButton = ci.rcButton;
3553 ci32->stateButton = ci.stateButton;
3554 ci32->hwndCombo = HandleToLong( ci.hwndCombo );
3555 ci32->hwndItem = HandleToLong( ci.hwndItem );
3556 ci32->hwndList = HandleToLong( ci.hwndList );
3557 return ret;
3558 }
3559
3560 default:
3561 return NtUserMessageCall( hwnd, msg, wparam, lparam, result_info, type, ansi );
3562 }
3563 }
3564
3565 NTSTATUS WINAPI wow64_NtUserMessageCall( UINT *args )
3566 {
3567 HWND hwnd = get_handle( &args );
3568 UINT msg = get_ulong( &args );
3569 LONG wparam = get_ulong( &args );
3570 LONG lparam = get_ulong( &args );
3571 void *result_info = get_ptr( &args );
3572 UINT type = get_ulong ( &args );
3573 BOOL ansi = get_ulong( &args );
3574
3575 switch (type)
3576 {
3577 case NtUserGetDispatchParams:
3578 case NtUserCallWindowProc:
3579 {
3580 struct win_proc_params32 *params32 = result_info;
3581 struct win_proc_params params;
3582
3583 if (type == NtUserCallWindowProc) params.func = UlongToPtr( params32->func );
3584
3585 if (!NtUserMessageCall( hwnd, msg, wparam, lparam, &params, type, ansi ))
3586 return FALSE;
3587
3588 win_proc_params_64to32( &params, params32 );
3589 return TRUE;
3590 }
3591
3592 case NtUserSendMessage:
3593 {
3594 struct win_proc_params32 *params32 = result_info;
3595
3596 if (params32)
3597 {
3598 struct win_proc_params params;
3599 NTSTATUS ret;
3600
3601 params.hwnd = 0;
3602 ret = message_call_32to64( hwnd, msg, wparam, lparam, &params, type, ansi );
3603 if (params.hwnd) win_proc_params_64to32( &params, params32 );
3604 return ret;
3605 }
3606
3607 return message_call_32to64( hwnd, msg, wparam, lparam, result_info, type, ansi );
3608 }
3609
3610 case NtUserSendMessageTimeout:
3611 {
3612 struct
3613 {
3614 UINT flags;
3615 UINT timeout;
3616 DWORD result;
3617 } *params32 = result_info;
3618 struct send_message_timeout_params params;
3619 LRESULT ret;
3620
3621 params.flags = params32->flags;
3622 params.timeout = params32->timeout;
3623 ret = message_call_32to64( hwnd, msg, wparam, lparam, &params, type, ansi );
3624 params32->result = params.result;
3625 return ret;
3626 }
3627
3628 case NtUserSendMessageCallback:
3629 {
3630 struct
3631 {
3632 ULONG callback;
3633 ULONG data;
3634 } *params32 = result_info;
3635 struct send_message_callback_params params;
3636
3637 params.callback = UlongToPtr( params32->callback );
3638 params.data = params32->data;
3639 return message_call_32to64( hwnd, msg, wparam, lparam, &params, type, ansi );
3640 }
3641
3642 case NtUserSpyGetMsgName:
3643 /* no argument conversion */
3644 return NtUserMessageCall( hwnd, msg, wparam, lparam, result_info, type, ansi );
3645
3646 case NtUserImeDriverCall:
3647 {
3648 struct
3649 {
3650 ULONG himc;
3651 ULONG state;
3652 ULONG compstr;
3653 } *params32 = result_info;
3654 struct ime_driver_call_params params;
3655 if (msg == WINE_IME_POST_UPDATE) ERR( "Unexpected WINE_IME_POST_UPDATE message\n" );
3656 params.himc = UlongToPtr( params32->himc );
3657 params.state = UlongToPtr( params32->state );
3658 params.compstr = UlongToPtr( params32->compstr );
3659 return NtUserMessageCall( hwnd, msg, wparam, lparam, &params, type, ansi );
3660 }
3661
3662 case NtUserSystemTrayCall:
3663 switch (msg)
3664 {
3665 case WINE_SYSTRAY_NOTIFY_ICON:
3666 {
3667 struct
3668 {
3669 DWORD cbSize;
3670 ULONG hWnd;
3671 UINT uID;
3672 UINT uFlags;
3673 UINT uCallbackMessage;
3674 ULONG hIcon;
3675 WCHAR szTip[128];
3676 DWORD dwState;
3677 DWORD dwStateMask;
3678 WCHAR szInfo[256];
3679 UINT uTimeout;
3680 WCHAR szInfoTitle[64];
3681 DWORD dwInfoFlags;
3682 GUID guidItem;
3683 ULONG hBalloonIcon;
3684 } *params32 = result_info;
3685
3686 NOTIFYICONDATAW params = {.cbSize = sizeof(params)};
3687 params.hWnd = UlongToHandle( params32->hWnd );
3688 params.uID = params32->uID;
3689 params.uFlags = params32->uFlags;
3690 params.uCallbackMessage = params32->uCallbackMessage;
3691 params.hIcon = UlongToHandle( params32->hIcon );
3692 if (params.uFlags & NIF_TIP) wcscpy( params.szTip, params32->szTip );
3693 params.dwState = params32->dwState;
3694 params.dwStateMask = params32->dwStateMask;
3695
3696 if (params.uFlags & NIF_INFO)
3697 {
3698 wcscpy( params.szInfoTitle, params32->szInfoTitle );
3699 wcscpy( params.szInfo, params32->szInfo );
3700 params.uTimeout = params32->uTimeout;
3701 params.dwInfoFlags = params32->dwInfoFlags;
3702 }
3703
3704 params.guidItem = params32->guidItem;
3705 params.hBalloonIcon = UlongToHandle( params32->hBalloonIcon );
3706
3707 return NtUserMessageCall( hwnd, msg, wparam, lparam, &params, type, ansi );
3708 }
3709
3710 default:
3711 return NtUserMessageCall( hwnd, msg, wparam, lparam, result_info, type, ansi );
3712 }
3713 }
3714
3715 return message_call_32to64( hwnd, msg, wparam, lparam, result_info, type, ansi );
3716 }
3717
3718 NTSTATUS WINAPI wow64_NtUserMoveWindow( UINT *args )
3719 {
3720 HWND hwnd = get_handle( &args );
3721 INT x = get_ulong( &args );
3722 INT y = get_ulong( &args );
3723 INT cx = get_ulong( &args );
3724 INT cy = get_ulong( &args );
3725 BOOL repaint = get_ulong( &args );
3726
3727 return NtUserMoveWindow( hwnd, x, y, cx, cy, repaint );
3728 }
3729
3730 NTSTATUS WINAPI wow64_NtUserMsgWaitForMultipleObjectsEx( UINT *args )
3731 {
3732 DWORD count = get_ulong( &args );
3733 const ULONG *handles32 = get_ptr( &args );
3734 DWORD timeout = get_ulong( &args );
3735 DWORD mask = get_ulong( &args );
3736 DWORD flags = get_ulong( &args );
3737
3738 HANDLE handles[MAXIMUM_WAIT_OBJECTS];
3739 unsigned int i;
3740
3741 if (count > ARRAYSIZE(handles))
3742 {
3743 set_last_error32( ERROR_INVALID_PARAMETER );
3744 return WAIT_FAILED;
3745 }
3746 for (i = 0; i < count; i++) handles[i] = LongToHandle( handles32[i] );
3747
3748 return NtUserMsgWaitForMultipleObjectsEx( count, handles, timeout, mask, flags );
3749 }
3750
3751 NTSTATUS WINAPI wow64_NtUserNotifyIMEStatus( UINT *args )
3752 {
3753 HWND hwnd = get_handle( &args );
3754 ULONG status = get_ulong( &args );
3755
3756 NtUserNotifyIMEStatus( hwnd, status );
3757 return 0;
3758 }
3759
3760 NTSTATUS WINAPI wow64_NtUserNotifyWinEvent( UINT *args )
3761 {
3762 DWORD event = get_ulong( &args );
3763 HWND hwnd = get_handle( &args );
3764 LONG object_id = get_ulong( &args );
3765 LONG child_id = get_ulong( &args );
3766
3767 NtUserNotifyWinEvent( event, hwnd, object_id, child_id );
3768 return 0;
3769 }
3770
3771 NTSTATUS WINAPI wow64_NtUserOpenClipboard( UINT *args )
3772 {
3773 HWND hwnd = get_handle( &args );
3774 ULONG unk = get_ulong( &args );
3775
3776 return NtUserOpenClipboard( hwnd, unk );
3777 }
3778
3779 NTSTATUS WINAPI wow64_NtUserOpenDesktop( UINT *args )
3780 {
3781 OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
3782 DWORD flags = get_ulong( &args );
3783 ACCESS_MASK access = get_ulong( &args );
3784
3785 struct object_attr64 attr;
3786 HANDLE ret;
3787
3788 ret = NtUserOpenDesktop( objattr_32to64( &attr, attr32 ), flags, access );
3789 return HandleToUlong( ret );
3790 }
3791
3792 NTSTATUS WINAPI wow64_NtUserOpenInputDesktop( UINT *args )
3793 {
3794 DWORD flags = get_ulong( &args );
3795 BOOL inherit = get_ulong( &args );
3796 ACCESS_MASK access = get_ulong( &args );
3797
3798 return HandleToUlong( NtUserOpenInputDesktop( flags, inherit, access ));
3799 }
3800
3801 NTSTATUS WINAPI wow64_NtUserOpenWindowStation( UINT *args )
3802 {
3803 OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
3804 ACCESS_MASK access = get_ulong( &args );
3805
3806 struct object_attr64 attr;
3807
3808 return HandleToUlong( NtUserOpenWindowStation( objattr_32to64( &attr, attr32 ), access ));
3809 }
3810
3811 NTSTATUS WINAPI wow64_NtUserPeekMessage( UINT *args )
3812 {
3813 MSG32 *msg32 = get_ptr( &args );
3814 HWND hwnd = get_handle( &args );
3815 UINT first = get_ulong( &args );
3816 UINT last = get_ulong( &args );
3817 UINT flags = get_ulong( &args );
3818 MSG msg;
3819
3820 if (!NtUserPeekMessage( msg32 ? &msg : NULL, hwnd, first, last, flags )) return FALSE;
3821 msg_64to32( &msg, msg32 );
3822 return TRUE;
3823 }
3824
3825 NTSTATUS WINAPI wow64_NtUserPerMonitorDPIPhysicalToLogicalPoint( UINT *args )
3826 {
3827 HWND hwnd = get_handle( &args );
3828 POINT *pt = get_ptr( &args );
3829
3830 return NtUserPerMonitorDPIPhysicalToLogicalPoint( hwnd, pt );
3831 }
3832
3833 NTSTATUS WINAPI wow64_NtUserPostMessage( UINT *args )
3834 {
3835 HWND hwnd = get_handle( &args );
3836 UINT msg = get_ulong( &args );
3837 WPARAM wparam = get_ulong( &args );
3838 LPARAM lparam = get_ulong( &args );
3839
3840 return NtUserPostMessage( hwnd, msg, wparam, lparam );
3841 }
3842
3843 NTSTATUS WINAPI wow64_NtUserPostThreadMessage( UINT *args )
3844 {
3845 DWORD thread = get_ulong( &args );
3846 UINT msg = get_ulong( &args );
3847 WPARAM wparam = get_ulong( &args );
3848 LPARAM lparam = get_ulong( &args );
3849
3850 return NtUserPostThreadMessage( thread, msg, wparam, lparam );
3851 }
3852
3853 NTSTATUS WINAPI wow64_NtUserPrintWindow( UINT *args )
3854 {
3855 HWND hwnd = get_handle( &args );
3856 HDC hdc = get_handle( &args );
3857 UINT flags = get_ulong( &args );
3858
3859 return NtUserPrintWindow( hwnd, hdc, flags );
3860 }
3861
3862 NTSTATUS WINAPI wow64_NtUserQueryDisplayConfig( UINT *args )
3863 {
3864 UINT32 flags = get_ulong( &args );
3865 UINT32 *paths_count = get_ptr( &args );
3866 DISPLAYCONFIG_PATH_INFO *paths = get_ptr( &args );
3867 UINT32 *modes_count = get_ptr( &args );
3868 DISPLAYCONFIG_MODE_INFO *modes = get_ptr( &args );
3869 DISPLAYCONFIG_TOPOLOGY_ID *topology_id = get_ptr( &args );
3870
3871 return NtUserQueryDisplayConfig( flags, paths_count, paths, modes_count, modes, topology_id );
3872 }
3873
3874 NTSTATUS WINAPI wow64_NtUserQueryInputContext( UINT *args )
3875 {
3876 HIMC handle = get_handle( &args );
3877 UINT attr = get_ulong( &args );
3878
3879 return NtUserQueryInputContext( handle, attr );
3880 }
3881
3882 NTSTATUS WINAPI wow64_NtUserRedrawWindow( UINT *args )
3883 {
3884 HWND hwnd = get_handle( &args );
3885 const RECT *rect = get_ptr( &args );
3886 HRGN hrgn = get_handle( &args );
3887 UINT flags = get_ulong( &args );
3888
3889 return NtUserRedrawWindow( hwnd, rect, hrgn, flags );
3890 }
3891
3892 NTSTATUS WINAPI wow64_NtUserRegisterHotKey( UINT *args )
3893 {
3894 HWND hwnd = get_handle( &args );
3895 INT id = get_ulong( &args );
3896 UINT modifiers = get_ulong( &args );
3897 UINT vk = get_ulong( &args );
3898
3899 return NtUserRegisterHotKey( hwnd, id, modifiers, vk );
3900 }
3901
3902 NTSTATUS WINAPI wow64_NtUserRegisterRawInputDevices( UINT *args )
3903 {
3904 const RAWINPUTDEVICE32 *devices32 = get_ptr( &args );
3905 UINT count = get_ulong( &args );
3906 UINT size = get_ulong( &args );
3907
3908 RAWINPUTDEVICE *devices64;
3909 unsigned int i;
3910
3911 if (size != sizeof(RAWINPUTDEVICE32))
3912 {
3913 set_last_error32( ERROR_INVALID_PARAMETER );
3914 return FALSE;
3915 }
3916
3917 if (!(devices64 = Wow64AllocateTemp( count * sizeof(*devices64) )))
3918 {
3919 set_last_error32( ERROR_NOT_ENOUGH_MEMORY );
3920 return FALSE;
3921 }
3922
3923 for (i = 0; i < count; ++i)
3924 {
3925 devices64[i].usUsagePage = devices32[i].usUsagePage;
3926 devices64[i].usUsage = devices32[i].usUsage;
3927 devices64[i].dwFlags = devices32[i].dwFlags;
3928 devices64[i].hwndTarget = UlongToPtr( devices32[i].hwndTarget );
3929 }
3930
3931 return NtUserRegisterRawInputDevices( devices64, count, sizeof(*devices64) );
3932 }
3933
3934 NTSTATUS WINAPI wow64_NtUserReleaseDC( UINT *args )
3935 {
3936 HWND hwnd = get_handle( &args );
3937 HDC hdc = get_handle( &args );
3938
3939 return NtUserReleaseDC( hwnd, hdc );
3940 }
3941
3942 NTSTATUS WINAPI wow64_NtUserRemoveClipboardFormatListener( UINT *args )
3943 {
3944 HWND hwnd = get_handle( &args );
3945
3946 return NtUserRemoveClipboardFormatListener( hwnd );
3947 }
3948
3949 NTSTATUS WINAPI wow64_NtUserRemoveMenu( UINT *args )
3950 {
3951 HMENU handle = get_handle( &args );
3952 UINT id = get_ulong( &args );
3953 UINT flags = get_ulong( &args );
3954
3955 return NtUserRemoveMenu( handle, id, flags );
3956 }
3957
3958 NTSTATUS WINAPI wow64_NtUserRemoveProp( UINT *args )
3959 {
3960 HWND hwnd = get_handle( &args );
3961 const WCHAR *str = get_ptr( &args );
3962
3963 return HandleToUlong( NtUserRemoveProp( hwnd, str ));
3964 }
3965
3966 NTSTATUS WINAPI wow64_NtUserScrollDC( UINT *args )
3967 {
3968 HDC hdc = get_handle( &args );
3969 INT dx = get_ulong( &args );
3970 INT dy = get_ulong( &args );
3971 const RECT *scroll = get_ptr( &args );
3972 const RECT *clip = get_ptr( &args );
3973 HRGN ret_update_rgn = get_handle( &args );
3974 RECT *update_rect = get_ptr( &args );
3975
3976 return NtUserScrollDC( hdc, dx, dy, scroll, clip, ret_update_rgn, update_rect );
3977 }
3978
3979 NTSTATUS WINAPI wow64_NtUserScrollWindowEx( UINT *args )
3980 {
3981 HWND hwnd = get_handle( &args );
3982 INT dx = get_ulong( &args );
3983 INT dy = get_ulong( &args );
3984 const RECT *rect = get_ptr( &args );
3985 const RECT *clip_rect = get_ptr( &args );
3986 HRGN update_rgn = get_handle( &args );
3987 RECT *update_rect = get_ptr( &args );
3988 UINT flags = get_ulong( &args );
3989
3990 return NtUserScrollWindowEx( hwnd, dx, dy, rect, clip_rect, update_rgn, update_rect, flags );
3991 }
3992
3993 NTSTATUS WINAPI wow64_NtUserSelectPalette( UINT *args )
3994 {
3995 HDC hdc = get_handle( &args );
3996 HPALETTE hpal = get_handle( &args );
3997 WORD bkg = get_ulong( &args );
3998
3999 return HandleToUlong( NtUserSelectPalette( hdc, hpal, bkg ));
4000 }
4001
4002 NTSTATUS WINAPI wow64_NtUserSendInput( UINT *args )
4003 {
4004 UINT count = get_ulong( &args );
4005 INPUT32 *inputs32 = get_ptr( &args );
4006 int size = get_ulong( &args );
4007
4008 INPUT *inputs = NULL;
4009 unsigned int i;
4010
4011 if (size != sizeof(*inputs32) || !count)
4012 {
4013 set_last_error32( ERROR_INVALID_PARAMETER );
4014 return 0;
4015 }
4016
4017 if (!inputs32)
4018 {
4019 set_last_error32( ERROR_NOACCESS );
4020 return 0;
4021 }
4022
4023 if (count && !(inputs = Wow64AllocateTemp( count * sizeof(*inputs) )))
4024 return 0;
4025
4026 for (i = 0; i < count; i++)
4027 {
4028 inputs[i].type = inputs32[i].type;
4029 switch (inputs[i].type)
4030 {
4031 case INPUT_MOUSE:
4032 inputs[i].mi.dx = inputs32[i].mi.dx;
4033 inputs[i].mi.dy = inputs32[i].mi.dy;
4034 inputs[i].mi.mouseData = inputs32[i].mi.mouseData;
4035 inputs[i].mi.dwFlags = inputs32[i].mi.dwFlags;
4036 inputs[i].mi.time = inputs32[i].mi.time;
4037 inputs[i].mi.dwExtraInfo = inputs32[i].mi.dwExtraInfo;
4038 break;
4039 case INPUT_KEYBOARD:
4040 inputs[i].ki.wVk = inputs32[i].ki.wVk;
4041 inputs[i].ki.wScan = inputs32[i].ki.wScan;
4042 inputs[i].ki.dwFlags = inputs32[i].ki.dwFlags;
4043 inputs[i].ki.time = inputs32[i].ki.time;
4044 inputs[i].ki.dwExtraInfo = inputs32[i].ki.dwExtraInfo;
4045 break;
4046 case INPUT_HARDWARE:
4047 inputs[i].hi = inputs32[i].hi;
4048 break;
4049 }
4050 }
4051
4052 return NtUserSendInput( count, inputs, sizeof(*inputs) );
4053 }
4054
4055 NTSTATUS WINAPI wow64_NtUserSetActiveWindow( UINT *args )
4056 {
4057 HWND hwnd = get_handle( &args );
4058
4059 return HandleToUlong( NtUserSetActiveWindow( hwnd ));
4060 }
4061
4062 NTSTATUS WINAPI wow64_NtUserSetCapture( UINT *args )
4063 {
4064 HWND hwnd = get_handle( &args );
4065
4066 return HandleToUlong( NtUserSetCapture( hwnd ));
4067 }
4068
4069 NTSTATUS WINAPI wow64_NtUserSetClassLong( UINT *args )
4070 {
4071 HWND hwnd = get_handle( &args );
4072 INT offset = get_ulong( &args );
4073 LONG newval = get_ulong( &args );
4074 BOOL ansi = get_ulong( &args );
4075
4076 return NtUserSetClassLong( hwnd, offset, newval, ansi );
4077 }
4078
4079 NTSTATUS WINAPI wow64_NtUserSetClassLongPtr( UINT *args )
4080 {
4081 HWND hwnd = get_handle( &args );
4082 INT offset = get_ulong( &args );
4083 LONG_PTR newval = get_ulong( &args );
4084 BOOL ansi = get_ulong( &args );
4085
4086 if (offset == GCLP_MENUNAME)
4087 {
4088 struct client_menu_name menu_name;
4089 struct client_menu_name32 *menu_name32 = UlongToPtr( newval );
4090 NtUserSetClassLongPtr( hwnd, offset,
4091 (UINT_PTR)client_menu_name_32to64( &menu_name, menu_name32 ), ansi );
4092 client_menu_name_64to32( &menu_name, menu_name32 );
4093 return 0;
4094 }
4095
4096 return NtUserSetClassLongPtr( hwnd, offset, newval, ansi );
4097 }
4098
4099 NTSTATUS WINAPI wow64_NtUserSetClassWord( UINT *args )
4100 {
4101 HWND hwnd = get_handle( &args );
4102 INT offset = get_ulong( &args );
4103 WORD newval = get_ulong( &args );
4104
4105 return NtUserSetClassWord( hwnd, offset, newval );
4106 }
4107
4108 NTSTATUS WINAPI wow64_NtUserSetClipboardData( UINT *args )
4109 {
4110 UINT format = get_ulong( &args );
4111 HANDLE handle = get_handle( &args );
4112 struct
4113 {
4114 UINT32 data;
4115 UINT32 size;
4116 BOOL cache_only;
4117 UINT seqno;
4118 } *params32 = get_ptr( &args );
4119
4120 struct set_clipboard_params params;
4121 params.data = UlongToPtr( params32->data );
4122 params.size = params32->size;
4123 params.cache_only = params32->cache_only;
4124 params.seqno = params32->seqno;
4125
4126 return NtUserSetClipboardData( format, handle, &params );
4127 }
4128
4129 NTSTATUS WINAPI wow64_NtUserSetClipboardViewer( UINT *args )
4130 {
4131 HWND hwnd = get_handle( &args );
4132
4133 return HandleToUlong( NtUserSetClipboardViewer( hwnd ));
4134 }
4135
4136 NTSTATUS WINAPI wow64_NtUserSetCursor( UINT *args )
4137 {
4138 HCURSOR cursor = get_handle( &args );
4139
4140 return HandleToUlong( NtUserSetCursor( cursor ));
4141 }
4142
4143 NTSTATUS WINAPI wow64_NtUserSetCursorIconData( UINT *args )
4144 {
4145 HCURSOR cursor = get_handle( &args );
4146 UNICODE_STRING32 *module32 = get_ptr( &args );
4147 UNICODE_STRING32 *res_name32 = get_ptr( &args );
4148 struct
4149 {
4150 UINT flags;
4151 UINT num_steps;
4152 UINT num_frames;
4153 UINT delay;
4154 ULONG frames;
4155 ULONG frame_seq;
4156 ULONG frame_rates;
4157 ULONG rsrc;
4158 } *desc32 = get_ptr( &args );
4159 struct
4160 {
4161 UINT width;
4162 UINT height;
4163 ULONG color;
4164 ULONG alpha;
4165 ULONG mask;
4166 POINT hotspot;
4167 } *frames32 = UlongToPtr( desc32->frames );
4168
4169 UNICODE_STRING module, res_name;
4170 struct cursoricon_desc desc;
4171 UINT i, num_frames;
4172
4173 num_frames = max( desc32->num_frames, 1 );
4174 if (!(desc.frames = Wow64AllocateTemp( num_frames * sizeof(*desc.frames) ))) return FALSE;
4175 desc.flags = desc32->flags;
4176 desc.num_steps = desc32->num_steps;
4177 desc.num_frames = desc32->num_frames;
4178 desc.delay = desc32->delay;
4179 desc.frame_seq = UlongToPtr( desc32->frame_seq );
4180 desc.frame_rates = UlongToPtr( desc32->frame_rates );
4181 desc.rsrc = UlongToPtr( desc32->rsrc );
4182
4183 for (i = 0; i < num_frames; i++)
4184 {
4185 desc.frames[i].width = frames32[i].width;
4186 desc.frames[i].height = frames32[i].height;
4187 desc.frames[i].color = UlongToHandle( frames32[i].color );
4188 desc.frames[i].alpha = UlongToHandle( frames32[i].alpha );
4189 desc.frames[i].mask = UlongToHandle( frames32[i].mask );
4190 desc.frames[i].hotspot = frames32[i].hotspot;
4191 }
4192
4193 return NtUserSetCursorIconData( cursor, unicode_str_32to64( &module, module32 ),
4194 unicode_str_32to64( &res_name, res_name32), &desc );
4195 }
4196
4197 NTSTATUS WINAPI wow64_NtUserSetCursorPos( UINT *args )
4198 {
4199 INT x = get_ulong( &args );
4200 INT y = get_ulong( &args );
4201
4202 return NtUserSetCursorPos( x, y );
4203 }
4204
4205 NTSTATUS WINAPI wow64_NtUserSetFocus( UINT *args )
4206 {
4207 HWND hwnd = get_handle( &args );
4208
4209 return HandleToUlong( NtUserSetFocus( hwnd ));
4210 }
4211
4212 NTSTATUS WINAPI wow64_NtUserSetInternalWindowPos( UINT *args )
4213 {
4214 HWND hwnd = get_handle( &args );
4215 UINT cmd = get_ulong( &args );
4216 RECT *rect = get_ptr( &args );
4217 POINT *pt = get_ptr( &args );
4218
4219 NtUserSetInternalWindowPos( hwnd, cmd, rect, pt );
4220 return 0;
4221 }
4222
4223 NTSTATUS WINAPI wow64_NtUserSetKeyboardState( UINT *args )
4224 {
4225 BYTE *state = get_ptr( &args );
4226
4227 return NtUserSetKeyboardState( state );
4228 }
4229
4230 NTSTATUS WINAPI wow64_NtUserSetLayeredWindowAttributes( UINT *args )
4231 {
4232 HWND hwnd = get_handle( &args );
4233 COLORREF key = get_ulong( &args );
4234 BYTE alpha = get_ulong( &args );
4235 DWORD flags = get_ulong( &args );
4236
4237 return NtUserSetLayeredWindowAttributes( hwnd, key, alpha, flags );
4238 }
4239
4240 NTSTATUS WINAPI wow64_NtUserSetMenu( UINT *args )
4241 {
4242 HWND hwnd = get_handle( &args );
4243 HMENU menu = get_handle( &args );
4244
4245 return NtUserSetMenu( hwnd, menu );
4246 }
4247
4248 NTSTATUS WINAPI wow64_NtUserSetMenuContextHelpId( UINT *args )
4249 {
4250 HMENU menu = get_handle( &args );
4251 DWORD id = get_ulong( &args );
4252
4253 return NtUserSetMenuContextHelpId( menu, id );
4254 }
4255
4256 NTSTATUS WINAPI wow64_NtUserSetMenuDefaultItem( UINT *args )
4257 {
4258 HMENU handle = get_handle( &args );
4259 UINT item = get_ulong( &args );
4260 UINT bypos = get_ulong( &args );
4261
4262 return NtUserSetMenuDefaultItem( handle, item, bypos );
4263 }
4264
4265 NTSTATUS WINAPI wow64_NtUserSetObjectInformation( UINT *args )
4266 {
4267 HANDLE handle = get_handle( &args );
4268 INT index = get_ulong( &args );
4269 void *info = get_ptr( &args );
4270 DWORD len = get_ulong( &args );
4271
4272 return NtUserSetObjectInformation( handle, index, info, len );
4273 }
4274
4275 NTSTATUS WINAPI wow64_NtUserSetParent( UINT *args )
4276 {
4277 HWND hwnd = get_handle( &args );
4278 HWND parent = get_handle( &args );
4279
4280 return HandleToUlong( NtUserSetParent( hwnd, parent ));
4281 }
4282
4283 NTSTATUS WINAPI wow64_NtUserSetProcessDpiAwarenessContext( UINT *args )
4284 {
4285 ULONG awareness = get_ulong( &args );
4286 ULONG unknown = get_ulong( &args );
4287
4288 return NtUserSetProcessDpiAwarenessContext( awareness, unknown );
4289 }
4290
4291 NTSTATUS WINAPI wow64_NtUserSetProcessWindowStation( UINT *args )
4292 {
4293 HWINSTA handle = get_handle( &args );
4294
4295 return NtUserSetProcessWindowStation( handle );
4296 }
4297
4298 NTSTATUS WINAPI wow64_NtUserSetProp( UINT *args )
4299 {
4300 HWND hwnd = get_handle( &args );
4301 const WCHAR *str = get_ptr( &args );
4302 HANDLE handle = get_handle( &args );
4303
4304 return NtUserSetProp( hwnd, str, handle );
4305 }
4306
4307 NTSTATUS WINAPI wow64_NtUserSetScrollInfo( UINT *args )
4308 {
4309 HWND hwnd = get_handle( &args );
4310 INT bar = get_ulong( &args );
4311 const SCROLLINFO *info = get_ptr( &args );
4312 BOOL redraw = get_ulong( &args );
4313
4314 return NtUserSetScrollInfo( hwnd, bar, info, redraw );
4315 }
4316
4317 NTSTATUS WINAPI wow64_NtUserSetShellWindowEx( UINT *args )
4318 {
4319 HWND shell = get_handle( &args );
4320 HWND list_view = get_handle( &args );
4321
4322 return NtUserSetShellWindowEx( shell, list_view );
4323 }
4324
4325 NTSTATUS WINAPI wow64_NtUserSetSysColors( UINT *args )
4326 {
4327 INT count = get_ulong( &args );
4328 const INT *colors = get_ptr( &args );
4329 const COLORREF *values = get_ptr( &args );
4330
4331 return NtUserSetSysColors( count, colors, values );
4332 }
4333
4334 NTSTATUS WINAPI wow64_NtUserSetSystemMenu( UINT *args )
4335 {
4336 HWND hwnd = get_handle( &args );
4337 HMENU menu = get_handle( &args );
4338
4339 return NtUserSetSystemMenu( hwnd, menu );
4340 }
4341
4342 NTSTATUS WINAPI wow64_NtUserSetSystemTimer( UINT *args )
4343 {
4344 HWND hwnd = get_handle( &args );
4345 UINT_PTR id = get_ulong( &args );
4346 UINT timeout = get_ulong( &args );
4347
4348 return NtUserSetSystemTimer( hwnd, id, timeout );
4349 }
4350
4351 NTSTATUS WINAPI wow64_NtUserSetThreadDesktop( UINT *args )
4352 {
4353 HDESK handle = get_handle( &args );
4354
4355 return NtUserSetThreadDesktop( handle );
4356 }
4357
4358 NTSTATUS WINAPI wow64_NtUserSetTimer( UINT *args )
4359 {
4360 HWND hwnd = get_handle( &args );
4361 UINT_PTR id = get_ulong( &args );
4362 UINT timeout = get_ulong( &args );
4363 TIMERPROC proc = get_ptr( &args );
4364 ULONG tolerance = get_ulong( &args );
4365
4366 return NtUserSetTimer( hwnd, id, timeout, proc, tolerance );
4367 }
4368
4369 NTSTATUS WINAPI wow64_NtUserSetWinEventHook( UINT *args )
4370 {
4371 DWORD event_min = get_ulong( &args );
4372 DWORD event_max = get_ulong( &args );
4373 HMODULE inst = get_ptr( &args );
4374 UNICODE_STRING32 *module32 = get_ptr( &args );
4375 WINEVENTPROC proc = get_ptr(&args );
4376 DWORD pid = get_ulong( &args );
4377 DWORD tid = get_ulong( &args );
4378 DWORD flags = get_ulong( &args );
4379 UNICODE_STRING module;
4380 HWINEVENTHOOK ret;
4381
4382 ret = NtUserSetWinEventHook( event_min, event_max, inst,
4383 unicode_str_32to64( &module, module32 ),
4384 proc, pid, tid, flags );
4385 return HandleToUlong( ret );
4386 }
4387
4388 NTSTATUS WINAPI wow64_NtUserSetWindowLong( UINT *args )
4389 {
4390 HWND hwnd = get_handle( &args );
4391 INT offset = get_ulong( &args );
4392 LONG newval = get_ulong( &args );
4393 BOOL ansi = get_ulong( &args );
4394
4395 switch (offset)
4396 {
4397 case GWLP_HINSTANCE:
4398 case GWLP_WNDPROC:
4399 return NtUserSetWindowLongPtr( hwnd, offset, (ULONG)newval, ansi );
4400 }
4401
4402 return NtUserSetWindowLong( hwnd, offset, newval, ansi );
4403 }
4404
4405 NTSTATUS WINAPI wow64_NtUserSetWindowLongPtr( UINT *args )
4406 {
4407 HWND hwnd = get_handle( &args );
4408 INT offset = get_ulong( &args );
4409 LONG_PTR newval = get_ulong( &args );
4410 BOOL ansi = get_ulong( &args );
4411
4412 return NtUserSetWindowLongPtr( hwnd, offset, newval, ansi );
4413 }
4414
4415 NTSTATUS WINAPI wow64_NtUserSetWindowPlacement( UINT *args )
4416 {
4417 HWND hwnd = get_handle( &args );
4418 const WINDOWPLACEMENT *wpl = get_ptr( &args );
4419
4420 return NtUserSetWindowPlacement( hwnd, wpl );
4421 }
4422
4423 NTSTATUS WINAPI wow64_NtUserSetWindowPos( UINT *args )
4424 {
4425 HWND hwnd = get_handle( &args );
4426 HWND after = get_handle( &args );
4427 INT x = get_ulong( &args );
4428 INT y = get_ulong( &args );
4429 INT cx = get_ulong( &args );
4430 INT cy = get_ulong( &args );
4431 UINT flags = get_ulong( &args );
4432
4433 return NtUserSetWindowPos( hwnd, after, x, y, cx, cy, flags );
4434 }
4435
4436 NTSTATUS WINAPI wow64_NtUserSetWindowRgn( UINT *args )
4437 {
4438 HWND hwnd = get_handle( &args );
4439 HRGN hrgn = get_handle( &args );
4440 BOOL redraw = get_ulong( &args );
4441
4442 return NtUserSetWindowRgn( hwnd, hrgn, redraw );
4443 }
4444
4445 NTSTATUS WINAPI wow64_NtUserSetWindowWord( UINT *args )
4446 {
4447 HWND hwnd = get_handle( &args );
4448 INT offset = get_ulong( &args );
4449 WORD newval = get_ulong( &args );
4450
4451 return NtUserSetWindowWord( hwnd, offset, newval );
4452 }
4453
4454 NTSTATUS WINAPI wow64_NtUserSetWindowsHookEx( UINT *args )
4455 {
4456 HINSTANCE inst = get_ptr( &args );
4457 UNICODE_STRING32 *module32 = get_ptr( &args );
4458 DWORD tid = get_ulong( &args );
4459 INT id = get_ulong( &args );
4460 HOOKPROC proc = get_ptr( &args );
4461 BOOL ansi = get_ulong( &args );
4462 UNICODE_STRING module;
4463 HHOOK ret;
4464
4465 ret = NtUserSetWindowsHookEx( inst, unicode_str_32to64( &module, module32 ),
4466 tid, id, proc, ansi );
4467 return HandleToUlong( ret );
4468 }
4469
4470 NTSTATUS WINAPI wow64_NtUserShowCaret( UINT *args )
4471 {
4472 HWND hwnd = get_handle( &args );
4473
4474 return NtUserShowCaret( hwnd );
4475 }
4476
4477 NTSTATUS WINAPI wow64_NtUserShowCursor( UINT *args )
4478 {
4479 BOOL show = get_ulong( &args );
4480
4481 return NtUserShowCursor( show );
4482 }
4483
4484 NTSTATUS WINAPI wow64_NtUserShowScrollBar( UINT *args )
4485 {
4486 HWND hwnd = get_handle( &args );
4487 INT bar = get_ulong( &args );
4488 BOOL show = get_ulong( &args );
4489
4490 return NtUserShowScrollBar( hwnd, bar, show );
4491 }
4492
4493 NTSTATUS WINAPI wow64_NtUserShowWindow( UINT *args )
4494 {
4495 HWND hwnd = get_handle( &args );
4496 INT cmd = get_ulong( &args );
4497
4498 return NtUserShowWindow( hwnd, cmd );
4499 }
4500
4501 NTSTATUS WINAPI wow64_NtUserShowWindowAsync( UINT *args )
4502 {
4503 HWND hwnd = get_handle( &args );
4504 INT cmd = get_ulong( &args );
4505
4506 return NtUserShowWindowAsync( hwnd, cmd );
4507 }
4508
4509 NTSTATUS WINAPI wow64_NtUserSwitchDesktop( UINT *args )
4510 {
4511 HDESK handle = get_handle( &args );
4512
4513 return NtUserSwitchDesktop( handle );
4514 }
4515
4516 NTSTATUS WINAPI wow64_NtUserSystemParametersInfo( UINT *args )
4517 {
4518 UINT action = get_ulong( &args );
4519 UINT val = get_ulong( &args );
4520 void *ptr = get_ptr( &args );
4521 UINT winini = get_ulong( &args );
4522
4523 switch (action)
4524 {
4525 case SPI_GETSERIALKEYS:
4526 if (ptr)
4527 {
4528 struct
4529 {
4530 UINT cbSize;
4531 DWORD dwFlags;
4532 ULONG lpszActivePort;
4533 ULONG lpszPort;
4534 UINT iBaudRate;
4535 UINT iPortState;
4536 UINT iActive;
4537 } *keys32 = ptr;
4538 SERIALKEYSW keys;
4539
4540 if (keys32->cbSize != sizeof(*keys32)) return FALSE;
4541 keys.cbSize = sizeof(keys);
4542 if (!NtUserSystemParametersInfo( action, val, &keys, winini )) return FALSE;
4543 keys32->dwFlags = keys.dwFlags;
4544 keys32->lpszActivePort = PtrToUlong( keys.lpszActivePort );
4545 keys32->lpszPort = PtrToUlong( keys.lpszPort );
4546 keys32->iBaudRate = keys.iBaudRate;
4547 keys32->iPortState = keys.iPortState;
4548 keys32->iActive = keys.iActive;
4549 return TRUE;
4550 }
4551 break;
4552
4553 case SPI_GETSOUNDSENTRY:
4554 if (ptr)
4555 {
4556 struct
4557 {
4558 UINT cbSize;
4559 DWORD dwFlags;
4560 DWORD iFSTextEffect;
4561 DWORD iFSTextEffectMSec;
4562 DWORD iFSTextEffectColorBits;
4563 DWORD iFSGrafEffect;
4564 DWORD iFSGrafEffectMSec;
4565 DWORD iFSGrafEffectColor;
4566 DWORD iWindowsEffect;
4567 DWORD iWindowsEffectMSec;
4568 ULONG lpszWindowsEffectDLL;
4569 DWORD iWindowsEffectOrdinal;
4570 } *entry32 = ptr;
4571 SOUNDSENTRYW entry;
4572
4573 if (entry32->cbSize != sizeof(*entry32)) return FALSE;
4574 entry.cbSize = sizeof(entry);
4575 if (!NtUserSystemParametersInfo( action, val, &entry, winini )) return FALSE;
4576 entry32->dwFlags = entry.dwFlags;
4577 entry32->iFSTextEffect = entry.iFSTextEffect;
4578 entry32->iFSTextEffectMSec = entry.iFSTextEffectMSec;
4579 entry32->iFSTextEffectColorBits = entry.iFSTextEffectColorBits;
4580 entry32->iFSGrafEffect = entry.iFSGrafEffect;
4581 entry32->iFSGrafEffectMSec = entry.iFSGrafEffectMSec;
4582 entry32->iFSGrafEffectColor = entry.iFSGrafEffectColor;
4583 entry32->iWindowsEffect = entry.iWindowsEffect;
4584 entry32->iWindowsEffectMSec = entry.iWindowsEffectMSec;
4585 entry32->lpszWindowsEffectDLL = PtrToUlong( entry.lpszWindowsEffectDLL );
4586 entry32->iWindowsEffectOrdinal = entry.iWindowsEffectOrdinal;
4587 return TRUE;
4588 }
4589 break;
4590
4591 case SPI_GETHIGHCONTRAST:
4592 if (ptr)
4593 {
4594 struct
4595 {
4596 UINT cbSize;
4597 DWORD dwFlags;
4598 ULONG lpszDefaultScheme;
4599 } *info32 = ptr;
4600 HIGHCONTRASTW info;
4601
4602 if (info32->cbSize != sizeof(*info32)) return FALSE;
4603 info.cbSize = sizeof(info);
4604 if (!NtUserSystemParametersInfo( action, val, &info, winini )) return FALSE;
4605 info32->dwFlags = info.dwFlags;
4606 info32->lpszDefaultScheme = PtrToUlong( info.lpszDefaultScheme );
4607 return TRUE;
4608 }
4609 break;
4610 }
4611
4612 return NtUserSystemParametersInfo( action, val, ptr, winini );
4613 }
4614
4615 NTSTATUS WINAPI wow64_NtUserSystemParametersInfoForDpi( UINT *args )
4616 {
4617 UINT action = get_ulong( &args );
4618 UINT val = get_ulong( &args );
4619 void *ptr = get_ptr( &args );
4620 UINT winini = get_ulong( &args );
4621 UINT dpi = get_ulong( &args );
4622
4623 return NtUserSystemParametersInfoForDpi( action, val, ptr, winini, dpi );
4624 }
4625
4626 NTSTATUS WINAPI wow64_NtUserThunkedMenuInfo( UINT *args )
4627 {
4628 HMENU menu = get_handle( &args );
4629 MENUINFO32 *info32 = get_ptr( &args );
4630 MENUINFO info;
4631
4632 if (info32)
4633 {
4634 info.cbSize = sizeof(info);
4635 info.fMask = info32->fMask;
4636 info.dwStyle = info32->dwStyle;
4637 info.cyMax = info32->cyMax;
4638 info.hbrBack = UlongToHandle( info32->hbrBack );
4639 info.dwContextHelpID = info32->dwContextHelpID;
4640 info.dwMenuData = info32->dwMenuData;
4641 }
4642
4643 return NtUserThunkedMenuInfo( menu, info32 ? &info : NULL );
4644 }
4645
4646 NTSTATUS WINAPI wow64_NtUserThunkedMenuItemInfo( UINT *args )
4647 {
4648 HMENU handle = get_handle( &args );
4649 UINT pos = get_ulong( &args );
4650 UINT flags = get_ulong( &args );
4651 UINT method = get_ulong( &args );
4652 MENUITEMINFOW32 *info32 = get_ptr( &args );
4653 UNICODE_STRING32 *str32 = get_ptr( &args );
4654 MENUITEMINFOW info = { sizeof(info) }, *info_ptr;
4655 UNICODE_STRING str;
4656 UINT ret;
4657
4658 if (info32)
4659 {
4660 info.cbSize = sizeof(info);
4661 info.fMask = info32->fMask;
4662 switch (method)
4663 {
4664 case NtUserSetMenuItemInfo:
4665 case NtUserInsertMenuItem:
4666 info.fType = info32->fType;
4667 info.fState = info32->fState;
4668 info.wID = info32->wID;
4669 info.hSubMenu = LongToHandle( info32->hSubMenu );
4670 info.hbmpChecked = UlongToHandle( info32->hbmpChecked );
4671 info.hbmpUnchecked = UlongToHandle( info32->hbmpUnchecked );
4672 info.dwItemData = info32->dwItemData;
4673 info.dwTypeData = UlongToPtr( info32->dwTypeData );
4674 info.cch = info32->cch;
4675 info.hbmpItem = UlongToHandle( info32->hbmpItem );
4676 break;
4677 case NtUserCheckMenuRadioItem:
4678 info.cch = info32->cch;
4679 break;
4680 case NtUserGetMenuItemInfoA:
4681 case NtUserGetMenuItemInfoW:
4682 info.dwTypeData = UlongToPtr( info32->dwTypeData );
4683 info.cch = info32->cch;
4684 break;
4685 }
4686 info_ptr = &info;
4687 }
4688 else info_ptr = NULL;
4689
4690 ret = NtUserThunkedMenuItemInfo( handle, pos, flags, method, info_ptr,
4691 unicode_str_32to64( &str, str32 ));
4692
4693 if (info_ptr)
4694 {
4695 switch (method)
4696 {
4697 case NtUserGetMenuItemInfoA:
4698 case NtUserGetMenuItemInfoW:
4699 if (info.fMask & (MIIM_TYPE | MIIM_STRING | MIIM_FTYPE))
4700 info32->fType = info.fType;
4701 if (info.fMask & (MIIM_TYPE | MIIM_BITMAP))
4702 info32->hbmpItem = HandleToUlong( info.hbmpItem );
4703 if (info.fMask & (MIIM_TYPE | MIIM_STRING))
4704 {
4705 info32->dwTypeData = (UINT_PTR)info.dwTypeData;
4706 info32->cch = info.cch;
4707 }
4708 if (info.fMask & MIIM_STATE) info32->fState = info.fState;
4709 if (info.fMask & MIIM_ID) info32->wID = info.wID;
4710 info32->hSubMenu = HandleToUlong( info.hSubMenu );
4711 if (info.fMask & MIIM_CHECKMARKS)
4712 {
4713 info32->hbmpChecked = HandleToUlong( info.hbmpChecked );
4714 info32->hbmpUnchecked = HandleToUlong( info.hbmpUnchecked );
4715 }
4716 if (info.fMask & MIIM_DATA) info32->dwItemData = info.dwItemData;
4717 break;
4718 }
4719 }
4720
4721 return ret;
4722 }
4723
4724 NTSTATUS WINAPI wow64_NtUserToUnicodeEx( UINT *args )
4725 {
4726 UINT virt = get_ulong( &args );
4727 UINT scan = get_ulong( &args );
4728 const BYTE *state = get_ptr( &args );
4729 WCHAR *str = get_ptr( &args );
4730 int size = get_ulong( &args );
4731 UINT flags = get_ulong( &args );
4732 HKL layout = get_handle( &args );
4733
4734 return NtUserToUnicodeEx( virt, scan, state, str, size, flags, layout );
4735 }
4736
4737 NTSTATUS WINAPI wow64_NtUserTrackMouseEvent( UINT *args )
4738 {
4739 struct
4740 {
4741 DWORD cbSize;
4742 DWORD dwFlags;
4743 UINT32 hwndTrack;
4744 DWORD dwHoverTime;
4745 } *info32 = get_ptr( &args );
4746 TRACKMOUSEEVENT info;
4747 BOOL ret;
4748
4749 if (info32->cbSize != sizeof(*info32))
4750 {
4751 set_last_error32( ERROR_INVALID_PARAMETER );
4752 return FALSE;
4753 }
4754
4755 info.cbSize = sizeof(info);
4756 info.dwFlags = info32->dwFlags;
4757 info.hwndTrack = LongToHandle( info32->hwndTrack );
4758 info.dwHoverTime = info32->dwHoverTime;
4759 ret = NtUserTrackMouseEvent( &info );
4760 info32->dwFlags = info.dwFlags;
4761 info32->hwndTrack = HandleToUlong( info.hwndTrack );
4762 info32->dwHoverTime = info.dwHoverTime;
4763 return ret;
4764 }
4765
4766 NTSTATUS WINAPI wow64_NtUserTrackPopupMenuEx( UINT *args )
4767 {
4768 HMENU handle = get_handle( &args );
4769 UINT flags = get_ulong( &args );
4770 int x = get_ulong( &args );
4771 int y = get_ulong( &args );
4772 HWND hwnd = get_handle( &args );
4773 TPMPARAMS *params = get_ptr( &args );
4774
4775 return NtUserTrackPopupMenuEx( handle, flags, x, y, hwnd, params );
4776 }
4777
4778 NTSTATUS WINAPI wow64_NtUserTranslateAccelerator( UINT *args )
4779 {
4780 HWND hwnd = get_handle( &args );
4781 HACCEL accel = get_handle( &args );
4782 MSG32 *msg32 = get_ptr( &args );
4783
4784 MSG msg;
4785
4786 return NtUserTranslateAccelerator( hwnd, accel, msg_32to64( &msg, msg32 ));
4787 }
4788
4789 NTSTATUS WINAPI wow64_NtUserTranslateMessage( UINT *args )
4790 {
4791 const MSG32 *msg32 = get_ptr( &args );
4792 UINT flags = get_ulong( &args );
4793 MSG msg;
4794
4795 return NtUserTranslateMessage( msg_32to64( &msg, msg32 ), flags );
4796 }
4797
4798 NTSTATUS WINAPI wow64_NtUserUnhookWinEvent( UINT *args )
4799 {
4800 HWINEVENTHOOK handle = get_handle( &args );
4801
4802 return NtUserUnhookWinEvent( handle );
4803 }
4804
4805 NTSTATUS WINAPI wow64_NtUserUnhookWindowsHookEx( UINT *args )
4806 {
4807 HHOOK handle = get_handle( &args );
4808
4809 return NtUserUnhookWindowsHookEx( handle );
4810 }
4811
4812 NTSTATUS WINAPI wow64_NtUserUnregisterClass( UINT *args )
4813 {
4814 UNICODE_STRING32 *name32 = get_ptr( &args );
4815 HINSTANCE instance = get_ptr( &args );
4816 struct client_menu_name32 *menu_name32 = get_ptr( &args );
4817
4818 UNICODE_STRING name;
4819 struct client_menu_name menu_name;
4820 BOOL ret;
4821
4822 ret = NtUserUnregisterClass( unicode_str_32to64( &name, name32 ), instance, &menu_name );
4823 if (ret) client_menu_name_64to32( &menu_name, menu_name32 );
4824 return ret;
4825 }
4826
4827 NTSTATUS WINAPI wow64_NtUserUnregisterHotKey( UINT *args )
4828 {
4829 HWND hwnd = get_handle( &args );
4830 int id = get_ulong( &args );
4831
4832 return NtUserUnregisterHotKey( hwnd, id );
4833 }
4834
4835 NTSTATUS WINAPI wow64_NtUserUpdateInputContext( UINT *args )
4836 {
4837 HIMC handle = get_handle( &args );
4838 UINT attr = get_ulong( &args );
4839 UINT_PTR value = get_ulong( &args );
4840
4841 return NtUserUpdateInputContext( handle, attr, value );
4842 }
4843
4844 NTSTATUS WINAPI wow64_NtUserUpdateLayeredWindow( UINT *args )
4845 {
4846 HWND hwnd = get_handle( &args );
4847 HDC hdc_dst = get_handle( &args );
4848 const POINT *pts_dst = get_ptr( &args );
4849 const SIZE *size = get_ptr( &args );
4850 HDC hdc_src = get_handle( &args );
4851 const POINT *pts_src = get_ptr( &args );
4852 COLORREF key = get_ulong( &args );
4853 const BLENDFUNCTION *blend = get_ptr( &args );
4854 DWORD flags = get_ulong( &args );
4855 const RECT *dirty = get_ptr( &args );
4856
4857 return NtUserUpdateLayeredWindow( hwnd, hdc_dst, pts_dst, size, hdc_src, pts_src,
4858 key, blend, flags, dirty );
4859 }
4860
4861 NTSTATUS WINAPI wow64_NtUserValidateRect( UINT *args )
4862 {
4863 HWND hwnd = get_handle( &args );
4864 const RECT *rect = get_ptr( &args );
4865
4866 return NtUserValidateRect( hwnd, rect );
4867 }
4868
4869 NTSTATUS WINAPI wow64_NtUserVkKeyScanEx( UINT *args )
4870 {
4871 WCHAR chr = get_ulong( &args );
4872 HKL layout = get_handle( &args );
4873
4874 return NtUserVkKeyScanEx( chr, layout );
4875 }
4876
4877 NTSTATUS WINAPI wow64_NtUserWaitForInputIdle( UINT *args )
4878 {
4879 HANDLE process = get_handle( &args );
4880 DWORD timeout = get_ulong( &args );
4881 BOOL wow = get_ulong( &args );
4882
4883 return NtUserWaitForInputIdle( process, timeout, wow );
4884 }
4885
4886 NTSTATUS WINAPI wow64_NtUserWaitMessage( UINT *args )
4887 {
4888 return NtUserWaitMessage();
4889 }
4890
4891 NTSTATUS WINAPI wow64_NtUserWindowFromDC( UINT *args )
4892 {
4893 HDC hdc = get_handle( &args );
4894
4895 return HandleToUlong( NtUserWindowFromDC( hdc ));
4896 }
4897
4898 NTSTATUS WINAPI wow64_NtUserWindowFromPoint( UINT *args )
4899 {
4900 LONG x = get_ulong( &args );
4901 LONG y = get_ulong( &args );
4902
4903 return HandleToUlong( NtUserWindowFromPoint( x, y ));
4904 }
4905
4906 NTSTATUS WINAPI wow64_NtUserDisplayConfigGetDeviceInfo( UINT *args )
4907 {
4908 DISPLAYCONFIG_DEVICE_INFO_HEADER *packet = get_ptr( &args );
4909
4910 return NtUserDisplayConfigGetDeviceInfo( packet );
4911 }
Windows API implementation