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