ReactOS  0.4.15-dev-994-ga9f6032
window.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: See COPYING in the top level directory
3  * PROJECT: ReactOS user32.dll
4  * FILE: win32ss/user/user32/windows/window.c
5  * PURPOSE: Window management
6  * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
7  * Katayama Hirofumi MZ (katayama.hirofumi.mz@gmail.com)
8  * UPDATE HISTORY:
9  * 06-06-2001 CSH Created
10  */
11 
12 #define DEBUG
13 #include <user32.h>
14 
16 
17 void MDI_CalcDefaultChildPos( HWND hwndClient, INT total, LPPOINT lpPos, INT delta, UINT *id );
18 extern LPCWSTR FASTCALL ClassNameToVersion(const void *lpszClass, LPCWSTR lpszMenuName, LPCWSTR *plpLibFileName, HANDLE *pContext, BOOL bAnsi);
19 
20 /* FUNCTIONS *****************************************************************/
21 
22 
24 User32CallSendAsyncProcForKernel(PVOID Arguments, ULONG ArgumentLength)
25 {
27 
28  TRACE("User32CallSendAsyncProcKernel()\n");
29 
30  CallbackArgs = (PSENDASYNCPROC_CALLBACK_ARGUMENTS)Arguments;
31 
32  if (ArgumentLength != sizeof(SENDASYNCPROC_CALLBACK_ARGUMENTS))
33  {
35  }
36 
37  CallbackArgs->Callback(CallbackArgs->Wnd,
38  CallbackArgs->Msg,
39  CallbackArgs->Context,
40  CallbackArgs->Result);
41  return(STATUS_SUCCESS);
42 }
43 
44 
45 /*
46  * @implemented
47  */
50 {
51  return NtUserxAllowSetForegroundWindow(dwProcessId);
52 }
53 
54 
55 /*
56  * @unimplemented
57  */
58 HDWP WINAPI
59 BeginDeferWindowPos(int nNumWindows)
60 {
61  return NtUserxBeginDeferWindowPos(nNumWindows);
62 }
63 
64 
65 /*
66  * @implemented
67  */
70 {
71  return NtUserSetWindowPos(hWnd,
72  HWND_TOP,
73  0,
74  0,
75  0,
76  0,
78 }
79 
80 
83 {
85 }
86 
87 
88 /*
89  * @implemented
90  */
93  POINT Point)
94 {
96 }
97 
98 
99 /*
100  * @implemented
101  */
102 HWND WINAPI
104  POINT pt,
105  UINT uFlags)
106 {
108 }
109 
110 
111 /*
112  * @implemented
113  */
114 BOOL WINAPI
116 {
117  /* NOTE: CloseWindow does minimizes, and doesn't close. */
120 }
121 
123 VOID
125  OUT PLARGE_STRING plstr,
126  LPCVOID psz,
127  BOOL bUnicode)
128 {
129  if(bUnicode)
130  {
132  }
133  else
134  {
136  }
137 }
138 
139 VOID
140 NTAPI
142  IN PLARGE_STRING LargeString)
143 {
144  if (LargeString->Buffer)
145  {
146  RtlFreeHeap(GetProcessHeap(), 0, LargeString->Buffer);
147  RtlZeroMemory(LargeString, sizeof(LARGE_STRING));
148  }
149 }
150 
151 DWORD
152 FASTCALL
154 {
155  DWORD dwMajorVersion = 3; // Set default to Windows 3.10.
156  DWORD dwMinorVersion = 10;
157  PIMAGE_NT_HEADERS pinth;
158 
159  if ( hModule && !((ULONG_PTR)hModule >> 16))
160  {
161  pinth = RtlImageNtHeader( hModule );
162  if ( pinth )
163  {
164  dwMajorVersion = pinth->OptionalHeader.MajorSubsystemVersion;
165 
166  if ( dwMajorVersion == 1 )
167  {
168  dwMajorVersion = 3;
169  }
170  else
171  {
172  dwMinorVersion = pinth->OptionalHeader.MinorSubsystemVersion;
173  }
174  }
175  }
176  return MAKELONG(MAKEWORD(dwMinorVersion, dwMajorVersion), 0);
177 }
178 
179 HWND WINAPI
181  LPCSTR lpClassName,
182  LPCSTR lpWindowName,
183  DWORD dwStyle,
184  int x,
185  int y,
186  int nWidth,
187  int nHeight,
189  HMENU hMenu,
191  LPVOID lpParam,
192  DWORD dwFlags)
193 {
194  LARGE_STRING WindowName;
195  LARGE_STRING lstrClassName, *plstrClassName;
196  LARGE_STRING lstrClassVersion, *plstrClassVersion;
197  UNICODE_STRING ClassName;
198  UNICODE_STRING ClassVersion;
199  WNDCLASSEXA wceA;
200  WNDCLASSEXW wceW;
202  DWORD dwLastError;
203  BOOL Unicode, ClassFound = FALSE;
204  HWND Handle = NULL;
205  LPCWSTR lpszClsVersion;
206  LPCWSTR lpLibFileName = NULL;
207  HANDLE pCtx = NULL;
208  DWORD dwFlagsVer;
209 
210 #if 0
211  DbgPrint("[window] User32CreateWindowEx style %d, exstyle %d, parent %d\n", dwStyle, dwExStyle, hWndParent);
212 #endif
213 
215  TRACE("Module Version %x\n",dwFlagsVer);
216 
218  {
219  TRACE("RegisterSystemControls\n");
221  }
222 
223  Unicode = !(dwFlags & NUCWE_ANSI);
224 
225  if (IS_ATOM(lpClassName))
226  {
227  plstrClassName = (PVOID)lpClassName;
228  }
229  else
230  {
231  if (Unicode)
232  {
233  RtlInitUnicodeString(&ClassName, (PCWSTR)lpClassName);
234  }
235  else
236  {
237  if (!RtlCreateUnicodeStringFromAsciiz(&ClassName, (PCSZ)lpClassName))
238  {
240  return NULL;
241  }
242  }
243 
244  /* Copy it to a LARGE_STRING */
245  lstrClassName.Buffer = ClassName.Buffer;
246  lstrClassName.Length = ClassName.Length;
247  lstrClassName.MaximumLength = ClassName.MaximumLength;
248  plstrClassName = &lstrClassName;
249  }
250 
251  /* Initialize a LARGE_STRING */
252  RtlInitLargeString(&WindowName, lpWindowName, Unicode);
253 
254  // HACK: The current implementation expects the Window name to be UNICODE
255  if (!Unicode)
256  {
258  PSTR AnsiBuffer = WindowName.Buffer;
259  ULONG AnsiLength = WindowName.Length;
260 
261  WindowName.Length = 0;
262  WindowName.MaximumLength = AnsiLength * sizeof(WCHAR);
263  WindowName.Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
264  0,
265  WindowName.MaximumLength);
266  if (!WindowName.Buffer)
267  {
269  goto cleanup;
270  }
271 
272  Status = RtlMultiByteToUnicodeN(WindowName.Buffer,
273  WindowName.MaximumLength,
274  &WindowName.Length,
275  AnsiBuffer,
276  AnsiLength);
277  if (!NT_SUCCESS(Status))
278  {
279  goto cleanup;
280  }
281  }
282 
283  if (!hMenu && (dwStyle & (WS_OVERLAPPEDWINDOW | WS_POPUP)))
284  {
285  if (Unicode)
286  {
287  wceW.cbSize = sizeof(wceW);
288  if (GetClassInfoExW(hInstance, (LPCWSTR)lpClassName, &wceW) && wceW.lpszMenuName)
289  {
290  hMenu = LoadMenuW(hInstance, wceW.lpszMenuName);
291  }
292  }
293  else
294  {
295  wceA.cbSize = sizeof(wceA);
296  if (GetClassInfoExA(hInstance, lpClassName, &wceA) && wceA.lpszMenuName)
297  {
298  hMenu = LoadMenuA(hInstance, wceA.lpszMenuName);
299  }
300  }
301  }
302 
303  if (!Unicode) dwExStyle |= WS_EX_SETANSICREATOR;
304 
305  lpszClsVersion = ClassNameToVersion(lpClassName, NULL, &lpLibFileName, &pCtx, !Unicode);
306  if (!lpszClsVersion)
307  {
308  plstrClassVersion = plstrClassName;
309  }
310  else
311  {
312  RtlInitUnicodeString(&ClassVersion, lpszClsVersion);
313  lstrClassVersion.Buffer = ClassVersion.Buffer;
314  lstrClassVersion.Length = ClassVersion.Length;
315  lstrClassVersion.MaximumLength = ClassVersion.MaximumLength;
316  plstrClassVersion = &lstrClassVersion;
317  }
318 
319  for (;;)
320  {
321  Handle = NtUserCreateWindowEx(dwExStyle,
322  plstrClassName,
323  plstrClassVersion,
324  &WindowName,
325  dwStyle,
326  x,
327  y,
328  nWidth,
329  nHeight,
330  hWndParent,
331  hMenu,
332  hInstance,
333  lpParam,
334  dwFlagsVer,
335  pCtx );
336  if (Handle) break;
337  if (!lpLibFileName) break;
338  if (!ClassFound)
339  {
340  dwLastError = GetLastError();
341  if (dwLastError == ERROR_CANNOT_FIND_WND_CLASS)
342  {
343  ClassFound = VersionRegisterClass(ClassName.Buffer, lpLibFileName, pCtx, &hLibModule);
344  if (ClassFound) continue;
345  }
346  }
347  if (hLibModule)
348  {
349  dwLastError = GetLastError();
351  SetLastError(dwLastError);
352  hLibModule = NULL;
353  }
354  break;
355  }
356 
357 #if 0
358  DbgPrint("[window] NtUserCreateWindowEx() == %d\n", Handle);
359 #endif
360 
361 cleanup:
362  if (!Unicode)
363  {
364  if (!IS_ATOM(lpClassName))
365  RtlFreeUnicodeString(&ClassName);
366 
367  RtlFreeLargeString(&WindowName);
368  }
369 
370  return Handle;
371 }
372 
373 
374 /*
375  * @implemented
376  */
377 HWND
378 WINAPI
381  LPCSTR lpClassName,
382  LPCSTR lpWindowName,
383  DWORD dwStyle,
384  int x,
385  int y,
386  int nWidth,
387  int nHeight,
389  HMENU hMenu,
391  LPVOID lpParam)
392 {
393  MDICREATESTRUCTA mdi;
394  HWND hwnd;
395 
397  {
398  TRACE("CreateWindowExA RegisterSystemControls\n");
400  }
401 
402  if (dwExStyle & WS_EX_MDICHILD)
403  {
404  POINT mPos[2];
405  UINT id = 0;
406  HWND top_child;
407  PWND pWndParent;
408 
409  pWndParent = ValidateHwnd(hWndParent);
410 
411  if (!pWndParent) return NULL;
412 
413  if (pWndParent->fnid != FNID_MDICLIENT) // wine uses WIN_ISMDICLIENT
414  {
415  WARN("WS_EX_MDICHILD, but parent %p is not MDIClient\n", hWndParent);
416  goto skip_mdi;
417  }
418 
419  /* lpParams of WM_[NC]CREATE is different for MDI children.
420  * MDICREATESTRUCT members have the originally passed values.
421  */
422  mdi.szClass = lpClassName;
423  mdi.szTitle = lpWindowName;
424  mdi.hOwner = hInstance;
425  mdi.x = x;
426  mdi.y = y;
427  mdi.cx = nWidth;
428  mdi.cy = nHeight;
429  mdi.style = dwStyle;
430  mdi.lParam = (LPARAM)lpParam;
431 
432  lpParam = (LPVOID)&mdi;
433 
434  if (pWndParent->style & MDIS_ALLCHILDSTYLES)
435  {
436  if (dwStyle & WS_POPUP)
437  {
438  WARN("WS_POPUP with MDIS_ALLCHILDSTYLES is not allowed\n");
439  return(0);
440  }
441  dwStyle |= (WS_CHILD | WS_CLIPSIBLINGS);
442  }
443  else
444  {
445  dwStyle &= ~WS_POPUP;
446  dwStyle |= (WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CAPTION |
448  }
449 
450  top_child = GetWindow(hWndParent, GW_CHILD);
451 
452  if (top_child)
453  {
454  /* Restore current maximized child */
455  if((dwStyle & WS_VISIBLE) && IsZoomed(top_child))
456  {
457  TRACE("Restoring current maximized child %p\n", top_child);
458  SendMessageW( top_child, WM_SETREDRAW, FALSE, 0 );
459  ShowWindow(top_child, SW_RESTORE);
460  SendMessageW( top_child, WM_SETREDRAW, TRUE, 0 );
461  }
462  }
463 
464  MDI_CalcDefaultChildPos(hWndParent, -1, mPos, 0, &id);
465 
466  if (!(dwStyle & WS_POPUP)) hMenu = UlongToHandle(id);
467 
468  if (dwStyle & (WS_CHILD | WS_POPUP))
469  {
470  if (x == CW_USEDEFAULT || x == CW_USEDEFAULT16)
471  {
472  x = mPos[0].x;
473  y = mPos[0].y;
474  }
475  if (nWidth == CW_USEDEFAULT || nWidth == CW_USEDEFAULT16 || !nWidth)
476  nWidth = mPos[1].x;
477  if (nHeight == CW_USEDEFAULT || nHeight == CW_USEDEFAULT16 || !nHeight)
478  nHeight = mPos[1].y;
479  }
480  }
481 
482 skip_mdi:
483  hwnd = User32CreateWindowEx(dwExStyle,
484  lpClassName,
485  lpWindowName,
486  dwStyle,
487  x,
488  y,
489  nWidth,
490  nHeight,
491  hWndParent,
492  hMenu,
493  hInstance,
494  lpParam,
495  NUCWE_ANSI);
496  return hwnd;
497 }
498 
499 
500 /*
501  * @implemented
502  */
503 HWND
504 WINAPI
507  LPCWSTR lpClassName,
508  LPCWSTR lpWindowName,
509  DWORD dwStyle,
510  int x,
511  int y,
512  int nWidth,
513  int nHeight,
515  HMENU hMenu,
517  LPVOID lpParam)
518 {
519  MDICREATESTRUCTW mdi;
520  HWND hwnd;
521 
523  {
524  ERR("CreateWindowExW RegisterSystemControls\n");
526  }
527 
528  if (dwExStyle & WS_EX_MDICHILD)
529  {
530  POINT mPos[2];
531  UINT id = 0;
532  HWND top_child;
533  PWND pWndParent;
534 
535  pWndParent = ValidateHwnd(hWndParent);
536 
537  if (!pWndParent) return NULL;
538 
539  if (pWndParent->fnid != FNID_MDICLIENT)
540  {
541  WARN("WS_EX_MDICHILD, but parent %p is not MDIClient\n", hWndParent);
542  goto skip_mdi;
543  }
544 
545  /* lpParams of WM_[NC]CREATE is different for MDI children.
546  * MDICREATESTRUCT members have the originally passed values.
547  */
548  mdi.szClass = lpClassName;
549  mdi.szTitle = lpWindowName;
550  mdi.hOwner = hInstance;
551  mdi.x = x;
552  mdi.y = y;
553  mdi.cx = nWidth;
554  mdi.cy = nHeight;
555  mdi.style = dwStyle;
556  mdi.lParam = (LPARAM)lpParam;
557 
558  lpParam = (LPVOID)&mdi;
559 
560  if (pWndParent->style & MDIS_ALLCHILDSTYLES)
561  {
562  if (dwStyle & WS_POPUP)
563  {
564  WARN("WS_POPUP with MDIS_ALLCHILDSTYLES is not allowed\n");
565  return(0);
566  }
567  dwStyle |= (WS_CHILD | WS_CLIPSIBLINGS);
568  }
569  else
570  {
571  dwStyle &= ~WS_POPUP;
572  dwStyle |= (WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CAPTION |
574  }
575 
576  top_child = GetWindow(hWndParent, GW_CHILD);
577 
578  if (top_child)
579  {
580  /* Restore current maximized child */
581  if((dwStyle & WS_VISIBLE) && IsZoomed(top_child))
582  {
583  TRACE("Restoring current maximized child %p\n", top_child);
584  SendMessageW( top_child, WM_SETREDRAW, FALSE, 0 );
585  ShowWindow(top_child, SW_RESTORE);
586  SendMessageW( top_child, WM_SETREDRAW, TRUE, 0 );
587  }
588  }
589 
590  MDI_CalcDefaultChildPos(hWndParent, -1, mPos, 0, &id);
591 
592  if (!(dwStyle & WS_POPUP)) hMenu = UlongToHandle(id);
593 
594  if (dwStyle & (WS_CHILD | WS_POPUP))
595  {
596  if (x == CW_USEDEFAULT || x == CW_USEDEFAULT16)
597  {
598  x = mPos[0].x;
599  y = mPos[0].y;
600  }
601  if (nWidth == CW_USEDEFAULT || nWidth == CW_USEDEFAULT16 || !nWidth)
602  nWidth = mPos[1].x;
603  if (nHeight == CW_USEDEFAULT || nHeight == CW_USEDEFAULT16 || !nHeight)
604  nHeight = mPos[1].y;
605  }
606  }
607 
608 skip_mdi:
609  hwnd = User32CreateWindowEx(dwExStyle,
610  (LPCSTR)lpClassName,
611  (LPCSTR)lpWindowName,
612  dwStyle,
613  x,
614  y,
615  nWidth,
616  nHeight,
617  hWndParent,
618  hMenu,
619  hInstance,
620  lpParam,
621  0);
622  return hwnd;
623 }
624 
625 /*
626  * @unimplemented
627  */
628 HDWP WINAPI
629 DeferWindowPos(HDWP hWinPosInfo,
630  HWND hWnd,
631  HWND hWndInsertAfter,
632  int x,
633  int y,
634  int cx,
635  int cy,
636  UINT uFlags)
637 {
638  return NtUserDeferWindowPos(hWinPosInfo, hWnd, hWndInsertAfter, x, y, cx, cy, uFlags);
639 }
640 
641 
642 /*
643  * @unimplemented
644  */
645 BOOL WINAPI
646 EndDeferWindowPos(HDWP hWinPosInfo)
647 {
648  return NtUserEndDeferWindowPosEx(hWinPosInfo, 0);
649 }
650 
651 
652 /*
653  * @implemented
654  */
655 HWND WINAPI
657 {
658  PWND Wnd;
659  HWND Ret = NULL;
660 
661  _SEH2_TRY
662  {
663  Wnd = GetThreadDesktopWnd();
664  if (Wnd != NULL)
665  Ret = UserHMGetHandle(Wnd);
666  }
668  {
669  /* Do nothing */
670  }
671  _SEH2_END;
672 
673  return Ret;
674 }
675 
676 
677 static BOOL
678 User32EnumWindows(HDESK hDesktop,
679  HWND hWndparent,
680  WNDENUMPROC lpfn,
681  LPARAM lParam,
683  BOOL bChildren)
684 {
685  DWORD i, dwCount = 0;
686  HWND* pHwnd = NULL;
687  HANDLE hHeap;
689 
690  if (!lpfn)
691  {
693  return FALSE;
694  }
695 
696  /* FIXME instead of always making two calls, should we use some
697  sort of persistent buffer and only grow it ( requiring a 2nd
698  call ) when the buffer wasn't already big enough? */
699  /* first get how many window entries there are */
700  Status = NtUserBuildHwndList(hDesktop,
701  hWndparent,
702  bChildren,
703  dwThreadId,
704  lParam,
705  NULL,
706  &dwCount);
707  if (!NT_SUCCESS(Status))
708  return FALSE;
709 
710  if (!dwCount)
711  {
712  if (!dwThreadId)
713  return FALSE;
714  else
715  return TRUE;
716  }
717 
718  /* allocate buffer to receive HWND handles */
719  hHeap = GetProcessHeap();
720  pHwnd = HeapAlloc(hHeap, 0, sizeof(HWND)*(dwCount+1));
721  if (!pHwnd)
722  {
724  return FALSE;
725  }
726 
727  /* now call kernel again to fill the buffer this time */
728  Status = NtUserBuildHwndList(hDesktop,
729  hWndparent,
730  bChildren,
731  dwThreadId,
732  lParam,
733  pHwnd,
734  &dwCount);
735  if (!NT_SUCCESS(Status))
736  {
737  if (pHwnd)
738  HeapFree(hHeap, 0, pHwnd);
739  return FALSE;
740  }
741 
742  /* call the user's callback function until we're done or
743  they tell us to quit */
744  for ( i = 0; i < dwCount; i++ )
745  {
746  /* FIXME I'm only getting NULLs from Thread Enumeration, and it's
747  * probably because I'm not doing it right in NtUserBuildHwndList.
748  * Once that's fixed, we shouldn't have to check for a NULL HWND
749  * here
750  * This is now fixed in revision 50205. (jt)
751  */
752  if (!pHwnd[i]) /* don't enumerate a NULL HWND */
753  continue;
754  if (!(*lpfn)(pHwnd[i], lParam))
755  {
756  HeapFree ( hHeap, 0, pHwnd );
757  return FALSE;
758  }
759  }
760  if (pHwnd)
761  HeapFree(hHeap, 0, pHwnd);
762  return TRUE;
763 }
764 
765 
766 /*
767  * @implemented
768  */
769 BOOL WINAPI
771  WNDENUMPROC lpEnumFunc,
772  LPARAM lParam)
773 {
774  if (!hWndParent)
775  {
776  return EnumWindows(lpEnumFunc, lParam);
777  }
778  return User32EnumWindows(NULL, hWndParent, lpEnumFunc, lParam, 0, TRUE);
779 }
780 
781 
782 /*
783  * @implemented
784  */
785 BOOL WINAPI
787  WNDENUMPROC lpfn,
788  LPARAM lParam)
789 {
790  if (!dwThreadId)
792  return User32EnumWindows(NULL, NULL, lpfn, lParam, dwThreadId, FALSE);
793 }
794 
795 
796 /*
797  * @implemented
798  */
799 BOOL WINAPI
801  LPARAM lParam)
802 {
803  return User32EnumWindows(NULL, NULL, lpEnumFunc, lParam, 0, FALSE);
804 }
805 
806 
807 /*
808  * @implemented
809  */
810 BOOL WINAPI
811 EnumDesktopWindows(HDESK hDesktop,
812  WNDENUMPROC lpfn,
813  LPARAM lParam)
814 {
815  return User32EnumWindows(hDesktop, NULL, lpfn, lParam, 0, FALSE);
816 }
817 
818 
819 /*
820  * @implemented
821  */
822 HWND WINAPI
824  HWND hwndChildAfter,
825  LPCSTR lpszClass,
826  LPCSTR lpszWindow)
827 {
828  LPWSTR titleW = NULL;
829  HWND hwnd = 0;
830 
831  if (lpszWindow)
832  {
833  DWORD len = MultiByteToWideChar( CP_ACP, 0, lpszWindow, -1, NULL, 0 );
834  if (!(titleW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return 0;
835  MultiByteToWideChar( CP_ACP, 0, lpszWindow, -1, titleW, len );
836  }
837 
838  if (!IS_INTRESOURCE(lpszClass))
839  {
840  WCHAR classW[256];
841  if (MultiByteToWideChar( CP_ACP, 0, lpszClass, -1, classW, sizeof(classW)/sizeof(WCHAR) ))
842  hwnd = FindWindowExW( hwndParent, hwndChildAfter, classW, titleW );
843  }
844  else
845  {
846  hwnd = FindWindowExW( hwndParent, hwndChildAfter, (LPCWSTR)lpszClass, titleW );
847  }
848 
849  HeapFree( GetProcessHeap(), 0, titleW );
850  return hwnd;
851 }
852 
853 
854 /*
855  * @implemented
856  */
857 HWND WINAPI
859  HWND hwndChildAfter,
860  LPCWSTR lpszClass,
861  LPCWSTR lpszWindow)
862 {
863  UNICODE_STRING ucClassName, *pucClassName = NULL;
864  UNICODE_STRING ucWindowName, *pucWindowName = NULL;
865 
866  if (IS_ATOM(lpszClass))
867  {
868  ucClassName.Length = 0;
869  ucClassName.Buffer = (LPWSTR)lpszClass;
870  pucClassName = &ucClassName;
871  }
872  else if (lpszClass != NULL)
873  {
874  RtlInitUnicodeString(&ucClassName,
875  lpszClass);
876  pucClassName = &ucClassName;
877  }
878 
879  if (lpszWindow != NULL)
880  {
881  RtlInitUnicodeString(&ucWindowName,
882  lpszWindow);
883  pucWindowName = &ucWindowName;
884  }
885 
887  hwndChildAfter,
888  pucClassName,
889  pucWindowName,
890  0);
891 }
892 
893 
894 /*
895  * @implemented
896  */
897 HWND WINAPI
898 FindWindowA(LPCSTR lpClassName, LPCSTR lpWindowName)
899 {
900  //FIXME: FindWindow does not search children, but FindWindowEx does.
901  // what should we do about this?
902  return FindWindowExA (NULL, NULL, lpClassName, lpWindowName);
903 }
904 
905 
906 /*
907  * @implemented
908  */
909 HWND WINAPI
910 FindWindowW(LPCWSTR lpClassName, LPCWSTR lpWindowName)
911 {
912  /*
913 
914  There was a FIXME here earlier, but I think it is just a documentation unclarity.
915 
916  FindWindow only searches top level windows. What they mean is that child
917  windows of other windows than the desktop can be searched.
918  FindWindowExW never does a recursive search.
919 
920  / Joakim
921  */
922 
923  return FindWindowExW(NULL, NULL, lpClassName, lpWindowName);
924 }
925 
926 
927 
928 /*
929  * @implemented
930  */
931 BOOL WINAPI
933  int iItem,
934  PALTTABINFO pati,
935  LPSTR pszItemText,
936  UINT cchItemText)
937 {
938  return NtUserGetAltTabInfo(hwnd,iItem,pati,(LPWSTR)pszItemText,cchItemText,TRUE);
939 }
940 
941 
942 /*
943  * @implemented
944  */
945 BOOL WINAPI
947  int iItem,
948  PALTTABINFO pati,
949  LPWSTR pszItemText,
950  UINT cchItemText)
951 {
952  return NtUserGetAltTabInfo(hwnd,iItem,pati,pszItemText,cchItemText,FALSE);
953 }
954 
955 
956 /*
957  * @implemented
958  */
959 HWND WINAPI
961 {
962  HWND Ret = NULL;
963  PWND Ancestor, Wnd;
964 
965  Wnd = ValidateHwnd(hwnd);
966  if (!Wnd)
967  return NULL;
968 
969  _SEH2_TRY
970  {
971  Ancestor = NULL;
972  switch (gaFlags)
973  {
974  case GA_PARENT:
975  if (Wnd->spwndParent != NULL)
976  Ancestor = DesktopPtrToUser(Wnd->spwndParent);
977  break;
978 
979  default:
980  /* FIXME: Call win32k for now */
981  Wnd = NULL;
982  break;
983  }
984 
985  if (Ancestor != NULL)
986  Ret = UserHMGetHandle(Ancestor);
987  }
989  {
990  /* Do nothing */
991  }
992  _SEH2_END;
993 
994  if (!Wnd) /* Fall back */
995  Ret = NtUserGetAncestor(hwnd, gaFlags);
996 
997  return Ret;
998 }
999 
1000 
1001 /*
1002  * @implemented
1003  */
1004 BOOL WINAPI
1006 {
1007  PWND Wnd = ValidateHwnd(hWnd);
1008 
1009  if (!Wnd) return FALSE;
1010  if (Wnd->style & WS_MINIMIZED)
1011  {
1012  lpRect->left = lpRect->top = 0;
1015  return TRUE;
1016  }
1017  if ( hWnd != GetDesktopWindow()) // Wnd->fnid != FNID_DESKTOP )
1018  {
1019 /* lpRect->left = lpRect->top = 0;
1020  lpRect->right = Wnd->rcClient.right - Wnd->rcClient.left;
1021  lpRect->bottom = Wnd->rcClient.bottom - Wnd->rcClient.top;
1022 */
1023  *lpRect = Wnd->rcClient;
1024  OffsetRect(lpRect, -Wnd->rcClient.left, -Wnd->rcClient.top);
1025  }
1026  else
1027  {
1028  lpRect->left = lpRect->top = 0;
1029  lpRect->right = Wnd->rcClient.right;
1030  lpRect->bottom = Wnd->rcClient.bottom;
1031 /* Do this until Init bug is fixed. This sets 640x480, see InitMetrics.
1032  lpRect->right = GetSystemMetrics(SM_CXSCREEN);
1033  lpRect->bottom = GetSystemMetrics(SM_CYSCREEN);
1034 */ }
1035  return TRUE;
1036 }
1037 
1038 
1039 /*
1040  * @implemented
1041  */
1042 HWND WINAPI
1044 {
1045  PWND Wnd;
1046  HWND Ret = hWnd;
1047 
1048  Wnd = ValidateHwnd(hWnd);
1049  if (Wnd != NULL)
1050  {
1051  _SEH2_TRY
1052  {
1053  if (Wnd->spwndLastActive)
1054  {
1055  PWND LastActive = DesktopPtrToUser(Wnd->spwndLastActive);
1056  Ret = UserHMGetHandle(LastActive);
1057  }
1058  }
1060  {
1061  /* Do nothing */
1062  }
1063  _SEH2_END;
1064  }
1065  return Ret;
1066 }
1067 
1068 
1069 /*
1070  * @implemented
1071  */
1072 HWND WINAPI
1074 {
1075  PWND Wnd, WndParent;
1076  HWND Ret = NULL;
1077 
1078  Wnd = ValidateHwnd(hWnd);
1079  if (Wnd != NULL)
1080  {
1081  _SEH2_TRY
1082  {
1083  WndParent = NULL;
1084  if (Wnd->style & WS_POPUP)
1085  {
1086  if (Wnd->spwndOwner != NULL)
1087  WndParent = DesktopPtrToUser(Wnd->spwndOwner);
1088  }
1089  else if (Wnd->style & WS_CHILD)
1090  {
1091  if (Wnd->spwndParent != NULL)
1092  WndParent = DesktopPtrToUser(Wnd->spwndParent);
1093  }
1094 
1095  if (WndParent != NULL)
1096  Ret = UserHMGetHandle(WndParent);
1097  }
1099  {
1100  /* Do nothing */
1101  }
1102  _SEH2_END;
1103  }
1104 
1105  return Ret;
1106 }
1107 
1108 
1109 /*
1110  * @implemented
1111  */
1112 BOOL WINAPI
1113 GetProcessDefaultLayout(DWORD *pdwDefaultLayout)
1114 {
1116 }
1117 
1118 
1119 /*
1120  * @implemented
1121  */
1122 HWND WINAPI
1124  UINT uCmd)
1125 {
1126  PWND Wnd, FoundWnd;
1127  HWND Ret = NULL;
1128 
1129  Wnd = ValidateHwnd(hWnd);
1130  if (!Wnd)
1131  return NULL;
1132 
1133  _SEH2_TRY
1134  {
1135  FoundWnd = NULL;
1136  switch (uCmd)
1137  {
1138  case GW_OWNER:
1139  if (Wnd->spwndOwner != NULL)
1140  FoundWnd = DesktopPtrToUser(Wnd->spwndOwner);
1141  break;
1142 
1143  case GW_HWNDFIRST:
1144  if(Wnd->spwndParent != NULL)
1145  {
1146  FoundWnd = DesktopPtrToUser(Wnd->spwndParent);
1147  if (FoundWnd->spwndChild != NULL)
1148  FoundWnd = DesktopPtrToUser(FoundWnd->spwndChild);
1149  }
1150  break;
1151  case GW_HWNDNEXT:
1152  if (Wnd->spwndNext != NULL)
1153  FoundWnd = DesktopPtrToUser(Wnd->spwndNext);
1154  break;
1155 
1156  case GW_HWNDPREV:
1157  if (Wnd->spwndPrev != NULL)
1158  FoundWnd = DesktopPtrToUser(Wnd->spwndPrev);
1159  break;
1160 
1161  case GW_CHILD:
1162  if (Wnd->spwndChild != NULL)
1163  FoundWnd = DesktopPtrToUser(Wnd->spwndChild);
1164  break;
1165 
1166  case GW_HWNDLAST:
1167  FoundWnd = Wnd;
1168  while ( FoundWnd->spwndNext != NULL)
1169  FoundWnd = DesktopPtrToUser(FoundWnd->spwndNext);
1170  break;
1171 
1172  default:
1173  Wnd = NULL;
1174  break;
1175  }
1176 
1177  if (FoundWnd != NULL)
1178  Ret = UserHMGetHandle(FoundWnd);
1179  }
1181  {
1182  /* Do nothing */
1183  }
1184  _SEH2_END;
1185 
1186  return Ret;
1187 }
1188 
1189 
1190 /*
1191  * @implemented
1192  */
1193 HWND WINAPI
1195 {
1196  if (!hWnd) hWnd = GetDesktopWindow();
1197  return GetWindow(hWnd, GW_CHILD);
1198 }
1199 
1200 
1201 /*
1202  * @implemented
1203  */
1204 BOOL
1205 WINAPI
1208  PWINDOWINFO pwi)
1209 {
1210  PWND pWnd;
1211  PCLS pCls = NULL;
1212  SIZE Size = {0,0};
1213  BOOL Ret = FALSE;
1214 
1215  if ( !pwi || pwi->cbSize != sizeof(WINDOWINFO))
1216  SetLastError(ERROR_INVALID_PARAMETER); // Just set the error and go!
1217 
1218  pWnd = ValidateHwnd(hWnd);
1219  if (!pWnd)
1220  return Ret;
1221 
1222  UserGetWindowBorders(pWnd->style, pWnd->ExStyle, &Size, FALSE);
1223 
1224  _SEH2_TRY
1225  {
1226  pCls = DesktopPtrToUser(pWnd->pcls);
1227  pwi->rcWindow = pWnd->rcWindow;
1228  pwi->rcClient = pWnd->rcClient;
1229  pwi->dwStyle = pWnd->style;
1230  pwi->dwExStyle = pWnd->ExStyle;
1231  pwi->cxWindowBorders = Size.cx;
1232  pwi->cyWindowBorders = Size.cy;
1233  pwi->dwWindowStatus = 0;
1234  if (pWnd->state & WNDS_ACTIVEFRAME || (GetActiveWindow() == hWnd))
1236  pwi->atomWindowType = (pCls ? pCls->atomClassName : 0 );
1237 
1238  if ( pWnd->state2 & WNDS2_WIN50COMPAT )
1239  {
1240  pwi->wCreatorVersion = 0x500;
1241  }
1242  else if ( pWnd->state2 & WNDS2_WIN40COMPAT )
1243  {
1244  pwi->wCreatorVersion = 0x400;
1245  }
1246  else if ( pWnd->state2 & WNDS2_WIN31COMPAT )
1247  {
1248  pwi->wCreatorVersion = 0x30A;
1249  }
1250  else
1251  {
1252  pwi->wCreatorVersion = 0x300;
1253  }
1254 
1255  Ret = TRUE;
1256  }
1258  {
1259  /* Do nothing */
1260  }
1261  _SEH2_END;
1262 
1263  return Ret;
1264 }
1265 
1266 
1267 /*
1268  * @implemented
1269  */
1270 UINT WINAPI
1272  LPSTR lpszFileName,
1273  UINT cchFileNameMax)
1274 {
1275  PWND Wnd = ValidateHwnd(hwnd);
1276 
1277  if (!Wnd)
1278  return 0;
1279 
1280  return GetModuleFileNameA(Wnd->hModule, lpszFileName, cchFileNameMax);
1281 }
1282 
1283 
1284 /*
1285  * @implemented
1286  */
1287 UINT WINAPI
1289  LPWSTR lpszFileName,
1290  UINT cchFileNameMax)
1291 {
1292  PWND Wnd = ValidateHwnd(hwnd);
1293 
1294  if (!Wnd)
1295  return 0;
1296 
1297  return GetModuleFileNameW( Wnd->hModule, lpszFileName, cchFileNameMax );
1298 }
1299 
1300 /*
1301  * @implemented
1302  */
1303 BOOL WINAPI
1305  LPRECT lpRect)
1306 {
1307  PWND Wnd = ValidateHwnd(hWnd);
1308 
1309  if (!Wnd) return FALSE;
1310  if ( hWnd != GetDesktopWindow()) // Wnd->fnid != FNID_DESKTOP )
1311  {
1312  *lpRect = Wnd->rcWindow;
1313  }
1314  else
1315  {
1316  lpRect->left = lpRect->top = 0;
1317  lpRect->right = Wnd->rcWindow.right;
1318  lpRect->bottom = Wnd->rcWindow.bottom;
1319 /* Do this until Init bug is fixed. This sets 640x480, see InitMetrics.
1320  lpRect->right = GetSystemMetrics(SM_CXSCREEN);
1321  lpRect->bottom = GetSystemMetrics(SM_CYSCREEN);
1322 */ }
1323  return TRUE;
1324 }
1325 
1326 /*
1327  * @implemented
1328  */
1329 int WINAPI
1331 {
1332  PWND Wnd;
1333  INT Length = 0;
1334 
1335  if (lpString == NULL || nMaxCount == 0)
1336  return 0;
1337 
1338  Wnd = ValidateHwnd(hWnd);
1339  if (!Wnd)
1340  return 0;
1341 
1342  lpString[0] = '\0';
1343 
1344  if (!TestWindowProcess(Wnd))
1345  {
1346  _SEH2_TRY
1347  {
1349  }
1351  {
1352  Length = 0;
1353  }
1354  _SEH2_END;
1355  }
1356  else
1357  {
1359  }
1360  //ERR("GWTA Len %d : %s\n",Length,lpString);
1361  return Length;
1362 }
1363 
1364 /*
1365  * @implemented
1366  */
1367 int WINAPI
1369 {
1370  PWND Wnd;
1371 
1372  Wnd = ValidateHwnd(hWnd);
1373  if (!Wnd)
1374  return 0;
1375 
1376  if (!TestWindowProcess(Wnd))
1377  {
1378  return DefWindowProcA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1379  }
1380  else
1381  {
1382  return SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1383  }
1384 }
1385 
1386 /*
1387  * @implemented
1388  */
1389 int WINAPI
1391 {
1392  PWND Wnd;
1393 
1394  Wnd = ValidateHwnd(hWnd);
1395  if (!Wnd)
1396  return 0;
1397 
1398  if (!TestWindowProcess(Wnd))
1399  {
1400  return DefWindowProcW(hWnd, WM_GETTEXTLENGTH, 0, 0);
1401  }
1402  else
1403  {
1404  return SendMessageW(hWnd, WM_GETTEXTLENGTH, 0, 0);
1405  }
1406 }
1407 
1408 /*
1409  * @implemented
1410  */
1411 int WINAPI
1413 {
1414  PWND Wnd;
1415  INT Length = 0;
1416 
1417  if (lpString == NULL || nMaxCount == 0)
1418  return 0;
1419 
1420  Wnd = ValidateHwnd(hWnd);
1421  if (!Wnd)
1422  return 0;
1423 
1424  lpString[0] = L'\0';
1425 
1426  if (!TestWindowProcess(Wnd))
1427  {
1428  _SEH2_TRY
1429  {
1431  }
1433  {
1434  Length = 0;
1435  }
1436  _SEH2_END;
1437  }
1438  else
1439  {
1441  }
1442  //ERR("GWTW Len %d : %S\n",Length,lpString);
1443  return Length;
1444 }
1445 
1446 DWORD WINAPI
1448  LPDWORD lpdwProcessId)
1449 {
1450  DWORD Ret = 0;
1451  PTHREADINFO ti;
1452  PWND pWnd = ValidateHwnd(hWnd);
1453 
1454  if (!pWnd) return Ret;
1455 
1456  ti = pWnd->head.pti;
1457 
1458  if (ti)
1459  {
1460  if (ti == GetW32ThreadInfo())
1461  { // We are current.
1462  //FIXME("Current!\n");
1463  if (lpdwProcessId)
1464  *lpdwProcessId = (DWORD_PTR)NtCurrentTeb()->ClientId.UniqueProcess;
1465  Ret = (DWORD_PTR)NtCurrentTeb()->ClientId.UniqueThread;
1466  }
1467  else
1468  { // Ask kernel for info.
1469  //FIXME("Kernel call!\n");
1470  if (lpdwProcessId)
1473  }
1474  }
1475  return Ret;
1476 }
1477 
1478 
1479 /*
1480  * @implemented
1481  */
1482 BOOL WINAPI
1484  HWND hWnd)
1485 {
1486  PWND WndParent, DesktopWnd, Wnd;
1487  BOOL Ret = FALSE;
1488 
1489  WndParent = ValidateHwnd(hWndParent);
1490  if (!WndParent)
1491  return FALSE;
1492  Wnd = ValidateHwnd(hWnd);
1493  if (!Wnd)
1494  return FALSE;
1495 
1496  DesktopWnd = GetThreadDesktopWnd();
1497  if (!DesktopWnd)
1498  return FALSE;
1499 
1500  _SEH2_TRY
1501  {
1502  while (Wnd != NULL && ((Wnd->style & (WS_POPUP|WS_CHILD)) == WS_CHILD))
1503  {
1504  if (Wnd->spwndParent != NULL)
1505  {
1506  Wnd = DesktopPtrToUser(Wnd->spwndParent);
1507 
1508  if (Wnd == WndParent)
1509  {
1510  Ret = TRUE;
1511  break;
1512  }
1513  }
1514  else
1515  break;
1516  }
1517  }
1519  {
1520  /* Do nothing */
1521  }
1522  _SEH2_END;
1523 
1524  return Ret;
1525 }
1526 
1527 
1528 /*
1529  * @implemented
1530  */
1531 BOOL WINAPI
1533 {
1534  PWND Wnd = ValidateHwnd(hWnd);
1535 
1536  if (Wnd != NULL)
1537  return (Wnd->style & WS_MINIMIZE) != 0;
1538 
1539  return FALSE;
1540 }
1541 
1542 
1543 /*
1544  * @implemented
1545  */
1546 BOOL WINAPI
1548 {
1549  PWND Wnd = ValidateHwndNoErr(hWnd);
1550  if (Wnd != NULL)
1551  {
1552  if (Wnd->state & WNDS_DESTROYED ||
1553  Wnd->state2 & WNDS2_INDESTROY)
1554  return FALSE;
1555  return TRUE;
1556  }
1557 
1558  return FALSE;
1559 }
1560 
1561 
1562 /*
1563  * @implemented
1564  */
1565 BOOL WINAPI
1567 {
1568  PWND Wnd = ValidateHwnd(hWnd);
1569 
1570  if (Wnd != NULL)
1571  return Wnd->Unicode;
1572 
1573  return FALSE;
1574 }
1575 
1576 
1577 /*
1578  * @implemented
1579  */
1580 BOOL WINAPI
1582 {
1583  BOOL Ret = FALSE;
1584  PWND Wnd = ValidateHwnd(hWnd);
1585 
1586  if (Wnd != NULL)
1587  {
1588  _SEH2_TRY
1589  {
1590  Ret = TRUE;
1591 
1592  do
1593  {
1594  if (!(Wnd->style & WS_VISIBLE))
1595  {
1596  Ret = FALSE;
1597  break;
1598  }
1599 
1600  if (Wnd->spwndParent != NULL)
1601  Wnd = DesktopPtrToUser(Wnd->spwndParent);
1602  else
1603  break;
1604 
1605  } while (Wnd != NULL);
1606  }
1608  {
1609  Ret = FALSE;
1610  }
1611  _SEH2_END;
1612  }
1613 
1614  return Ret;
1615 }
1616 
1617 
1618 /*
1619  * @implemented
1620  */
1621 BOOL WINAPI
1623 {
1624  // AG: I don't know if child windows are affected if the parent is
1625  // disabled. I think they stop processing messages but stay appearing
1626  // as enabled.
1627 
1629 }
1630 
1631 
1632 /*
1633  * @implemented
1634  */
1635 BOOL WINAPI
1637 {
1638  return (GetWindowLongPtrW(hWnd, GWL_STYLE) & WS_MAXIMIZE) != 0;
1639 }
1640 
1641 
1642 /*
1643  * @implemented
1644  */
1645 BOOL WINAPI
1647 {
1648  return NtUserxLockSetForegroundWindow(uLockCode);
1649 }
1650 
1651 
1652 /*
1653  * @implemented
1654  */
1655 BOOL WINAPI
1657  DWORD dwTime,
1658  DWORD dwFlags)
1659 {
1660  /* FIXME Add animation code */
1661 
1662  /* If trying to show/hide and it's already *
1663  * shown/hidden or invalid window, fail with *
1664  * invalid parameter */
1665 
1666  BOOL visible;
1667  visible = IsWindowVisible(hwnd);
1668  if(!IsWindow(hwnd) ||
1669  (visible && !(dwFlags & AW_HIDE)) ||
1670  (!visible && (dwFlags & AW_HIDE)))
1671  {
1673  return FALSE;
1674  }
1675 
1676  ShowWindow(hwnd, (dwFlags & AW_HIDE) ? SW_HIDE : ((dwFlags & AW_ACTIVATE) ? SW_SHOW : SW_SHOWNA));
1677 
1678  return TRUE;
1679 }
1680 
1681 
1682 /*
1683  * @implemented
1684  */
1685 BOOL WINAPI
1687 {
1689  return FALSE;
1690 
1692  return TRUE;
1693 }
1694 
1695 
1696 /*
1697  * @implemented
1698  */
1699 HWND WINAPI
1701  POINT ptParentClientCoords)
1702 {
1703  return NtUserRealChildWindowFromPoint(hwndParent, ptParentClientCoords.x, ptParentClientCoords.y);
1704 }
1705 
1706 /*
1707  * @unimplemented
1708  */
1709 BOOL WINAPI
1711 {
1713 }
1714 
1715 
1716 /*
1717  * @implemented
1718  */
1719 BOOL WINAPI
1721 {
1723 }
1724 
1725 
1726 /*
1727  * @implemented
1728  */
1729 BOOL
1730 WINAPI
1733  LPCSTR lpString)
1734 {
1735  PWND pwnd;
1736 
1737  pwnd = ValidateHwnd(hWnd);
1738  if (pwnd)
1739  {
1740  if (!TestWindowProcess(pwnd))
1741  {
1742  /* do not send WM_GETTEXT messages to other processes */
1743  return (DefWindowProcA(hWnd, WM_SETTEXT, 0, (LPARAM)lpString) >= 0);
1744  }
1745  return (SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)lpString) >= 0);
1746  }
1747  return FALSE;
1748 }
1749 
1750 
1751 /*
1752  * @implemented
1753  */
1754 BOOL
1755 WINAPI
1758  LPCWSTR lpString)
1759 {
1760  PWND pwnd;
1761 
1762  pwnd = ValidateHwnd(hWnd);
1763  if (pwnd)
1764  {
1765  if (!TestWindowProcess(pwnd))
1766  {
1767  /* do not send WM_GETTEXT messages to other processes */
1768  return (DefWindowProcW(hWnd, WM_SETTEXT, 0, (LPARAM)lpString) >= 0);
1769  }
1770  return (SendMessageW(hWnd, WM_SETTEXT, 0, (LPARAM)lpString) >= 0);
1771  }
1772  return FALSE;
1773 }
1774 
1775 
1776 /*
1777  * @implemented
1778  */
1779 BOOL WINAPI
1781 {
1782  return NtUserxShowOwnedPopups(hWnd, fShow);
1783 }
1784 
1785 
1786 /*
1787  * @implemented
1788  */
1789 BOOL WINAPI
1791  HDC hdcDst,
1792  POINT *pptDst,
1793  SIZE *psize,
1794  HDC hdcSrc,
1795  POINT *pptSrc,
1796  COLORREF crKey,
1797  BLENDFUNCTION *pbl,
1798  DWORD dwFlags)
1799 {
1800  if (dwFlags & ULW_EX_NORESIZE) /* only valid for UpdateLayeredWindowIndirect */
1801  {
1803  return FALSE;
1804  }
1806  hdcDst,
1807  pptDst,
1808  psize,
1809  hdcSrc,
1810  pptSrc,
1811  crKey,
1812  pbl,
1813  dwFlags,
1814  NULL);
1815 }
1816 
1817 /*
1818  * @implemented
1819  */
1820 BOOL WINAPI
1822  const UPDATELAYEREDWINDOWINFO *info)
1823 {
1824  if (info && info->cbSize == sizeof(*info))
1825  {
1827  info->hdcDst,
1828  (POINT *)info->pptDst,
1829  (SIZE *)info->psize,
1830  info->hdcSrc,
1831  (POINT *)info->pptSrc,
1832  info->crKey,
1833  (BLENDFUNCTION *)info->pblend,
1834  info->dwFlags,
1835  (RECT *)info->prcDirty);
1836  }
1838  return FALSE;
1839 }
1840 
1841 /*
1842  * @implemented
1843  */
1844 BOOL WINAPI
1846  DWORD dwContextHelpId)
1847 {
1848  return NtUserxSetWindowContextHelpId(hwnd, dwContextHelpId);
1849 }
1850 
1851 /*
1852  * @implemented
1853  */
1854 DWORD WINAPI
1856 {
1858 }
1859 
1860 /*
1861  * @implemented
1862  */
1863 int WINAPI
1865 {
1866  INT Ret = NtUserInternalGetWindowText(hWnd, lpString, nMaxCount);
1867  if (Ret == 0 && lpString)
1868  *lpString = L'\0';
1869  return Ret;
1870 }
1871 
1872 /*
1873  * @implemented
1874  */
1875 BOOL WINAPI
1877 {
1878  PWND Window;
1879  UNICODE_STRING ClassName;
1880  WCHAR szClass[16];
1881  static const UNICODE_STRING GhostClass = RTL_CONSTANT_STRING(L"Ghost");
1882 
1883  /* Ghost is a hung window */
1884  RtlInitEmptyUnicodeString(&ClassName, szClass, sizeof(szClass));
1886  if (Window && Window->fnid == FNID_GHOST &&
1887  NtUserGetClassName(hwnd, FALSE, &ClassName) &&
1888  RtlEqualUnicodeString(&ClassName, &GhostClass, TRUE))
1889  {
1890  return TRUE;
1891  }
1892 
1893  return (NtUserQueryWindow(hwnd, QUERY_WINDOW_ISHUNG) != 0);
1894 }
1895 
1896 /*
1897  * @implemented
1898  */
1899 VOID WINAPI
1900 SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
1901 {
1902  SetLastError(dwErrCode);
1903 }
1904 
1905 /*
1906  * @implemented
1907  */
1908 HWND WINAPI
1910 {
1912 }
1913 
1914 DWORD WINAPI
1916 {
1918 }
1919 
1920 /*
1921  * @implemented
1922  */
1923 HWND WINAPI
1925 {
1926  return NtUserxSetTaskmanWindow(hWnd);
1927 }
1928 
1929 /*
1930  * @implemented
1931  */
1932 HWND WINAPI
1934 {
1935  return NtUserxSetProgmanWindow(hWnd);
1936 }
1937 
1938 /*
1939  * @implemented
1940  */
1941 HWND WINAPI
1943 {
1945 }
1946 
1947 /*
1948  * @implemented
1949  */
1950 HWND WINAPI
1952 {
1954 }
1955 
1956 /*
1957  * @implemented
1958  */
1959 BOOL WINAPI
1961  int dx,
1962  int dy,
1963  CONST RECT *lpRect,
1964  CONST RECT *prcClip)
1965 {
1966  return NtUserScrollWindowEx(hWnd,
1967  dx,
1968  dy,
1969  lpRect,
1970  prcClip,
1971  0,
1972  NULL,
1974 }
1975 
1976 /* ScrollWindow uses the window DC, ScrollWindowEx doesn't */
1977 
1978 /*
1979  * @implemented
1980  */
1981 INT WINAPI
1983  int dx,
1984  int dy,
1985  CONST RECT *prcScroll,
1986  CONST RECT *prcClip,
1987  HRGN hrgnUpdate,
1988  LPRECT prcUpdate,
1989  UINT flags)
1990 {
1991  if (flags & SW_SMOOTHSCROLL)
1992  {
1993  FIXME("SW_SMOOTHSCROLL not supported.");
1994  // Fall through....
1995  }
1996  return NtUserScrollWindowEx(hWnd,
1997  dx,
1998  dy,
1999  prcScroll,
2000  prcClip,
2001  hrgnUpdate,
2002  prcUpdate,
2003  flags);
2004 }
2005 
2006 /*
2007  * @implemented
2008  */
2009 BOOL WINAPI
2011 {
2012  int i;
2013  BOOL retvalue;
2015 
2016  if (!list) return FALSE;
2017  for (i = 0; list[i]; i++)
2018  {
2019  if (IsWindowVisible( list[i] ) && GetWindow( list[i], GW_OWNER )) break;
2020  }
2021  retvalue = (list[i] != 0);
2022  HeapFree( GetProcessHeap(), 0, list );
2023  return retvalue;
2024 }
2025 
2026 /*
2027  * @implemented
2028  */
2029 BOOL WINAPI
2031 {
2032  PWND pwnd;
2033  pwnd = ValidateHwnd(hWnd);
2034  if (!pwnd)
2035  return FALSE;
2036  return ((pwnd->state2 & WNDS2_INDESTROY) == WNDS2_INDESTROY);
2037 }
2038 
2039 /*
2040  * @implemented
2041  */
2042 VOID WINAPI
2044 {
2046 }
2047 
2048 /* EOF */
2049 
#define GW_HWNDNEXT
Definition: winuser.h:756
#define WS_CLIPSIBLINGS
Definition: pedump.c:618
HWND NTAPI NtUserCreateWindowEx(DWORD dwExStyle, PLARGE_STRING plstrClassName, PLARGE_STRING plstrClsVersion, PLARGE_STRING plstrWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam, DWORD dwFlags, PVOID acbiBuffer)
Definition: window.c:2426
VOID NTAPI RtlInitLargeUnicodeString(IN OUT PLARGE_UNICODE_STRING, IN PCWSTR, IN INT)
Definition: rtlstr.c:42
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
static const WCHAR classW[]
Definition: lex.c:40
#define WM_GETTEXTLENGTH
Definition: winuser.h:1601
CONST char * PCSZ
Definition: umtypes.h:125
#define WS_DISABLED
Definition: pedump.c:621
HWND APIENTRY NtUserGetAncestor(HWND hWnd, UINT Type)
Definition: window.c:3148
WINE_DEFAULT_DEBUG_CHANNEL(oleacc)
DWORD WINAPI GetModuleFileNameW(HINSTANCE hModule, LPWSTR lpFilename, DWORD nSize)
Definition: loader.c:600
#define WS_THICKFRAME
Definition: pedump.c:630
HWND WINAPI DECLSPEC_HOTPATCH CreateWindowExA(DWORD dwExStyle, LPCSTR lpClassName, LPCSTR lpWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam)
Definition: window.c:380
const DOCKBAR PVOID HWND HWND * hwnd
Definition: tooldock.h:22
const uint16_t * PCWSTR
Definition: typedefs.h:57
#define IN
Definition: typedefs.h:39
HINSTANCE hLibModule
Definition: sfc.c:23
DWORD ExStyle
Definition: ntuser.h:668
BOOL WINAPI EnumThreadWindows(DWORD dwThreadId, WNDENUMPROC lpfn, LPARAM lParam)
Definition: window.c:786
VOID NTAPI RtlFreeLargeString(IN PLARGE_STRING LargeString)
Definition: window.c:141
#define QUERY_WINDOW_UNIQUE_THREAD_ID
Definition: ntuser.h:2803
LPCSTR lpszMenuName
Definition: winuser.h:3185
DWORD cbSize
Definition: winuser.h:3741
#define QUERY_WINDOW_UNIQUE_PROCESS_ID
Definition: ntuser.h:2802
BOOL WINAPI GetClassInfoExW(_In_opt_ HINSTANCE, _In_ LPCWSTR, _Out_ LPWNDCLASSEXW)
PWND FASTCALL ValidateHwndNoErr(HWND hWnd)
Definition: window.c:96
LPCWSTR FASTCALL ClassNameToVersion(const void *lpszClass, LPCWSTR lpszMenuName, LPCWSTR *plpLibFileName, HANDLE *pContext, BOOL bAnsi)
Definition: class.c:85
DWORD WINAPI GetWindowContextHelpId(HWND hwnd)
Definition: window.c:1855
#define WS_ACTIVECAPTION
Definition: winuser.h:2634
int WINAPI InternalGetWindowText(HWND hWnd, LPWSTR lpString, int nMaxCount)
Definition: window.c:1864
HWND WINAPI ChildWindowFromPoint(HWND hWndParent, POINT Point)
Definition: window.c:92
DWORD_PTR NTAPI NtUserGetThreadState(DWORD Routine)
Definition: misc.c:231
_Must_inspect_result_ _Out_ LPSIZE psize
Definition: ntgdi.h:1569
int WINAPI GetWindowTextA(HWND hWnd, LPSTR lpString, int nMaxCount)
Definition: window.c:1330
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
#define GW_CHILD
Definition: winuser.h:758
UINT WINAPI GetWindowModuleFileNameA(HWND hwnd, LPSTR lpszFileName, UINT cchFileNameMax)
Definition: window.c:1271
long y
Definition: polytest.cpp:48
#define DWORD_PTR
Definition: treelist.c:76
BOOL WINAPI OffsetRect(_Inout_ LPRECT, _In_ int, _In_ int)
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
#define DbgPrint
Definition: loader.c:25
USHORT MaximumLength
Definition: env_spec_w32.h:370
HWND WINAPI GetParent(HWND hWnd)
Definition: window.c:1073
long x
Definition: polytest.cpp:48
PVOID Buffer
Definition: ntuser.h:97
#define MAKEWORD(a, b)
Definition: typedefs.h:248
HDWP WINAPI DeferWindowPos(HDWP hWinPosInfo, HWND hWnd, HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT uFlags)
Definition: window.c:629
#define TRUE
Definition: types.h:120
#define pt(x, y)
Definition: drawing.c:79
DWORD dwStyle
Definition: winuser.h:3744
#define SM_CXMINIMIZED
Definition: winuser.h:1010
#define SW_HIDE
Definition: winuser.h:762
UINT cxWindowBorders
Definition: winuser.h:3747
LRESULT WINAPI SendMessageA(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
uint16_t * PWSTR
Definition: typedefs.h:56
HINSTANCE hModule
Definition: ntuser.h:672
#define ERROR(name)
Definition: error_private.h:53
BOOL WINAPI EnumWindows(WNDENUMPROC lpEnumFunc, LPARAM lParam)
Definition: window.c:800
#define CP_ACP
Definition: compat.h:109
EXTINLINE DWORD NtUserxGetWindowContextHelpId(HWND hwnd)
Definition: ntwrapper.h:726
GLint dy
Definition: linetemp.h:97
HMENU WINAPI LoadMenuA(_In_opt_ HINSTANCE, _In_ LPCSTR)
VOID UserGetWindowBorders(DWORD Style, DWORD ExStyle, SIZE *Size, BOOL WithClient)
Definition: winpos.c:885
#define QUERY_WINDOW_REAL_ID
Definition: ntuser.h:2807
#define WM_GETTEXT
Definition: winuser.h:1600
#define WARN(fmt,...)
Definition: debug.h:112
LONG NTSTATUS
Definition: precomp.h:26
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
static HDC
Definition: imagelist.c:92
#define WM_SETREDRAW
Definition: winuser.h:1598
HWND hWnd
Definition: settings.c:17
#define CW_USEDEFAULT16
Definition: undocuser.h:167
LONG top
Definition: windef.h:307
BOOL FASTCALL TestWindowProcess(PWND)
Definition: misc.c:176
HWND WINAPI GetTaskmanWindow(VOID)
Definition: window.c:1951
#define NUCWE_ANSI
Definition: undocuser.h:74
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
UINT cyWindowBorders
Definition: winuser.h:3748
DWORD_PTR NTAPI NtUserCallOneParam(DWORD_PTR Param, DWORD Routine)
Definition: simplecall.c:145
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
HWND NTAPI NtUserChildWindowFromPointEx(HWND Parent, LONG x, LONG y, UINT Flags)
Definition: winpos.c:3126
#define HWND_TOP
Definition: winuser.h:1193
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
BOOL NTAPI NtUserEndDeferWindowPosEx(HDWP WinPosInfo, DWORD Unknown1)
Definition: winpos.c:3147
WORD wCreatorVersion
Definition: winuser.h:3750
#define WS_CHILD
Definition: pedump.c:617
RECT rcClient
Definition: ntuser.h:681
#define GetWindowLongPtrW
Definition: winuser.h:4804
HDWP WINAPI BeginDeferWindowPos(int nNumWindows)
Definition: window.c:59
LONG left
Definition: windef.h:306
BOOL WINAPI IsWindowUnicode(HWND hWnd)
Definition: window.c:1566
UINT uFlags
Definition: api.c:59
BOOL WINAPI ShowWindow(_In_ HWND, _In_ int)
static HDC hdcSrc
Definition: xlate.c:32
#define SW_SHOWMINIMIZED
Definition: winuser.h:765
char * LPSTR
Definition: xmlstorage.h:182
#define SW_RESTORE
Definition: winuser.h:773
BOOL WINAPI AllowSetForegroundWindow(DWORD dwProcessId)
Definition: window.c:49
BOOL(CALLBACK * WNDENUMPROC)(HWND, LPARAM)
Definition: winuser.h:2883
LONG right
Definition: windef.h:308
ATOM atomWindowType
Definition: winuser.h:3749
#define FASTCALL
Definition: nt_native.h:50
DWORD_PTR APIENTRY NtUserQueryWindow(HWND hWnd, DWORD Index)
Definition: window.c:3929
RTL_ATOM atomClassName
Definition: ntuser.h:536
int32_t INT
Definition: typedefs.h:58
DWORD WINAPI GetModuleFileNameA(HINSTANCE hModule, LPSTR lpFilename, DWORD nSize)
Definition: loader.c:539
VOID WINAPI DisableProcessWindowsGhosting(VOID)
Definition: window.c:2043
BOOL WINAPI IsZoomed(HWND hWnd)
Definition: window.c:1636
HWND WINAPI SetProgmanWindow(HWND hWnd)
Definition: window.c:1933
LRESULT WINAPI DefWindowProcW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
_SEH2_TRY
Definition: create.c:4226
struct _THREADINFO * GetW32ThreadInfo(VOID)
Definition: misc.c:779
BOOL WINAPI OpenIcon(HWND hWnd)
Definition: window.c:1686
uint32_t ULONG_PTR
Definition: typedefs.h:65
UINT WINAPI GetWindowModuleFileNameW(HWND hwnd, LPWSTR lpszFileName, UINT cchFileNameMax)
Definition: window.c:1288
#define ULW_EX_NORESIZE
Definition: winuser.h:2762
BOOL WINAPI GetClientRect(HWND hWnd, LPRECT lpRect)
Definition: window.c:1005
void MDI_CalcDefaultChildPos(HWND hwndClient, INT total, LPPOINT lpPos, INT delta, UINT *id)
Definition: mdi.c:309
Definition: window.c:28
HWND WINAPI ChildWindowFromPointEx(HWND hwndParent, POINT pt, UINT uFlags)
Definition: window.c:103
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
HINSTANCE hInstance
Definition: charmap.c:20
#define WS_EX_MDICHILD
Definition: winuser.h:394
LPCWSTR lpszMenuName
Definition: winuser.h:3200
static __inline PVOID DesktopPtrToUser(PVOID Ptr)
Definition: user_x.h:12
BOOL NTAPI NtUserUpdateLayeredWindow(HWND hwnd, HDC hdcDst, POINT *pptDst, SIZE *psize, HDC hdcSrc, POINT *pptSrc, COLORREF crKey, BLENDFUNCTION *pblend, DWORD dwFlags, RECT *prcDirty)
Definition: layered.c:341
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define FALSE
Definition: types.h:117
HWND WINAPI SetActiveWindow(_In_ HWND)
DWORD WINAPI GetWindowThreadProcessId(HWND hWnd, LPDWORD lpdwProcessId)
Definition: window.c:1447
#define WS_MINIMIZE
Definition: pedump.c:622
DWORD fnid
Definition: ntuser.h:673
unsigned int BOOL
Definition: ntddk_ex.h:94
HWND WINAPI GetDesktopWindow(VOID)
Definition: window.c:656
EXTINLINE BOOL NtUserxLockSetForegroundWindow(UINT uLockCode)
Definition: ntwrapper.h:841
#define GA_PARENT
Definition: winuser.h:2763
int WINAPI GetWindowTextLengthA(HWND hWnd)
Definition: window.c:1368
BOOL WINAPI SetWindowContextHelpId(HWND hwnd, DWORD dwContextHelpId)
Definition: window.c:1845
INT WINAPI ScrollWindowEx(HWND hWnd, int dx, int dy, CONST RECT *prcScroll, CONST RECT *prcClip, HRGN hrgnUpdate, LPRECT prcUpdate, UINT flags)
Definition: window.c:1982
HWND WINAPI GetFocus(VOID)
Definition: window.c:1909
#define FIXME(fmt,...)
Definition: debug.h:111
BOOL WINAPI IsHungAppWindow(HWND hwnd)
Definition: window.c:1876
#define SW_ERASE
Definition: winuser.h:2555
struct _WND * spwndOwner
Definition: ntuser.h:679
#define CW_USEDEFAULT
Definition: winuser.h:225
HWND WINAPI RealChildWindowFromPoint(HWND hwndParent, POINT ptParentClientCoords)
Definition: window.c:1700
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:581
BOOL WINAPI IsWindowVisible(HWND hWnd)
Definition: window.c:1581
THRDESKHEAD head
Definition: ntuser.h:659
#define MAKELONG(a, b)
Definition: typedefs.h:249
BOOL WINAPI DECLSPEC_HOTPATCH SetWindowTextA(HWND hWnd, LPCSTR lpString)
Definition: window.c:1732
smooth NULL
Definition: ftsmooth.c:416
static HWND hwndParent
Definition: cryptui.c:300
HWND WINAPI FindWindowExA(HWND hwndParent, HWND hwndChildAfter, LPCSTR lpszClass, LPCSTR lpszWindow)
Definition: window.c:823
#define FORCEINLINE
Definition: ntbasedef.h:221
Definition: ntuser.h:533
LONG_PTR LPARAM
Definition: windef.h:208
BOOL WINAPI GetWindowRect(HWND hWnd, LPRECT lpRect)
Definition: window.c:1304
UINT cbSize
Definition: winuser.h:3176
HWND WINAPI GetWindow(HWND hWnd, UINT uCmd)
Definition: window.c:1123
HWND WINAPI GetLastActivePopup(HWND hWnd)
Definition: window.c:1043
static BOOL User32EnumWindows(HDESK hDesktop, HWND hWndparent, WNDENUMPROC lpfn, LPARAM lParam, DWORD dwThreadId, BOOL bChildren)
Definition: window.c:678
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
DWORD NTAPI NtUserScrollWindowEx(HWND hWnd, INT dx, INT dy, const RECT *rect, const RECT *clipRect, HRGN hrgnUpdate, LPRECT rcUpdate, UINT flags)
Definition: scrollex.c:571
struct _WND * spwndNext
Definition: ntuser.h:675
BOOL WINAPI LockSetForegroundWindow(UINT uLockCode)
Definition: window.c:1646
const char * LPCSTR
Definition: xmlstorage.h:183
void * PVOID
Definition: retypes.h:9
RECT rcWindow
Definition: winuser.h:3742
#define SW_SHOW
Definition: winuser.h:769
#define WS_MAXIMIZEBOX
Definition: pedump.c:632
VOID WINAPI SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
Definition: window.c:1900
#define SW_SCROLLWNDDCE
Definition: undocuser.h:90
HWND WINAPI GetAncestor(HWND hwnd, UINT gaFlags)
Definition: window.c:960
#define FNID_MDICLIENT
Definition: ntuser.h:834
#define WM_SETTEXT
Definition: winuser.h:1599
INT APIENTRY NtUserInternalGetWindowText(HWND hWnd, LPWSTR lpString, INT nMaxCount)
Definition: window.c:4326
DWORD WINAPI GetCurrentThreadId(VOID)
Definition: thread.c:458
HWND APIENTRY NtUserFindWindowEx(HWND hwndParent, HWND hwndChildAfter, PUNICODE_STRING ucClassName, PUNICODE_STRING ucWindowName, DWORD dwUnknown)
Definition: window.c:2878
BOOL WINAPI GetProcessDefaultLayout(DWORD *pdwDefaultLayout)
Definition: window.c:1113
BOOL WINAPI EnumChildWindows(HWND hWndParent, WNDENUMPROC lpEnumFunc, LPARAM lParam)
Definition: window.c:770
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
#define DECLSPEC_HOTPATCH
Definition: _mingw.h:242
BOOL WINAPI SetForegroundWindow(HWND hWnd)
Definition: window.c:1710
#define WS_MINIMIZED
Definition: undocuser.h:18
DWORD dwTime
Definition: solitaire.cpp:25
BOOL WINAPI SetProcessDefaultLayout(DWORD dwDefaultLayout)
Definition: window.c:1720
BOOL WINAPI UpdateLayeredWindow(HWND hwnd, HDC hdcDst, POINT *pptDst, SIZE *psize, HDC hdcSrc, POINT *pptSrc, COLORREF crKey, BLENDFUNCTION *pbl, DWORD dwFlags)
Definition: window.c:1790
NTSTATUS WINAPI User32CallSendAsyncProcForKernel(PVOID Arguments, ULONG ArgumentLength)
Definition: window.c:24
#define UserHMGetHandle(obj)
Definition: ntuser.h:208
#define WS_CAPTION
Definition: pedump.c:624
BOOL WINAPI CloseWindow(HWND hWnd)
Definition: window.c:115
_In_ HANDLE Handle
Definition: extypes.h:390
BOOL WINAPI IsWindow(HWND hWnd)
Definition: window.c:1547
BOOL NTAPI NtUserGetAltTabInfo(HWND hwnd, INT iItem, PALTTABINFO pati, LPWSTR pszItemText, UINT cchItemText, BOOL Ansi)
Definition: ntstubs.c:109
DWORD dwExStyle
Definition: winuser.h:3745
#define TRACE(s)
Definition: solgame.cpp:4
#define FreeLibrary(x)
Definition: compat.h:496
EXTINLINE BOOL NtUserxAllowSetForegroundWindow(DWORD dwProcessId)
Definition: ntwrapper.h:836
#define IS_INTRESOURCE(i)
Definition: winuser.h:580
#define GetProcessHeap()
Definition: compat.h:484
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
NTSYSAPI NTSTATUS WINAPI RtlMultiByteToUnicodeN(LPWSTR, DWORD, LPDWORD, LPCSTR, DWORD)
NTSTATUS APIENTRY NtUserBuildHwndList(HDESK hDesktop, HWND hwndParent, BOOLEAN bChildren, ULONG dwThreadId, ULONG lParam, HWND *pWnd, ULONG *pBufSize)
Definition: window.c:1338
__wchar_t WCHAR
Definition: xmlstorage.h:180
BOOL WINAPI IsWindowEnabled(HWND hWnd)
Definition: window.c:1622
VOID NTAPI RtlInitLargeAnsiString(IN OUT PLARGE_ANSI_STRING, IN PCSZ, IN INT)
Definition: rtlstr.c:17
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define MDIS_ALLCHILDSTYLES
Definition: winuser.h:253
UINT cbSize
Definition: winuser.h:3191
ULONG Length
Definition: ntuser.h:94
DWORD COLORREF
Definition: windef.h:300
#define UlongToHandle(ul)
Definition: basetsd.h:97
DWORD dwWindowStatus
Definition: winuser.h:3746
BOOL WINAPI IsWindowInDestroy(HWND hWnd)
Definition: window.c:2030
#define WINAPI
Definition: msvc.h:6
#define GW_HWNDLAST
Definition: winuser.h:760
EXTINLINE VOID NtUserxEnableProcessWindowGhosting(BOOL bEnable)
Definition: ntwrapper.h:801
static const WCHAR titleW[]
Definition: htmlelem.c:1067
int WINAPI GetSystemMetrics(_In_ int)
CHAR AnsiBuffer[1024]
Definition: debug.c:15
unsigned long DWORD
Definition: ntddk_ex.h:95
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define SetLastError(x)
Definition: compat.h:500
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
#define LPVOID
Definition: nt_native.h:45
HWND WINAPI User32CreateWindowEx(DWORD dwExStyle, LPCSTR lpClassName, LPCSTR lpWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam, DWORD dwFlags)
Definition: window.c:180
HDWP NTAPI NtUserDeferWindowPos(HDWP WinPosInfo, HWND Wnd, HWND WndInsertAfter, int x, int y, int cx, int cy, UINT Flags)
Definition: winpos.c:3163
int Window
Definition: x11stubs.h:26
GLbitfield flags
Definition: glext.h:7161
BOOL WINAPI IsChild(HWND hWndParent, HWND hWnd)
Definition: window.c:1483
BOOL WINAPI AnimateWindow(HWND hwnd, DWORD dwTime, DWORD dwFlags)
Definition: window.c:1656
DWORD dwThreadId
Definition: fdebug.c:31
Status
Definition: gdiplustypes.h:24
#define QUERY_WINDOW_ISHUNG
Definition: ntuser.h:2806
BOOL WINAPI ScrollWindow(HWND hWnd, int dx, int dy, CONST RECT *lpRect, CONST RECT *prcClip)
Definition: window.c:1960
#define SM_CYMINIMIZED
Definition: winuser.h:1011
#define WNDS2_WIN50COMPAT
Definition: ntuser.h:619
static const WCHAR L[]
Definition: oid.c:1250
PWND FASTCALL ValidateHwnd(HWND hwnd)
Definition: misc.c:369
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
EXTINLINE VOID NtUserxSwitchToThisWindow(HWND hWnd, BOOL fAltTab)
Definition: ntwrapper.h:691
GLenum GLsizei len
Definition: glext.h:6722
#define WNDS_ACTIVEFRAME
Definition: ntuser.h:579
Definition: _list.h:228
RECT rcWindow
Definition: ntuser.h:680
LRESULT WINAPI DefWindowProcA(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define GW_HWNDFIRST
Definition: winuser.h:759
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
uint32_t DWORD_PTR
Definition: typedefs.h:65
HWND NTAPI NtUserRealChildWindowFromPoint(HWND Parent, LONG x, LONG y)
Definition: winpos.c:3388
#define SW_SHOWNA
Definition: winuser.h:772
IMAGE_OPTIONAL_HEADER32 OptionalHeader
Definition: ntddk_ex.h:184
#define SW_INVALIDATE
Definition: winuser.h:2554
EXTINLINE HDWP NtUserxBeginDeferWindowPos(INT nNumWindows)
Definition: ntwrapper.h:651
BOOL WINAPI UpdateLayeredWindowIndirect(HWND hwnd, const UPDATELAYEREDWINDOWINFO *info)
Definition: window.c:1821
#define WS_EX_SETANSICREATOR
Definition: undocuser.h:28
#define SWP_NOSIZE
Definition: winuser.h:1230
#define ERR(fmt,...)
Definition: debug.h:110
HWND WINAPI GetProgmanWindow(VOID)
Definition: window.c:1942
#define GWL_STYLE
Definition: winuser.h:846
Definition: ntuser.h:657
EXTINLINE BOOL NtUserxSetForegroundWindow(HWND hWnd)
Definition: ntwrapper.h:788
#define FNID_GHOST
Definition: ntuser.h:837
HWND WINAPI DECLSPEC_HOTPATCH CreateWindowExW(DWORD dwExStyle, LPCWSTR lpClassName, LPCWSTR lpWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam)
Definition: window.c:506
BOOL WINAPI GetClassInfoExA(_In_opt_ HINSTANCE, _In_ LPCSTR, _Out_ LPWNDCLASSEXA)
_SEH2_END
Definition: create.c:4400
static HDC hdcDst
Definition: xlate.c:32
FORCEINLINE struct _TEB * NtCurrentTeb(VOID)
Definition: psfuncs.h:420
HWND WINAPI SetTaskmanWindow(HWND hWnd)
Definition: window.c:1924
EXTINLINE BOOL NtUserxSetWindowContextHelpId(HWND hWnd, DWORD_PTR dwContextHelpId)
Definition: ntwrapper.h:706
#define WS_MINIMIZEBOX
Definition: pedump.c:631
INT NTAPI NtUserGetClassName(HWND hWnd, BOOL Real, PUNICODE_STRING ClassName)
int WINAPI GetWindowTextW(HWND hWnd, LPWSTR lpString, int nMaxCount)
Definition: window.c:1412
HWND WINAPI FindWindowW(LPCWSTR lpClassName, LPCWSTR lpWindowName)
Definition: window.c:910
BOOL WINAPI ShowOwnedPopups(HWND hWnd, BOOL fShow)
Definition: window.c:1780
struct _WND * spwndLastActive
Definition: ntuser.h:703
BOOL WINAPI AnyPopup(VOID)
Definition: window.c:2010
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
BOOL WINAPI IsIconic(HWND hWnd)
Definition: window.c:1532
signed char * PSTR
Definition: retypes.h:7
DWORD state
Definition: ntuser.h:665
BOOL NTAPI NtUserSetWindowPos(HWND hWnd, HWND hWndInsertAfter, int X, int Y, int cx, int cy, UINT uFlags)
Definition: winpos.c:3408
#define WNDS2_WIN31COMPAT
Definition: ntuser.h:617
#define WS_POPUP
Definition: pedump.c:616
unsigned int UINT
Definition: ndis.h:50
#define GW_OWNER
Definition: winuser.h:761
#define SW_SCROLLCHILDREN
Definition: winuser.h:2553
DWORD WINAPI GetRealWindowOwner(HWND hwnd)
Definition: window.c:1915
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLint dx
Definition: linetemp.h:97
#define MultiByteToWideChar
Definition: compat.h:110
EXTINLINE BOOL NtUserxShowOwnedPopups(HWND hWnd, BOOL fShow)
Definition: ntwrapper.h:696
#define RtlImageNtHeader
Definition: compat.h:554
HWND * WIN_ListChildren(HWND hWndparent)
Definition: mdi.c:140
CONST void * LPCVOID
Definition: windef.h:191
PWND FASTCALL GetThreadDesktopWnd(VOID)
Definition: misc.c:407
_Out_opt_ int * cx
Definition: commctrl.h:581
static UNICODE_STRING GhostClass
Definition: ghost.c:16
#define OUT
Definition: typedefs.h:40
uint32_t * LPDWORD
Definition: typedefs.h:59
HMENU WINAPI LoadMenuW(_In_opt_ HINSTANCE, _In_ LPCWSTR)
struct _WND * spwndParent
Definition: ntuser.h:677
#define WS_OVERLAPPEDWINDOW
Definition: pedump.c:637
BOOL WINAPI RegisterSystemControls(VOID)
Definition: regcontrol.c:70
FORCEINLINE VOID RtlInitLargeString(OUT PLARGE_STRING plstr, LPCVOID psz, BOOL bUnicode)
Definition: window.c:124
HWND WINAPI FindWindowExW(HWND hwndParent, HWND hwndChildAfter, LPCWSTR lpszClass, LPCWSTR lpszWindow)
Definition: window.c:858
unsigned int ULONG
Definition: retypes.h:1
DWORD state2
Definition: ntuser.h:666
HMODULE WINAPI GetModuleHandleW(LPCWSTR lpModuleName)
Definition: loader.c:838
EXTINLINE HWND NtUserxSetProgmanWindow(HWND hWnd)
Definition: ntwrapper.h:763
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
LONG bottom
Definition: windef.h:309
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
char * cleanup(char *str)
Definition: wpickclick.c:99
#define SWP_NOMOVE
Definition: winuser.h:1229
#define IS_ATOM(x)
Definition: class.h:3
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
DWORD RegisterDefaultClasses
Definition: regcontrol.c:13
RECT rcClient
Definition: winuser.h:3743
BOOL WINAPI GetAltTabInfoA(HWND hwnd, int iItem, PALTTABINFO pati, LPSTR pszItemText, UINT cchItemText)
Definition: window.c:932
BOOL WINAPI BringWindowToTop(HWND hWnd)
Definition: window.c:69
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define WNDS2_WIN40COMPAT
Definition: ntuser.h:618
DWORD FASTCALL RtlGetExpWinVer(HMODULE hModule)
Definition: window.c:153
struct _WND * spwndChild
Definition: ntuser.h:678
return STATUS_SUCCESS
Definition: btrfs.c:3014
#define WS_VISIBLE
Definition: pedump.c:620
HWND WINAPI GetTopWindow(HWND hWnd)
Definition: window.c:1194
BOOL WINAPI EnumDesktopWindows(HDESK hDesktop, WNDENUMPROC lpfn, LPARAM lParam)
Definition: window.c:811
#define WS_SYSMENU
Definition: pedump.c:629
int WINAPI GetWindowTextLengthW(HWND hWnd)
Definition: window.c:1390
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:60
#define WNDS_DESTROYED
Definition: ntuser.h:604
NTSYSAPI BOOLEAN NTAPI RtlEqualUnicodeString(PUNICODE_STRING String1, PUNICODE_STRING String2, BOOLEAN CaseInSensitive)
LPARAM lParam
Definition: combotst.c:139
_In_ int nMaxCount
Definition: winuser.h:4852
HWND WINAPI GetActiveWindow(void)
Definition: winpos.c:138
#define GW_HWNDPREV
Definition: winuser.h:757
VOID WINAPI SwitchToThisWindow(HWND hwnd, BOOL fAltTab)
Definition: window.c:82
UINT Unicode
Definition: ntuser.h:720
#define HeapFree(x, y, z)
Definition: compat.h:483
#define CONST
Definition: pedump.c:81
BOOL WINAPI DECLSPEC_HOTPATCH SetWindowTextW(HWND hWnd, LPCWSTR lpString)
Definition: window.c:1757
#define WNDS2_INDESTROY
Definition: ntuser.h:616
ULONG MaximumLength
Definition: ntuser.h:95
struct _SENDASYNCPROC_CALLBACK_ARGUMENTS * PSENDASYNCPROC_CALLBACK_ARGUMENTS
BOOL WINAPI DECLSPEC_HOTPATCH GetWindowInfo(HWND hWnd, PWINDOWINFO pwi)
Definition: window.c:1207
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
EXTINLINE HWND NtUserxSetTaskmanWindow(HWND hWnd)
Definition: ntwrapper.h:758
BOOL FASTCALL VersionRegisterClass(PCWSTR, LPCWSTR, HANDLE, HMODULE *)
Definition: class.c:195
HMODULE hModule
Definition: animate.c:44
BOOL WINAPI GetAltTabInfoW(HWND hwnd, int iItem, PALTTABINFO pati, LPWSTR pszItemText, UINT cchItemText)
Definition: window.c:946
BOOL WINAPI EndDeferWindowPos(HDWP hWinPosInfo)
Definition: window.c:646
HWND WINAPI FindWindowA(LPCSTR lpClassName, LPCSTR lpWindowName)
Definition: window.c:898
PCLS pcls
Definition: ntuser.h:684
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
#define WS_MAXIMIZE
Definition: pedump.c:623
DWORD style
Definition: ntuser.h:670
struct _WND * spwndPrev
Definition: ntuser.h:676
#define ERROR_CANNOT_FIND_WND_CLASS
Definition: winerror.h:888