projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
- Sync with trunk up to r46941.
[reactos.git] / subsystems / win32 / win32k / ntuser / window.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * PURPOSE: Windows
5 * FILE: subsystems/win32/win32k/ntuser/window.c
6 * PROGRAMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * REVISION HISTORY:
8 * 06-06-2001 CSH Created
9 */
10
11 /* INCLUDES ******************************************************************/
12
13 #include <w32k.h>
14
15 #define NDEBUG
16 #include <debug.h>
17
18
19 /* dialog resources appear to pass this in 16 bits, handle them properly */
20 #define CW_USEDEFAULT16 (0x8000)
21
22 #define POINT_IN_RECT(p, r) (((r.bottom >= p.y) && (r.top <= p.y))&&((r.left <= p.x )&&( r.right >= p.x )))
23
24 /* PRIVATE FUNCTIONS **********************************************************/
25
26 /*
27 * InitWindowImpl
28 *
29 * Initialize windowing implementation.
30 */
31
32 NTSTATUS FASTCALL
33 InitWindowImpl(VOID)
34 {
35 return STATUS_SUCCESS;
36 }
37
38 /*
39 * CleanupWindowImpl
40 *
41 * Cleanup windowing implementation.
42 */
43
44 NTSTATUS FASTCALL
45 CleanupWindowImpl(VOID)
46 {
47 return STATUS_SUCCESS;
48 }
49
50 /* HELPER FUNCTIONS ***********************************************************/
51
52 BOOL FASTCALL UserUpdateUiState(PWND Wnd, WPARAM wParam)
53 {
54 WORD Action = LOWORD(wParam);
55 WORD Flags = HIWORD(wParam);
56
57 if (Flags & ~(UISF_HIDEFOCUS | UISF_HIDEACCEL | UISF_ACTIVE))
58 {
59 SetLastWin32Error(ERROR_INVALID_PARAMETER);
60 return FALSE;
61 }
62
63 switch (Action)
64 {
65 case UIS_INITIALIZE:
66 SetLastWin32Error(ERROR_INVALID_PARAMETER);
67 return FALSE;
68
69 case UIS_SET:
70 if (Flags & UISF_HIDEFOCUS)
71 Wnd->HideFocus = TRUE;
72 if (Flags & UISF_HIDEACCEL)
73 Wnd->HideAccel = TRUE;
74 break;
75
76 case UIS_CLEAR:
77 if (Flags & UISF_HIDEFOCUS)
78 Wnd->HideFocus = FALSE;
79 if (Flags & UISF_HIDEACCEL)
80 Wnd->HideAccel = FALSE;
81 break;
82 }
83
84 return TRUE;
85 }
86
87 PWINDOW_OBJECT FASTCALL IntGetWindowObject(HWND hWnd)
88 {
89 PWINDOW_OBJECT Window;
90
91 if (!hWnd) return NULL;
92
93 Window = UserGetWindowObject(hWnd);
94 if (Window)
95 {
96 ASSERT(Window->head.cLockObj >= 0);
97
98 Window->head.cLockObj++;
99 }
100 return Window;
101 }
102
103 /* temp hack */
104 PWINDOW_OBJECT FASTCALL UserGetWindowObject(HWND hWnd)
105 {
106 PTHREADINFO ti;
107 PWINDOW_OBJECT Window;
108
109 if (PsGetCurrentProcess() != PsInitialSystemProcess)
110 {
111 ti = GetW32ThreadInfo();
112 if (ti == NULL)
113 {
114 SetLastWin32Error(ERROR_ACCESS_DENIED);
115 return NULL;
116 }
117 }
118
119 if (!hWnd)
120 {
121 SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
122 return NULL;
123 }
124
125 Window = (PWINDOW_OBJECT)UserGetObject(gHandleTable, hWnd, otWindow);
126 if (!Window || 0 != (Window->state & WINDOWSTATUS_DESTROYED))
127 {
128 SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
129 return NULL;
130 }
131
132 ASSERT(Window->head.cLockObj >= 0);
133 return Window;
134 }
135
136
137 /*
138 * IntIsWindow
139 *
140 * The function determines whether the specified window handle identifies
141 * an existing window.
142 *
143 * Parameters
144 * hWnd
145 * Handle to the window to test.
146 *
147 * Return Value
148 * If the window handle identifies an existing window, the return value
149 * is TRUE. If the window handle does not identify an existing window,
150 * the return value is FALSE.
151 */
152
153 BOOL FASTCALL
154 IntIsWindow(HWND hWnd)
155 {
156 PWINDOW_OBJECT Window;
157
158 if (!(Window = UserGetWindowObject(hWnd)))
159 return FALSE;
160
161 return TRUE;
162 }
163
164
165
166 /*
167 Caller must NOT dereference retval!
168 But if caller want the returned value to persist spanning a co_ call,
169 it must reference the value (because the owner is not garanteed to
170 exist just because the owned window exist)!
171 */
172 PWINDOW_OBJECT FASTCALL
173 IntGetParent(PWINDOW_OBJECT Wnd)
174 {
175 if (!Wnd->Wnd) return NULL;
176
177 if (Wnd->Wnd->style & WS_POPUP)
178 {
179 return UserGetWindowObject(Wnd->hOwner);
180 }
181 else if (Wnd->Wnd->style & WS_CHILD)
182 {
183 return Wnd->spwndParent;
184 }
185
186 return NULL;
187 }
188
189
190 /*
191 Caller must NOT dereference retval!
192 But if caller want the returned value to persist spanning a co_ call,
193 it must reference the value (because the owner is not garanteed to
194 exist just because the owned window exist)!
195 */
196 PWINDOW_OBJECT FASTCALL
197 IntGetOwner(PWINDOW_OBJECT Wnd)
198 {
199 return UserGetWindowObject(Wnd->hOwner);
200 }
201
202
203
204 /*
205 * IntWinListChildren
206 *
207 * Compile a list of all child window handles from given window.
208 *
209 * Remarks
210 * This function is similar to Wine WIN_ListChildren. The caller
211 * must free the returned list with ExFreePool.
212 */
213
214 HWND* FASTCALL
215 IntWinListChildren(PWINDOW_OBJECT Window)
216 {
217 PWINDOW_OBJECT Child;
218 HWND *List;
219 UINT Index, NumChildren = 0;
220
221 if (!Window) return NULL;
222
223 for (Child = Window->spwndChild; Child; Child = Child->spwndNext)
224 ++NumChildren;
225
226 List = ExAllocatePoolWithTag(PagedPool, (NumChildren + 1) * sizeof(HWND), TAG_WINLIST);
227 if(!List)
228 {
229 DPRINT1("Failed to allocate memory for children array\n");
230 SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
231 return NULL;
232 }
233 for (Child = Window->spwndChild, Index = 0;
234 Child != NULL;
235 Child = Child->spwndNext, ++Index)
236 List[Index] = Child->hSelf;
237 List[Index] = NULL;
238
239 return List;
240 }
241
242 /***********************************************************************
243 * IntSendDestroyMsg
244 */
245 static void IntSendDestroyMsg(HWND hWnd)
246 {
247
248 PWINDOW_OBJECT Window;
249 #if 0 /* FIXME */
250
251 GUITHREADINFO info;
252
253 if (GetGUIThreadInfo(GetCurrentThreadId(), &info))
254 {
255 if (hWnd == info.hwndCaret)
256 {
257 DestroyCaret();
258 }
259 }
260 #endif
261
262 Window = UserGetWindowObject(hWnd);
263 if (Window)
264 {
265 // USER_REFERENCE_ENTRY Ref;
266 // UserRefObjectCo(Window, &Ref);
267
268 if (!IntGetOwner(Window) && !IntGetParent(Window))
269 {
270 co_IntShellHookNotify(HSHELL_WINDOWDESTROYED, (LPARAM) hWnd);
271 }
272
273 // UserDerefObjectCo(Window);
274 }
275
276 /* The window could already be destroyed here */
277
278 /*
279 * Send the WM_DESTROY to the window.
280 */
281
282 co_IntSendMessage(hWnd, WM_DESTROY, 0, 0);
283
284 /*
285 * This WM_DESTROY message can trigger re-entrant calls to DestroyWindow
286 * make sure that the window still exists when we come back.
287 */
288 #if 0 /* FIXME */
289
290 if (IsWindow(Wnd))
291 {
292 HWND* pWndArray;
293 int i;
294
295 if (!(pWndArray = WIN_ListChildren( hwnd )))
296 return;
297
298 /* start from the end (FIXME: is this needed?) */
299 for (i = 0; pWndArray[i]; i++)
300 ;
301
302 while (--i >= 0)
303 {
304 if (IsWindow( pWndArray[i] ))
305 WIN_SendDestroyMsg( pWndArray[i] );
306 }
307 HeapFree(GetProcessHeap(), 0, pWndArray);
308 }
309 else
310 {
311 DPRINT("destroyed itself while in WM_DESTROY!\n");
312 }
313 #endif
314 }
315
316 static VOID
317 UserFreeWindowInfo(PTHREADINFO ti, PWINDOW_OBJECT WindowObject)
318 {
319 PCLIENTINFO ClientInfo = GetWin32ClientInfo();
320 PWND Wnd = WindowObject->Wnd;
321
322 if (!Wnd) return;
323
324 if (ClientInfo->CallbackWnd.pvWnd == DesktopHeapAddressToUser(WindowObject->Wnd))
325 {
326 ClientInfo->CallbackWnd.hWnd = NULL;
327 ClientInfo->CallbackWnd.pvWnd = NULL;
328 }
329
330 if (Wnd->strName.Buffer != NULL)
331 {
332 Wnd->strName.Length = 0;
333 Wnd->strName.MaximumLength = 0;
334 DesktopHeapFree(Wnd->head.rpdesk,
335 Wnd->strName.Buffer);
336 Wnd->strName.Buffer = NULL;
337 }
338
339 DesktopHeapFree(Wnd->head.rpdesk, Wnd);
340 WindowObject->Wnd = NULL;
341 }
342
343 /***********************************************************************
344 * IntDestroyWindow
345 *
346 * Destroy storage associated to a window. "Internals" p.358
347 *
348 * This is the "functional" DestroyWindows function ei. all stuff
349 * done in CreateWindow is undone here and not in DestroyWindow:-P
350
351 */
352 static LRESULT co_UserFreeWindow(PWINDOW_OBJECT Window,
353 PPROCESSINFO ProcessData,
354 PTHREADINFO ThreadData,
355 BOOLEAN SendMessages)
356 {
357 HWND *Children;
358 HWND *ChildHandle;
359 PWINDOW_OBJECT Child;
360 PMENU_OBJECT Menu;
361 BOOLEAN BelongsToThreadData;
362 PWND Wnd;
363
364 ASSERT(Window);
365
366 Wnd = Window->Wnd;
367
368 if(Window->state & WINDOWSTATUS_DESTROYING)
369 {
370 DPRINT("Tried to call IntDestroyWindow() twice\n");
371 return 0;
372 }
373 Window->state |= WINDOWSTATUS_DESTROYING;
374 Wnd->style &= ~WS_VISIBLE;
375
376 IntNotifyWinEvent(EVENT_OBJECT_DESTROY, Wnd, OBJID_WINDOW, 0);
377
378 /* remove the window already at this point from the thread window list so we
379 don't get into trouble when destroying the thread windows while we're still
380 in IntDestroyWindow() */
381 RemoveEntryList(&Window->ThreadListEntry);
382
383 BelongsToThreadData = IntWndBelongsToThread(Window, ThreadData);
384
385 IntDeRegisterShellHookWindow(Window->hSelf);
386
387 if(SendMessages)
388 {
389 /* Send destroy messages */
390 IntSendDestroyMsg(Window->hSelf);
391 }
392
393 /* free child windows */
394 Children = IntWinListChildren(Window);
395 if (Children)
396 {
397 for (ChildHandle = Children; *ChildHandle; ++ChildHandle)
398 {
399 if ((Child = IntGetWindowObject(*ChildHandle)))
400 {
401 if(!IntWndBelongsToThread(Child, ThreadData))
402 {
403 /* send WM_DESTROY messages to windows not belonging to the same thread */
404 IntSendDestroyMsg(Child->hSelf);
405 }
406 else
407 co_UserFreeWindow(Child, ProcessData, ThreadData, SendMessages);
408
409 UserDereferenceObject(Child);
410 }
411 }
412 ExFreePool(Children);
413 }
414
415 if(SendMessages)
416 {
417 /*
418 * Clear the update region to make sure no WM_PAINT messages will be
419 * generated for this window while processing the WM_NCDESTROY.
420 */
421 co_UserRedrawWindow(Window, NULL, 0,
422 RDW_VALIDATE | RDW_NOFRAME | RDW_NOERASE |
423 RDW_NOINTERNALPAINT | RDW_NOCHILDREN);
424 if(BelongsToThreadData)
425 co_IntSendMessage(Window->hSelf, WM_NCDESTROY, 0, 0);
426 }
427 MsqRemoveTimersWindow(ThreadData->MessageQueue, Window->hSelf);
428 HOOK_DestroyThreadHooks(ThreadData->pEThread); // This is needed here too!
429
430 /* flush the message queue */
431 MsqRemoveWindowMessagesFromQueue(Window);
432
433 /* from now on no messages can be sent to this window anymore */
434 Window->state |= WINDOWSTATUS_DESTROYED;
435 Wnd->state |= WNDS_DESTROYED;
436 Wnd->fnid |= FNID_FREED;
437
438 /* don't remove the WINDOWSTATUS_DESTROYING bit */
439
440 /* reset shell window handles */
441 if(ThreadData->rpdesk)
442 {
443 if (Window->hSelf == ThreadData->rpdesk->rpwinstaParent->ShellWindow)
444 ThreadData->rpdesk->rpwinstaParent->ShellWindow = NULL;
445
446 if (Window->hSelf == ThreadData->rpdesk->rpwinstaParent->ShellListView)
447 ThreadData->rpdesk->rpwinstaParent->ShellListView = NULL;
448 }
449
450 /* Unregister hot keys */
451 UnregisterWindowHotKeys (Window);
452
453 /* FIXME: do we need to fake QS_MOUSEMOVE wakebit? */
454
455 #if 0 /* FIXME */
456
457 WinPosCheckInternalPos(Window->hSelf);
458 if (Window->hSelf == GetCapture())
459 {
460 ReleaseCapture();
461 }
462
463 /* free resources associated with the window */
464 TIMER_RemoveWindowTimers(Window->hSelf);
465 #endif
466
467 if (!(Wnd->style & WS_CHILD) && Wnd->IDMenu
468 && (Menu = UserGetMenuObject((HMENU)Wnd->IDMenu)))
469 {
470 IntDestroyMenuObject(Menu, TRUE, TRUE);
471 Wnd->IDMenu = 0;
472 }
473
474 if(Window->SystemMenu
475 && (Menu = UserGetMenuObject(Window->SystemMenu)))
476 {
477 IntDestroyMenuObject(Menu, TRUE, TRUE);
478 Window->SystemMenu = (HMENU)0;
479 }
480
481 DceFreeWindowDCE(Window); /* Always do this to catch orphaned DCs */
482 #if 0 /* FIXME */
483
484 WINPROC_FreeProc(Window->winproc, WIN_PROC_WINDOW);
485 CLASS_RemoveWindow(Window->Class);
486 #endif
487
488 IntUnlinkWindow(Window);
489
490 UserReferenceObject(Window);
491 UserDeleteObject(Window->hSelf, otWindow);
492
493 IntDestroyScrollBars(Window);
494
495 /* dereference the class */
496 IntDereferenceClass(Wnd->pcls,
497 Window->pti->pDeskInfo,
498 Window->pti->ppi);
499 Wnd->pcls = NULL;
500
501 if(Window->hrgnClip)
502 {
503 GreDeleteObject(Window->hrgnClip);
504 }
505
506 ASSERT(Window->Wnd != NULL);
507 UserFreeWindowInfo(Window->pti, Window);
508
509 UserDereferenceObject(Window);
510
511 IntClipboardFreeWindow(Window);
512
513 return 0;
514 }
515
516 VOID FASTCALL
517 IntGetWindowBorderMeasures(PWINDOW_OBJECT Window, UINT *cx, UINT *cy)
518 {
519 PWND Wnd = Window->Wnd;
520 if(HAS_DLGFRAME(Wnd->style, Wnd->ExStyle) && !(Wnd->style & WS_MINIMIZE))
521 {
522 *cx = UserGetSystemMetrics(SM_CXDLGFRAME);
523 *cy = UserGetSystemMetrics(SM_CYDLGFRAME);
524 }
525 else
526 {
527 if(HAS_THICKFRAME(Wnd->style, Wnd->ExStyle)&& !(Wnd->style & WS_MINIMIZE))
528 {
529 *cx = UserGetSystemMetrics(SM_CXFRAME);
530 *cy = UserGetSystemMetrics(SM_CYFRAME);
531 }
532 else if(HAS_THINFRAME(Wnd->style, Wnd->ExStyle))
533 {
534 *cx = UserGetSystemMetrics(SM_CXBORDER);
535 *cy = UserGetSystemMetrics(SM_CYBORDER);
536 }
537 else
538 {
539 *cx = *cy = 0;
540 }
541 }
542 }
543
544 //
545 // Same as User32:IntGetWndProc.
546 //
547 WNDPROC FASTCALL
548 IntGetWindowProc(PWND pWnd,
549 BOOL Ansi)
550 {
551 INT i;
552 PCLS Class;
553 WNDPROC gcpd, Ret = 0;
554
555 ASSERT(UserIsEnteredExclusive() == TRUE);
556
557 Class = pWnd->pcls;
558
559 if (pWnd->state & WNDS_SERVERSIDEWINDOWPROC)
560 {
561 for ( i = FNID_FIRST; i <= FNID_SWITCH; i++)
562 {
563 if (GETPFNSERVER(i) == pWnd->lpfnWndProc)
564 {
565 if (Ansi)
566 Ret = GETPFNCLIENTA(i);
567 else
568 Ret = GETPFNCLIENTW(i);
569 }
570 }
571 return Ret;
572 }
573
574 if (Class->fnid == FNID_EDIT)
575 Ret = pWnd->lpfnWndProc;
576 else
577 {
578 Ret = pWnd->lpfnWndProc;
579
580 if (Class->fnid <= FNID_GHOST && Class->fnid >= FNID_BUTTON)
581 {
582 if (Ansi)
583 {
584 if (GETPFNCLIENTW(Class->fnid) == pWnd->lpfnWndProc)
585 Ret = GETPFNCLIENTA(Class->fnid);
586 }
587 else
588 {
589 if (GETPFNCLIENTA(Class->fnid) == pWnd->lpfnWndProc)
590 Ret = GETPFNCLIENTW(Class->fnid);
591 }
592 }
593 if ( Ret != pWnd->lpfnWndProc)
594 return Ret;
595 }
596 if ( Ansi == !!(pWnd->state & WNDS_ANSIWINDOWPROC) )
597 return Ret;
598
599 gcpd = (WNDPROC)UserGetCPD(
600 pWnd,
601 (Ansi ? UserGetCPDA2U : UserGetCPDU2A )|UserGetCPDWindow,
602 (ULONG_PTR)Ret);
603
604 return (gcpd ? gcpd : Ret);
605 }
606
607 static WNDPROC
608 IntSetWindowProc(PWND pWnd,
609 WNDPROC NewWndProc,
610 BOOL Ansi)
611 {
612 INT i;
613 PCALLPROCDATA CallProc;
614 PCLS Class;
615 WNDPROC Ret, chWndProc = NULL;
616
617 // Retrieve previous window proc.
618 Ret = IntGetWindowProc(pWnd, Ansi);
619
620 Class = pWnd->pcls;
621
622 if (IsCallProcHandle(NewWndProc))
623 {
624 CallProc = UserGetObject(gHandleTable, NewWndProc, otCallProc);
625 if (CallProc)
626 { // Reset new WndProc.
627 NewWndProc = CallProc->pfnClientPrevious;
628 // Reset Ansi from CallProc handle. This is expected with wine "deftest".
629 Ansi = !!(CallProc->wType & UserGetCPDU2A);
630 }
631 }
632 // Switch from Client Side call to Server Side call if match. Ref: "deftest".
633 for ( i = FNID_FIRST; i <= FNID_SWITCH; i++)
634 {
635 if (GETPFNCLIENTW(i) == NewWndProc)
636 {
637 chWndProc = GETPFNSERVER(i);
638 break;
639 }
640 if (GETPFNCLIENTA(i) == NewWndProc)
641 {
642 chWndProc = GETPFNSERVER(i);
643 break;
644 }
645 }
646 // If match, set/reset to Server Side and clear ansi.
647 if (chWndProc)
648 {
649 pWnd->lpfnWndProc = chWndProc;
650 pWnd->Unicode = TRUE;
651 pWnd->state &= ~WNDS_ANSIWINDOWPROC;
652 pWnd->state |= WNDS_SERVERSIDEWINDOWPROC;
653 }
654 else
655 {
656 pWnd->Unicode = !Ansi;
657 // Handle the state change in here.
658 if (Ansi)
659 pWnd->state |= WNDS_ANSIWINDOWPROC;
660 else
661 pWnd->state &= ~WNDS_ANSIWINDOWPROC;
662
663 if (pWnd->state & WNDS_SERVERSIDEWINDOWPROC)
664 pWnd->state &= ~WNDS_SERVERSIDEWINDOWPROC;
665
666 if (!NewWndProc) NewWndProc = pWnd->lpfnWndProc;
667
668 if (Class->fnid <= FNID_GHOST && Class->fnid >= FNID_BUTTON)
669 {
670 if (Ansi)
671 {
672 if (GETPFNCLIENTW(Class->fnid) == NewWndProc)
673 chWndProc = GETPFNCLIENTA(Class->fnid);
674 }
675 else
676 {
677 if (GETPFNCLIENTA(Class->fnid) == NewWndProc)
678 chWndProc = GETPFNCLIENTW(Class->fnid);
679 }
680 }
681 // Now set the new window proc.
682 pWnd->lpfnWndProc = (chWndProc ? chWndProc : NewWndProc);
683 }
684 return Ret;
685 }
686
687 // Move this to user space!
688 BOOL FASTCALL
689 IntGetWindowInfo(PWINDOW_OBJECT Window, PWINDOWINFO pwi)
690 {
691 PWND Wnd = Window->Wnd;
692
693 pwi->cbSize = sizeof(WINDOWINFO);
694 pwi->rcWindow = Window->Wnd->rcWindow;
695 pwi->rcClient = Window->Wnd->rcClient;
696 pwi->dwStyle = Wnd->style;
697 pwi->dwExStyle = Wnd->ExStyle;
698 pwi->dwWindowStatus = (UserGetForegroundWindow() == Window->hSelf); /* WS_ACTIVECAPTION */
699 IntGetWindowBorderMeasures(Window, &pwi->cxWindowBorders, &pwi->cyWindowBorders);
700 pwi->atomWindowType = (Wnd->pcls ? Wnd->pcls->atomClassName : 0);
701 pwi->wCreatorVersion = 0x400; /* FIXME - return a real version number */
702 return TRUE;
703 }
704
705 static BOOL FASTCALL
706 IntSetMenu(
707 PWINDOW_OBJECT Window,
708 HMENU Menu,
709 BOOL *Changed)
710 {
711 PMENU_OBJECT OldMenu, NewMenu = NULL;
712 PWND Wnd = Window->Wnd;
713
714 if ((Wnd->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
715 {
716 SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
717 return FALSE;
718 }
719
720 *Changed = (Wnd->IDMenu != (UINT) Menu);
721 if (! *Changed)
722 {
723 return TRUE;
724 }
725
726 if (Wnd->IDMenu)
727 {
728 OldMenu = IntGetMenuObject((HMENU) Wnd->IDMenu);
729 ASSERT(NULL == OldMenu || OldMenu->MenuInfo.Wnd == Window->hSelf);
730 }
731 else
732 {
733 OldMenu = NULL;
734 }
735
736 if (NULL != Menu)
737 {
738 NewMenu = IntGetMenuObject(Menu);
739 if (NULL == NewMenu)
740 {
741 if (NULL != OldMenu)
742 {
743 IntReleaseMenuObject(OldMenu);
744 }
745 SetLastWin32Error(ERROR_INVALID_MENU_HANDLE);
746 return FALSE;
747 }
748 if (NULL != NewMenu->MenuInfo.Wnd)
749 {
750 /* Can't use the same menu for two windows */
751 if (NULL != OldMenu)
752 {
753 IntReleaseMenuObject(OldMenu);
754 }
755 SetLastWin32Error(ERROR_INVALID_MENU_HANDLE);
756 return FALSE;
757 }
758
759 }
760
761 Wnd->IDMenu = (UINT) Menu;
762 if (NULL != NewMenu)
763 {
764 NewMenu->MenuInfo.Wnd = Window->hSelf;
765 IntReleaseMenuObject(NewMenu);
766 }
767 if (NULL != OldMenu)
768 {
769 OldMenu->MenuInfo.Wnd = NULL;
770 IntReleaseMenuObject(OldMenu);
771 }
772
773 return TRUE;
774 }
775
776
777 /* INTERNAL ******************************************************************/
778
779
780 VOID FASTCALL
781 co_DestroyThreadWindows(struct _ETHREAD *Thread)
782 {
783 PTHREADINFO WThread;
784 PLIST_ENTRY Current;
785 PWINDOW_OBJECT Wnd;
786 USER_REFERENCE_ENTRY Ref;
787 WThread = (PTHREADINFO)Thread->Tcb.Win32Thread;
788
789 while (!IsListEmpty(&WThread->WindowListHead))
790 {
791 Current = WThread->WindowListHead.Flink;
792 Wnd = CONTAINING_RECORD(Current, WINDOW_OBJECT, ThreadListEntry);
793
794 DPRINT("thread cleanup: while destroy wnds, wnd=0x%x\n",Wnd);
795
796 /* window removes itself from the list */
797
798 /*
799 fixme: it is critical that the window removes itself! if now, we will loop
800 here forever...
801 */
802
803 //ASSERT(co_UserDestroyWindow(Wnd));
804
805 UserRefObjectCo(Wnd, &Ref);//faxme: temp hack??
806 if (!co_UserDestroyWindow(Wnd))
807 {
808 DPRINT1("Unable to destroy window 0x%x at thread cleanup... This is _VERY_ bad!\n", Wnd);
809 }
810 UserDerefObjectCo(Wnd);//faxme: temp hack??
811 }
812 }
813
814
815
816 /*!
817 * Internal function.
818 * Returns client window rectangle relative to the upper-left corner of client area.
819 *
820 * \note Does not check the validity of the parameters
821 */
822 VOID FASTCALL
823 IntGetClientRect(PWINDOW_OBJECT Window, RECTL *Rect)
824 {
825 ASSERT( Window );
826 ASSERT( Rect );
827
828 Rect->left = Rect->top = 0;
829 Rect->right = Window->Wnd->rcClient.right - Window->Wnd->rcClient.left;
830 Rect->bottom = Window->Wnd->rcClient.bottom - Window->Wnd->rcClient.top;
831 }
832
833
834 #if 0
835 HWND FASTCALL
836 IntGetFocusWindow(VOID)
837 {
838 PUSER_MESSAGE_QUEUE Queue;
839 PDESKTOP pdo = IntGetActiveDesktop();
840
841 if( !pdo )
842 return NULL;
843
844 Queue = (PUSER_MESSAGE_QUEUE)pdo->ActiveMessageQueue;
845
846 if (Queue == NULL)
847 return(NULL);
848 else
849 return(Queue->FocusWindow);
850 }
851 #endif
852
853 PMENU_OBJECT FASTCALL
854 IntGetSystemMenu(PWINDOW_OBJECT Window, BOOL bRevert, BOOL RetMenu)
855 {
856 PMENU_OBJECT Menu, NewMenu = NULL, SysMenu = NULL, ret = NULL;
857 PTHREADINFO W32Thread;
858 HMENU hNewMenu, hSysMenu;
859 ROSMENUITEMINFO ItemInfo;
860
861 if(bRevert)
862 {
863 W32Thread = PsGetCurrentThreadWin32Thread();
864
865 if(!W32Thread->rpdesk)
866 return NULL;
867
868 if(Window->SystemMenu)
869 {
870 Menu = UserGetMenuObject(Window->SystemMenu);
871 if(Menu)
872 {
873 IntDestroyMenuObject(Menu, TRUE, TRUE);
874 Window->SystemMenu = (HMENU)0;
875 }
876 }
877
878 if(W32Thread->rpdesk->rpwinstaParent->SystemMenuTemplate)
879 {
880 /* clone system menu */
881 Menu = UserGetMenuObject(W32Thread->rpdesk->rpwinstaParent->SystemMenuTemplate);
882 if(!Menu)
883 return NULL;
884
885 NewMenu = IntCloneMenu(Menu);
886 if(NewMenu)
887 {
888 Window->SystemMenu = NewMenu->MenuInfo.Self;
889 NewMenu->MenuInfo.Flags |= MF_SYSMENU;
890 NewMenu->MenuInfo.Wnd = Window->hSelf;
891 ret = NewMenu;
892 //IntReleaseMenuObject(NewMenu);
893 }
894 }
895 else
896 {
897 hSysMenu = UserCreateMenu(FALSE);
898 if (NULL == hSysMenu)
899 {
900 return NULL;
901 }
902 SysMenu = IntGetMenuObject(hSysMenu);
903 if (NULL == SysMenu)
904 {
905 UserDestroyMenu(hSysMenu);
906 return NULL;
907 }
908 SysMenu->MenuInfo.Flags |= MF_SYSMENU;
909 SysMenu->MenuInfo.Wnd = Window->hSelf;
910 hNewMenu = co_IntLoadSysMenuTemplate();
911 if(!hNewMenu)
912 {
913 IntReleaseMenuObject(SysMenu);
914 UserDestroyMenu(hSysMenu);
915 return NULL;
916 }
917 Menu = IntGetMenuObject(hNewMenu);
918 if(!Menu)
919 {
920 IntReleaseMenuObject(SysMenu);
921 UserDestroyMenu(hSysMenu);
922 return NULL;
923 }
924
925 NewMenu = IntCloneMenu(Menu);
926 if(NewMenu)
927 {
928 NewMenu->MenuInfo.Flags |= MF_SYSMENU | MF_POPUP;
929 IntReleaseMenuObject(NewMenu);
930 UserSetMenuDefaultItem(NewMenu, SC_CLOSE, FALSE);
931
932 ItemInfo.cbSize = sizeof(MENUITEMINFOW);
933 ItemInfo.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_STATE | MIIM_SUBMENU;
934 ItemInfo.fType = MF_POPUP;
935 ItemInfo.fState = MFS_ENABLED;
936 ItemInfo.dwTypeData = NULL;
937 ItemInfo.cch = 0;
938 ItemInfo.hSubMenu = NewMenu->MenuInfo.Self;
939 IntInsertMenuItem(SysMenu, (UINT) -1, TRUE, &ItemInfo);
940
941 Window->SystemMenu = SysMenu->MenuInfo.Self;
942
943 ret = SysMenu;
944 }
945 IntDestroyMenuObject(Menu, FALSE, TRUE);
946 }
947 if(RetMenu)
948 return ret;
949 else
950 return NULL;
951 }
952 else
953 {
954 if(Window->SystemMenu)
955 return IntGetMenuObject((HMENU)Window->SystemMenu);
956 else
957 return NULL;
958 }
959 }
960
961
962 BOOL FASTCALL
963 IntIsChildWindow(PWINDOW_OBJECT Parent, PWINDOW_OBJECT BaseWindow)
964 {
965 PWINDOW_OBJECT Window;
966 PWND Wnd;
967
968 Window = BaseWindow;
969 while (Window)
970 {
971 Wnd = Window->Wnd;
972 if (Window == Parent)
973 {
974 return(TRUE);
975 }
976 if(!(Wnd->style & WS_CHILD))
977 {
978 break;
979 }
980
981 Window = Window->spwndParent;
982 }
983
984 return(FALSE);
985 }
986
987 BOOL FASTCALL
988 IntIsWindowVisible(PWINDOW_OBJECT BaseWindow)
989 {
990 PWINDOW_OBJECT Window;
991 PWND Wnd;
992
993 Window = BaseWindow;
994 while(Window)
995 {
996 Wnd = Window->Wnd;
997 if(!(Wnd->style & WS_CHILD))
998 {
999 break;
1000 }
1001 if(!(Wnd->style & WS_VISIBLE))
1002 {
1003 return FALSE;
1004 }
1005
1006 Window = Window->spwndParent;
1007 }
1008
1009 if(Window && Wnd->style & WS_VISIBLE)
1010 {
1011 return TRUE;
1012 }
1013
1014 return FALSE;
1015 }
1016
1017 VOID FASTCALL
1018 IntLinkWnd(
1019 PWND Wnd,
1020 PWND WndParent,
1021 PWND WndPrevSibling) /* set to NULL if top sibling */
1022 {
1023 Wnd->spwndParent = WndParent;
1024 if ((Wnd->spwndPrev = WndPrevSibling))
1025 {
1026 /* link after WndPrevSibling */
1027 if ((Wnd->spwndNext = WndPrevSibling->spwndNext))
1028 Wnd->spwndNext->spwndPrev = Wnd;
1029
1030 Wnd->spwndPrev->spwndNext = Wnd;
1031 }
1032 else
1033 {
1034 /* link at top */
1035 if ((Wnd->spwndNext = WndParent->spwndChild))
1036 Wnd->spwndNext->spwndPrev = Wnd;
1037
1038 WndParent->spwndChild = Wnd;
1039 }
1040
1041 }
1042
1043 /* link the window into siblings and parent. children are kept in place. */
1044 VOID FASTCALL
1045 IntLinkWindow(
1046 PWINDOW_OBJECT Wnd,
1047 PWINDOW_OBJECT WndParent,
1048 PWINDOW_OBJECT WndPrevSibling /* set to NULL if top sibling */
1049 )
1050 {
1051 PWINDOW_OBJECT Parent;
1052
1053 IntLinkWnd(Wnd->Wnd,
1054 WndParent->Wnd,
1055 WndPrevSibling ? WndPrevSibling->Wnd : NULL);
1056
1057 Wnd->spwndParent = WndParent;
1058 if ((Wnd->spwndPrev = WndPrevSibling))
1059 {
1060 /* link after WndPrevSibling */
1061 if ((Wnd->spwndNext = WndPrevSibling->spwndNext))
1062 Wnd->spwndNext->spwndPrev = Wnd;
1063 Wnd->spwndPrev->spwndNext = Wnd;
1064 }
1065 else
1066 {
1067 /* link at top */
1068 Parent = Wnd->spwndParent;
1069 if ((Wnd->spwndNext = WndParent->spwndChild))
1070 Wnd->spwndNext->spwndPrev = Wnd;
1071 else if (Parent)
1072 {
1073 Parent->spwndChild = Wnd;
1074 return;
1075 }
1076 if(Parent)
1077 {
1078 Parent->spwndChild = Wnd;
1079 }
1080 }
1081
1082 }
1083
1084 HWND FASTCALL
1085 IntSetOwner(HWND hWnd, HWND hWndNewOwner)
1086 {
1087 PWINDOW_OBJECT Wnd, WndOldOwner, WndNewOwner;
1088 HWND ret;
1089
1090 Wnd = IntGetWindowObject(hWnd);
1091 if(!Wnd)
1092 return NULL;
1093
1094 WndOldOwner = IntGetWindowObject(Wnd->hOwner);
1095 if (WndOldOwner)
1096 {
1097 ret = WndOldOwner->hSelf;
1098 UserDereferenceObject(WndOldOwner);
1099 }
1100 else
1101 {
1102 ret = 0;
1103 }
1104
1105 if((WndNewOwner = UserGetWindowObject(hWndNewOwner)))
1106 {
1107 Wnd->hOwner = hWndNewOwner;
1108 Wnd->Wnd->spwndOwner = WndNewOwner->Wnd;
1109 }
1110 else
1111 {
1112 Wnd->hOwner = NULL;
1113 Wnd->Wnd->spwndOwner = NULL;
1114 }
1115
1116 UserDereferenceObject(Wnd);
1117 return ret;
1118 }
1119
1120 PWINDOW_OBJECT FASTCALL
1121 co_IntSetParent(PWINDOW_OBJECT Wnd, PWINDOW_OBJECT WndNewParent)
1122 {
1123 PWINDOW_OBJECT WndOldParent, Sibling, InsertAfter;
1124 // HWND hWnd, hWndNewParent;
1125 BOOL WasVisible;
1126
1127 ASSERT(Wnd);
1128 ASSERT(WndNewParent);
1129 ASSERT_REFS_CO(Wnd);
1130 ASSERT_REFS_CO(WndNewParent);
1131
1132 // hWnd = Wnd->hSelf;
1133 // hWndNewParent = WndNewParent->hSelf;
1134
1135 /* Some applications try to set a child as a parent */
1136 if (IntIsChildWindow(Wnd, WndNewParent))
1137 {
1138 SetLastWin32Error( ERROR_INVALID_PARAMETER );
1139 return NULL;
1140 }
1141
1142 /*
1143 * Windows hides the window first, then shows it again
1144 * including the WM_SHOWWINDOW messages and all
1145 */
1146 WasVisible = co_WinPosShowWindow(Wnd, SW_HIDE);
1147
1148 // /* Validate that window and parent still exist */
1149 // if (!IntIsWindow(hWnd) || !IntIsWindow(hWndNewParent))
1150 // return NULL;
1151
1152 /* Window must belong to current process */
1153 if (Wnd->pti->pEThread->ThreadsProcess != PsGetCurrentProcess())
1154 return NULL;
1155
1156 WndOldParent = Wnd->spwndParent;
1157
1158 if (WndOldParent) UserReferenceObject(WndOldParent); /* caller must deref */
1159
1160 if (WndNewParent != WndOldParent)
1161 {
1162 IntUnlinkWindow(Wnd);
1163 InsertAfter = NULL;
1164 if (0 == (Wnd->Wnd->ExStyle & WS_EX_TOPMOST))
1165 {
1166 /* Not a TOPMOST window, put after TOPMOSTs of new parent */
1167 Sibling = WndNewParent->spwndChild;
1168 while (NULL != Sibling && 0 != (Sibling->Wnd->ExStyle & WS_EX_TOPMOST))
1169 {
1170 InsertAfter = Sibling;
1171 Sibling = Sibling->spwndNext;
1172 }
1173 }
1174 if (NULL == InsertAfter)
1175 {
1176 IntLinkWindow(Wnd, WndNewParent, InsertAfter /*prev sibling*/);
1177 }
1178 else
1179 {
1180 // UserReferenceObject(InsertAfter);
1181 IntLinkWindow(Wnd, WndNewParent, InsertAfter /*prev sibling*/);
1182 // UserDereferenceObject(InsertAfter);
1183 }
1184 }
1185
1186 /*
1187 * SetParent additionally needs to make hwnd the top window
1188 * in the z-order and send the expected WM_WINDOWPOSCHANGING and
1189 * WM_WINDOWPOSCHANGED notification messages.
1190 */
1191 co_WinPosSetWindowPos(Wnd, (0 == (Wnd->Wnd->ExStyle & WS_EX_TOPMOST) ? HWND_TOP : HWND_TOPMOST),
1192 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE
1193 | (WasVisible ? SWP_SHOWWINDOW : 0));
1194
1195 /*
1196 * FIXME: a WM_MOVE is also generated (in the DefWindowProc handler
1197 * for WM_WINDOWPOSCHANGED) in Windows, should probably remove SWP_NOMOVE
1198 */
1199
1200 /*
1201 * Validate that the old parent still exist, since it migth have been
1202 * destroyed during the last callbacks to user-mode
1203 */
1204 // if(WndOldParent)
1205 // {
1206 // if(!IntIsWindow(WndOldParent->hSelf))
1207 // {
1208 // UserDereferenceObject(WndOldParent);
1209 // return NULL;
1210 // }
1211
1212 /* don't dereference the window object here, it must be done by the caller
1213 of IntSetParent() */
1214 // return WndOldParent;
1215 // }
1216
1217 return WndOldParent;//NULL;
1218 }
1219
1220 BOOL FASTCALL
1221 IntSetSystemMenu(PWINDOW_OBJECT Window, PMENU_OBJECT Menu)
1222 {
1223 PMENU_OBJECT OldMenu;
1224 if(Window->SystemMenu)
1225 {
1226 OldMenu = IntGetMenuObject(Window->SystemMenu);
1227 if(OldMenu)
1228 {
1229 OldMenu->MenuInfo.Flags &= ~ MF_SYSMENU;
1230 IntReleaseMenuObject(OldMenu);
1231 }
1232 }
1233
1234 if(Menu)
1235 {
1236 /* FIXME check window style, propably return FALSE ? */
1237 Window->SystemMenu = Menu->MenuInfo.Self;
1238 Menu->MenuInfo.Flags |= MF_SYSMENU;
1239 }
1240 else
1241 Window->SystemMenu = (HMENU)0;
1242
1243 return TRUE;
1244 }
1245
1246 /* unlink the window from siblings and parent. children are kept in place. */
1247 VOID FASTCALL
1248 IntUnlinkWnd(PWND Wnd)
1249 {
1250 if (Wnd->spwndNext)
1251 Wnd->spwndNext->spwndPrev = Wnd->spwndPrev;
1252
1253 if (Wnd->spwndPrev)
1254 Wnd->spwndPrev->spwndNext = Wnd->spwndNext;
1255
1256 if (Wnd->spwndParent && Wnd->spwndParent->spwndChild == Wnd)
1257 Wnd->spwndParent->spwndChild = Wnd->spwndNext;
1258
1259 Wnd->spwndPrev = Wnd->spwndNext = Wnd->spwndParent = NULL;
1260 }
1261
1262
1263 /* unlink the window from siblings and parent. children are kept in place. */
1264 VOID FASTCALL
1265 IntUnlinkWindow(PWINDOW_OBJECT Wnd)
1266 {
1267 PWINDOW_OBJECT WndParent = Wnd->spwndParent;
1268
1269 IntUnlinkWnd(Wnd->Wnd);
1270
1271 if (Wnd->spwndNext)
1272 Wnd->spwndNext->spwndPrev = Wnd->spwndPrev;
1273
1274 if (Wnd->spwndPrev)
1275 Wnd->spwndPrev->spwndNext = Wnd->spwndNext;
1276 else if (WndParent && WndParent->spwndChild == Wnd)
1277 WndParent->spwndChild = Wnd->spwndNext;
1278
1279 Wnd->spwndPrev = Wnd->spwndNext = Wnd->spwndParent = NULL;
1280 }
1281
1282 BOOL FASTCALL
1283 IntAnyPopup(VOID)
1284 {
1285 PWINDOW_OBJECT Window, Child;
1286
1287 if(!(Window = UserGetWindowObject(IntGetDesktopWindow())))
1288 {
1289 return FALSE;
1290 }
1291
1292 for(Child = Window->spwndChild; Child; Child = Child->spwndNext)
1293 {
1294 if(Child->hOwner && Child->Wnd->style & WS_VISIBLE)
1295 {
1296 /*
1297 * The desktop has a popup window if one of them has
1298 * an owner window and is visible
1299 */
1300 return TRUE;
1301 }
1302 }
1303
1304 return FALSE;
1305 }
1306
1307 BOOL FASTCALL
1308 IntIsWindowInDestroy(PWINDOW_OBJECT Window)
1309 {
1310 return ((Window->state & WINDOWSTATUS_DESTROYING) == WINDOWSTATUS_DESTROYING);
1311 }
1312
1313
1314 BOOL
1315 FASTCALL
1316 IntGetWindowPlacement(PWINDOW_OBJECT Window, WINDOWPLACEMENT *lpwndpl)
1317 {
1318 PWND Wnd;
1319 POINT Size;
1320
1321 Wnd = Window->Wnd;
1322 if (!Wnd) return FALSE;
1323
1324 if(lpwndpl->length != sizeof(WINDOWPLACEMENT))
1325 {
1326 return FALSE;
1327 }
1328
1329 lpwndpl->flags = 0;
1330 if (0 == (Wnd->style & WS_VISIBLE))
1331 {
1332 lpwndpl->showCmd = SW_HIDE;
1333 }
1334 else if (0 != (Window->state & WINDOWOBJECT_RESTOREMAX) ||
1335 0 != (Wnd->style & WS_MAXIMIZE))
1336 {
1337 lpwndpl->showCmd = SW_MAXIMIZE;
1338 }
1339 else if (0 != (Wnd->style & WS_MINIMIZE))
1340 {
1341 lpwndpl->showCmd = SW_MINIMIZE;
1342 }
1343 else if (0 != (Wnd->style & WS_VISIBLE))
1344 {
1345 lpwndpl->showCmd = SW_SHOWNORMAL;
1346 }
1347
1348 Size.x = Wnd->rcWindow.left;
1349 Size.y = Wnd->rcWindow.top;
1350 WinPosInitInternalPos(Window, &Size,
1351 &Wnd->rcWindow);
1352
1353 lpwndpl->rcNormalPosition = Wnd->InternalPos.NormalRect;
1354 lpwndpl->ptMinPosition = Wnd->InternalPos.IconPos;
1355 lpwndpl->ptMaxPosition = Wnd->InternalPos.MaxPos;
1356
1357 return TRUE;
1358 }
1359
1360
1361 /* FUNCTIONS *****************************************************************/
1362
1363 /*
1364 * @unimplemented
1365 */
1366 DWORD APIENTRY
1367 NtUserAlterWindowStyle(DWORD Unknown0,
1368 DWORD Unknown1,
1369 DWORD Unknown2)
1370 {
1371 UNIMPLEMENTED
1372
1373 return(0);
1374 }
1375
1376 /*
1377 * As best as I can figure, this function is used by EnumWindows,
1378 * EnumChildWindows, EnumDesktopWindows, & EnumThreadWindows.
1379 *
1380 * It's supposed to build a list of HWNDs to return to the caller.
1381 * We can figure out what kind of list by what parameters are
1382 * passed to us.
1383 */
1384 /*
1385 * @implemented
1386 */
1387 NTSTATUS
1388 APIENTRY
1389 NtUserBuildHwndList(
1390 HDESK hDesktop,
1391 HWND hwndParent,
1392 BOOLEAN bChildren,
1393 ULONG dwThreadId,
1394 ULONG lParam,
1395 HWND* pWnd,
1396 ULONG* pBufSize)
1397 {
1398 NTSTATUS Status;
1399 ULONG dwCount = 0;
1400
1401 if (pBufSize == 0)
1402 return ERROR_INVALID_PARAMETER;
1403
1404 if (hwndParent || !dwThreadId)
1405 {
1406 PDESKTOP Desktop;
1407 PWINDOW_OBJECT Parent, Window;
1408
1409 if(!hwndParent)
1410 {
1411 if(hDesktop == NULL && !(Desktop = IntGetActiveDesktop()))
1412 {
1413 return ERROR_INVALID_HANDLE;
1414 }
1415
1416 if(hDesktop)
1417 {
1418 Status = IntValidateDesktopHandle(hDesktop,
1419 UserMode,
1420 0,
1421 &Desktop);
1422 if(!NT_SUCCESS(Status))
1423 {
1424 return ERROR_INVALID_HANDLE;
1425 }
1426 }
1427 hwndParent = Desktop->DesktopWindow;
1428 }
1429 else
1430 {
1431 hDesktop = 0;
1432 }
1433
1434 if((Parent = UserGetWindowObject(hwndParent)) &&
1435 (Window = Parent->spwndChild))
1436 {
1437 BOOL bGoDown = TRUE;
1438
1439 Status = STATUS_SUCCESS;
1440 while(TRUE)
1441 {
1442 if (bGoDown)
1443 {
1444 if(dwCount++ < *pBufSize && pWnd)
1445 {
1446 _SEH2_TRY
1447 {
1448 ProbeForWrite(pWnd, sizeof(HWND), 1);
1449 *pWnd = Window->hSelf;
1450 pWnd++;
1451 }
1452 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1453 {
1454 Status = _SEH2_GetExceptionCode();
1455 }
1456 _SEH2_END
1457 if(!NT_SUCCESS(Status))
1458 {
1459 SetLastNtError(Status);
1460 break;
1461 }
1462 }
1463 if (Window->spwndChild && bChildren)
1464 {
1465 Window = Window->spwndChild;
1466 continue;
1467 }
1468 bGoDown = FALSE;
1469 }
1470 if (Window->spwndNext)
1471 {
1472 Window = Window->spwndNext;
1473 bGoDown = TRUE;
1474 continue;
1475 }
1476 Window = Window->spwndParent;
1477 if (Window == Parent)
1478 {
1479 break;
1480 }
1481 }
1482 }
1483
1484 if(hDesktop)
1485 {
1486 ObDereferenceObject(Desktop);
1487 }
1488 }
1489 else
1490 {
1491 PETHREAD Thread;
1492 PTHREADINFO W32Thread;
1493 PLIST_ENTRY Current;
1494 PWINDOW_OBJECT Window;
1495
1496 Status = PsLookupThreadByThreadId((HANDLE)dwThreadId, &Thread);
1497 if(!NT_SUCCESS(Status))
1498 {
1499 return ERROR_INVALID_PARAMETER;
1500 }
1501 if(!(W32Thread = (PTHREADINFO)Thread->Tcb.Win32Thread))
1502 {
1503 ObDereferenceObject(Thread);
1504 DPRINT("Thread is not a GUI Thread!\n");
1505 return ERROR_INVALID_PARAMETER;
1506 }
1507
1508 Current = W32Thread->WindowListHead.Flink;
1509 while(Current != &(W32Thread->WindowListHead))
1510 {
1511 Window = CONTAINING_RECORD(Current, WINDOW_OBJECT, ThreadListEntry);
1512 ASSERT(Window);
1513
1514 if(bChildren || Window->hOwner != NULL)
1515 {
1516 if(dwCount < *pBufSize && pWnd)
1517 {
1518 Status = MmCopyToCaller(pWnd++, &Window->hSelf, sizeof(HWND));
1519 if(!NT_SUCCESS(Status))
1520 {
1521 SetLastNtError(Status);
1522 break;
1523 }
1524 }
1525 dwCount++;
1526 }
1527 Current = Current->Flink;
1528 }
1529
1530 ObDereferenceObject(Thread);
1531 }
1532
1533 *pBufSize = dwCount;
1534 return STATUS_SUCCESS;
1535 }
1536
1537
1538 /*
1539 * @implemented
1540 */
1541 HWND APIENTRY
1542 NtUserChildWindowFromPointEx(HWND hwndParent,
1543 LONG x,
1544 LONG y,
1545 UINT uiFlags)
1546 {
1547 PWINDOW_OBJECT Parent;
1548 POINTL Pt;
1549 HWND Ret;
1550 HWND *List, *phWnd;
1551
1552 if(!(Parent = UserGetWindowObject(hwndParent)))
1553 {
1554 return NULL;
1555 }
1556
1557 Pt.x = x;
1558 Pt.y = y;
1559
1560 if(Parent->hSelf != IntGetDesktopWindow())
1561 {
1562 Pt.x += Parent->Wnd->rcClient.left;
1563 Pt.y += Parent->Wnd->rcClient.top;
1564 }
1565
1566 if(!IntPtInWindow(Parent, Pt.x, Pt.y))
1567 {
1568 return NULL;
1569 }
1570
1571 Ret = Parent->hSelf;
1572 if((List = IntWinListChildren(Parent)))
1573 {
1574 for(phWnd = List; *phWnd; phWnd++)
1575 {
1576 PWINDOW_OBJECT Child;
1577 PWND ChildWnd;
1578 if((Child = UserGetWindowObject(*phWnd)))
1579 {
1580 ChildWnd = Child->Wnd;
1581 if(!(ChildWnd->style & WS_VISIBLE) && (uiFlags & CWP_SKIPINVISIBLE))
1582 {
1583 continue;
1584 }
1585 if((ChildWnd->style & WS_DISABLED) && (uiFlags & CWP_SKIPDISABLED))
1586 {
1587 continue;
1588 }
1589 if((ChildWnd->ExStyle & WS_EX_TRANSPARENT) && (uiFlags & CWP_SKIPTRANSPARENT))
1590 {
1591 continue;
1592 }
1593 if(IntPtInWindow(Child, Pt.x, Pt.y))
1594 {
1595 Ret = Child->hSelf;
1596 break;
1597 }
1598 }
1599 }
1600 ExFreePool(List);
1601 }
1602
1603 return Ret;
1604 }
1605
1606
1607 /*
1608 * calculates the default position of a window
1609 */
1610 BOOL FASTCALL
1611 IntCalcDefPosSize(PWINDOW_OBJECT Parent, RECTL *rc, BOOL IncPos)
1612 {
1613 SIZE Sz;
1614 PMONITOR pMonitor;
1615 POINT Pos = {0, 0};
1616
1617 pMonitor = IntGetPrimaryMonitor();
1618
1619 if(Parent != NULL)
1620 {
1621 RECTL_bIntersectRect(rc, rc, &pMonitor->rcMonitor);
1622
1623 if(IncPos)
1624 {
1625 Pos.x = pMonitor->cWndStack * (UserGetSystemMetrics(SM_CXSIZE) + UserGetSystemMetrics(SM_CXFRAME));
1626 Pos.y = pMonitor->cWndStack * (UserGetSystemMetrics(SM_CYSIZE) + UserGetSystemMetrics(SM_CYFRAME));
1627 if (Pos.x > ((rc->right - rc->left) / 4) ||
1628 Pos.y > ((rc->bottom - rc->top) / 4))
1629 {
1630 /* reset counter and position */
1631 Pos.x = 0;
1632 Pos.y = 0;
1633 pMonitor->cWndStack = 0;
1634 }
1635 pMonitor->cWndStack++;
1636 }
1637 Pos.x += rc->left;
1638 Pos.y += rc->top;
1639 }
1640 else
1641 {
1642 Pos.x = rc->left;
1643 Pos.y = rc->top;
1644 }
1645
1646 Sz.cx = EngMulDiv(rc->right - rc->left, 3, 4);
1647 Sz.cy = EngMulDiv(rc->bottom - rc->top, 3, 4);
1648
1649 rc->left = Pos.x;
1650 rc->top = Pos.y;
1651 rc->right = rc->left + Sz.cx;
1652 rc->bottom = rc->top + Sz.cy;
1653 return TRUE;
1654 }
1655
1656
1657 /*
1658 * @implemented
1659 */
1660 PWND APIENTRY
1661 co_IntCreateWindowEx(DWORD dwExStyle,
1662 PUNICODE_STRING ClassName,
1663 PUNICODE_STRING WindowName,
1664 DWORD dwStyle,
1665 LONG x,
1666 LONG y,
1667 LONG nWidth,
1668 LONG nHeight,
1669 HWND hWndParent,
1670 HMENU hMenu,
1671 HINSTANCE hInstance,
1672 LPVOID lpParam,
1673 DWORD dwShowMode,
1674 BOOL bUnicodeWindow)
1675 {
1676 PWINSTATION_OBJECT WinSta;
1677 PWND Wnd = NULL;
1678 PCLS *ClassLink, Class = NULL;
1679 RTL_ATOM ClassAtom;
1680 PWINDOW_OBJECT Window = NULL;
1681 PWINDOW_OBJECT ParentWindow = NULL, OwnerWindow;
1682 HWND ParentWindowHandle = NULL;
1683 HWND OwnerWindowHandle;
1684 PMENU_OBJECT SystemMenu;
1685 HWND hWnd;
1686 POINT Pos;
1687 SIZE Size;
1688 PTHREADINFO ti = NULL;
1689 #if 0
1690
1691 POINT MaxSize, MaxPos, MinTrack, MaxTrack;
1692 #else
1693
1694 POINT MaxPos;
1695 #endif
1696 CREATESTRUCTW Cs;
1697 CBT_CREATEWNDW CbtCreate;
1698 LRESULT Result;
1699 BOOL MenuChanged;
1700 DECLARE_RETURN(PWND);
1701 BOOL HasOwner;
1702 USER_REFERENCE_ENTRY ParentRef, Ref;
1703 PTHREADINFO pti;
1704
1705 pti = PsGetCurrentThreadWin32Thread();
1706
1707 if (pti->rpdesk)
1708 {
1709 ParentWindowHandle = pti->rpdesk->DesktopWindow;
1710 }
1711
1712
1713 if ( !(pti->ppi->W32PF_flags & W32PF_CLASSESREGISTERED ))
1714 {
1715 UserRegisterSystemClasses();
1716 }
1717
1718 OwnerWindowHandle = NULL;
1719
1720 DPRINT("co_IntCreateWindowEx %wZ\n", ClassName);
1721
1722 if (hWndParent == HWND_MESSAGE)
1723 {
1724 /*
1725 * native ole32.OleInitialize uses HWND_MESSAGE to create the
1726 * message window (style: WS_POPUP|WS_DISABLED)
1727 */
1728 ParentWindowHandle = IntGetMessageWindow();
1729 DPRINT("Parent is HWND_MESSAGE 0x%x\n", ParentWindowHandle);
1730 }
1731 else if (hWndParent)
1732 {
1733 if ((dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD)
1734 { //temp hack
1735 PWINDOW_OBJECT Par = UserGetWindowObject(hWndParent), Root;
1736 if (Par && (Root = UserGetAncestor(Par, GA_ROOT)))
1737 OwnerWindowHandle = Root->hSelf;
1738 }
1739 else
1740 ParentWindowHandle = hWndParent;
1741 }
1742 else if ((dwStyle & (WS_CHILD | WS_POPUP)) == WS_CHILD)
1743 {
1744 SetLastWin32Error(ERROR_TLW_WITH_WSCHILD);
1745 RETURN( (PWND)0); /* WS_CHILD needs a parent, but WS_POPUP doesn't */
1746 }
1747
1748 if (ParentWindowHandle)
1749 {
1750 ParentWindow = UserGetWindowObject(ParentWindowHandle);
1751
1752 if (ParentWindow) UserRefObjectCo(ParentWindow, &ParentRef);
1753 }
1754 else
1755 {
1756 ParentWindow = NULL;
1757 }
1758
1759 /* FIXME: parent must belong to the current process */
1760
1761 /* Check the window station. */
1762 ti = GetW32ThreadInfo();
1763 if (ti == NULL || pti->rpdesk == NULL)
1764 {
1765 DPRINT1("Thread is not attached to a desktop! Cannot create window!\n");
1766 RETURN( (PWND)0);
1767 }
1768
1769 /* Check the class. */
1770
1771 DPRINT("Class %wZ\n", ClassName);
1772
1773 ClassAtom = IntGetClassAtom(ClassName,
1774 hInstance,
1775 ti->ppi,
1776 &Class,
1777 &ClassLink);
1778
1779 if (ClassAtom == (RTL_ATOM)0)
1780 {
1781 if (IS_ATOM(ClassName->Buffer))
1782 {
1783 DPRINT1("Class 0x%p not found\n", (DWORD_PTR) ClassName->Buffer);
1784 }
1785 else
1786 {
1787 DPRINT1("Class \"%wZ\" not found\n", ClassName);
1788 }
1789
1790 SetLastWin32Error(ERROR_CANNOT_FIND_WND_CLASS);
1791 RETURN((PWND)0);
1792 }
1793 DPRINT("ClassAtom %x\n", ClassAtom);
1794 Class = IntReferenceClass(Class,
1795 ClassLink,
1796 pti->rpdesk);
1797 if (Class == NULL)
1798 {
1799 DPRINT1("Failed to reference window class!\n");
1800 RETURN(NULL);
1801 }
1802
1803 WinSta = pti->rpdesk->rpwinstaParent;
1804
1805 //FIXME: Reference thread/desktop instead
1806 ObReferenceObjectByPointer(WinSta, KernelMode, ExWindowStationObjectType, 0);
1807
1808 /* Create the window object. */
1809 Window = (PWINDOW_OBJECT) UserCreateObject( gHandleTable,
1810 pti->rpdesk,
1811 (PHANDLE)&hWnd,
1812 otWindow,
1813 sizeof(WINDOW_OBJECT));
1814 if (Window)
1815 {
1816 Window->Wnd = DesktopHeapAlloc(pti->rpdesk,
1817 sizeof(WND) + Class->cbwndExtra);
1818 if (!Window->Wnd)
1819 goto AllocErr;
1820 RtlZeroMemory(Window->Wnd,
1821 sizeof(WND) + Class->cbwndExtra);
1822 Window->Wnd->head.h = hWnd;
1823 Wnd = Window->Wnd;
1824 Wnd->fnid = 0;
1825
1826 Wnd->head.pti = ti;
1827 Wnd->head.rpdesk = pti->rpdesk;
1828 Wnd->hWndLastActive = hWnd;
1829 Wnd->state2 |= WNDS2_WIN40COMPAT;
1830 }
1831
1832 DPRINT("Created object with handle %X\n", hWnd);
1833 if (!Window)
1834 {
1835 AllocErr:
1836 ObDereferenceObject(WinSta);
1837 SetLastNtError(STATUS_INSUFFICIENT_RESOURCES);
1838 RETURN( (PWND)0);
1839 }
1840
1841 UserRefObjectCo(Window, &Ref);
1842
1843 ObDereferenceObject(WinSta);
1844
1845 if (NULL == pti->rpdesk->DesktopWindow)
1846 {
1847 /* If there is no desktop window yet, we must be creating it */
1848 pti->rpdesk->DesktopWindow = hWnd;
1849 pti->rpdesk->pDeskInfo->spwnd = Wnd;
1850 }
1851
1852 /*
1853 * Fill out the structure describing it.
1854 */
1855 Window->pti = ti;
1856 Wnd->pcls = Class;
1857 Class = NULL;
1858
1859 Window->SystemMenu = (HMENU)0;
1860 Wnd->IDMenu = 0;
1861 Wnd->hModule = hInstance;
1862 Window->hSelf = hWnd;
1863
1864 IntReferenceMessageQueue(Window->pti->MessageQueue);
1865 Window->spwndParent = ParentWindow;
1866 Wnd->spwndParent = ParentWindow ? ParentWindow->Wnd : NULL;
1867 if (Wnd->spwndParent != NULL && hWndParent != 0)
1868 {
1869 Wnd->HideFocus = Wnd->spwndParent->HideFocus;
1870 Wnd->HideAccel = Wnd->spwndParent->HideAccel;
1871 }
1872
1873 if((OwnerWindow = UserGetWindowObject(OwnerWindowHandle)))
1874 {
1875 Window->hOwner = OwnerWindowHandle;
1876 Wnd->spwndOwner = OwnerWindow->Wnd;
1877 HasOwner = TRUE;
1878 }
1879 else
1880 {
1881 Window->hOwner = NULL;
1882 Wnd->spwndOwner = NULL;
1883 HasOwner = FALSE;
1884 }
1885
1886 Wnd->dwUserData = 0;
1887
1888 if (Wnd->pcls->CSF_flags & CSF_SERVERSIDEPROC)
1889 Wnd->state |= WNDS_SERVERSIDEWINDOWPROC;
1890
1891 /* BugBoy Comments: Comment below say that System classes are always created
1892 as UNICODE. In windows, creating a window with the ANSI version of CreateWindow
1893 sets the window to ansi as verified by testing with IsUnicodeWindow API.
1894
1895 No where can I see in code or through testing does the window change back
1896 to ANSI after being created as UNICODE in ROS. I didnt do more testing to
1897 see what problems this would cause.*/
1898
1899 // Set WndProc from Class.
1900 Wnd->lpfnWndProc = Wnd->pcls->lpfnWndProc;
1901
1902 // GetWindowProc, test for non server side default classes and set WndProc.
1903 if ( Wnd->pcls->fnid <= FNID_GHOST && Wnd->pcls->fnid >= FNID_BUTTON )
1904 {
1905 if (bUnicodeWindow)
1906 {
1907 if (GETPFNCLIENTA(Wnd->pcls->fnid) == Wnd->lpfnWndProc)
1908 Wnd->lpfnWndProc = GETPFNCLIENTW(Wnd->pcls->fnid);
1909 }
1910 else
1911 {
1912 if (GETPFNCLIENTW(Wnd->pcls->fnid) == Wnd->lpfnWndProc)
1913 Wnd->lpfnWndProc = GETPFNCLIENTA(Wnd->pcls->fnid);
1914 }
1915 }
1916
1917 // If not an Unicode caller, set Ansi creator bit.
1918 if (!bUnicodeWindow) Wnd->state |= WNDS_ANSICREATOR;
1919
1920 // Clone Class Ansi/Unicode proc type.
1921 if (Wnd->pcls->CSF_flags & CSF_ANSIPROC)
1922 {
1923 Wnd->state |= WNDS_ANSIWINDOWPROC;
1924 Wnd->Unicode = FALSE;
1925 }
1926 else
1927 { /*
1928 It seems there can be both an Ansi creator and Unicode Class Window
1929 WndProc, unless the following overriding conditions occur:
1930 */
1931 if ( !bUnicodeWindow &&
1932 ( ClassAtom == gpsi->atomSysClass[ICLS_BUTTON] ||
1933 ClassAtom == gpsi->atomSysClass[ICLS_COMBOBOX] ||
1934 ClassAtom == gpsi->atomSysClass[ICLS_COMBOLBOX] ||
1935 ClassAtom == gpsi->atomSysClass[ICLS_DIALOG] ||
1936 ClassAtom == gpsi->atomSysClass[ICLS_EDIT] ||
1937 ClassAtom == gpsi->atomSysClass[ICLS_IME] ||
1938 ClassAtom == gpsi->atomSysClass[ICLS_LISTBOX] ||
1939 ClassAtom == gpsi->atomSysClass[ICLS_MDICLIENT] ||
1940 ClassAtom == gpsi->atomSysClass[ICLS_STATIC] ) )
1941 { // Override Class and set the window Ansi WndProc.
1942 Wnd->state |= WNDS_ANSIWINDOWPROC;
1943 Wnd->Unicode = FALSE;
1944 }
1945 else
1946 { // Set the window Unicode WndProc.
1947 Wnd->state &= ~WNDS_ANSIWINDOWPROC;
1948 Wnd->Unicode = TRUE;
1949 }
1950 }
1951
1952 Window->spwndChild = NULL;
1953 Window->spwndPrev = NULL;
1954 Window->spwndNext = NULL;
1955
1956 Wnd->spwndNext = NULL;
1957 Wnd->spwndPrev = NULL;
1958 Wnd->spwndChild = NULL;
1959
1960 Wnd->cbwndExtra = Wnd->pcls->cbwndExtra;
1961
1962 InitializeListHead(&Wnd->PropListHead);
1963
1964 if ( NULL != WindowName->Buffer && WindowName->Length > 0 )
1965 {
1966 Wnd->strName.Buffer = DesktopHeapAlloc(Wnd->head.rpdesk,
1967 WindowName->Length + sizeof(UNICODE_NULL));
1968 if (Wnd->strName.Buffer == NULL)
1969 {
1970 SetLastNtError(STATUS_INSUFFICIENT_RESOURCES);
1971 RETURN( (PWND)0);
1972 }
1973
1974 Wnd->strName.Buffer[WindowName->Length / sizeof(WCHAR)] = L'\0';
1975 _SEH2_TRY
1976 {
1977 RtlCopyMemory(Wnd->strName.Buffer,
1978 WindowName->Buffer,
1979 WindowName->Length);
1980 Wnd->strName.Length = WindowName->Length;
1981 }
1982 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1983 {
1984 WindowName->Length = 0;
1985 Wnd->strName.Buffer[0] = L'\0';
1986 }
1987 _SEH2_END;
1988 }
1989
1990 /*
1991 * This has been tested for WS_CHILD | WS_VISIBLE. It has not been
1992 * tested for WS_POPUP
1993 */
1994 if ((dwExStyle & WS_EX_DLGMODALFRAME) ||
1995 ((!(dwExStyle & WS_EX_STATICEDGE)) &&
1996 (dwStyle & (WS_DLGFRAME | WS_THICKFRAME))))
1997 dwExStyle |= WS_EX_WINDOWEDGE;
1998 else
1999 dwExStyle &= ~WS_EX_WINDOWEDGE;
2000
2001 /* Correct the window style. */
2002 if (!(dwStyle & WS_CHILD))
2003 {
2004 dwStyle |= WS_CLIPSIBLINGS;
2005 DPRINT("3: Style is now %lx\n", dwStyle);
2006 if (!(dwStyle & WS_POPUP))
2007 {
2008 dwStyle |= WS_CAPTION;
2009 Window->state |= WINDOWOBJECT_NEED_SIZE;
2010 DPRINT("4: Style is now %lx\n", dwStyle);
2011 }
2012 }
2013
2014 /* create system menu */
2015 if((dwStyle & WS_SYSMENU) )//&& (dwStyle & WS_CAPTION) == WS_CAPTION)
2016 {
2017 SystemMenu = IntGetSystemMenu(Window, TRUE, TRUE);
2018 if(SystemMenu)
2019 {
2020 Window->SystemMenu = SystemMenu->MenuInfo.Self;
2021 IntReleaseMenuObject(SystemMenu);
2022 }
2023 }
2024
2025 /* Set the window menu */
2026 if ((dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD)
2027 {
2028 if (hMenu)
2029 IntSetMenu(Window, hMenu, &MenuChanged);
2030 else if (Wnd->pcls->lpszMenuName) // Take it from the parent.
2031 {
2032 UNICODE_STRING MenuName;
2033 if (IS_INTRESOURCE(Wnd->pcls->lpszMenuName))
2034 {
2035 MenuName.Length = 0;
2036 MenuName.MaximumLength = 0;
2037 MenuName.Buffer = Wnd->pcls->lpszMenuName;
2038 }
2039 else
2040 {
2041 RtlInitUnicodeString( &MenuName, Wnd->pcls->lpszMenuName);
2042 }
2043 hMenu = co_IntCallLoadMenu( Wnd->pcls->hModule, &MenuName);
2044 if (hMenu) IntSetMenu(Window, hMenu, &MenuChanged);
2045 }
2046 }
2047 else // Not a child
2048 Wnd->IDMenu = (UINT) hMenu;
2049
2050 /* Insert the window into the thread's window list. */
2051 InsertTailList (&pti->WindowListHead, &Window->ThreadListEntry);
2052
2053 /* Handle "CS_CLASSDC", it is tested first. */
2054 if ( (Wnd->pcls->style & CS_CLASSDC) && !(Wnd->pcls->pdce) )
2055 { /* One DCE per class to have CLASS. */
2056 Wnd->pcls->pdce = DceAllocDCE( Window, DCE_CLASS_DC );
2057 }
2058 else if ( Wnd->pcls->style & CS_OWNDC)
2059 { /* Allocate a DCE for this window. */
2060 DceAllocDCE(Window, DCE_WINDOW_DC);
2061 }
2062
2063 Pos.x = x;
2064 Pos.y = y;
2065 Size.cx = nWidth;
2066 Size.cy = nHeight;
2067
2068 Wnd->ExStyle = dwExStyle;
2069 Wnd->style = dwStyle & ~WS_VISIBLE;
2070
2071 /* call hook */
2072 Cs.lpCreateParams = lpParam;
2073 Cs.hInstance = hInstance;
2074 Cs.hMenu = hMenu;
2075 Cs.hwndParent = hWndParent; //Pass the original Parent handle!
2076 Cs.cx = Size.cx;
2077 Cs.cy = Size.cy;
2078 Cs.x = Pos.x;
2079 Cs.y = Pos.y;
2080 Cs.style = Wnd->style;
2081 // Cs.lpszName = (LPCWSTR) WindowName->Buffer;
2082 // Cs.lpszClass = (LPCWSTR) ClassName->Buffer;
2083 Cs.lpszName = (LPCWSTR) WindowName;
2084 Cs.lpszClass = (LPCWSTR) ClassName;
2085 Cs.dwExStyle = dwExStyle;
2086 CbtCreate.lpcs = &Cs;
2087 CbtCreate.hwndInsertAfter = HWND_TOP;
2088 if (ISITHOOKED(WH_CBT))
2089 {
2090 if (co_HOOK_CallHooks(WH_CBT, HCBT_CREATEWND, (WPARAM) hWnd, (LPARAM) &CbtCreate))
2091 {
2092 /* FIXME - Delete window object and remove it from the thread windows list */
2093 /* FIXME - delete allocated DCE */
2094 DPRINT1("CBT-hook returned !0\n");
2095 RETURN( (PWND) NULL);
2096 }
2097 }
2098 x = Cs.x;
2099 y = Cs.y;
2100 nWidth = Cs.cx;
2101 nHeight = Cs.cy;
2102 // FIXME: Need to set the Z order in the window link list if the hook callback changed it!
2103 // hwndInsertAfter = CbtCreate.hwndInsertAfter;
2104
2105 /* default positioning for overlapped windows */
2106 if(!(Wnd->style & (WS_POPUP | WS_CHILD)))
2107 {
2108 RECTL rc, WorkArea;
2109 PRTL_USER_PROCESS_PARAMETERS ProcessParams;
2110 BOOL CalculatedDefPosSize = FALSE;
2111
2112 IntGetDesktopWorkArea(Window->pti->rpdesk, &WorkArea);
2113
2114 rc = WorkArea;
2115 ProcessParams = PsGetCurrentProcess()->Peb->ProcessParameters;
2116
2117 if(x == CW_USEDEFAULT || x == CW_USEDEFAULT16)
2118 {
2119 CalculatedDefPosSize = IntCalcDefPosSize(ParentWindow, &rc, TRUE);
2120
2121 if(ProcessParams->WindowFlags & STARTF_USEPOSITION)
2122 {
2123 ProcessParams->WindowFlags &= ~STARTF_USEPOSITION;
2124 Pos.x = WorkArea.left + ProcessParams->StartingX;
2125 Pos.y = WorkArea.top + ProcessParams->StartingY;
2126 }
2127 else
2128 {
2129 Pos.x = rc.left;
2130 Pos.y = rc.top;
2131 }
2132
2133 /*
2134 According to wine, the ShowMode is set to y if x == CW_USEDEFAULT(16) and
2135 y is something else. and Quote!
2136 */
2137
2138 /* Never believe Microsoft's documentation... CreateWindowEx doc says
2139 * that if an overlapped window is created with WS_VISIBLE style bit
2140 * set and the x parameter is set to CW_USEDEFAULT, the system ignores
2141 * the y parameter. However, disassembling NT implementation (WIN32K.SYS)
2142 * reveals that
2143 *
2144 * 1) not only it checks for CW_USEDEFAULT but also for CW_USEDEFAULT16
2145 * 2) it does not ignore the y parameter as the docs claim; instead, it
2146 * uses it as second parameter to ShowWindow() unless y is either
2147 * CW_USEDEFAULT or CW_USEDEFAULT16.
2148 *
2149 * The fact that we didn't do 2) caused bogus windows pop up when wine
2150 * was running apps that were using this obscure feature. Example -
2151 * calc.exe that comes with Win98 (only Win98, it's different from
2152 * the one that comes with Win95 and NT)
2153 */
2154 if(y != CW_USEDEFAULT && y != CW_USEDEFAULT16)
2155 {
2156 dwShowMode = y;
2157 }
2158 }
2159 if(nWidth == CW_USEDEFAULT || nWidth == CW_USEDEFAULT16)
2160 {
2161 if(!CalculatedDefPosSize)
2162 {
2163 IntCalcDefPosSize(ParentWindow, &rc, FALSE);
2164 }
2165 if(ProcessParams->WindowFlags & STARTF_USESIZE)
2166 {
2167 ProcessParams->WindowFlags &= ~STARTF_USESIZE;
2168 Size.cx = ProcessParams->CountX;
2169 Size.cy = ProcessParams->CountY;
2170 }
2171 else
2172 {
2173 Size.cx = rc.right - rc.left;
2174 Size.cy = rc.bottom - rc.top;
2175 }
2176
2177 /* move the window if necessary */
2178 if(Pos.x > rc.left)
2179 Pos.x = max(rc.left, 0);
2180 if(Pos.y > rc.top)
2181 Pos.y = max(rc.top, 0);
2182 }
2183 }
2184 else
2185 {
2186 /* if CW_USEDEFAULT(16) is set for non-overlapped windows, both values are set to zero) */
2187 if(x == CW_USEDEFAULT || x == CW_USEDEFAULT16)
2188 {
2189 Pos.x = 0;
2190 Pos.y = 0;
2191 }
2192 if(nWidth == CW_USEDEFAULT || nWidth == CW_USEDEFAULT16)
2193 {
2194 Size.cx = 0;
2195 Size.cy = 0;
2196 }
2197 }
2198
2199 /* Initialize the window dimensions. */
2200 Wnd->rcWindow.left = Pos.x;
2201 Wnd->rcWindow.top = Pos.y;
2202 Wnd->rcWindow.right = Pos.x + Size.cx;
2203 Wnd->rcWindow.bottom = Pos.y + Size.cy;
2204 if (0 != (Wnd->style & WS_CHILD) && ParentWindow)
2205 {
2206 RECTL_vOffsetRect(&(Wnd->rcWindow), ParentWindow->Wnd->rcClient.left,
2207 ParentWindow->Wnd->rcClient.top);
2208 }
2209 Wnd->rcClient = Wnd->rcWindow;
2210
2211 /*
2212 * Get the size and position of the window.
2213 */
2214 if ((dwStyle & WS_THICKFRAME) || !(dwStyle & (WS_POPUP | WS_CHILD)))
2215 {
2216 POINT MaxSize, MaxPos, MinTrack, MaxTrack;
2217
2218 /* WinPosGetMinMaxInfo sends the WM_GETMINMAXINFO message */
2219 co_WinPosGetMinMaxInfo(Window, &MaxSize, &MaxPos, &MinTrack,
2220 &MaxTrack);
2221 if (MaxSize.x < Size.cx)
2222 Size.cx = MaxSize.x;
2223 if (MaxSize.y < Size.cy)
2224 Size.cy = MaxSize.y;
2225 if (Size.cx < MinTrack.x )
2226 Size.cx = MinTrack.x;
2227 if (Size.cy < MinTrack.y )
2228 Size.cy = MinTrack.y;
2229 if (Size.cx < 0)
2230 Size.cx = 0;
2231 if (Size.cy < 0)
2232 Size.cy = 0;
2233 }
2234
2235 Wnd->rcWindow.left = Pos.x;
2236 Wnd->rcWindow.top = Pos.y;
2237 Wnd->rcWindow.right = Pos.x + Size.cx;
2238 Wnd->rcWindow.bottom = Pos.y + Size.cy;
2239 if (0 != (Wnd->style & WS_CHILD) && ParentWindow)
2240 {
2241 RECTL_vOffsetRect(&(Wnd->rcWindow), ParentWindow->Wnd->rcClient.left,
2242 ParentWindow->Wnd->rcClient.top);
2243 }
2244 Wnd->rcClient = Wnd->rcWindow;
2245
2246 /* FIXME: Initialize the window menu. */
2247
2248 /* Send a NCCREATE message. */
2249 Cs.cx = Size.cx;
2250 Cs.cy = Size.cy;
2251 Cs.x = Pos.x;
2252 Cs.y = Pos.y;
2253
2254 DPRINT("[win32k.window] IntCreateWindowEx style %d, exstyle %d, parent %d\n", Cs.style, Cs.dwExStyle, Cs.hwndParent);
2255 DPRINT("IntCreateWindowEx(): (%d,%d-%d,%d)\n", x, y, Size.cx, Size.cy);
2256 DPRINT("IntCreateWindowEx(): About to send NCCREATE message.\n");
2257 Result = co_IntSendMessage(Window->hSelf, WM_NCCREATE, 0, (LPARAM) &Cs);
2258 if (!Result)
2259 {
2260 /* FIXME: Cleanup. */
2261 DPRINT1("IntCreateWindowEx(): NCCREATE message failed. No cleanup performed!\n");
2262 RETURN((PWND)0);
2263 }
2264
2265 /* Calculate the non-client size. */
2266 MaxPos.x = Window->Wnd->rcWindow.left;
2267 MaxPos.y = Window->Wnd->rcWindow.top;
2268
2269
2270 DPRINT("IntCreateWindowEx(): About to get non-client size.\n");
2271 /* WinPosGetNonClientSize SENDS THE WM_NCCALCSIZE message */
2272 Result = co_WinPosGetNonClientSize(Window,
2273 &Window->Wnd->rcWindow,
2274 &Window->Wnd->rcClient);
2275
2276 RECTL_vOffsetRect(&Window->Wnd->rcWindow,
2277 MaxPos.x - Window->Wnd->rcWindow.left,
2278 MaxPos.y - Window->Wnd->rcWindow.top);
2279
2280
2281 if (NULL != ParentWindow)
2282 {
2283 /* link the window into the parent's child list */
2284 if ((dwStyle & (WS_CHILD|WS_MAXIMIZE)) == WS_CHILD)
2285 {
2286 PWINDOW_OBJECT PrevSibling;
2287
2288 PrevSibling = ParentWindow->spwndChild;
2289
2290 if(PrevSibling)
2291 {
2292 while (PrevSibling->spwndNext)
2293 PrevSibling = PrevSibling->spwndNext;
2294 }
2295
2296 /* link window as bottom sibling */
2297 IntLinkWindow(Window, ParentWindow, PrevSibling /*prev sibling*/);
2298 }
2299 else
2300 {
2301 /* link window as top sibling (but after topmost siblings) */
2302 PWINDOW_OBJECT InsertAfter, Sibling;
2303 if (!(dwExStyle & WS_EX_TOPMOST))
2304 {
2305 InsertAfter = NULL;
2306 Sibling = ParentWindow->spwndChild;
2307 while (Sibling && (Sibling->Wnd->ExStyle & WS_EX_TOPMOST))
2308 {
2309 InsertAfter = Sibling;
2310 Sibling = Sibling->spwndNext;
2311 }
2312 }
2313 else
2314 {
2315 InsertAfter = NULL;
2316 }
2317
2318 IntLinkWindow(Window, ParentWindow, InsertAfter /* prev sibling */);
2319 }
2320 }
2321
2322 /* Send the WM_CREATE message. */
2323 DPRINT("IntCreateWindowEx(): about to send CREATE message.\n");
2324 Result = co_IntSendMessage(Window->hSelf, WM_CREATE, 0, (LPARAM) &Cs);
2325
2326 if (Result == (LRESULT)-1)
2327 {
2328 /* FIXME: Cleanup. */
2329 DPRINT1("IntCreateWindowEx(): send CREATE message failed. No cleanup performed!\n");
2330 IntUnlinkWindow(Window);
2331 RETURN((PWND)0);
2332 }
2333
2334 IntNotifyWinEvent(EVENT_OBJECT_CREATE, Window->Wnd, OBJID_WINDOW, 0);
2335
2336 /* Send move and size messages. */
2337 if (!(Window->state & WINDOWOBJECT_NEED_SIZE))
2338 {
2339 LONG lParam;
2340
2341 DPRINT("IntCreateWindow(): About to send WM_SIZE\n");
2342
2343 if ((Window->Wnd->rcClient.right - Window->Wnd->rcClient.left) < 0 ||
2344 (Window->Wnd->rcClient.bottom - Window->Wnd->rcClient.top) < 0)
2345 {
2346 DPRINT("Sending bogus WM_SIZE\n");
2347 }
2348
2349 lParam = MAKE_LONG(Window->Wnd->rcClient.right -
2350 Window->Wnd->rcClient.left,
2351 Window->Wnd->rcClient.bottom -
2352 Window->Wnd->rcClient.top);
2353 co_IntSendMessage(Window->hSelf, WM_SIZE, SIZE_RESTORED,
2354 lParam);
2355
2356 DPRINT("IntCreateWindow(): About to send WM_MOVE\n");
2357
2358 if (0 != (Wnd->style & WS_CHILD) && ParentWindow)
2359 {
2360 lParam = MAKE_LONG(Wnd->rcClient.left - ParentWindow->Wnd->rcClient.left,
2361 Wnd->rcClient.top - ParentWindow->Wnd->rcClient.top);
2362 }
2363 else
2364 {
2365 lParam = MAKE_LONG(Wnd->rcClient.left,
2366 Wnd->rcClient.top);
2367 }
2368
2369 co_IntSendMessage(Window->hSelf, WM_MOVE, 0, lParam);
2370
2371 /* Call WNDOBJ change procs */
2372 IntEngWindowChanged(Window, WOC_RGN_CLIENT);
2373 }
2374
2375 /* Show or maybe minimize or maximize the window. */
2376 if (Wnd->style & (WS_MINIMIZE | WS_MAXIMIZE))
2377 {
2378 RECTL NewPos;
2379 UINT16 SwFlag;
2380
2381 SwFlag = (Wnd->style & WS_MINIMIZE) ? SW_MINIMIZE :
2382 SW_MAXIMIZE;
2383
2384 co_WinPosMinMaximize(Window, SwFlag, &NewPos);
2385
2386 SwFlag = ((Wnd->style & WS_CHILD) || UserGetActiveWindow()) ?
2387 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED :
2388 SWP_NOZORDER | SWP_FRAMECHANGED;
2389
2390 DPRINT("IntCreateWindow(): About to minimize/maximize\n");
2391 DPRINT("%d,%d %dx%d\n", NewPos.left, NewPos.top, NewPos.right, NewPos.bottom);
2392 co_WinPosSetWindowPos(Window, 0, NewPos.left, NewPos.top,
2393 NewPos.right, NewPos.bottom, SwFlag);
2394 }
2395
2396 /* Notify the parent window of a new child. */
2397 if ((Wnd->style & WS_CHILD) &&
2398 (!(Wnd->ExStyle & WS_EX_NOPARENTNOTIFY)) && ParentWindow)
2399 {
2400 DPRINT("IntCreateWindow(): About to notify parent\n");
2401 co_IntSendMessage(ParentWindow->hSelf,
2402 WM_PARENTNOTIFY,
2403 MAKEWPARAM(WM_CREATE, Wnd->IDMenu),
2404 (LPARAM)Window->hSelf);
2405 }
2406
2407 if ((!hWndParent) && (!HasOwner))
2408 {
2409 DPRINT("Sending CREATED notify\n");
2410 co_IntShellHookNotify(HSHELL_WINDOWCREATED, (LPARAM)hWnd);
2411 }
2412 else
2413 {
2414 DPRINT("Not sending CREATED notify, %x %d\n", ParentWindow, HasOwner);
2415 }
2416
2417 /* Initialize and show the window's scrollbars */
2418 if (Wnd->style & WS_VSCROLL)
2419 {
2420 co_UserShowScrollBar(Window, SB_VERT, TRUE);
2421 }
2422 if (Wnd->style & WS_HSCROLL)
2423 {
2424 co_UserShowScrollBar(Window, SB_HORZ, TRUE);
2425 }
2426
2427 if (dwStyle & WS_VISIBLE)
2428 {
2429 if (Wnd->style & WS_MAXIMIZE)
2430 dwShowMode = SW_SHOW;
2431 else if (Wnd->style & WS_MINIMIZE)
2432 dwShowMode = SW_SHOWMINIMIZED;
2433
2434 DPRINT("IntCreateWindow(): About to show window\n");
2435 co_WinPosShowWindow(Window, dwShowMode);
2436
2437 if (Wnd->ExStyle & WS_EX_MDICHILD)
2438 {
2439 co_IntSendMessage(ParentWindow->hSelf, WM_MDIREFRESHMENU, 0, 0);
2440 /* ShowWindow won't activate child windows */
2441 co_WinPosSetWindowPos(Window, HWND_TOP, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE);
2442 }
2443 }
2444
2445 /* BugBoy Comments: if the window being created is a edit control, ATOM 0xCxxx,
2446 then my testing shows that windows (2k and XP) creates a CallProc for it immediately
2447 Dont understand why it does this. */
2448 if (ClassAtom == gpsi->atomSysClass[ICLS_EDIT])
2449 {
2450 PCALLPROCDATA CallProc;
2451 //CallProc = CreateCallProc(NULL, Wnd->lpfnWndProc, bUnicodeWindow, Wnd->ti->ppi);
2452 CallProc = CreateCallProc(NULL, Wnd->lpfnWndProc, Wnd->Unicode , Wnd->head.pti->ppi);
2453
2454 if (!CallProc)
2455 {
2456 SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
2457 DPRINT1("Warning: Unable to create CallProc for edit control. Control may not operate correctly! hwnd %x\n",hWnd);
2458 }
2459 else
2460 {
2461 UserAddCallProcToClass(Wnd->pcls, CallProc);
2462 }
2463 }
2464
2465 DPRINT("IntCreateWindow(): = %X\n", hWnd);
2466 DPRINT("WindowObject->SystemMenu = 0x%x\n", Window->SystemMenu);
2467 RETURN( Wnd);
2468
2469 CLEANUP:
2470 if (!_ret_ && Window && Window->Wnd && ti)
2471 co_UserDestroyWindow(Window);
2472 // UserFreeWindowInfo(ti, Window);
2473 if (Window)
2474 {
2475 UserDerefObjectCo(Window);
2476 UserDereferenceObject(Window);
2477 }
2478 if (ParentWindow) UserDerefObjectCo(ParentWindow);
2479 if (!_ret_ && ti != NULL)
2480 {
2481 if (Class != NULL)
2482 {
2483 IntDereferenceClass(Class,
2484 ti->pDeskInfo,
2485 ti->ppi);
2486 }
2487 }
2488 END_CLEANUP;
2489 }
2490
2491 HWND APIENTRY
2492 NtUserCreateWindowEx(DWORD dwExStyle,
2493 PUNICODE_STRING UnsafeClassName,
2494 PUNICODE_STRING UnsafeWindowName,
2495 DWORD dwStyle,
2496 LONG x,
2497 LONG y,
2498 LONG nWidth,
2499 LONG nHeight,
2500 HWND hWndParent,
2501 HMENU hMenu,
2502 HINSTANCE hInstance,
2503 LPVOID lpParam,
2504 DWORD dwShowMode,
2505 BOOL bUnicodeWindow,
2506 DWORD dwUnknown)
2507 {
2508 NTSTATUS Status;
2509 UNICODE_STRING WindowName;
2510 UNICODE_STRING ClassName;
2511 HWND NewWindow = NULL;
2512 PWND pNewWindow;
2513 DECLARE_RETURN(HWND);
2514
2515 DPRINT("Enter NtUserCreateWindowEx(): (%d,%d-%d,%d)\n", x, y, nWidth, nHeight);
2516 UserEnterExclusive();
2517
2518 /* Get the class name (string or atom) */
2519 Status = MmCopyFromCaller(&ClassName, UnsafeClassName, sizeof(UNICODE_STRING));
2520 if (! NT_SUCCESS(Status))
2521 {
2522 SetLastNtError(Status);
2523 RETURN( NULL);
2524 }
2525 if (ClassName.Length != 0)
2526 {
2527 Status = IntSafeCopyUnicodeStringTerminateNULL(&ClassName, UnsafeClassName);
2528 if (! NT_SUCCESS(Status))
2529 {
2530 SetLastNtError(Status);
2531 RETURN( NULL);
2532 }
2533 }
2534 else if (! IS_ATOM(ClassName.Buffer))
2535 {
2536 SetLastWin32Error(ERROR_INVALID_PARAMETER);
2537 RETURN(NULL);
2538 }
2539
2540 /* safely copy the window name */
2541 if (NULL != UnsafeWindowName)
2542 {
2543 Status = IntSafeCopyUnicodeString(&WindowName, UnsafeWindowName);
2544 if (! NT_SUCCESS(Status))
2545 {
2546 if (! IS_ATOM(ClassName.Buffer))
2547 {
2548 ExFreePoolWithTag(ClassName.Buffer, TAG_STRING);
2549 }
2550 SetLastNtError(Status);
2551 RETURN( NULL);
2552 }
2553 }
2554 else
2555 {
2556 RtlInitUnicodeString(&WindowName, NULL);
2557 }
2558
2559 pNewWindow = co_IntCreateWindowEx( dwExStyle,
2560 &ClassName,
2561 &WindowName,
2562 dwStyle,
2563 x,
2564 y,
2565 nWidth,
2566 nHeight,
2567 hWndParent,
2568 hMenu,
2569 hInstance,
2570 lpParam,
2571 dwShowMode,
2572 bUnicodeWindow);
2573
2574 if (pNewWindow) NewWindow = UserHMGetHandle(pNewWindow);
2575
2576 if (WindowName.Buffer)
2577 {
2578 ExFreePoolWithTag(WindowName.Buffer, TAG_STRING);
2579 }
2580 if (! IS_ATOM(ClassName.Buffer))
2581 {
2582 ExFreePoolWithTag(ClassName.Buffer, TAG_STRING);
2583 }
2584
2585 RETURN( NewWindow);
2586
2587 CLEANUP:
2588 DPRINT("Leave NtUserCreateWindowEx, ret=%i\n",_ret_);
2589 UserLeave();
2590 END_CLEANUP;
2591 }
2592
2593 /*
2594 * @unimplemented
2595 */
2596 HDWP APIENTRY
2597 NtUserDeferWindowPos(HDWP WinPosInfo,
2598 HWND Wnd,
2599 HWND WndInsertAfter,
2600 int x,
2601 int y,
2602 int cx,
2603 int cy,
2604 UINT Flags)
2605 {
2606 UNIMPLEMENTED
2607
2608 return 0;
2609 }
2610
2611
2612 BOOLEAN FASTCALL co_UserDestroyWindow(PWINDOW_OBJECT Window)
2613 {
2614 BOOLEAN isChild;
2615 PWND Wnd;
2616 HWND hWnd;
2617
2618 ASSERT_REFS_CO(Window); // FIXME: temp hack?
2619
2620 hWnd = Window->hSelf;
2621
2622 Wnd = Window->Wnd;
2623
2624 if (!Wnd) return TRUE; // FIXME: Need to finish object rewrite or lock the thread when killing the window!
2625
2626 DPRINT("co_UserDestroyWindow \n");
2627
2628 /* Check for owner thread */
2629 if ( (Window->pti->pEThread != PsGetCurrentThread()) ||
2630 Wnd->head.pti != PsGetCurrentThreadWin32Thread() )
2631 {
2632 SetLastWin32Error(ERROR_ACCESS_DENIED);
2633 return FALSE;
2634 }
2635
2636 /* Call hooks */
2637 if (ISITHOOKED(WH_CBT))
2638 {
2639 if (co_HOOK_CallHooks(WH_CBT, HCBT_DESTROYWND, (WPARAM) hWnd, 0)) return FALSE;
2640 }
2641
2642 /* Look whether the focus is within the tree of windows we will
2643 * be destroying.
2644 */
2645 if (!co_WinPosShowWindow(Window, SW_HIDE))
2646 {
2647 if (UserGetActiveWindow() == Window->hSelf)
2648 {
2649 co_WinPosActivateOtherWindow(Window);
2650 }
2651 }
2652
2653 if (Window->pti->MessageQueue->ActiveWindow == Window->hSelf)
2654 Window->pti->MessageQueue->ActiveWindow = NULL;
2655 if (Window->pti->MessageQueue->FocusWindow == Window->hSelf)
2656 Window->pti->MessageQueue->FocusWindow = NULL;
2657 if (Window->pti->MessageQueue->CaptureWindow == Window->hSelf)
2658 Window->pti->MessageQueue->CaptureWindow = NULL;
2659
2660 IntDereferenceMessageQueue(Window->pti->MessageQueue);
2661
2662 IntEngWindowChanged(Window, WOC_DELETE);
2663 isChild = (0 != (Wnd->style & WS_CHILD));
2664
2665 #if 0 /* FIXME */
2666
2667 if (isChild)
2668 {
2669 if (! USER_IsExitingThread(GetCurrentThreadId()))
2670 {
2671 send_parent_notify(hwnd, WM_DESTROY);
2672 }
2673 }
2674 else if (NULL != GetWindow(Wnd, GW_OWNER))
2675 {
2676 co_HOOK_CallHooks( WH_SHELL, HSHELL_WINDOWDESTROYED, (WPARAM)hwnd, 0L, TRUE );
2677 /* FIXME: clean up palette - see "Internals" p.352 */
2678 }
2679 #endif
2680
2681 if (!IntIsWindow(Window->hSelf))
2682 {
2683 return TRUE;
2684 }
2685
2686 /* Recursively destroy owned windows */
2687 if (! isChild)
2688 {
2689 for (;;)
2690 {
2691 BOOL GotOne = FALSE;
2692 HWND *Children;
2693 HWND *ChildHandle;
2694 PWINDOW_OBJECT Child, Desktop;
2695
2696 Desktop = IntIsDesktopWindow(Window) ? Window :
2697 UserGetWindowObject(IntGetDesktopWindow());
2698 Children = IntWinListChildren(Desktop);
2699
2700 if (Children)
2701 {
2702 for (ChildHandle = Children; *ChildHandle; ++ChildHandle)
2703 {
2704 Child = UserGetWindowObject(*ChildHandle);
2705 if (Child == NULL)
2706 continue;
2707 if (Child->hOwner != Window->hSelf)
2708 {
2709 continue;
2710 }
2711
2712 if (IntWndBelongsToThread(Child, PsGetCurrentThreadWin32Thread()))
2713 {
2714 USER_REFERENCE_ENTRY ChildRef;
2715 UserRefObjectCo(Child, &ChildRef);//temp hack?
2716 co_UserDestroyWindow(Child);
2717 UserDerefObjectCo(Child);//temp hack?
2718
2719 GotOne = TRUE;
2720 continue;
2721 }
2722
2723 if (Child->hOwner != NULL)
2724 {
2725 Child->hOwner = NULL;
2726 Child->Wnd->spwndOwner = NULL;
2727 }
2728
2729 }
2730 ExFreePool(Children);
2731 }
2732 if (! GotOne)
2733 {
2734 break;
2735 }
2736 }
2737 }
2738
2739 if (!IntIsWindow(Window->hSelf))
2740 {
2741 return TRUE;
2742 }
2743
2744 /* Destroy the window storage */
2745 co_UserFreeWindow(Window, PsGetCurrentProcessWin32Process(), PsGetCurrentThreadWin32Thread(), TRUE);
2746
2747 return TRUE;
2748 }
2749
2750
2751 /*
2752 * @implemented
2753 */
2754 BOOLEAN APIENTRY
2755 NtUserDestroyWindow(HWND Wnd)
2756 {
2757 PWINDOW_OBJECT Window;
2758 DECLARE_RETURN(BOOLEAN);
2759 BOOLEAN ret;
2760 USER_REFERENCE_ENTRY Ref;
2761
2762 DPRINT("Enter NtUserDestroyWindow\n");
2763 UserEnterExclusive();
2764
2765 if (!(Window = UserGetWindowObject(Wnd)))
2766 {
2767 RETURN(FALSE);
2768 }
2769
2770 UserRefObjectCo(Window, &Ref);//faxme: dunno if win should be reffed during destroy..
2771 ret = co_UserDestroyWindow(Window);
2772 UserDerefObjectCo(Window);//faxme: dunno if win should be reffed during destroy..
2773
2774 RETURN(ret);
2775
2776 CLEANUP:
2777 DPRINT("Leave NtUserDestroyWindow, ret=%i\n",_ret_);
2778 UserLeave();
2779 END_CLEANUP;
2780 }
2781
2782
2783
2784 /*
2785 * @unimplemented
2786 */
2787 DWORD
2788 APIENTRY
2789 NtUserDrawMenuBarTemp(
2790 HWND hWnd,
2791 HDC hDC,
2792 PRECT hRect,
2793 HMENU hMenu,
2794 HFONT hFont)
2795 {
2796 /* we'll use this function just for caching the menu bar */
2797 UNIMPLEMENTED
2798 return 0;
2799 }
2800
2801
2802 /*
2803 * @unimplemented
2804 */
2805 DWORD APIENTRY
2806 NtUserEndDeferWindowPosEx(DWORD Unknown0,
2807 DWORD Unknown1)
2808 {
2809 UNIMPLEMENTED
2810
2811 return 0;
2812 }
2813
2814
2815 /*
2816 * FillWindow: Called from User; Dialog, Edit and ListBox procs during a WM_ERASEBKGND.
2817 */
2818 /*
2819 * @unimplemented
2820 */
2821 BOOL APIENTRY
2822 NtUserFillWindow(HWND hWndPaint,
2823 HWND hWndPaint1,
2824 HDC hDC,
2825 HBRUSH hBrush)
2826 {
2827 UNIMPLEMENTED
2828
2829 return 0;
2830 }
2831
2832
2833 static HWND FASTCALL
2834 IntFindWindow(PWINDOW_OBJECT Parent,
2835 PWINDOW_OBJECT ChildAfter,
2836 RTL_ATOM ClassAtom,
2837 PUNICODE_STRING WindowName)
2838 {
2839 BOOL CheckWindowName;
2840 HWND *List, *phWnd;
2841 HWND Ret = NULL;
2842
2843 ASSERT(Parent);
2844
2845 CheckWindowName = WindowName->Length != 0;
2846
2847 if((List = IntWinListChildren(Parent)))
2848 {
2849 phWnd = List;
2850 if(ChildAfter)
2851 {
2852 /* skip handles before and including ChildAfter */
2853 while(*phWnd && (*(phWnd++) != ChildAfter->hSelf))
2854 ;
2855 }
2856
2857 /* search children */
2858 while(*phWnd)
2859 {
2860 PWINDOW_OBJECT Child;
2861 if(!(Child = UserGetWindowObject(*(phWnd++))))
2862 {
2863 continue;
2864 }
2865
2866 /* Do not send WM_GETTEXT messages in the kernel mode version!
2867 The user mode version however calls GetWindowText() which will
2868 send WM_GETTEXT messages to windows belonging to its processes */
2869 if((!CheckWindowName || !RtlCompareUnicodeString(WindowName, &(Child->Wnd->strName), TRUE)) &&
2870 (!ClassAtom || Child->Wnd->pcls->atomClassName == ClassAtom))
2871 {
2872 Ret = Child->hSelf;
2873 break;
2874 }
2875
2876 }
2877 ExFreePool(List);
2878 }
2879
2880 return Ret;
2881 }
2882
2883 /*
2884 * FUNCTION:
2885 * Searches a window's children for a window with the specified
2886 * class and name
2887 * ARGUMENTS:
2888 * hwndParent = The window whose childs are to be searched.
2889 * NULL = desktop
2890 * HWND_MESSAGE = message-only windows
2891 *
2892 * hwndChildAfter = Search starts after this child window.
2893 * NULL = start from beginning
2894 *
2895 * ucClassName = Class name to search for
2896 * Reguired parameter.
2897 *
2898 * ucWindowName = Window name
2899 * ->Buffer == NULL = don't care
2900 *
2901 * RETURNS:
2902 * The HWND of the window if it was found, otherwise NULL
2903 */
2904 /*
2905 * @implemented
2906 */
2907 HWND APIENTRY
2908 NtUserFindWindowEx(HWND hwndParent,
2909 HWND hwndChildAfter,
2910 PUNICODE_STRING ucClassName,
2911 PUNICODE_STRING ucWindowName,
2912 DWORD dwUnknown)
2913 {
2914 PWINDOW_OBJECT Parent, ChildAfter;
2915 UNICODE_STRING ClassName = {0}, WindowName = {0};
2916 HWND Desktop, Ret = NULL;
2917 RTL_ATOM ClassAtom = (RTL_ATOM)0;
2918 DECLARE_RETURN(HWND);
2919
2920 DPRINT("Enter NtUserFindWindowEx\n");
2921 UserEnterShared();
2922
2923 if (ucClassName != NULL || ucWindowName != NULL)
2924 {
2925 _SEH2_TRY
2926 {
2927 if (ucClassName != NULL)
2928 {
2929 ClassName = ProbeForReadUnicodeString(ucClassName);
2930 if (ClassName.Length != 0)
2931 {
2932 ProbeForRead(ClassName.Buffer,
2933 ClassName.Length,
2934 sizeof(WCHAR));
2935 }
2936 else if (!IS_ATOM(ClassName.Buffer))
2937 {
2938 SetLastWin32Error(ERROR_INVALID_PARAMETER);
2939 _SEH2_LEAVE;
2940 }
2941
2942 if (!IntGetAtomFromStringOrAtom(&ClassName,
2943 &ClassAtom))
2944 {
2945 _SEH2_LEAVE;
2946 }
2947 }
2948
2949 if (ucWindowName != NULL)
2950 {
2951 WindowName = ProbeForReadUnicodeString(ucWindowName);
2952 if (WindowName.Length != 0)
2953 {
2954 ProbeForRead(WindowName.Buffer,
2955 WindowName.Length,
2956 sizeof(WCHAR));
2957 }
2958 }
2959 }
2960 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2961 {
2962 SetLastNtError(_SEH2_GetExceptionCode());
2963 _SEH2_YIELD(RETURN(NULL));
2964 }
2965 _SEH2_END;
2966
2967 if (ucClassName != NULL)
2968 {
2969 if (ClassName.Length == 0 && ClassName.Buffer != NULL &&
2970 !IS_ATOM(ClassName.Buffer))
2971 {
2972 SetLastWin32Error(ERROR_INVALID_PARAMETER);
2973 RETURN(NULL);
2974 }
2975 else if (ClassAtom == (RTL_ATOM)0)
2976 {
2977 /* LastError code was set by IntGetAtomFromStringOrAtom */
2978 RETURN(NULL);
2979 }
2980 }
2981 }
2982
2983 Desktop = IntGetCurrentThreadDesktopWindow();
2984
2985 if(hwndParent == NULL)
2986 hwndParent = Desktop;
2987 else if(hwndParent == HWND_MESSAGE)
2988 {
2989 hwndParent = IntGetMessageWindow();
2990 }
2991
2992 if(!(Parent = UserGetWindowObject(hwndParent)))
2993 {
2994 RETURN( NULL);
2995 }
2996
2997 ChildAfter = NULL;
2998 if(hwndChildAfter && !(ChildAfter = UserGetWindowObject(hwndChildAfter)))
2999 {
3000 RETURN( NULL);
3001 }
3002
3003 _SEH2_TRY
3004 {
3005 if(Parent->hSelf == Desktop)
3006 {
3007 HWND *List, *phWnd;
3008 PWINDOW_OBJECT TopLevelWindow;
3009 BOOLEAN CheckWindowName;
3010 BOOLEAN WindowMatches;
3011 BOOLEAN ClassMatches;
3012
3013 /* windows searches through all top-level windows if the parent is the desktop
3014 window */
3015
3016 if((List = IntWinListChildren(Parent)))
3017 {
3018 phWnd = List;
3019
3020 if(ChildAfter)
3021 {
3022 /* skip handles before and including ChildAfter */
3023 while(*phWnd && (*(phWnd++) != ChildAfter->hSelf))
3024 ;
3025 }
3026
3027 CheckWindowName = WindowName.Length != 0;
3028
3029 /* search children */
3030 while(*phWnd)
3031 {
3032 if(!(TopLevelWindow = UserGetWindowObject(*(phWnd++))))
3033 {
3034 continue;
3035 }
3036
3037 /* Do not send WM_GETTEXT messages in the kernel mode version!
3038 The user mode version however calls GetWindowText() which will
3039 send WM_GETTEXT messages to windows belonging to its processes */
3040 WindowMatches = !CheckWindowName || !RtlCompareUnicodeString(
3041 &WindowName, &TopLevelWindow->Wnd->strName, TRUE);
3042 ClassMatches = (ClassAtom == (RTL_ATOM)0) ||
3043 ClassAtom == TopLevelWindow->Wnd->pcls->atomClassName;
3044
3045 if (WindowMatches && ClassMatches)
3046 {
3047 Ret = TopLevelWindow->hSelf;
3048 break;
3049 }
3050
3051 if (IntFindWindow(TopLevelWindow, NULL, ClassAtom, &WindowName))
3052 {
3053 /* window returns the handle of the top-level window, in case it found
3054 the child window */
3055 Ret = TopLevelWindow->hSelf;
3056 break;
3057 }
3058
3059 }
3060 ExFreePool(List);
3061 }
3062 }
3063 else
3064 Ret = IntFindWindow(Parent, ChildAfter, ClassAtom, &WindowName);
3065
3066 #if 0
3067
3068 if(Ret == NULL && hwndParent == NULL && hwndChildAfter == NULL)
3069 {
3070 /* FIXME - if both hwndParent and hwndChildAfter are NULL, we also should
3071 search the message-only windows. Should this also be done if
3072 Parent is the desktop window??? */
3073 PWINDOW_OBJECT MsgWindows;
3074
3075 if((MsgWindows = UserGetWindowObject(IntGetMessageWindow())))
3076 {
3077 Ret = IntFindWindow(MsgWindows, ChildAfter, ClassAtom, &WindowName);
3078 }
3079 }
3080 #endif
3081 }
3082 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
3083 {
3084 SetLastNtError(_SEH2_GetExceptionCode());
3085 Ret = NULL;
3086 }
3087 _SEH2_END;
3088
3089 RETURN( Ret);
3090
3091 CLEANUP:
3092 DPRINT("Leave NtUserFindWindowEx, ret %i\n",_ret_);
3093 UserLeave();
3094 END_CLEANUP;
3095 }
3096
3097
3098 /*
3099 * @unimplemented
3100 */
3101 BOOL APIENTRY
3102 NtUserFlashWindowEx(IN PFLASHWINFO pfwi)
3103 {
3104 UNIMPLEMENTED
3105
3106 return 0;
3107 }
3108
3109
3110 /*
3111 * @implemented
3112 */
3113 PWINDOW_OBJECT FASTCALL UserGetAncestor(PWINDOW_OBJECT Wnd, UINT Type)
3114 {
3115 PWINDOW_OBJECT WndAncestor, Parent;
3116
3117 if (Wnd->hSelf == IntGetDesktopWindow())
3118 {
3119 return NULL;
3120 }
3121
3122 switch (Type)
3123 {
3124 case GA_PARENT:
3125 {
3126 WndAncestor = Wnd->spwndParent;
3127 break;
3128 }
3129
3130 case GA_ROOT:
3131 {
3132 WndAncestor = Wnd;
3133 Parent = NULL;
3134
3135 for(;;)
3136 {
3137 if(!(Parent = WndAncestor->spwndParent))
3138 {
3139 break;
3140 }
3141 if(IntIsDesktopWindow(Parent))
3142 {
3143 break;
3144 }
3145
3146 WndAncestor = Parent;
3147 }
3148 break;
3149 }
3150
3151 case GA_ROOTOWNER:
3152 {
3153 WndAncestor = Wnd;
3154
3155 for (;;)
3156 {
3157 PWINDOW_OBJECT Parent, Old;
3158
3159 Old = WndAncestor;
3160 Parent = IntGetParent(WndAncestor);
3161
3162 if (!Parent)
3163 {
3164 break;
3165 }
3166
3167 //temp hack
3168 // UserDereferenceObject(Parent);
3169
3170 WndAncestor = Parent;
3171 }
3172 break;
3173 }
3174
3175 default:
3176 {
3177 return NULL;
3178 }
3179 }
3180
3181 return WndAncestor;
3182 }
3183
3184 /*
3185 * @implemented
3186 */
3187 HWND APIENTRY
3188 NtUserGetAncestor(HWND hWnd, UINT Type)
3189 {
3190 PWINDOW_OBJECT Window, Ancestor;
3191 DECLARE_RETURN(HWND);
3192
3193 DPRINT("Enter NtUserGetAncestor\n");
3194 UserEnterExclusive();
3195
3196 if (!(Window = UserGetWindowObject(hWnd)))
3197 {
3198 RETURN(NULL);
3199 }
3200
3201 Ancestor = UserGetAncestor(Window, Type);
3202 /* faxme: can UserGetAncestor ever return NULL for a valid window? */
3203
3204 RETURN(Ancestor ? Ancestor->hSelf : NULL);
3205
3206 CLEANUP:
3207 DPRINT("Leave NtUserGetAncestor, ret=%i\n",_ret_);
3208 UserLeave();
3209 END_CLEANUP;
3210 }
3211
3212
3213 BOOL
3214 APIENTRY
3215 NtUserGetComboBoxInfo(
3216 HWND hWnd,
3217 PCOMBOBOXINFO pcbi)
3218 {
3219 PWINDOW_OBJECT Wnd;
3220 DECLARE_RETURN(BOOL);
3221
3222 DPRINT("Enter NtUserGetComboBoxInfo\n");
3223 UserEnterShared();
3224
3225 if (!(Wnd = UserGetWindowObject(hWnd)))
3226 {
3227 RETURN( FALSE );
3228 }
3229 _SEH2_TRY
3230 {
3231 if(pcbi)
3232 {
3233 ProbeForWrite(pcbi,
3234 sizeof(COMBOBOXINFO),
3235 1);
3236 }
3237 }
3238 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
3239 {
3240 SetLastNtError(_SEH2_GetExceptionCode());
3241 _SEH2_YIELD(RETURN(FALSE));
3242 }
3243 _SEH2_END;
3244
3245 // Pass the user pointer, it was already probed.
3246 RETURN( (BOOL) co_IntSendMessage( Wnd->hSelf, CB_GETCOMBOBOXINFO, 0, (LPARAM)pcbi));
3247
3248 CLEANUP:
3249 DPRINT("Leave NtUserGetComboBoxInfo, ret=%i\n",_ret_);
3250 UserLeave();
3251 END_CLEANUP;
3252 }
3253
3254
3255 /*
3256 * @implemented
3257 */
3258 DWORD APIENTRY
3259 NtUserGetInternalWindowPos( HWND hWnd,
3260 LPRECT rectWnd,
3261 LPPOINT ptIcon)
3262 {
3263 PWINDOW_OBJECT Window;
3264 PWND Wnd;
3265 DWORD Ret = 0;
3266 BOOL Hit = FALSE;
3267 WINDOWPLACEMENT wndpl;
3268
3269 UserEnterShared();
3270
3271 if (!(Window = UserGetWindowObject(hWnd)) || !Window->Wnd)
3272 {
3273 Hit = FALSE;
3274 goto Exit;
3275 }
3276 Wnd = Window->Wnd;
3277
3278 _SEH2_TRY
3279 {
3280 if(rectWnd)
3281 {
3282 ProbeForWrite(rectWnd,
3283 sizeof(RECT),
3284 1);
3285 }
3286 if(ptIcon)
3287 {
3288 ProbeForWrite(ptIcon,
3289 sizeof(POINT),
3290 1);
3291 }
3292
3293 }
3294 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
3295 {
3296 SetLastNtError(_SEH2_GetExceptionCode());
3297 Hit = TRUE;
3298 }
3299 _SEH2_END;
3300
3301 wndpl.length = sizeof(WINDOWPLACEMENT);
3302
3303 if (IntGetWindowPlacement(Window, &wndpl) && !Hit)
3304 {
3305 _SEH2_TRY
3306 {
3307 if (rectWnd)
3308 {
3309 RtlCopyMemory(rectWnd, &wndpl.rcNormalPosition , sizeof(RECT));
3310 }
3311 if (ptIcon)
3312 {
3313 RtlCopyMemory(ptIcon, &wndpl.ptMinPosition, sizeof(POINT));
3314 }
3315
3316 }
3317 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
3318 {
3319 SetLastNtError(_SEH2_GetExceptionCode());
3320 Hit = TRUE;
3321 }
3322 _SEH2_END;
3323
3324 if (!Hit) Ret = wndpl.showCmd;
3325 }
3326 Exit:
3327 UserLeave();
3328 return Ret;
3329 }
3330
3331 DWORD
3332 APIENTRY
3333 NtUserGetListBoxInfo(
3334 HWND hWnd)
3335 {
3336 PWINDOW_OBJECT Wnd;
3337 DECLARE_RETURN(DWORD);
3338
3339 DPRINT("Enter NtUserGetListBoxInfo\n");
3340 UserEnterShared();
3341
3342 if (!(Wnd = UserGetWindowObject(hWnd)))
3343 {
3344 RETURN( 0 );
3345 }
3346
3347 RETURN( (DWORD) co_IntSendMessage( Wnd->hSelf, LB_GETLISTBOXINFO, 0, 0 ));
3348
3349 CLEANUP:
3350 DPRINT("Leave NtUserGetListBoxInfo, ret=%i\n",_ret_);
3351 UserLeave();
3352 END_CLEANUP;
3353 }
3354
3355
3356 HWND FASTCALL
3357 co_UserSetParent(HWND hWndChild, HWND hWndNewParent)
3358 {
3359 PWINDOW_OBJECT Wnd = NULL, WndParent = NULL, WndOldParent;
3360 HWND hWndOldParent = NULL;
3361 USER_REFERENCE_ENTRY Ref, ParentRef;
3362
3363 if (IntIsBroadcastHwnd(hWndChild) || IntIsBroadcastHwnd(hWndNewParent))
3364 {
3365 SetLastWin32Error(ERROR_INVALID_PARAMETER);
3366 return( NULL);
3367 }
3368
3369 if (hWndChild == IntGetDesktopWindow())
3370 {
3371 SetLastWin32Error(ERROR_ACCESS_DENIED);
3372 return( NULL);
3373 }
3374
3375 if (hWndNewParent)
3376 {
3377 if (!(WndParent = UserGetWindowObject(hWndNewParent)))
3378 {
3379 return( NULL);
3380 }
3381 }
3382 else
3383 {
3384 if (!(WndParent = UserGetWindowObject(IntGetDesktopWindow())))
3385 {
3386 return( NULL);
3387 }
3388 }
3389
3390 if (!(Wnd = UserGetWindowObject(hWndChild)))
3391 {
3392 return( NULL);
3393 }
3394
3395 UserRefObjectCo(Wnd, &Ref);
3396 UserRefObjectCo(WndParent, &ParentRef);
3397
3398 WndOldParent = co_IntSetParent(Wnd, WndParent);
3399
3400 UserDerefObjectCo(WndParent);
3401 UserDerefObjectCo(Wnd);
3402
3403 if (WndOldParent)
3404 {
3405 hWndOldParent = WndOldParent->hSelf;
3406 UserDereferenceObject(WndOldParent);
3407 }
3408
3409 return( hWndOldParent);
3410 }
3411
3412 /*
3413 * NtUserSetParent
3414 *
3415 * The NtUserSetParent function changes the parent window of the specified
3416 * child window.
3417 *
3418 * Remarks
3419 * The new parent window and the child window must belong to the same
3420 * application. If the window identified by the hWndChild parameter is
3421 * visible, the system performs the appropriate redrawing and repainting.
3422 * For compatibility reasons, NtUserSetParent does not modify the WS_CHILD
3423 * or WS_POPUP window styles of the window whose parent is being changed.
3424 *
3425 * Status
3426 * @implemented
3427 */
3428
3429 HWND APIENTRY
3430 NtUserSetParent(HWND hWndChild, HWND hWndNewParent)
3431 {
3432 DECLARE_RETURN(HWND);
3433
3434 DPRINT("Enter NtUserSetParent\n");
3435 UserEnterExclusive();
3436
3437 /*
3438 Check Parent first from user space, set it here.
3439 */
3440 if (!hWndNewParent)
3441 {
3442 hWndNewParent = IntGetDesktopWindow();
3443 }
3444 else if (hWndNewParent == HWND_MESSAGE)
3445 {
3446 hWndNewParent = IntGetMessageWindow();
3447 }
3448
3449 RETURN( co_UserSetParent(hWndChild, hWndNewParent));
3450
3451 CLEANUP:
3452 DPRINT("Leave NtUserSetParent, ret=%i\n",_ret_);
3453 UserLeave();
3454 END_CLEANUP;
3455 }
3456
3457 /*
3458 * UserGetShellWindow
3459 *
3460 * Returns a handle to shell window that was set by NtUserSetShellWindowEx.
3461 *
3462 * Status
3463 * @implemented
3464 */
3465 HWND FASTCALL UserGetShellWindow(VOID)
3466 {
3467 PWINSTATION_OBJECT WinStaObject;
3468 HWND Ret;
3469
3470 NTSTATUS Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
3471 KernelMode,
3472 0,
3473 &WinStaObject);
3474
3475 if (!NT_SUCCESS(Status))
3476 {
3477 SetLastNtError(Status);
3478 return( (HWND)0);
3479 }
3480
3481 Ret = (HWND)WinStaObject->ShellWindow;
3482
3483 ObDereferenceObject(WinStaObject);
3484 return( Ret);
3485 }
3486
3487 /*
3488 * NtUserSetShellWindowEx
3489 *
3490 * This is undocumented function to set global shell window. The global
3491 * shell window has special handling of window position.
3492 *
3493 * Status
3494 * @implemented
3495 */
3496 BOOL APIENTRY
3497 NtUserSetShellWindowEx(HWND hwndShell, HWND hwndListView)
3498 {
3499 PWINSTATION_OBJECT WinStaObject;
3500 PWINDOW_OBJECT WndShell;
3501 DECLARE_RETURN(BOOL);
3502 USER_REFERENCE_ENTRY Ref;
3503 NTSTATUS Status;
3504 PTHREADINFO ti;
3505
3506 DPRINT("Enter NtUserSetShellWindowEx\n");
3507 UserEnterExclusive();
3508
3509 if (!(WndShell = UserGetWindowObject(hwndShell)))
3510 {
3511 RETURN(FALSE);
3512 }
3513
3514 Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
3515 KernelMode,
3516 0,
3517 &WinStaObject);
3518
3519 if (!NT_SUCCESS(Status))
3520 {
3521 SetLastNtError(Status);
3522 RETURN( FALSE);
3523 }
3524
3525 /*
3526 * Test if we are permitted to change the shell window.
3527 */
3528 if (WinStaObject->ShellWindow)
3529 {
3530 ObDereferenceObject(WinStaObject);
3531 RETURN( FALSE);
3532 }
3533
3534 /*
3535 * Move shell window into background.
3536 */
3537 if (hwndListView && hwndListView != hwndShell)
3538 {
3539 /*
3540 * Disabled for now to get Explorer working.
3541 * -- Filip, 01/nov/2003
3542 */
3543 #if 0
3544 co_WinPosSetWindowPos(hwndListView, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
3545 #endif
3546
3547 if (UserGetWindowLong(hwndListView, GWL_EXSTYLE, FALSE) & WS_EX_TOPMOST)
3548 {
3549 ObDereferenceObject(WinStaObject);
3550 RETURN( FALSE);
3551 }
3552 }
3553
3554 if (UserGetWindowLong(hwndShell, GWL_EXSTYLE, FALSE) & WS_EX_TOPMOST)
3555 {
3556 ObDereferenceObject(WinStaObject);
3557 RETURN( FALSE);
3558 }
3559
3560 UserRefObjectCo(WndShell, &Ref);
3561 co_WinPosSetWindowPos(WndShell, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
3562
3563 WinStaObject->ShellWindow = hwndShell;
3564 WinStaObject->ShellListView = hwndListView;
3565
3566 ti = GetW32ThreadInfo();
3567 if (ti->pDeskInfo) ti->pDeskInfo->hShellWindow = hwndShell;
3568
3569 UserDerefObjectCo(WndShell);
3570
3571 ObDereferenceObject(WinStaObject);
3572 RETURN( TRUE);
3573
3574 CLEANUP:
3575 DPRINT("Leave NtUserSetShellWindowEx, ret=%i\n",_ret_);
3576 UserLeave();
3577 END_CLEANUP;
3578 }
3579
3580 /*
3581 * NtUserGetSystemMenu
3582 *
3583 * The NtUserGetSystemMenu function allows the application to access the
3584 * window menu (also known as the system menu or the control menu) for
3585 * copying and modifying.
3586 *
3587 * Parameters
3588 * hWnd
3589 * Handle to the window that will own a copy of the window menu.
3590 * bRevert
3591 * Specifies the action to be taken. If this parameter is FALSE,
3592 * NtUserGetSystemMenu returns a handle to the copy of the window menu
3593 * currently in use. The copy is initially identical to the window menu
3594 * but it can be modified.
3595 * If this parameter is TRUE, GetSystemMenu resets the window menu back
3596 * to the default state. The previous window menu, if any, is destroyed.
3597 *
3598 * Return Value
3599 * If the bRevert parameter is FALSE, the return value is a handle to a
3600 * copy of the window menu. If the bRevert parameter is TRUE, the return
3601 * value is NULL.
3602 *
3603 * Status
3604 * @implemented
3605 */
3606
3607 HMENU APIENTRY
3608 NtUserGetSystemMenu(HWND hWnd, BOOL bRevert)
3609 {
3610 PWINDOW_OBJECT Window;
3611 PMENU_OBJECT Menu;
3612 DECLARE_RETURN(HMENU);
3613
3614 DPRINT("Enter NtUserGetSystemMenu\n");
3615 UserEnterShared();
3616
3617 if (!(Window = UserGetWindowObject(hWnd)))
3618 {
3619 RETURN(NULL);
3620 }
3621
3622 if (!(Menu = IntGetSystemMenu(Window, bRevert, FALSE)))
3623 {
3624 RETURN(NULL);
3625 }
3626
3627 RETURN(Menu->MenuInfo.Self);
3628
3629 CLEANUP:
3630 DPRINT("Leave NtUserGetSystemMenu, ret=%i\n",_ret_);
3631 UserLeave();
3632 END_CLEANUP;
3633 }
3634
3635 /*
3636 * NtUserSetSystemMenu
3637 *
3638 * Status
3639 * @implemented
3640 */
3641
3642 BOOL APIENTRY
3643 NtUserSetSystemMenu(HWND hWnd, HMENU hMenu)
3644 {
3645 BOOL Result = FALSE;
3646 PWINDOW_OBJECT Window;
3647 PMENU_OBJECT Menu;
3648 DECLARE_RETURN(BOOL);
3649
3650 DPRINT("Enter NtUserSetSystemMenu\n");
3651 UserEnterExclusive();
3652
3653 if (!(Window = UserGetWindowObject(hWnd)))
3654 {
3655 RETURN( FALSE);
3656 }
3657
3658 if (hMenu)
3659 {
3660 /*
3661 * Assign new menu handle.
3662 */
3663 if (!(Menu = UserGetMenuObject(hMenu)))
3664 {
3665 RETURN( FALSE);
3666 }
3667
3668 Result = IntSetSystemMenu(Window, Menu);
3669 }
3670
3671 RETURN( Result);
3672
3673 CLEANUP:
3674 DPRINT("Leave NtUserSetSystemMenu, ret=%i\n",_ret_);
3675 UserLeave();
3676 END_CLEANUP;
3677 }
3678
3679 HWND FASTCALL
3680 UserGetWindow(HWND hWnd, UINT Relationship)
3681 {
3682 PWINDOW_OBJECT Parent, Window;
3683 HWND hWndResult = NULL;
3684
3685 if (!(Window = UserGetWindowObject(hWnd)))
3686 return NULL;
3687
3688 switch (Relationship)
3689 {
3690 case GW_HWNDFIRST:
3691 if((Parent = Window->spwndParent))
3692 {
3693 if (Parent->spwndChild)
3694 hWndResult = Parent->spwndChild->hSelf;
3695 }
3696 break;
3697
3698 case GW_HWNDLAST:
3699 if((Parent = Window->spwndParent))
3700 {
3701 if (Parent->spwndChild)
3702 {
3703 Window = Parent->spwndChild;
3704 if(Window)
3705 {
3706 while(Window->spwndNext)
3707 Window = Window->spwndNext;
3708 }
3709 hWndResult = Window->hSelf;
3710 }
3711 }
3712 break;
3713
3714 case GW_HWNDNEXT:
3715 if (Window->spwndNext)
3716 hWndResult = Window->spwndNext->hSelf;
3717 break;
3718
3719 case GW_HWNDPREV:
3720 if (Window->spwndPrev)
3721 hWndResult = Window->spwndPrev->hSelf;
3722 break;
3723
3724 case GW_OWNER:
3725 if((Parent = UserGetWindowObject(Window->hOwner)))
3726 {
3727 hWndResult = Parent->hSelf;
3728 }
3729 break;
3730 case GW_CHILD:
3731 if (Window->spwndChild)
3732 hWndResult = Window->spwndChild->hSelf;
3733 break;
3734 }
3735
3736 return hWndResult;
3737 }
3738
3739 /*
3740 * NtUserGetWindowLong
3741 *
3742 * The NtUserGetWindowLong function retrieves information about the specified
3743 * window. The function also retrieves the 32-bit (long) value at the
3744 * specified offset into the extra window memory.
3745 *
3746 * Status
3747 * @implemented
3748 */
3749
3750 LONG FASTCALL
3751 UserGetWindowLong(HWND hWnd, DWORD Index, BOOL Ansi)
3752 {
3753 PWINDOW_OBJECT Window, Parent;
3754 PWND Wnd;
3755 LONG Result = 0;
3756
3757 DPRINT("NtUserGetWindowLong(%x,%d,%d)\n", hWnd, (INT)Index, Ansi);
3758
3759 if (!(Window = UserGetWindowObject(hWnd)) || !Window->Wnd)
3760 {
3761 return 0;
3762 }
3763
3764 Wnd = Window->Wnd;
3765
3766 /*
3767 * WndProc is only available to the owner process
3768 */
3769 if (GWL_WNDPROC == Index
3770 && Window->pti->pEThread->ThreadsProcess != PsGetCurrentProcess())
3771 {
3772 SetLastWin32Error(ERROR_ACCESS_DENIED);
3773 return 0;
3774 }
3775
3776 if ((INT)Index >= 0)
3777 {
3778 if ((Index + sizeof(LONG)) > Window->Wnd->cbwndExtra)
3779 {
3780 SetLastWin32Error(ERROR_INVALID_PARAMETER);
3781 return 0;
3782 }
3783 Result = *((LONG *)((PCHAR)(Window->Wnd + 1) + Index));
3784 }
3785 else
3786 {
3787 switch (Index)
3788 {
3789 case GWL_EXSTYLE:
3790 Result = Wnd->ExStyle;
3791 break;
3792
3793 case GWL_STYLE:
3794 Result = Wnd->style;
3795 break;
3796
3797 case GWL_WNDPROC:
3798 Result = (LONG)IntGetWindowProc(Wnd, Ansi);
3799 break;
3800
3801 case GWL_HINSTANCE:
3802 Result = (LONG) Wnd->hModule;
3803 break;
3804
3805 case GWL_HWNDPARENT:
3806 Parent = Window->spwndParent;
3807 if(Parent)
3808 {
3809 if (Parent && Parent->hSelf == IntGetDesktopWindow())
3810 Result = (LONG) UserGetWindow(Window->hSelf, GW_OWNER);
3811 else
3812 Result = (LONG) Parent->hSelf;
3813 }
3814 break;
3815
3816 case GWL_ID:
3817 Result = (LONG) Wnd->IDMenu;
3818 break;
3819
3820 case GWL_USERDATA:
3821 Result = Wnd->dwUserData;
3822 break;
3823
3824 default:
3825 DPRINT1("NtUserGetWindowLong(): Unsupported index %d\n", Index);
3826 SetLastWin32Error(ERROR_INVALID_PARAMETER);
3827 Result = 0;
3828 break;
3829 }
3830 }
3831
3832 return Result;
3833 }
3834
3835 LONG FASTCALL
3836 co_UserSetWindowLong(HWND hWnd, DWORD Index, LONG NewValue, BOOL Ansi)
3837 {
3838 PWINDOW_OBJECT Window, Parent;
3839 PWND Wnd;
3840 PWINSTATION_OBJECT WindowStation;
3841 LONG OldValue;
3842 STYLESTRUCT Style;
3843
3844 if (hWnd == IntGetDesktopWindow())
3845 {
3846 SetLastWin32Error(STATUS_ACCESS_DENIED);
3847 return( 0);
3848 }
3849
3850 if (!(Window = UserGetWindowObject(hWnd)))
3851 {
3852 return( 0);
3853 }
3854
3855 Wnd = Window->Wnd;
3856
3857 if (!Wnd) return 0; // No go on zero.
3858
3859 if ((INT)Index >= 0)
3860 {
3861 if ((Index + sizeof(LONG)) > Wnd->cbwndExtra)
3862 {
3863 SetLastWin32Error(ERROR_INVALID_INDEX);
3864 return( 0);
3865 }
3866
3867 OldValue = *((LONG *)((PCHAR)(Wnd + 1) + Index));
3868 /*
3869 if ( Index == DWLP_DLGPROC && Wnd->state & WNDS_DIALOGWINDOW)
3870 {
3871 OldValue = (LONG)IntSetWindowProc( Wnd,
3872 (WNDPROC)NewValue,
3873 Ansi);
3874 if (!OldValue) return 0;
3875 }
3876 */
3877 *((LONG *)((PCHAR)(Wnd + 1) + Index)) = NewValue;
3878 }
3879 else
3880 {
3881 switch (Index)
3882 {
3883 case GWL_EXSTYLE:
3884 OldValue = (LONG) Wnd->ExStyle;
3885 Style.styleOld = OldValue;
3886 Style.styleNew = NewValue;
3887
3888 /*
3889 * Remove extended window style bit WS_EX_TOPMOST for shell windows.
3890 */
3891 WindowStation = Window->pti->rpdesk->rpwinstaParent;
3892 if(WindowStation)
3893 {
3894 if (hWnd == WindowStation->ShellWindow || hWnd == WindowStation->ShellListView)
3895 Style.styleNew &= ~WS_EX_TOPMOST;
3896 }
3897
3898 co_IntSendMessage(hWnd, WM_STYLECHANGING, GWL_EXSTYLE, (LPARAM) &Style);
3899 Wnd->ExStyle = (DWORD)Style.styleNew;
3900 co_IntSendMessage(hWnd, WM_STYLECHANGED, GWL_EXSTYLE, (LPARAM) &Style);
3901 break;
3902
3903 case GWL_STYLE:
3904 OldValue = (LONG) Wnd->style;
3905 Style.styleOld = OldValue;
3906 Style.styleNew = NewValue;
3907 co_IntSendMessage(hWnd, WM_STYLECHANGING, GWL_STYLE, (LPARAM) &Style);
3908 Wnd->style = (DWORD)Style.styleNew;
3909 co_IntSendMessage(hWnd, WM_STYLECHANGED, GWL_STYLE, (LPARAM) &Style);
3910 break;
3911
3912 case GWL_WNDPROC:
3913 {
3914 if ( Wnd->head.pti->ppi != PsGetCurrentProcessWin32Process() ||
3915 Wnd->fnid & FNID_FREED)
3916 {
3917 SetLastWin32Error(ERROR_ACCESS_DENIED);
3918 return( 0);
3919 }
3920 OldValue = (LONG)IntSetWindowProc(Wnd,
3921 (WNDPROC)NewValue,
3922 Ansi);
3923 break;
3924 }
3925
3926 case GWL_HINSTANCE:
3927 OldValue = (LONG) Wnd->hModule;
3928 Wnd->hModule = (HINSTANCE) NewValue;
3929 break;
3930
3931 case GWL_HWNDPARENT:
3932 Parent = Window->spwndParent;
3933 if (Parent && (Parent->hSelf == IntGetDesktopWindow()))
3934 OldValue = (LONG) IntSetOwner(Window->hSelf, (HWND) NewValue);
3935 else
3936 OldValue = (LONG) co_UserSetParent(Window->hSelf, (HWND) NewValue);
3937 break;
3938
3939 case GWL_ID:
3940 OldValue = (LONG) Wnd->IDMenu;
3941 Wnd->IDMenu = (UINT) NewValue;
3942 break;
3943
3944 case GWL_USERDATA:
3945 OldValue = Wnd->dwUserData;
3946 Wnd->dwUserData = NewValue;
3947 break;
3948
3949 default:
3950 DPRINT1("NtUserSetWindowLong(): Unsupported index %d\n", Index);
3951 SetLastWin32Error(ERROR_INVALID_INDEX);
3952 OldValue = 0;
3953 break;
3954 }
3955 }
3956
3957 return( OldValue);
3958 }
3959
3960 /*
3961 * NtUserSetWindowLong
3962 *
3963 * The NtUserSetWindowLong function changes an attribute of the specified
3964 * window. The function also sets the 32-bit (long) value at the specified
3965 * offset into the extra window memory.
3966 *
3967 * Status
3968 * @implemented
3969 */
3970
3971 LONG APIENTRY
3972 NtUserSetWindowLong(HWND hWnd, DWORD Index, LONG NewValue, BOOL Ansi)
3973 {
3974 DECLARE_RETURN(LONG);
3975
3976 DPRINT("Enter NtUserSetWindowLong\n");
3977 UserEnterExclusive();
3978
3979 RETURN( co_UserSetWindowLong(hWnd, Index, NewValue, Ansi));
3980
3981 CLEANUP:
3982 DPRINT("Leave NtUserSetWindowLong, ret=%i\n",_ret_);
3983 UserLeave();
3984 END_CLEANUP;
3985 }
3986
3987 /*
3988 * NtUserSetWindowWord
3989 *
3990 * Legacy function similar to NtUserSetWindowLong.
3991 *
3992 * Status
3993 * @implemented
3994 */
3995
3996 WORD APIENTRY
3997 NtUserSetWindowWord(HWND hWnd, INT Index, WORD NewValue)
3998 {
3999 PWINDOW_OBJECT Window;
4000 WORD OldValue;
4001 DECLARE_RETURN(WORD);
4002
4003 DPRINT("Enter NtUserSetWindowWord\n");
4004 UserEnterExclusive();
4005
4006 if (!(Window = UserGetWindowObject(hWnd)))
4007 {
4008 RETURN( 0);
4009 }
4010
4011 switch (Index)
4012 {
4013 case GWL_ID:
4014 case GWL_HINSTANCE:
4015 case GWL_HWNDPARENT:
4016 RETURN( co_UserSetWindowLong(Window->hSelf, Index, (UINT)NewValue, TRUE));
4017 default:
4018 if (Index < 0)
4019 {
4020 SetLastWin32Error(ERROR_INVALID_INDEX);
4021 RETURN( 0);
4022 }
4023 }
4024
4025 if (Index > Window->Wnd->cbwndExtra - sizeof(WORD))
4026 {
4027 SetLastWin32Error(ERROR_INVALID_PARAMETER);
4028 RETURN( 0);
4029 }
4030
4031 OldValue = *((WORD *)((PCHAR)(Window->Wnd + 1) + Index));
4032 *((WORD *)((PCHAR)(Window->Wnd + 1) + Index)) = NewValue;
4033
4034 RETURN( OldValue);
4035
4036 CLEANUP:
4037 DPRINT("Leave NtUserSetWindowWord, ret=%i\n",_ret_);
4038 UserLeave();
4039 END_CLEANUP;
4040 }
4041
4042 /*
4043 * @implemented
4044 */
4045 BOOL APIENTRY
4046 NtUserGetWindowPlacement(HWND hWnd,
4047 WINDOWPLACEMENT *lpwndpl)
4048 {
4049 PWINDOW_OBJECT Window;
4050 PWND Wnd;
4051 POINT Size;
4052 WINDOWPLACEMENT Safepl;
4053 NTSTATUS Status;
4054 DECLARE_RETURN(BOOL);
4055
4056 DPRINT("Enter NtUserGetWindowPlacement\n");
4057 UserEnterShared();
4058
4059 if (!(Window = UserGetWindowObject(hWnd)))
4060 {
4061 RETURN( FALSE);
4062 }
4063 Wnd = Window->Wnd;
4064
4065 Status = MmCopyFromCaller(&Safepl, lpwndpl, sizeof(WINDOWPLACEMENT));
4066 if(!NT_SUCCESS(Status))
4067 {
4068 SetLastNtError(Status);
4069 RETURN( FALSE);
4070 }
4071 if(Safepl.length != sizeof(WINDOWPLACEMENT))
4072 {
4073 RETURN( FALSE);
4074 }
4075
4076 Safepl.flags = 0;
4077 if (0 == (Wnd->style & WS_VISIBLE))
4078 {
4079 Safepl.showCmd = SW_HIDE;
4080 }
4081 else if ((0 != (Window->state & WINDOWOBJECT_RESTOREMAX) ||
4082 0 != (Wnd->style & WS_MAXIMIZE)) &&
4083 0 == (Wnd->style & WS_MINIMIZE))
4084 {
4085 Safepl.showCmd = SW_SHOWMAXIMIZED;
4086 }
4087 else if (0 != (Wnd->style & WS_MINIMIZE))
4088 {
4089 Safepl.showCmd = SW_SHOWMINIMIZED;
4090 }
4091 else if (0 != (Wnd->style & WS_VISIBLE))
4092 {
4093 Safepl.showCmd = SW_SHOWNORMAL;
4094 }
4095
4096 Size.x = Wnd->rcWindow.left;
4097 Size.y = Wnd->rcWindow.top;
4098 WinPosInitInternalPos(Window, &Size,
4099 &Wnd->rcWindow);
4100
4101 Safepl.rcNormalPosition = Wnd->InternalPos.NormalRect;
4102 Safepl.ptMinPosition = Wnd->InternalPos.IconPos;
4103 Safepl.ptMaxPosition = Wnd->InternalPos.MaxPos;
4104
4105 Status = MmCopyToCaller(lpwndpl, &Safepl, sizeof(WINDOWPLACEMENT));
4106 if(!NT_SUCCESS(Status))
4107 {
4108 SetLastNtError(Status);
4109 RETURN( FALSE);
4110 }
4111
4112 RETURN( TRUE);
4113
4114 CLEANUP:
4115 DPRINT("Leave NtUserGetWindowPlacement, ret=%i\n",_ret_);
4116 UserLeave();
4117 END_CLEANUP;
4118 }
4119
4120
4121 /*
4122 * @unimplemented
4123 */
4124 BOOL APIENTRY
4125 NtUserLockWindowUpdate(HWND hWnd)
4126 {
4127 UNIMPLEMENTED
4128
4129 return 0;
4130 }
4131
4132
4133 /*
4134 * @implemented
4135 */
4136 BOOL APIENTRY
4137 NtUserMoveWindow(
4138 HWND hWnd,
4139 int X,
4140 int Y,
4141 int nWidth,
4142 int nHeight,
4143 BOOL bRepaint)
4144 {
4145 return NtUserSetWindowPos(hWnd, 0, X, Y, nWidth, nHeight,
4146 (bRepaint ? SWP_NOZORDER | SWP_NOACTIVATE :
4147 SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW));
4148 }
4149
4150 /*
4151 QueryWindow based on KJK::Hyperion and James Tabor.
4152
4153 0 = QWUniqueProcessId
4154 1 = QWUniqueThreadId
4155 2 = QWActiveWindow
4156 3 = QWFocusWindow
4157 4 = QWIsHung Implements IsHungAppWindow found
4158 by KJK::Hyperion.
4159
4160 9 = QWKillWindow When I called this with hWnd ==
4161 DesktopWindow, it shutdown the system
4162 and rebooted.
4163 */
4164 /*
4165 * @implemented
4166 */
4167 DWORD APIENTRY
4168 NtUserQueryWindow(HWND hWnd, DWORD Index)
4169 {
4170 PWINDOW_OBJECT Window;
4171 PWND pWnd;
4172 DWORD Result;
4173 DECLARE_RETURN(UINT);
4174
4175 DPRINT("Enter NtUserQueryWindow\n");
4176 UserEnterShared();
4177
4178 if (!(Window = UserGetWindowObject(hWnd)) || !Window->Wnd)
4179 {
4180 RETURN( 0);
4181 }
4182
4183 pWnd = Window->Wnd;
4184
4185 switch(Index)
4186 {
4187 case QUERY_WINDOW_UNIQUE_PROCESS_ID:
4188 Result = (DWORD)IntGetWndProcessId(Window);
4189 break;
4190
4191 case QUERY_WINDOW_UNIQUE_THREAD_ID:
4192 Result = (DWORD)IntGetWndThreadId(Window);
4193 break;
4194
4195 case QUERY_WINDOW_ACTIVE:
4196 Result = (DWORD)UserGetActiveWindow();
4197 break;
4198
4199 case QUERY_WINDOW_FOCUS:
4200 Result = (DWORD)IntGetFocusWindow();
4201 break;
4202
4203 case QUERY_WINDOW_ISHUNG:
4204 Result = (DWORD)MsqIsHung(Window->pti->MessageQueue);
4205 break;
4206
4207 case QUERY_WINDOW_REAL_ID:
4208 Result = (DWORD)pWnd->head.pti->pEThread->Cid.UniqueProcess;
4209
4210 default:
4211 Result = (DWORD)NULL;
4212 break;
4213 }
4214
4215 RETURN( Result);
4216
4217 CLEANUP:
4218 DPRINT("Leave NtUserQueryWindow, ret=%i\n",_ret_);
4219 UserLeave();
4220 END_CLEANUP;
4221 }
4222
4223
4224 /*
4225 * @unimplemented
4226 */
4227 DWORD APIENTRY
4228 NtUserRealChildWindowFromPoint(DWORD Unknown0,
4229 DWORD Unknown1,
4230 DWORD Unknown2)
4231 {
4232 UNIMPLEMENTED
4233
4234 return 0;
4235 }
4236
4237
4238 /*
4239 * @implemented
4240 */
4241 UINT APIENTRY
4242 NtUserRegisterWindowMessage(PUNICODE_STRING MessageNameUnsafe)
4243 {
4244 UNICODE_STRING SafeMessageName;
4245 NTSTATUS Status;
4246 UINT Ret;
4247 DECLARE_RETURN(UINT);
4248
4249 DPRINT("Enter NtUserRegisterWindowMessage\n");
4250 UserEnterExclusive();
4251
4252 if(MessageNameUnsafe == NULL)
4253 {
4254 SetLastWin32Error(ERROR_INVALID_PARAMETER);
4255 RETURN( 0);
4256 }
4257
4258 Status = IntSafeCopyUnicodeStringTerminateNULL(&SafeMessageName, MessageNameUnsafe);
4259 if(!NT_SUCCESS(Status))
4260 {
4261 SetLastNtError(Status);
4262 RETURN( 0);
4263 }
4264
4265 Ret = (UINT)IntAddAtom(SafeMessageName.Buffer);
4266
4267 ExFreePoolWithTag(SafeMessageName.Buffer, TAG_STRING);
4268 RETURN( Ret);
4269
4270 CLEANUP:
4271 DPRINT("Leave NtUserRegisterWindowMessage, ret=%i\n",_ret_);
4272 UserLeave();
4273 END_CLEANUP;
4274 }
4275
4276
4277 /*
4278 * @unimplemented
4279 */
4280 DWORD APIENTRY
4281 NtUserSetImeOwnerWindow(DWORD Unknown0,
4282 DWORD Unknown1)
4283 {
4284 UNIMPLEMENTED
4285
4286 return 0;
4287 }
4288
4289
4290 /*
4291 * @unimplemented
4292 */
4293 DWORD APIENTRY
4294 NtUserSetInternalWindowPos(
4295 HWND hwnd,
4296 UINT showCmd,
4297 LPRECT rect,
4298 LPPOINT pt)
4299 {
4300 UNIMPLEMENTED
4301
4302 return 0;
4303
4304 }
4305
4306
4307 /*
4308 * @unimplemented
4309 */
4310 BOOL APIENTRY
4311 NtUserSetLayeredWindowAttributes(HWND hwnd,
4312 COLORREF crKey,
4313 BYTE bAlpha,
4314 DWORD dwFlags)
4315 {
4316 UNIMPLEMENTED;
4317 return FALSE;
4318 }
4319
4320
4321 /*
4322 * @unimplemented
4323 */
4324 BOOL APIENTRY
4325 NtUserSetLogonNotifyWindow(HWND hWnd)
4326 {
4327 UNIMPLEMENTED
4328
4329 return 0;
4330 }
4331
4332
4333 /*
4334 * @implemented
4335 */
4336 BOOL APIENTRY
4337 NtUserSetMenu(
4338 HWND hWnd,
4339 HMENU Menu,
4340 BOOL Repaint)
4341 {
4342 PWINDOW_OBJECT Window;
4343 BOOL Changed;
4344 DECLARE_RETURN(BOOL);
4345
4346 DPRINT("Enter NtUserSetMenu\n");
4347 UserEnterExclusive();
4348
4349 if (!(Window = UserGetWindowObject(hWnd)))
4350 {
4351 RETURN( FALSE);
4352 }
4353
4354 if (! IntSetMenu(Window, Menu, &Changed))
4355 {
4356 RETURN( FALSE);
4357 }
4358
4359 if (Changed && Repaint)
4360 {
4361 USER_REFERENCE_ENTRY Ref;
4362
4363 UserRefObjectCo(Window, &Ref);
4364 co_WinPosSetWindowPos(Window, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
4365 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED);
4366
4367 UserDerefObjectCo(Window);
4368 }
4369
4370 RETURN( TRUE);
4371
4372 CLEANUP:
4373 DPRINT("Leave NtUserSetMenu, ret=%i\n",_ret_);
4374 UserLeave();
4375 END_CLEANUP;
4376 }
4377
4378
4379 /*
4380 * @implemented
4381 */
4382 BOOL APIENTRY
4383 NtUserSetWindowFNID(HWND hWnd,
4384 WORD fnID)
4385 {
4386 PWINDOW_OBJECT Window;
4387 PWND Wnd;
4388 DECLARE_RETURN(BOOL);
4389
4390 DPRINT("Enter NtUserSetWindowFNID\n");
4391 UserEnterExclusive();
4392
4393 if (!(Window = UserGetWindowObject(hWnd)))
4394 {
4395 RETURN( FALSE);
4396 }
4397 Wnd = Window->Wnd;
4398
4399 if (Wnd->pcls)
4400 { // From user land we only set these.
4401 if ((fnID != FNID_DESTROY) || ((fnID < FNID_BUTTON) && (fnID > FNID_IME)) )
4402 {
4403 RETURN( FALSE);
4404 }
4405 else
4406 Wnd->pcls->fnid |= fnID;
4407 }
4408 RETURN( TRUE);
4409
4410 CLEANUP:
4411 DPRINT("Leave NtUserSetWindowFNID\n");
4412 UserLeave();
4413 END_CLEANUP;
4414 }
4415
4416
4417 /*
4418 * @implemented
4419 */
4420 BOOL APIENTRY
4421 NtUserSetWindowPlacement(HWND hWnd,
4422 WINDOWPLACEMENT *lpwndpl)
4423 {
4424 PWINDOW_OBJECT Window;
4425 PWND Wnd;
4426 WINDOWPLACEMENT Safepl;
4427 NTSTATUS Status;
4428 DECLARE_RETURN(BOOL);
4429 USER_REFERENCE_ENTRY Ref;
4430
4431 DPRINT("Enter NtUserSetWindowPlacement\n");
4432 UserEnterExclusive();
4433
4434 if (!(Window = UserGetWindowObject(hWnd)))
4435 {
4436 RETURN( FALSE);
4437 }
4438 Wnd = Window->Wnd;
4439
4440 Status = MmCopyFromCaller(&Safepl, lpwndpl, sizeof(WINDOWPLACEMENT));
4441 if(!NT_SUCCESS(Status))
4442 {
4443 SetLastNtError(Status);
4444 RETURN( FALSE);
4445 }
4446 if(Safepl.length != sizeof(WINDOWPLACEMENT))
4447 {
4448 RETURN( FALSE);
4449 }
4450
4451 UserRefObjectCo(Window, &Ref);
4452
4453 if ((Wnd->style & (WS_MAXIMIZE | WS_MINIMIZE)) == 0)
4454 {
4455 co_WinPosSetWindowPos(Window, NULL,
4456 Safepl.rcNormalPosition.left, Safepl.rcNormalPosition.top,
4457 Safepl.rcNormalPosition.right - Safepl.rcNormalPosition.left,
4458 Safepl.rcNormalPosition.bottom - Safepl.rcNormalPosition.top,
4459 SWP_NOZORDER | SWP_NOACTIVATE);
4460 }
4461
4462 /* FIXME - change window status */
4463 co_WinPosShowWindow(Window, Safepl.showCmd);
4464
4465 Wnd->InternalPosInitialized = TRUE;
4466 Wnd->InternalPos.NormalRect = Safepl.rcNormalPosition;
4467 Wnd->InternalPos.IconPos = Safepl.ptMinPosition;
4468 Wnd->InternalPos.MaxPos = Safepl.ptMaxPosition;
4469
4470 UserDerefObjectCo(Window);
4471 RETURN(TRUE);
4472
4473 CLEANUP:
4474 DPRINT("Leave NtUserSetWindowPlacement, ret=%i\n",_ret_);
4475 UserLeave();
4476 END_CLEANUP;
4477 }
4478
4479
4480 /*
4481 * @implemented
4482 */
4483 BOOL APIENTRY
4484 NtUserSetWindowPos(
4485 HWND hWnd,
4486 HWND hWndInsertAfter,
4487 int X,
4488 int Y,
4489 int cx,
4490 int cy,
4491 UINT uFlags)
4492 {
4493 DECLARE_RETURN(BOOL);
4494 PWINDOW_OBJECT Window;
4495 BOOL ret;
4496 USER_REFERENCE_ENTRY Ref;
4497
4498 DPRINT("Enter NtUserSetWindowPos\n");
4499 UserEnterExclusive();
4500
4501 if (!(Window = UserGetWindowObject(hWnd)))
4502 {
4503 RETURN(FALSE);
4504 }
4505
4506 /* First make sure that coordinates are valid for WM_WINDOWPOSCHANGING */
4507 if (!(uFlags & SWP_NOMOVE))
4508 {
4509 if (X < -32768) X = -32768;
4510 else if (X > 32767) X = 32767;
4511 if (Y < -32768) Y = -32768;
4512 else if (Y > 32767) Y = 32767;
4513 }
4514 if (!(uFlags & SWP_NOSIZE))
4515 {
4516 if (cx < 0) cx = 0;
4517 else if (cx > 32767) cx = 32767;
4518 if (cy < 0) cy = 0;
4519 else if (cy > 32767) cy = 32767;
4520 }
4521
4522 UserRefObjectCo(Window, &Ref);
4523 ret = co_WinPosSetWindowPos(Window, hWndInsertAfter, X, Y, cx, cy, uFlags);
4524 UserDerefObjectCo(Window);
4525
4526 RETURN(ret);
4527
4528 CLEANUP:
4529 DPRINT("Leave NtUserSetWindowPos, ret=%i\n",_ret_);
4530 UserLeave();
4531 END_CLEANUP;
4532 }
4533
4534
4535 INT FASTCALL
4536 IntGetWindowRgn(PWINDOW_OBJECT Window, HRGN hRgn)
4537 {
4538 INT Ret;
4539 HRGN VisRgn;
4540 ROSRGNDATA *pRgn;
4541 PWND Wnd;
4542
4543 if(!Window)
4544 {
4545 return ERROR;
4546 }
4547 if(!hRgn)
4548 {
4549 return ERROR;
4550 }
4551
4552 Wnd = Window->Wnd;
4553
4554 /* Create a new window region using the window rectangle */
4555 VisRgn = IntSysCreateRectRgnIndirect(&Window->Wnd->rcWindow);
4556 NtGdiOffsetRgn(VisRgn, -Window->Wnd->rcWindow.left, -Window->Wnd->rcWindow.top);
4557 /* if there's a region assigned to the window, combine them both */
4558 if(Window->hrgnClip && !(Wnd->style & WS_MINIMIZE))
4559 NtGdiCombineRgn(VisRgn, VisRgn, Window->hrgnClip, RGN_AND);
4560 /* Copy the region into hRgn */
4561 NtGdiCombineRgn(hRgn, VisRgn, NULL, RGN_COPY);
4562
4563 if((pRgn = RGNOBJAPI_Lock(hRgn, NULL)))
4564 {
4565 Ret = pRgn->rdh.iType;
4566 RGNOBJAPI_Unlock(pRgn);
4567 }
4568 else
4569 Ret = ERROR;
4570
4571 REGION_FreeRgnByHandle(VisRgn);
4572
4573 return Ret;
4574 }
4575
4576 INT FASTCALL
4577 IntGetWindowRgnBox(PWINDOW_OBJECT Window, RECTL *Rect)
4578 {
4579 INT Ret;
4580 HRGN VisRgn;
4581 ROSRGNDATA *pRgn;
4582 PWND Wnd;
4583
4584 if(!Window)
4585 {
4586 return ERROR;
4587 }
4588 if(!Rect)
4589 {
4590 return ERROR;
4591 }
4592
4593 Wnd = Window->Wnd;
4594
4595 /* Create a new window region using the window rectangle */
4596 VisRgn = IntSysCreateRectRgnIndirect(&Window->Wnd->rcWindow);
4597 NtGdiOffsetRgn(VisRgn, -Window->Wnd->rcWindow.left, -Window->Wnd->rcWindow.top);
4598 /* if there's a region assigned to the window, combine them both */
4599 if(Window->hrgnClip && !(Wnd->style & WS_MINIMIZE))
4600 NtGdiCombineRgn(VisRgn, VisRgn, Window->hrgnClip, RGN_AND);
4601
4602 if((pRgn = RGNOBJAPI_Lock(VisRgn, NULL)))
4603 {
4604 Ret = pRgn->rdh.iType;
4605 *Rect = pRgn->rdh.rcBound;
4606 RGNOBJAPI_Unlock(pRgn);
4607 }
4608 else
4609 Ret = ERROR;
4610
4611 REGION_FreeRgnByHandle(VisRgn);
4612
4613 return Ret;
4614 }
4615
4616
4617 /*
4618 * @implemented
4619 */
4620 INT APIENTRY
4621 NtUserSetWindowRgn(
4622 HWND hWnd,
4623 HRGN hRgn,
4624 BOOL bRedraw)
4625 {
4626 HRGN hrgnCopy;
4627 PWINDOW_OBJECT Window;
4628 DECLARE_RETURN(INT);
4629
4630 DPRINT("Enter NtUserSetWindowRgn\n");
4631 UserEnterExclusive();
4632
4633 if (!(Window = UserGetWindowObject(hWnd)))
4634 {
4635 RETURN( 0);
4636 }
4637
4638 if (hRgn) // The region will be deleted in user32.
4639 {
4640 if (GDIOBJ_ValidateHandle(hRgn, GDI_OBJECT_TYPE_REGION))
4641 {
4642 hrgnCopy = IntSysCreateRectRgn(0, 0, 0, 0);
4643 NtGdiCombineRgn(hrgnCopy, hRgn, 0, RGN_COPY);
4644 }
4645 else
4646 RETURN( 0);
4647 }
4648 else
4649 hrgnCopy = (HRGN) 1;
4650
4651 if (Window->hrgnClip)
4652 {
4653 /* Delete no longer needed region handle */
4654 GreDeleteObject(Window->hrgnClip);
4655 }
4656 Window->hrgnClip = hrgnCopy;
4657
4658 /* FIXME - send WM_WINDOWPOSCHANGING and WM_WINDOWPOSCHANGED messages to the window */
4659
4660 if(bRedraw)
4661 {
4662 USER_REFERENCE_ENTRY Ref;
4663 UserRefObjectCo(Window, &Ref);
4664 co_UserRedrawWindow(Window, NULL, NULL, RDW_INVALIDATE);
4665 UserDerefObjectCo(Window);
4666 }
4667
4668 RETURN( (INT)hRgn);
4669
4670 CLEANUP:
4671 DPRINT("Leave NtUserSetWindowRgn, ret=%i\n",_ret_);
4672 UserLeave();
4673 END_CLEANUP;
4674 }
4675
4676
4677 /*
4678 * @implemented
4679 */
4680 BOOL APIENTRY
4681 NtUserShowWindow(HWND hWnd, LONG nCmdShow)
4682 {
4683 PWINDOW_OBJECT Window;
4684 BOOL ret;
4685 DECLARE_RETURN(BOOL);
4686 USER_REFERENCE_ENTRY Ref;
4687
4688 DPRINT("Enter NtUserShowWindow\n");
4689 UserEnterExclusive();
4690
4691 if (!(Window = UserGetWindowObject(hWnd)))
4692 {
4693 RETURN(FALSE);
4694 }
4695
4696 UserRefObjectCo(Window, &Ref);
4697 ret = co_WinPosShowWindow(Window, nCmdShow);
4698 UserDerefObjectCo(Window);
4699
4700 RETURN(ret);
4701
4702 CLEANUP:
4703 DPRINT("Leave NtUserShowWindow, ret=%i\n",_ret_);
4704 UserLeave();
4705 END_CLEANUP;
4706 }
4707
4708
4709 /*
4710 * @unimplemented
4711 */
4712 BOOL APIENTRY
4713 NtUserShowWindowAsync(HWND hWnd, LONG nCmdShow)
4714 {
4715 #if 0
4716 UNIMPLEMENTED
4717 return 0;
4718 #else
4719 return NtUserShowWindow(hWnd, nCmdShow);
4720 #endif
4721 }
4722
4723
4724 /*
4725 * @unimplemented
4726 */
4727 BOOL
4728 APIENTRY
4729 NtUserUpdateLayeredWindow(
4730 HWND hwnd,
4731 HDC hdcDst,
4732 POINT *pptDst,
4733 SIZE *psize,
4734 HDC hdcSrc,
4735 POINT *pptSrc,
4736 COLORREF crKey,
4737 BLENDFUNCTION *pblend,
4738 DWORD dwFlags,
4739 RECT *prcDirty)
4740 {
4741 UNIMPLEMENTED
4742
4743 return 0;
4744 }
4745
4746 /*
4747 * @unimplemented
4748 */
4749 HWND APIENTRY
4750 NtUserWindowFromPhysicalPoint(POINT Point)
4751 {
4752 UNIMPLEMENTED
4753
4754 return NULL;
4755 }
4756
4757 /*
4758 * @implemented
4759 */
4760 HWND APIENTRY
4761 NtUserWindowFromPoint(LONG X, LONG Y)
4762 {
4763 POINT pt;
4764 HWND Ret;
4765 PWINDOW_OBJECT DesktopWindow = NULL, Window = NULL;
4766 DECLARE_RETURN(HWND);
4767 USER_REFERENCE_ENTRY Ref;
4768
4769 DPRINT("Enter NtUserWindowFromPoint\n");
4770 UserEnterExclusive();
4771
4772 if ((DesktopWindow = UserGetWindowObject(IntGetDesktopWindow())))
4773 {
4774 PTHREADINFO pti;
4775 USHORT Hit;
4776
4777 pt.x = X;
4778 pt.y = Y;
4779
4780 //hmm... threads live on desktops thus we have a reference on the desktop and indirectly the desktop window
4781 //its possible this referencing is useless, thou it shouldnt hurt...
4782 UserRefObjectCo(DesktopWindow, &Ref);
4783
4784 pti = PsGetCurrentThreadWin32Thread();
4785 Hit = co_WinPosWindowFromPoint(DesktopWindow, pti->MessageQueue, &pt, &Window);
4786
4787 if(Window)
4788 {
4789 Ret = Window->hSelf;
4790
4791 RETURN( Ret);
4792 }
4793 }
4794
4795 RETURN( NULL);
4796
4797 CLEANUP:
4798 if (Window) UserDereferenceObject(Window);
4799 if (DesktopWindow) UserDerefObjectCo(DesktopWindow);
4800
4801 DPRINT("Leave NtUserWindowFromPoint, ret=%i\n",_ret_);
4802 UserLeave();
4803 END_CLEANUP;
4804
4805 }
4806
4807
4808 /*
4809 * NtUserDefSetText
4810 *
4811 * Undocumented function that is called from DefWindowProc to set
4812 * window text.
4813 *
4814 * Status
4815 * @implemented
4816 */
4817 BOOL APIENTRY
4818 NtUserDefSetText(HWND hWnd, PLARGE_STRING WindowText)
4819 {
4820 PWINDOW_OBJECT Window;
4821 PWND Wnd;
4822 LARGE_STRING SafeText;
4823 UNICODE_STRING UnicodeString;
4824 BOOL Ret = TRUE;
4825
4826 DPRINT("Enter NtUserDefSetText\n");
4827
4828 if (WindowText != NULL)
4829 {
4830 _SEH2_TRY
4831 {
4832 SafeText = ProbeForReadLargeString(WindowText);
4833 }
4834 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
4835 {
4836 Ret = FALSE;
4837 SetLastNtError(_SEH2_GetExceptionCode());
4838 }
4839 _SEH2_END;
4840
4841 if (!Ret)
4842 return FALSE;
4843 }
4844 else
4845 return TRUE;
4846
4847 UserEnterExclusive();
4848
4849 if(!(Window = UserGetWindowObject(hWnd)) || !Window->Wnd)
4850 {
4851 UserLeave();
4852 return FALSE;
4853 }
4854 Wnd = Window->Wnd;
4855
4856 // ReactOS uses Unicode and not mixed. Up/Down converting will take time.
4857 // Brought to you by: The Wine Project! Dysfunctional Thought Processes!
4858 // Now we know what the bAnsi is for.
4859 RtlInitUnicodeString(&UnicodeString, NULL);
4860 if (SafeText.Buffer)
4861 {
4862 _SEH2_TRY
4863 {
4864 if (SafeText.bAnsi)
4865 ProbeForRead(SafeText.Buffer, SafeText.Length, sizeof(CHAR));
4866 else
4867 ProbeForRead(SafeText.Buffer, SafeText.Length, sizeof(WCHAR));
4868 Ret = RtlLargeStringToUnicodeString(&UnicodeString, &SafeText);
4869 }
4870 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
4871 {
4872 Ret = FALSE;
4873 SetLastNtError(_SEH2_GetExceptionCode());
4874 }
4875 _SEH2_END;
4876 if (!Ret) goto Exit;
4877 }
4878
4879 if (UnicodeString.Length != 0)
4880 {
4881 if (Wnd->strName.MaximumLength > 0 &&
4882 UnicodeString.Length <= Wnd->strName.MaximumLength - sizeof(UNICODE_NULL))
4883 {
4884 ASSERT(Wnd->strName.Buffer != NULL);
4885
4886 Wnd->strName.Length = UnicodeString.Length;
4887 Wnd->strName.Buffer[UnicodeString.Length / sizeof(WCHAR)] = L'\0';
4888 RtlCopyMemory(Wnd->strName.Buffer,
4889 UnicodeString.Buffer,
4890 UnicodeString.Length);
4891 }
4892 else
4893 {
4894 PWCHAR buf;
4895 Wnd->strName.MaximumLength = Wnd->strName.Length = 0;
4896 buf = Wnd->strName.Buffer;
4897 Wnd->strName.Buffer = NULL;
4898 if (buf != NULL)
4899 {
4900 DesktopHeapFree(Wnd->head.rpdesk, buf);
4901 }
4902
4903 Wnd->strName.Buffer = DesktopHeapAlloc(Wnd->head.rpdesk,
4904 UnicodeString.Length + sizeof(UNICODE_NULL));
4905 if (Wnd->strName.Buffer != NULL)
4906 {
4907 Wnd->strName.Buffer[UnicodeString.Length / sizeof(WCHAR)] = L'\0';
4908 RtlCopyMemory(Wnd->strName.Buffer,
4909 UnicodeString.Buffer,
4910 UnicodeString.Length);
4911 Wnd->strName.MaximumLength = UnicodeString.Length + sizeof(UNICODE_NULL);
4912 Wnd->strName.Length = UnicodeString.Length;
4913 }
4914 else
4915 {
4916 SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
4917 Ret = FALSE;
4918 goto Exit;
4919 }
4920 }
4921 }
4922 else
4923 {
4924 Wnd->strName.Length = 0;
4925 if (Wnd->strName.Buffer != NULL)
4926 Wnd->strName.Buffer[0] = L'\0';
4927 }
4928
4929 // HAX! FIXME! Windows does not do this in here!
4930 // In User32, these are called after: NotifyWinEvent EVENT_OBJECT_NAMECHANGE than
4931 // RepaintButton, StaticRepaint, NtUserCallHwndLock HWNDLOCK_ROUTINE_REDRAWFRAMEANDHOOK, etc.
4932 /* Send shell notifications */
4933 if (!IntGetOwner(Window) && !IntGetParent(Window))
4934 {
4935 co_IntShellHookNotify(HSHELL_REDRAW, (LPARAM) hWnd);
4936 }
4937
4938 Ret = TRUE;
4939 Exit:
4940 if (UnicodeString.Buffer) RtlFreeUnicodeString(&UnicodeString);
4941 DPRINT("Leave NtUserDefSetText, ret=%i\n", Ret);
4942 UserLeave();
4943 return Ret;
4944 }
4945
4946 /*
4947 * NtUserInternalGetWindowText
4948 *
4949 * Status
4950 * @implemented
4951 */
4952
4953 INT APIENTRY
4954 NtUserInternalGetWindowText(HWND hWnd, LPWSTR lpString, INT nMaxCount)
4955 {
4956 PWINDOW_OBJECT Window;
4957 PWND Wnd;
4958 NTSTATUS Status;
4959 INT Result;
4960 DECLARE_RETURN(INT);
4961
4962 DPRINT("Enter NtUserInternalGetWindowText\n");
4963 UserEnterShared();
4964
4965 if(lpString && (nMaxCount <= 1))
4966 {
4967 SetLastWin32Error(ERROR_INVALID_PARAMETER);
4968 RETURN( 0);
4969 }
4970
4971 if(!(Window = UserGetWindowObject(hWnd)))
4972 {
4973 RETURN( 0);
4974 }
4975 Wnd = Window->Wnd;
4976
4977 Result = Wnd->strName.Length / sizeof(WCHAR);
4978 if(lpString)
4979 {
4980 const WCHAR Terminator = L'\0';
4981 INT Copy;
4982 WCHAR *Buffer = (WCHAR*)lpString;
4983
4984 Copy = min(nMaxCount - 1, Result);
4985 if(Copy > 0)
4986 {
4987 Status = MmCopyToCaller(Buffer, Wnd->strName.Buffer, Copy * sizeof(WCHAR));
4988 if(!NT_SUCCESS(Status))
4989 {
4990 SetLastNtError(Status);
4991 RETURN( 0);
4992 }
4993 Buffer += Copy;
4994 }
4995
4996 Status = MmCopyToCaller(Buffer, &Terminator, sizeof(WCHAR));
4997 if(!NT_SUCCESS(Status))
4998 {
4999 SetLastNtError(Status);
5000 RETURN( 0);
5001 }
5002
5003 Result = Copy;
5004 }
5005
5006 RETURN( Result);
5007
5008 CLEANUP:
5009 DPRINT("Leave NtUserInternalGetWindowText, ret=%i\n",_ret_);
5010 UserLeave();
5011 END_CLEANUP;
5012 }
5013
5014
5015 BOOL
5016 FASTCALL
5017 IntShowOwnedPopups(PWINDOW_OBJECT OwnerWnd, BOOL fShow )
5018 {
5019 int count = 0;
5020 PWINDOW_OBJECT pWnd;
5021 HWND *win_array;
5022
5023 // ASSERT(OwnerWnd);
5024
5025 win_array = IntWinListChildren(UserGetWindowObject(IntGetDesktopWindow()));
5026
5027 if (!win_array)
5028 return TRUE;
5029
5030 while (win_array[count])
5031 count++;
5032 while (--count >= 0)
5033 {
5034 if (UserGetWindow( win_array[count], GW_OWNER ) != OwnerWnd->hSelf)
5035 continue;
5036 if (!(pWnd = UserGetWindowObject( win_array[count] )))
5037 continue;
5038 // if (pWnd == WND_OTHER_PROCESS) continue;
5039
5040 if (fShow)
5041 {
5042 if (pWnd->Wnd->state & WNDS_HIDDENPOPUP)
5043 {
5044 /* In Windows, ShowOwnedPopups(TRUE) generates
5045 * WM_SHOWWINDOW messages with SW_PARENTOPENING,
5046 * regardless of the state of the owner
5047 */
5048 co_IntSendMessage(win_array[count], WM_SHOWWINDOW, SW_SHOWNORMAL, SW_PARENTOPENING);
5049 continue;
5050 }
5051 }
5052 else
5053 {
5054 if (pWnd->Wnd->style & WS_VISIBLE)
5055 {
5056 /* In Windows, ShowOwnedPopups(FALSE) generates
5057 * WM_SHOWWINDOW messages with SW_PARENTCLOSING,
5058 * regardless of the state of the owner
5059 */
5060 co_IntSendMessage(win_array[count], WM_SHOWWINDOW, SW_HIDE, SW_PARENTCLOSING);
5061 continue;
5062 }
5063 }
5064
5065 }
5066 ExFreePool( win_array );
5067 return TRUE;
5068 }
5069
5070 /*
5071 * NtUserValidateHandleSecure
5072 *
5073 * Status
5074 * @implemented
5075 */
5076
5077 BOOL
5078 APIENTRY
5079 NtUserValidateHandleSecure(
5080 HANDLE handle,
5081 BOOL Restricted)
5082 {
5083 if(!Restricted)
5084 {
5085 UINT uType;
5086 {
5087 PUSER_HANDLE_ENTRY entry;
5088 if (!(entry = handle_to_entry(gHandleTable, handle )))
5089 {
5090 SetLastWin32Error(ERROR_INVALID_HANDLE);
5091 return FALSE;
5092 }
5093 uType = entry->type;
5094 }
5095 switch (uType)
5096 {
5097 case otWindow:
5098 {
5099 PWINDOW_OBJECT Window;
5100 if ((Window = UserGetWindowObject((HWND) handle))) return TRUE;
5101 return FALSE;
5102 }
5103 case otMenu:
5104 {
5105 PMENU_OBJECT Menu;
5106 if ((Menu = UserGetMenuObject((HMENU) handle))) return TRUE;
5107 return FALSE;
5108 }
5109 case otAccel:
5110 {
5111 PACCELERATOR_TABLE Accel;
5112 if ((Accel = UserGetAccelObject((HACCEL) handle))) return TRUE;
5113 return FALSE;
5114 }
5115 case otCursorIcon:
5116 {
5117 PCURICON_OBJECT Cursor;
5118 if ((Cursor = UserGetCurIconObject((HCURSOR) handle))) return TRUE;
5119 return FALSE;
5120 }
5121 case otHook:
5122 {
5123 PHOOK Hook;
5124 if ((Hook = IntGetHookObject((HHOOK) handle))) return TRUE;
5125 return FALSE;
5126 }
5127 case otMonitor:
5128 {
5129 PMONITOR Monitor;
5130 if ((Monitor = UserGetMonitorObject((HMONITOR) handle))) return TRUE;
5131 return FALSE;
5132 }
5133 case otCallProc:
5134 {
5135 WNDPROC_INFO Proc;
5136 return UserGetCallProcInfo( handle, &Proc );
5137 }
5138 default:
5139 SetLastWin32Error(ERROR_INVALID_HANDLE);
5140 }
5141 }
5142 else
5143 { /* Is handle entry restricted? */
5144 UNIMPLEMENTED
5145 }
5146 return FALSE;
5147 }
5148
5149
5150 /* EOF */
A free Windows-compatible Operating System