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