1 /* 2 * COPYRIGHT: See COPYING in the top level directory 3 * PROJECT: ReactOS Win32k subsystem 4 * PURPOSE: Windows 5 * FILE: win32ss/user/ntuser/window.c 6 * PROGRAMER: Casper S. Hornstrup (chorns@users.sourceforge.net) 7 */ 8 9 #include <win32k.h> 10 DBG_DEFAULT_CHANNEL(UserWnd); 11 12 INT gNestedWindowLimit = 50; 13 14 /* HELPER FUNCTIONS ***********************************************************/ 15 16 BOOL FASTCALL UserUpdateUiState(PWND Wnd, WPARAM wParam) 17 { 18 WORD Action = LOWORD(wParam); 19 WORD Flags = HIWORD(wParam); 20 21 if (Flags & ~(UISF_HIDEFOCUS | UISF_HIDEACCEL | UISF_ACTIVE)) 22 { 23 EngSetLastError(ERROR_INVALID_PARAMETER); 24 return FALSE; 25 } 26 27 switch (Action) 28 { 29 case UIS_INITIALIZE: 30 EngSetLastError(ERROR_INVALID_PARAMETER); 31 return FALSE; 32 33 case UIS_SET: 34 if (Flags & UISF_HIDEFOCUS) 35 Wnd->HideFocus = TRUE; 36 if (Flags & UISF_HIDEACCEL) 37 Wnd->HideAccel = TRUE; 38 break; 39 40 case UIS_CLEAR: 41 if (Flags & UISF_HIDEFOCUS) 42 Wnd->HideFocus = FALSE; 43 if (Flags & UISF_HIDEACCEL) 44 Wnd->HideAccel = FALSE; 45 break; 46 } 47 48 return TRUE; 49 } 50 51 PWND FASTCALL IntGetWindowObject(HWND hWnd) 52 { 53 PWND Window; 54 55 if (!hWnd) return NULL; 56 57 Window = UserGetWindowObject(hWnd); 58 if (Window) 59 Window->head.cLockObj++; 60 61 return Window; 62 } 63 64 PWND FASTCALL VerifyWnd(PWND pWnd) 65 { 66 HWND hWnd; 67 UINT State, State2; 68 ULONG Error; 69 70 if (!pWnd) return NULL; 71 72 Error = EngGetLastError(); 73 74 _SEH2_TRY 75 { 76 hWnd = UserHMGetHandle(pWnd); 77 State = pWnd->state; 78 State2 = pWnd->state2; 79 } 80 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) 81 { 82 EngSetLastError(Error); 83 _SEH2_YIELD(return NULL); 84 } 85 _SEH2_END 86 87 if ( UserObjectInDestroy(hWnd) || 88 State & WNDS_DESTROYED || 89 State2 & WNDS2_INDESTROY ) 90 pWnd = NULL; 91 92 EngSetLastError(Error); 93 return pWnd; 94 } 95 96 PWND FASTCALL ValidateHwndNoErr(HWND hWnd) 97 { 98 if (hWnd) return (PWND)UserGetObjectNoErr(gHandleTable, hWnd, TYPE_WINDOW); 99 return NULL; 100 } 101 102 /* Temp HACK */ 103 PWND FASTCALL UserGetWindowObject(HWND hWnd) 104 { 105 PWND Window; 106 107 if (!hWnd) 108 { 109 EngSetLastError(ERROR_INVALID_WINDOW_HANDLE); 110 return NULL; 111 } 112 113 Window = (PWND)UserGetObject(gHandleTable, hWnd, TYPE_WINDOW); 114 if (!Window || 0 != (Window->state & WNDS_DESTROYED)) 115 { 116 EngSetLastError(ERROR_INVALID_WINDOW_HANDLE); 117 return NULL; 118 } 119 120 return Window; 121 } 122 123 ULONG FASTCALL 124 IntSetStyle( PWND pwnd, ULONG set_bits, ULONG clear_bits ) 125 { 126 ULONG styleOld, styleNew; 127 styleOld = pwnd->style; 128 styleNew = (pwnd->style | set_bits) & ~clear_bits; 129 if (styleNew == styleOld) return styleNew; 130 pwnd->style = styleNew; 131 if ((styleOld ^ styleNew) & WS_VISIBLE) // State Change. 132 { 133 if (styleOld & WS_VISIBLE) pwnd->head.pti->cVisWindows--; 134 if (styleNew & WS_VISIBLE) pwnd->head.pti->cVisWindows++; 135 DceResetActiveDCEs( pwnd ); 136 } 137 return styleOld; 138 } 139 140 /* 141 * IntIsWindow 142 * 143 * The function determines whether the specified window handle identifies 144 * an existing window. 145 * 146 * Parameters 147 * hWnd 148 * Handle to the window to test. 149 * 150 * Return Value 151 * If the window handle identifies an existing window, the return value 152 * is TRUE. If the window handle does not identify an existing window, 153 * the return value is FALSE. 154 */ 155 156 BOOL FASTCALL 157 IntIsWindow(HWND hWnd) 158 { 159 PWND Window; 160 161 if (!(Window = UserGetWindowObject(hWnd))) 162 { 163 return FALSE; 164 } 165 166 return TRUE; 167 } 168 169 BOOL FASTCALL 170 IntIsWindowVisible(PWND Wnd) 171 { 172 PWND Temp = Wnd; 173 for (;;) 174 { 175 if (!Temp) return TRUE; 176 if (!(Temp->style & WS_VISIBLE)) break; 177 if (Temp->style & WS_MINIMIZE && Temp != Wnd) break; 178 if (Temp->fnid == FNID_DESKTOP) return TRUE; 179 Temp = Temp->spwndParent; 180 } 181 return FALSE; 182 } 183 184 PWND FASTCALL 185 IntGetParent(PWND Wnd) 186 { 187 if (Wnd->style & WS_POPUP) 188 { 189 return Wnd->spwndOwner; 190 } 191 else if (Wnd->style & WS_CHILD) 192 { 193 return Wnd->spwndParent; 194 } 195 196 return NULL; 197 } 198 199 BOOL 200 FASTCALL 201 IntEnableWindow( HWND hWnd, BOOL bEnable ) 202 { 203 BOOL Update; 204 PWND pWnd; 205 UINT bIsDisabled; 206 207 if(!(pWnd = UserGetWindowObject(hWnd))) 208 { 209 return FALSE; 210 } 211 212 /* check if updating is needed */ 213 bIsDisabled = !!(pWnd->style & WS_DISABLED); 214 Update = bIsDisabled; 215 216 if (bEnable) 217 { 218 IntSetStyle( pWnd, 0, WS_DISABLED ); 219 } 220 else 221 { 222 Update = !bIsDisabled; 223 224 co_IntSendMessage( hWnd, WM_CANCELMODE, 0, 0); 225 226 /* Remove keyboard focus from that window if it had focus */ 227 if (hWnd == IntGetThreadFocusWindow()) 228 { 229 TRACE("IntEnableWindow SF NULL\n"); 230 co_UserSetFocus(NULL); 231 } 232 IntSetStyle( pWnd, WS_DISABLED, 0 ); 233 } 234 235 if (Update) 236 { 237 IntNotifyWinEvent(EVENT_OBJECT_STATECHANGE, pWnd, OBJID_WINDOW, CHILDID_SELF, 0); 238 co_IntSendMessage(hWnd, WM_ENABLE, (LPARAM)bEnable, 0); 239 } 240 // Return nonzero if it was disabled, or zero if it wasn't: 241 return bIsDisabled; 242 } 243 244 /* 245 * IntWinListChildren 246 * 247 * Compile a list of all child window handles from given window. 248 * 249 * Remarks 250 * This function is similar to Wine WIN_ListChildren. The caller 251 * must free the returned list with ExFreePool. 252 */ 253 254 HWND* FASTCALL 255 IntWinListChildren(PWND Window) 256 { 257 PWND Child; 258 HWND *List; 259 UINT Index, NumChildren = 0; 260 261 if (!Window) return NULL; 262 263 for (Child = Window->spwndChild; Child; Child = Child->spwndNext) 264 { 265 ++NumChildren; 266 } 267 268 List = ExAllocatePoolWithTag(PagedPool, (NumChildren + 1) * sizeof(HWND), USERTAG_WINDOWLIST); 269 if(!List) 270 { 271 ERR("Failed to allocate memory for children array\n"); 272 EngSetLastError(ERROR_NOT_ENOUGH_MEMORY); 273 return NULL; 274 } 275 276 Index = 0; 277 for (Child = Window->spwndChild; Child; Child = Child->spwndNext) 278 { 279 List[Index++] = Child->head.h; 280 } 281 List[Index] = NULL; 282 283 return List; 284 } 285 286 HWND* FASTCALL 287 IntWinListOwnedPopups(PWND Window) 288 { 289 PWND Child, Desktop; 290 HWND *List; 291 UINT Index, NumOwned = 0; 292 293 Desktop = co_GetDesktopWindow(Window); 294 if (!Desktop) 295 return NULL; 296 297 for (Child = Desktop->spwndChild; Child; Child = Child->spwndNext) 298 { 299 if (Child->spwndOwner == Window) 300 ++NumOwned; 301 } 302 303 List = ExAllocatePoolWithTag(PagedPool, (NumOwned + 1) * sizeof(HWND), USERTAG_WINDOWLIST); 304 if (!List) 305 { 306 ERR("Failed to allocate memory for children array\n"); 307 EngSetLastError(ERROR_NOT_ENOUGH_MEMORY); 308 return NULL; 309 } 310 311 Index = 0; 312 for (Child = Desktop->spwndChild; Child; Child = Child->spwndNext) 313 { 314 if (Child->spwndOwner == Window) 315 List[Index++] = Child->head.h; 316 } 317 List[Index] = NULL; 318 319 return List; 320 } 321 322 PWND FASTCALL 323 IntGetNonChildAncestor(PWND pWnd) 324 { 325 while(pWnd && (pWnd->style & (WS_CHILD | WS_POPUP)) == WS_CHILD) 326 pWnd = pWnd->spwndParent; 327 return pWnd; 328 } 329 330 BOOL FASTCALL 331 IntIsTopLevelWindow(PWND pWnd) 332 { 333 if ( pWnd->spwndParent && 334 pWnd->spwndParent == co_GetDesktopWindow(pWnd) ) return TRUE; 335 return FALSE; 336 } 337 338 BOOL FASTCALL 339 IntValidateOwnerDepth(PWND Wnd, PWND Owner) 340 { 341 INT Depth = 1; 342 for (;;) 343 { 344 if ( !Owner ) return gNestedWindowLimit >= Depth; 345 if (Owner == Wnd) break; 346 Owner = Owner->spwndOwner; 347 Depth++; 348 } 349 return FALSE; 350 } 351 352 HWND FASTCALL 353 IntGetWindow(HWND hWnd, 354 UINT uCmd) 355 { 356 PWND Wnd, FoundWnd; 357 HWND Ret = NULL; 358 359 Wnd = ValidateHwndNoErr(hWnd); 360 if (!Wnd) 361 return NULL; 362 363 FoundWnd = NULL; 364 switch (uCmd) 365 { 366 case GW_OWNER: 367 if (Wnd->spwndOwner != NULL) 368 FoundWnd = Wnd->spwndOwner; 369 break; 370 371 case GW_HWNDFIRST: 372 if(Wnd->spwndParent != NULL) 373 { 374 FoundWnd = Wnd->spwndParent; 375 if (FoundWnd->spwndChild != NULL) 376 FoundWnd = FoundWnd->spwndChild; 377 } 378 break; 379 case GW_HWNDNEXT: 380 if (Wnd->spwndNext != NULL) 381 FoundWnd = Wnd->spwndNext; 382 break; 383 384 case GW_HWNDPREV: 385 if (Wnd->spwndPrev != NULL) 386 FoundWnd = Wnd->spwndPrev; 387 break; 388 389 case GW_CHILD: 390 if (Wnd->spwndChild != NULL) 391 FoundWnd = Wnd->spwndChild; 392 break; 393 394 case GW_HWNDLAST: 395 FoundWnd = Wnd; 396 while ( FoundWnd->spwndNext != NULL) 397 FoundWnd = FoundWnd->spwndNext; 398 break; 399 400 default: 401 Wnd = NULL; 402 break; 403 } 404 405 if (FoundWnd != NULL) 406 Ret = UserHMGetHandle(FoundWnd); 407 return Ret; 408 } 409 410 DWORD FASTCALL IntGetWindowContextHelpId( PWND pWnd ) 411 { 412 DWORD HelpId; 413 414 do 415 { 416 HelpId = (DWORD)(DWORD_PTR)UserGetProp(pWnd, gpsi->atomContextHelpIdProp, TRUE); 417 if (!HelpId) break; 418 pWnd = IntGetParent(pWnd); 419 } 420 while (pWnd && pWnd->fnid != FNID_DESKTOP); 421 return HelpId; 422 } 423 424 425 VOID 426 FASTCALL 427 IntRemoveTrackMouseEvent( 428 PDESKTOP pDesk); 429 430 /*********************************************************************** 431 * IntSendDestroyMsg 432 */ 433 static void IntSendDestroyMsg(HWND hWnd) 434 { 435 PTHREADINFO ti; 436 PWND Window; 437 438 ti = PsGetCurrentThreadWin32Thread(); 439 Window = UserGetWindowObject(hWnd); 440 441 if (Window) 442 { 443 /* 444 * Look whether the focus is within the tree of windows 445 * we will be destroying. 446 */ 447 // Rule #1 448 if ( ti->MessageQueue->spwndActive == Window || // Fixes CORE-106 RegSvr32 exit and return focus to CMD. 449 (ti->MessageQueue->spwndActive == NULL && ti->MessageQueue == IntGetFocusMessageQueue()) ) 450 { 451 co_WinPosActivateOtherWindow(Window); 452 } 453 454 /* Fixes CMD properties closing and returning focus to CMD */ 455 if (ti->MessageQueue->spwndFocus == Window) 456 { 457 if ((Window->style & (WS_CHILD | WS_POPUP)) == WS_CHILD) 458 { 459 co_UserSetFocus(Window->spwndParent); 460 } 461 else 462 { 463 co_UserSetFocus(NULL); 464 } 465 } 466 467 if (ti->MessageQueue->CaretInfo.hWnd == UserHMGetHandle(Window)) 468 { 469 co_IntDestroyCaret(ti); 470 } 471 472 /* If the window being destroyed is currently tracked... */ 473 if (ti->rpdesk->spwndTrack == Window) 474 { 475 IntRemoveTrackMouseEvent(ti->rpdesk); 476 } 477 } 478 479 /* If the window being destroyed is the current clipboard owner... */ 480 if (ti->ppi->prpwinsta != NULL && Window == ti->ppi->prpwinsta->spwndClipOwner) 481 { 482 /* ... make it release the clipboard */ 483 UserClipboardRelease(Window); 484 } 485 486 /* Send the WM_DESTROY to the window */ 487 co_IntSendMessage(hWnd, WM_DESTROY, 0, 0); 488 489 /* 490 * This WM_DESTROY message can trigger re-entrant calls to DestroyWindow 491 * make sure that the window still exists when we come back. 492 */ 493 if (IntIsWindow(hWnd)) 494 { 495 HWND* pWndArray; 496 int i; 497 498 if (!(pWndArray = IntWinListChildren( Window ))) return; 499 500 for (i = 0; pWndArray[i]; i++) 501 { 502 if (IntIsWindow( pWndArray[i] )) IntSendDestroyMsg( pWndArray[i] ); 503 } 504 ExFreePoolWithTag(pWndArray, USERTAG_WINDOWLIST); 505 } 506 else 507 { 508 TRACE("destroyed itself while in WM_DESTROY!\n"); 509 } 510 } 511 512 static VOID 513 UserFreeWindowInfo(PTHREADINFO ti, PWND Wnd) 514 { 515 PCLIENTINFO ClientInfo = GetWin32ClientInfo(); 516 517 if (!Wnd) return; 518 519 if (ClientInfo->CallbackWnd.pWnd == DesktopHeapAddressToUser(Wnd)) 520 { 521 ClientInfo->CallbackWnd.hWnd = NULL; 522 ClientInfo->CallbackWnd.pWnd = NULL; 523 } 524 525 if (Wnd->strName.Buffer != NULL) 526 { 527 Wnd->strName.Length = 0; 528 Wnd->strName.MaximumLength = 0; 529 DesktopHeapFree(Wnd->head.rpdesk, 530 Wnd->strName.Buffer); 531 Wnd->strName.Buffer = NULL; 532 } 533 534 // DesktopHeapFree(Wnd->head.rpdesk, Wnd); 535 // WindowObject->hWnd = NULL; 536 } 537 538 /*********************************************************************** 539 * co_UserFreeWindow 540 * 541 * Destroy storage associated to a window. "Internals" p.358 542 * 543 * This is the "functional" DestroyWindows function i.e. all stuff 544 * done in CreateWindow is undone here and not in DestroyWindow :-P 545 */ 546 LRESULT co_UserFreeWindow(PWND Window, 547 PPROCESSINFO ProcessData, 548 PTHREADINFO ThreadData, 549 BOOLEAN SendMessages) 550 { 551 HWND *Children; 552 HWND *ChildHandle; 553 PWND Child; 554 PMENU Menu; 555 BOOLEAN BelongsToThreadData; 556 557 ASSERT(Window); 558 559 if(Window->state2 & WNDS2_INDESTROY) 560 { 561 TRACE("Tried to call co_UserFreeWindow() twice\n"); 562 return 0; 563 } 564 Window->state2 |= WNDS2_INDESTROY; 565 Window->style &= ~WS_VISIBLE; 566 Window->head.pti->cVisWindows--; 567 568 569 /* remove the window already at this point from the thread window list so we 570 don't get into trouble when destroying the thread windows while we're still 571 in co_UserFreeWindow() */ 572 RemoveEntryList(&Window->ThreadListEntry); 573 574 BelongsToThreadData = IntWndBelongsToThread(Window, ThreadData); 575 576 IntDeRegisterShellHookWindow(UserHMGetHandle(Window)); 577 578 /* free child windows */ 579 Children = IntWinListChildren(Window); 580 if (Children) 581 { 582 for (ChildHandle = Children; *ChildHandle; ++ChildHandle) 583 { 584 if ((Child = IntGetWindowObject(*ChildHandle))) 585 { 586 if (!IntWndBelongsToThread(Child, ThreadData)) 587 { 588 /* send WM_DESTROY messages to windows not belonging to the same thread */ 589 co_IntSendMessage( UserHMGetHandle(Child), WM_ASYNC_DESTROYWINDOW, 0, 0 ); 590 } 591 else 592 co_UserFreeWindow(Child, ProcessData, ThreadData, SendMessages); 593 594 UserDereferenceObject(Child); 595 } 596 } 597 ExFreePoolWithTag(Children, USERTAG_WINDOWLIST); 598 } 599 600 if (SendMessages) 601 { 602 /* 603 * Clear the update region to make sure no WM_PAINT messages will be 604 * generated for this window while processing the WM_NCDESTROY. 605 */ 606 co_UserRedrawWindow(Window, NULL, 0, 607 RDW_VALIDATE | RDW_NOFRAME | RDW_NOERASE | 608 RDW_NOINTERNALPAINT | RDW_NOCHILDREN); 609 if (BelongsToThreadData) 610 co_IntSendMessage(UserHMGetHandle(Window), WM_NCDESTROY, 0, 0); 611 } 612 613 UserClipboardFreeWindow(Window); 614 615 DestroyTimersForWindow(ThreadData, Window); 616 617 /* Unregister hot keys */ 618 UnregisterWindowHotKeys(Window); 619 620 /* flush the message queue */ 621 MsqRemoveWindowMessagesFromQueue(Window); 622 623 /* from now on no messages can be sent to this window anymore */ 624 Window->state |= WNDS_DESTROYED; 625 Window->fnid |= FNID_FREED; 626 627 /* don't remove the WINDOWSTATUS_DESTROYING bit */ 628 629 /* reset shell window handles */ 630 if (ThreadData->rpdesk) 631 { 632 if (Window->head.h == ThreadData->rpdesk->rpwinstaParent->ShellWindow) 633 ThreadData->rpdesk->rpwinstaParent->ShellWindow = NULL; 634 635 if (Window->head.h == ThreadData->rpdesk->rpwinstaParent->ShellListView) 636 ThreadData->rpdesk->rpwinstaParent->ShellListView = NULL; 637 } 638 639 /* Fixes dialog test_focus breakage due to r66237. */ 640 if (ThreadData->MessageQueue->spwndFocus == Window) 641 ThreadData->MessageQueue->spwndFocus = NULL; 642 643 if (ThreadData->MessageQueue->spwndActive == Window) 644 ThreadData->MessageQueue->spwndActive = NULL; 645 646 if (ThreadData->MessageQueue->spwndCapture == Window) 647 { 648 IntReleaseCapture(); 649 } 650 651 //// Now kill those remaining "PAINTING BUG: Thread marked as containing dirty windows" spam!!! 652 if ( Window->hrgnUpdate != NULL || Window->state & WNDS_INTERNALPAINT ) 653 { 654 MsqDecPaintCountQueue(Window->head.pti); 655 if (Window->hrgnUpdate > HRGN_WINDOW && GreIsHandleValid(Window->hrgnUpdate)) 656 { 657 IntGdiSetRegionOwner(Window->hrgnUpdate, GDI_OBJ_HMGR_POWNED); 658 GreDeleteObject(Window->hrgnUpdate); 659 } 660 Window->hrgnUpdate = NULL; 661 Window->state &= ~WNDS_INTERNALPAINT; 662 } 663 664 if (Window->state & (WNDS_SENDERASEBACKGROUND|WNDS_SENDNCPAINT)) 665 { 666 Window->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_SENDNCPAINT); 667 } 668 669 if ( ((Window->style & (WS_CHILD|WS_POPUP)) != WS_CHILD) && 670 Window->IDMenu && 671 (Menu = UserGetMenuObject((HMENU)Window->IDMenu))) 672 { 673 TRACE("UFW: IDMenu %p\n",Window->IDMenu); 674 IntDestroyMenuObject(Menu, TRUE); 675 Window->IDMenu = 0; 676 } 677 678 if (Window->SystemMenu 679 && (Menu = UserGetMenuObject(Window->SystemMenu))) 680 { 681 IntDestroyMenuObject(Menu, TRUE); 682 Window->SystemMenu = (HMENU)0; 683 } 684 685 DceFreeWindowDCE(Window); /* Always do this to catch orphaned DCs */ 686 687 IntUnlinkWindow(Window); 688 689 if (Window->PropListItems) 690 { 691 UserRemoveWindowProps(Window); 692 TRACE("Window->PropListItems %lu\n",Window->PropListItems); 693 ASSERT(Window->PropListItems==0); 694 } 695 696 UserReferenceObject(Window); 697 UserMarkObjectDestroy(Window); 698 699 IntDestroyScrollBars(Window); 700 701 if (Window->pcls->atomClassName == gaGuiConsoleWndClass) 702 { 703 /* Count only console windows manually */ 704 co_IntUserManualGuiCheck(FALSE); 705 } 706 707 /* dereference the class */ 708 NT_ASSERT(Window->head.pti != NULL); 709 IntDereferenceClass(Window->pcls, 710 Window->head.pti->pDeskInfo, 711 Window->head.pti->ppi); 712 Window->pcls = NULL; 713 714 if (Window->hrgnClip) 715 { 716 IntGdiSetRegionOwner(Window->hrgnClip, GDI_OBJ_HMGR_POWNED); 717 GreDeleteObject(Window->hrgnClip); 718 Window->hrgnClip = NULL; 719 } 720 Window->head.pti->cWindows--; 721 722 // ASSERT(Window != NULL); 723 UserFreeWindowInfo(Window->head.pti, Window); 724 725 UserDereferenceObject(Window); 726 UserDeleteObject(UserHMGetHandle(Window), TYPE_WINDOW); 727 728 return 0; 729 } 730 731 // 732 // Same as User32:IntGetWndProc. 733 // 734 WNDPROC FASTCALL 735 IntGetWindowProc(PWND pWnd, 736 BOOL Ansi) 737 { 738 INT i; 739 PCLS Class; 740 WNDPROC gcpd, Ret = 0; 741 742 ASSERT(UserIsEnteredExclusive() == TRUE); 743 744 Class = pWnd->pcls; 745 746 if (pWnd->state & WNDS_SERVERSIDEWINDOWPROC) 747 { 748 for ( i = FNID_FIRST; i <= FNID_SWITCH; i++) 749 { 750 if (GETPFNSERVER(i) == pWnd->lpfnWndProc) 751 { 752 if (Ansi) 753 Ret = GETPFNCLIENTA(i); 754 else 755 Ret = GETPFNCLIENTW(i); 756 } 757 } 758 return Ret; 759 } 760 761 if (Class->fnid == FNID_EDIT) 762 Ret = pWnd->lpfnWndProc; 763 else 764 { 765 Ret = pWnd->lpfnWndProc; 766 767 if (Class->fnid <= FNID_GHOST && Class->fnid >= FNID_BUTTON) 768 { 769 if (Ansi) 770 { 771 if (GETPFNCLIENTW(Class->fnid) == pWnd->lpfnWndProc) 772 Ret = GETPFNCLIENTA(Class->fnid); 773 } 774 else 775 { 776 if (GETPFNCLIENTA(Class->fnid) == pWnd->lpfnWndProc) 777 Ret = GETPFNCLIENTW(Class->fnid); 778 } 779 } 780 if ( Ret != pWnd->lpfnWndProc) 781 return Ret; 782 } 783 if ( Ansi == !!(pWnd->state & WNDS_ANSIWINDOWPROC) ) 784 return Ret; 785 786 gcpd = (WNDPROC)UserGetCPD( 787 pWnd, 788 (Ansi ? UserGetCPDA2U : UserGetCPDU2A )|UserGetCPDWindow, 789 (ULONG_PTR)Ret); 790 791 return (gcpd ? gcpd : Ret); 792 } 793 794 static WNDPROC 795 IntSetWindowProc(PWND pWnd, 796 WNDPROC NewWndProc, 797 BOOL Ansi) 798 { 799 INT i; 800 PCALLPROCDATA CallProc; 801 PCLS Class; 802 WNDPROC Ret, chWndProc = NULL; 803 804 // Retrieve previous window proc. 805 Ret = IntGetWindowProc(pWnd, Ansi); 806 807 Class = pWnd->pcls; 808 809 if (IsCallProcHandle(NewWndProc)) 810 { 811 CallProc = UserGetObject(gHandleTable, NewWndProc, TYPE_CALLPROC); 812 if (CallProc) 813 { // Reset new WndProc. 814 NewWndProc = CallProc->pfnClientPrevious; 815 // Reset Ansi from CallProc handle. This is expected with wine "deftest". 816 Ansi = !!(CallProc->wType & UserGetCPDU2A); 817 } 818 } 819 // Switch from Client Side call to Server Side call if match. Ref: "deftest". 820 for ( i = FNID_FIRST; i <= FNID_SWITCH; i++) 821 { 822 if (GETPFNCLIENTW(i) == NewWndProc) 823 { 824 chWndProc = GETPFNSERVER(i); 825 break; 826 } 827 if (GETPFNCLIENTA(i) == NewWndProc) 828 { 829 chWndProc = GETPFNSERVER(i); 830 break; 831 } 832 } 833 // If match, set/reset to Server Side and clear ansi. 834 if (chWndProc) 835 { 836 pWnd->lpfnWndProc = chWndProc; 837 pWnd->Unicode = TRUE; 838 pWnd->state &= ~WNDS_ANSIWINDOWPROC; 839 pWnd->state |= WNDS_SERVERSIDEWINDOWPROC; 840 } 841 else 842 { 843 pWnd->Unicode = !Ansi; 844 // Handle the state change in here. 845 if (Ansi) 846 pWnd->state |= WNDS_ANSIWINDOWPROC; 847 else 848 pWnd->state &= ~WNDS_ANSIWINDOWPROC; 849 850 if (pWnd->state & WNDS_SERVERSIDEWINDOWPROC) 851 pWnd->state &= ~WNDS_SERVERSIDEWINDOWPROC; 852 853 if (!NewWndProc) NewWndProc = pWnd->lpfnWndProc; 854 855 if (Class->fnid <= FNID_GHOST && Class->fnid >= FNID_BUTTON) 856 { 857 if (Ansi) 858 { 859 if (GETPFNCLIENTW(Class->fnid) == NewWndProc) 860 chWndProc = GETPFNCLIENTA(Class->fnid); 861 } 862 else 863 { 864 if (GETPFNCLIENTA(Class->fnid) == NewWndProc) 865 chWndProc = GETPFNCLIENTW(Class->fnid); 866 } 867 } 868 // Now set the new window proc. 869 pWnd->lpfnWndProc = (chWndProc ? chWndProc : NewWndProc); 870 } 871 return Ret; 872 } 873 874 875 /* INTERNAL ******************************************************************/ 876 877 //// 878 // This fixes a check for children messages that need paint while searching the parents messages! 879 // Fixes wine msg:test_paint_messages:WmParentErasePaint .. 880 //// 881 BOOL FASTCALL 882 IntIsChildWindow(PWND Parent, PWND BaseWindow) 883 { 884 PWND Window = BaseWindow; 885 do 886 { 887 if ( Window == NULL || (Window->style & (WS_POPUP|WS_CHILD)) != WS_CHILD ) 888 return FALSE; 889 890 Window = Window->spwndParent; 891 } 892 while(Parent != Window); 893 return TRUE; 894 } 895 //// 896 897 /* Link the window into siblings list. Children and parent are kept in place. */ 898 VOID FASTCALL 899 IntLinkWindow( 900 PWND Wnd, 901 PWND WndInsertAfter /* Set to NULL if top sibling */ 902 ) 903 { 904 if (Wnd == WndInsertAfter) 905 { 906 ERR("IntLinkWindow -- Trying to link window 0x%p to itself!!\n", Wnd); 907 return; 908 } 909 910 Wnd->spwndPrev = WndInsertAfter; 911 if (Wnd->spwndPrev) 912 { 913 /* Link after WndInsertAfter */ 914 ASSERT(Wnd != WndInsertAfter->spwndNext); 915 Wnd->spwndNext = WndInsertAfter->spwndNext; 916 if (Wnd->spwndNext) 917 Wnd->spwndNext->spwndPrev = Wnd; 918 919 ASSERT(Wnd != Wnd->spwndPrev); 920 Wnd->spwndPrev->spwndNext = Wnd; 921 } 922 else 923 { 924 /* Link at the top */ 925 ASSERT(Wnd != Wnd->spwndParent->spwndChild); 926 Wnd->spwndNext = Wnd->spwndParent->spwndChild; 927 if (Wnd->spwndNext) 928 Wnd->spwndNext->spwndPrev = Wnd; 929 930 Wnd->spwndParent->spwndChild = Wnd; 931 } 932 } 933 934 /* 935 Note: Wnd->spwndParent can be null if it is the desktop. 936 */ 937 VOID FASTCALL IntLinkHwnd(PWND Wnd, HWND hWndPrev) 938 { 939 if (hWndPrev == HWND_NOTOPMOST) 940 { 941 if (!(Wnd->ExStyle & WS_EX_TOPMOST) && (Wnd->ExStyle2 & WS_EX2_LINKED)) 942 return; /* nothing to do */ 943 Wnd->ExStyle &= ~WS_EX_TOPMOST; 944 hWndPrev = HWND_TOP; /* fallback to the HWND_TOP case */ 945 } 946 947 IntUnlinkWindow(Wnd); /* unlink it from the previous location */ 948 949 if (hWndPrev == HWND_BOTTOM) 950 { 951 /* Link in the bottom of the list */ 952 PWND WndInsertAfter; 953 954 WndInsertAfter = Wnd->spwndParent->spwndChild; 955 while (WndInsertAfter && WndInsertAfter->spwndNext) 956 { 957 WndInsertAfter = WndInsertAfter->spwndNext; 958 } 959 960 IntLinkWindow(Wnd, WndInsertAfter); 961 Wnd->ExStyle &= ~WS_EX_TOPMOST; 962 } 963 else if (hWndPrev == HWND_TOPMOST) 964 { 965 /* Link in the top of the list */ 966 IntLinkWindow(Wnd, NULL); 967 Wnd->ExStyle |= WS_EX_TOPMOST; 968 } 969 else if (hWndPrev == HWND_TOP) 970 { 971 /* Link it after the last topmost window */ 972 PWND WndInsertBefore; 973 974 WndInsertBefore = Wnd->spwndParent->spwndChild; 975 976 if (!(Wnd->ExStyle & WS_EX_TOPMOST)) /* put it above the first non-topmost window */ 977 { 978 while (WndInsertBefore != NULL && WndInsertBefore->spwndNext != NULL) 979 { 980 if (!(WndInsertBefore->ExStyle & WS_EX_TOPMOST)) 981 break; 982 983 if (WndInsertBefore == Wnd->spwndOwner) /* keep it above owner */ 984 { 985 Wnd->ExStyle |= WS_EX_TOPMOST; 986 break; 987 } 988 WndInsertBefore = WndInsertBefore->spwndNext; 989 } 990 } 991 992 IntLinkWindow(Wnd, WndInsertBefore ? WndInsertBefore->spwndPrev : NULL); 993 } 994 else 995 { 996 /* Link it after hWndPrev */ 997 PWND WndInsertAfter; 998 999 WndInsertAfter = UserGetWindowObject(hWndPrev); 1000 /* Are we called with an erroneous handle */ 1001 if (WndInsertAfter == NULL) 1002 { 1003 /* Link in a default position */ 1004 IntLinkHwnd(Wnd, HWND_TOP); 1005 return; 1006 } 1007 1008 if (Wnd == WndInsertAfter) 1009 ERR("IntLinkHwnd -- Trying to link window 0x%p to itself!!\n", Wnd); 1010 IntLinkWindow(Wnd, WndInsertAfter); 1011 1012 /* Fix the WS_EX_TOPMOST flag */ 1013 if (!(WndInsertAfter->ExStyle & WS_EX_TOPMOST)) 1014 { 1015 Wnd->ExStyle &= ~WS_EX_TOPMOST; 1016 } 1017 else 1018 { 1019 if (WndInsertAfter->spwndNext && 1020 (WndInsertAfter->spwndNext->ExStyle & WS_EX_TOPMOST)) 1021 { 1022 Wnd->ExStyle |= WS_EX_TOPMOST; 1023 } 1024 } 1025 } 1026 Wnd->ExStyle2 |= WS_EX2_LINKED; 1027 } 1028 1029 VOID FASTCALL 1030 IntProcessOwnerSwap(PWND Wnd, PWND WndNewOwner, PWND WndOldOwner) 1031 { 1032 if (WndOldOwner) 1033 { 1034 if (Wnd->head.pti != WndOldOwner->head.pti) 1035 { 1036 if (!WndNewOwner || 1037 Wnd->head.pti == WndNewOwner->head.pti || 1038 WndOldOwner->head.pti != WndNewOwner->head.pti ) 1039 { 1040 //ERR("ProcessOwnerSwap Old out.\n"); 1041 UserAttachThreadInput(Wnd->head.pti, WndOldOwner->head.pti, FALSE); 1042 } 1043 } 1044 } 1045 if (WndNewOwner) 1046 { 1047 if (Wnd->head.pti != WndNewOwner->head.pti) 1048 { 1049 if (!WndOldOwner || 1050 WndOldOwner->head.pti != WndNewOwner->head.pti ) 1051 { 1052 //ERR("ProcessOwnerSwap New in.\n"); 1053 UserAttachThreadInput(Wnd->head.pti, WndNewOwner->head.pti, TRUE); 1054 } 1055 } 1056 } 1057 // FIXME: System Tray checks. 1058 } 1059 1060 HWND FASTCALL 1061 IntSetOwner(HWND hWnd, HWND hWndNewOwner) 1062 { 1063 PWND Wnd, WndOldOwner, WndNewOwner; 1064 HWND ret; 1065 1066 Wnd = IntGetWindowObject(hWnd); 1067 if(!Wnd) 1068 return NULL; 1069 1070 WndOldOwner = Wnd->spwndOwner; 1071 1072 ret = WndOldOwner ? UserHMGetHandle(WndOldOwner) : 0; 1073 WndNewOwner = UserGetWindowObject(hWndNewOwner); 1074 1075 if (!WndNewOwner && hWndNewOwner) 1076 { 1077 EngSetLastError(ERROR_INVALID_PARAMETER); 1078 ret = NULL; 1079 goto Error; 1080 } 1081 1082 /* if parent belongs to a different thread and the window isn't */ 1083 /* top-level, attach the two threads */ 1084 IntProcessOwnerSwap(Wnd, WndNewOwner, WndOldOwner); 1085 1086 if (IntValidateOwnerDepth(Wnd, WndNewOwner)) 1087 { 1088 if (WndNewOwner) 1089 { 1090 Wnd->spwndOwner= WndNewOwner; 1091 } 1092 else 1093 { 1094 Wnd->spwndOwner = NULL; 1095 } 1096 } 1097 else 1098 { 1099 IntProcessOwnerSwap(Wnd, WndOldOwner, WndNewOwner); 1100 EngSetLastError(ERROR_INVALID_PARAMETER); 1101 ret = NULL; 1102 } 1103 Error: 1104 UserDereferenceObject(Wnd); 1105 return ret; 1106 } 1107 1108 PWND FASTCALL 1109 co_IntSetParent(PWND Wnd, PWND WndNewParent) 1110 { 1111 PWND WndOldParent, pWndExam; 1112 BOOL WasVisible; 1113 POINT pt; 1114 int swFlags = SWP_NOSIZE|SWP_NOZORDER; 1115 1116 ASSERT(Wnd); 1117 ASSERT(WndNewParent); 1118 ASSERT_REFS_CO(Wnd); 1119 ASSERT_REFS_CO(WndNewParent); 1120 1121 if (Wnd == Wnd->head.rpdesk->spwndMessage) 1122 { 1123 EngSetLastError(ERROR_ACCESS_DENIED); 1124 return( NULL); 1125 } 1126 1127 /* Some applications try to set a child as a parent */ 1128 if (IntIsChildWindow(Wnd, WndNewParent)) 1129 { 1130 TRACE("IntSetParent try to set a child as a parent.\n"); 1131 EngSetLastError( ERROR_INVALID_PARAMETER ); 1132 return NULL; 1133 } 1134 1135 pWndExam = WndNewParent; // Load parent Window to examine. 1136 // Now test for set parent to parent hit. 1137 while (pWndExam) 1138 { 1139 if (Wnd == pWndExam) 1140 { 1141 TRACE("IntSetParent Failed Test for set parent to parent!\n"); 1142 EngSetLastError(ERROR_INVALID_PARAMETER); 1143 return NULL; 1144 } 1145 pWndExam = pWndExam->spwndParent; 1146 } 1147 1148 /* 1149 * Windows hides the window first, then shows it again 1150 * including the WM_SHOWWINDOW messages and all 1151 */ 1152 WasVisible = co_WinPosShowWindow(Wnd, SW_HIDE); 1153 1154 /* Window must belong to current process */ 1155 if (Wnd->head.pti->ppi != PsGetCurrentProcessWin32Process()) 1156 { 1157 ERR("IntSetParent Window must belong to current process!\n"); 1158 return NULL; 1159 } 1160 1161 WndOldParent = Wnd->spwndParent; 1162 1163 if ( WndOldParent && 1164 WndOldParent->ExStyle & WS_EX_LAYOUTRTL) 1165 pt.x = Wnd->rcWindow.right; 1166 else 1167 pt.x = Wnd->rcWindow.left; 1168 pt.y = Wnd->rcWindow.top; 1169 1170 IntScreenToClient(WndOldParent, &pt); 1171 1172 if (WndOldParent) UserReferenceObject(WndOldParent); /* Caller must deref */ 1173 1174 if (WndNewParent != WndOldParent) 1175 { 1176 /* Unlink the window from the siblings list */ 1177 IntUnlinkWindow(Wnd); 1178 Wnd->ExStyle2 &= ~WS_EX2_LINKED; 1179 1180 /* Set the new parent */ 1181 Wnd->spwndParent = WndNewParent; 1182 1183 if ( Wnd->style & WS_CHILD && 1184 Wnd->spwndOwner && 1185 Wnd->spwndOwner->ExStyle & WS_EX_TOPMOST ) 1186 { 1187 ERR("SetParent Top Most from Pop up!\n"); 1188 Wnd->ExStyle |= WS_EX_TOPMOST; 1189 } 1190 1191 /* Link the window with its new siblings */ 1192 IntLinkHwnd( Wnd, 1193 ((0 == (Wnd->ExStyle & WS_EX_TOPMOST) && 1194 UserIsDesktopWindow(WndNewParent) ) ? HWND_TOP : HWND_TOPMOST ) ); 1195 } 1196 1197 if ( WndNewParent == co_GetDesktopWindow(Wnd) && 1198 !(Wnd->style & WS_CLIPSIBLINGS) ) 1199 { 1200 Wnd->style |= WS_CLIPSIBLINGS; 1201 DceResetActiveDCEs(Wnd); 1202 } 1203 1204 /* if parent belongs to a different thread and the window isn't */ 1205 /* top-level, attach the two threads */ 1206 if ((Wnd->style & (WS_CHILD|WS_POPUP)) == WS_CHILD) 1207 { 1208 if ( Wnd->spwndParent != co_GetDesktopWindow(Wnd)) 1209 { 1210 if (WndOldParent && (Wnd->head.pti != WndOldParent->head.pti)) 1211 { 1212 //ERR("SetParent Old out.\n"); 1213 UserAttachThreadInput(Wnd->head.pti, WndOldParent->head.pti, FALSE); 1214 } 1215 } 1216 if ( WndNewParent != co_GetDesktopWindow(Wnd)) 1217 { 1218 if (Wnd->head.pti != WndNewParent->head.pti) 1219 { 1220 //ERR("SetParent New in.\n"); 1221 UserAttachThreadInput(Wnd->head.pti, WndNewParent->head.pti, TRUE); 1222 } 1223 } 1224 } 1225 1226 if (UserIsMessageWindow(WndOldParent) || UserIsMessageWindow(WndNewParent)) 1227 swFlags |= SWP_NOACTIVATE; 1228 1229 IntNotifyWinEvent(EVENT_OBJECT_PARENTCHANGE, Wnd ,OBJID_WINDOW, CHILDID_SELF, WEF_SETBYWNDPTI); 1230 /* 1231 * SetParent additionally needs to make hwnd the top window 1232 * in the z-order and send the expected WM_WINDOWPOSCHANGING and 1233 * WM_WINDOWPOSCHANGED notification messages. 1234 */ 1235 //ERR("IntSetParent SetWindowPos 1\n"); 1236 co_WinPosSetWindowPos( Wnd, 1237 (0 == (Wnd->ExStyle & WS_EX_TOPMOST) ? HWND_TOP : HWND_TOPMOST), 1238 pt.x, pt.y, 0, 0, swFlags); 1239 //ERR("IntSetParent SetWindowPos 2 X %d Y %d\n",pt.x, pt.y); 1240 if (WasVisible) co_WinPosShowWindow(Wnd, SW_SHOWNORMAL); 1241 1242 return WndOldParent; 1243 } 1244 1245 HWND FASTCALL 1246 co_UserSetParent(HWND hWndChild, HWND hWndNewParent) 1247 { 1248 PWND Wnd = NULL, WndParent = NULL, WndOldParent; 1249 HWND hWndOldParent = NULL; 1250 USER_REFERENCE_ENTRY Ref, ParentRef; 1251 1252 if (IntIsBroadcastHwnd(hWndChild) || IntIsBroadcastHwnd(hWndNewParent)) 1253 { 1254 EngSetLastError(ERROR_INVALID_PARAMETER); 1255 return( NULL); 1256 } 1257 1258 if (hWndChild == IntGetDesktopWindow()) 1259 { 1260 ERR("UserSetParent Access Denied!\n"); 1261 EngSetLastError(ERROR_ACCESS_DENIED); 1262 return( NULL); 1263 } 1264 1265 if (hWndNewParent) 1266 { 1267 if (!(WndParent = UserGetWindowObject(hWndNewParent))) 1268 { 1269 ERR("UserSetParent Bad New Parent!\n"); 1270 return( NULL); 1271 } 1272 } 1273 else 1274 { 1275 if (!(WndParent = UserGetWindowObject(IntGetDesktopWindow()))) 1276 { 1277 return( NULL); 1278 } 1279 } 1280 1281 if (!(Wnd = UserGetWindowObject(hWndChild))) 1282 { 1283 ERR("UserSetParent Bad Child!\n"); 1284 return( NULL); 1285 } 1286 1287 UserRefObjectCo(Wnd, &Ref); 1288 UserRefObjectCo(WndParent, &ParentRef); 1289 //ERR("Enter co_IntSetParent\n"); 1290 WndOldParent = co_IntSetParent(Wnd, WndParent); 1291 //ERR("Leave co_IntSetParent\n"); 1292 UserDerefObjectCo(WndParent); 1293 UserDerefObjectCo(Wnd); 1294 1295 if (WndOldParent) 1296 { 1297 hWndOldParent = WndOldParent->head.h; 1298 UserDereferenceObject(WndOldParent); 1299 } 1300 1301 return( hWndOldParent); 1302 } 1303 1304 /* Unlink the window from siblings. Children and parent are kept in place. */ 1305 VOID FASTCALL 1306 IntUnlinkWindow(PWND Wnd) 1307 { 1308 ASSERT(Wnd != Wnd->spwndNext); 1309 ASSERT(Wnd != Wnd->spwndPrev); 1310 1311 if (Wnd->spwndNext) 1312 Wnd->spwndNext->spwndPrev = Wnd->spwndPrev; 1313 1314 if (Wnd->spwndPrev) 1315 Wnd->spwndPrev->spwndNext = Wnd->spwndNext; 1316 1317 if (Wnd->spwndParent && Wnd->spwndParent->spwndChild == Wnd) 1318 Wnd->spwndParent->spwndChild = Wnd->spwndNext; 1319 1320 Wnd->spwndPrev = Wnd->spwndNext = NULL; 1321 } 1322 1323 /* FUNCTIONS *****************************************************************/ 1324 1325 /* 1326 * As best as I can figure, this function is used by EnumWindows, 1327 * EnumChildWindows, EnumDesktopWindows, & EnumThreadWindows. 1328 * 1329 * It's supposed to build a list of HWNDs to return to the caller. 1330 * We can figure out what kind of list by what parameters are 1331 * passed to us. 1332 */ 1333 /* 1334 * @implemented 1335 */ 1336 NTSTATUS 1337 APIENTRY 1338 NtUserBuildHwndList( 1339 HDESK hDesktop, 1340 HWND hwndParent, 1341 BOOLEAN bChildren, 1342 ULONG dwThreadId, 1343 ULONG lParam, 1344 HWND* pWnd, 1345 ULONG* pBufSize) 1346 { 1347 NTSTATUS Status; 1348 ULONG dwCount = 0; 1349 1350 if (pBufSize == 0) 1351 return ERROR_INVALID_PARAMETER; 1352 1353 if (hwndParent || !dwThreadId) 1354 { 1355 PDESKTOP Desktop; 1356 PWND Parent, Window; 1357 1358 if(!hwndParent) 1359 { 1360 if(hDesktop == NULL && !(Desktop = IntGetActiveDesktop())) 1361 { 1362 return ERROR_INVALID_HANDLE; 1363 } 1364 1365 if(hDesktop) 1366 { 1367 Status = IntValidateDesktopHandle(hDesktop, 1368 UserMode, 1369 0, 1370 &Desktop); 1371 if(!NT_SUCCESS(Status)) 1372 { 1373 return ERROR_INVALID_HANDLE; 1374 } 1375 } 1376 hwndParent = Desktop->DesktopWindow; 1377 } 1378 else 1379 { 1380 hDesktop = 0; 1381 } 1382 1383 if((Parent = UserGetWindowObject(hwndParent)) && 1384 (Window = Parent->spwndChild)) 1385 { 1386 BOOL bGoDown = TRUE; 1387 1388 Status = STATUS_SUCCESS; 1389 while(TRUE) 1390 { 1391 if (bGoDown) 1392 { 1393 if(dwCount++ < *pBufSize && pWnd) 1394 { 1395 _SEH2_TRY 1396 { 1397 ProbeForWrite(pWnd, sizeof(HWND), 1); 1398 *pWnd = Window->head.h; 1399 pWnd++; 1400 } 1401 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) 1402 { 1403 Status = _SEH2_GetExceptionCode(); 1404 } 1405 _SEH2_END 1406 if(!NT_SUCCESS(Status)) 1407 { 1408 SetLastNtError(Status); 1409 break; 1410 } 1411 } 1412 if (Window->spwndChild && bChildren) 1413 { 1414 Window = Window->spwndChild; 1415 continue; 1416 } 1417 bGoDown = FALSE; 1418 } 1419 if (Window->spwndNext) 1420 { 1421 Window = Window->spwndNext; 1422 bGoDown = TRUE; 1423 continue; 1424 } 1425 Window = Window->spwndParent; 1426 if (Window == Parent) 1427 { 1428 break; 1429 } 1430 } 1431 } 1432 1433 if(hDesktop) 1434 { 1435 ObDereferenceObject(Desktop); 1436 } 1437 } 1438 else // Build EnumThreadWindows list! 1439 { 1440 PETHREAD Thread; 1441 PTHREADINFO W32Thread; 1442 PWND Window; 1443 HWND *List = NULL; 1444 1445 Status = PsLookupThreadByThreadId(UlongToHandle(dwThreadId), &Thread); 1446 if (!NT_SUCCESS(Status)) 1447 { 1448 ERR("Thread Id is not valid!\n"); 1449 return ERROR_INVALID_PARAMETER; 1450 } 1451 if (!(W32Thread = (PTHREADINFO)Thread->Tcb.Win32Thread)) 1452 { 1453 ObDereferenceObject(Thread); 1454 TRACE("Tried to enumerate windows of a non gui thread\n"); 1455 return ERROR_INVALID_PARAMETER; 1456 } 1457 1458 // Do not use Thread link list due to co_UserFreeWindow!!! 1459 // Current = W32Thread->WindowListHead.Flink; 1460 // Fixes Api:CreateWindowEx tests!!! 1461 List = IntWinListChildren(UserGetDesktopWindow()); 1462 if (List) 1463 { 1464 int i; 1465 for (i = 0; List[i]; i++) 1466 { 1467 Window = ValidateHwndNoErr(List[i]); 1468 if (Window && Window->head.pti == W32Thread) 1469 { 1470 if (dwCount < *pBufSize && pWnd) 1471 { 1472 _SEH2_TRY 1473 { 1474 ProbeForWrite(pWnd, sizeof(HWND), 1); 1475 *pWnd = Window->head.h; 1476 pWnd++; 1477 } 1478 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) 1479 { 1480 Status = _SEH2_GetExceptionCode(); 1481 } 1482 _SEH2_END 1483 if (!NT_SUCCESS(Status)) 1484 { 1485 ERR("Failure to build window list!\n"); 1486 SetLastNtError(Status); 1487 break; 1488 } 1489 } 1490 dwCount++; 1491 } 1492 } 1493 ExFreePoolWithTag(List, USERTAG_WINDOWLIST); 1494 } 1495 1496 ObDereferenceObject(Thread); 1497 } 1498 1499 *pBufSize = dwCount; 1500 return STATUS_SUCCESS; 1501 } 1502 1503 static void IntSendParentNotify( PWND pWindow, UINT msg ) 1504 { 1505 if ( (pWindow->style & (WS_CHILD | WS_POPUP)) == WS_CHILD && 1506 !(pWindow->ExStyle & WS_EX_NOPARENTNOTIFY)) 1507 { 1508 if (VerifyWnd(pWindow->spwndParent) && !UserIsDesktopWindow(pWindow->spwndParent)) 1509 { 1510 USER_REFERENCE_ENTRY Ref; 1511 UserRefObjectCo(pWindow->spwndParent, &Ref); 1512 co_IntSendMessage( pWindow->spwndParent->head.h, 1513 WM_PARENTNOTIFY, 1514 MAKEWPARAM( msg, pWindow->IDMenu), 1515 (LPARAM)pWindow->head.h ); 1516 UserDerefObjectCo(pWindow->spwndParent); 1517 } 1518 } 1519 } 1520 1521 void FASTCALL 1522 IntFixWindowCoordinates(CREATESTRUCTW* Cs, PWND ParentWindow, DWORD* dwShowMode) 1523 { 1524 #define IS_DEFAULT(x) ((x) == CW_USEDEFAULT || (x) == (SHORT)0x8000) 1525 1526 /* default positioning for overlapped windows */ 1527 if(!(Cs->style & (WS_POPUP | WS_CHILD))) 1528 { 1529 PMONITOR pMonitor; 1530 PRTL_USER_PROCESS_PARAMETERS ProcessParams; 1531 1532 pMonitor = UserGetPrimaryMonitor(); 1533 1534 /* Check if we don't have a monitor attached yet */ 1535 if(pMonitor == NULL) 1536 { 1537 Cs->x = Cs->y = 0; 1538 Cs->cx = 800; 1539 Cs->cy = 600; 1540 return; 1541 } 1542 1543 ProcessParams = PsGetCurrentProcess()->Peb->ProcessParameters; 1544 1545 if (IS_DEFAULT(Cs->x)) 1546 { 1547 if (!IS_DEFAULT(Cs->y)) *dwShowMode = Cs->y; 1548 1549 if(ProcessParams->WindowFlags & STARTF_USEPOSITION) 1550 { 1551 Cs->x = ProcessParams->StartingX; 1552 Cs->y = ProcessParams->StartingY; 1553 } 1554 else 1555 { 1556 Cs->x = pMonitor->cWndStack * (UserGetSystemMetrics(SM_CXSIZE) + UserGetSystemMetrics(SM_CXFRAME)); 1557 Cs->y = pMonitor->cWndStack * (UserGetSystemMetrics(SM_CYSIZE) + UserGetSystemMetrics(SM_CYFRAME)); 1558 if (Cs->x > ((pMonitor->rcWork.right - pMonitor->rcWork.left) / 4) || 1559 Cs->y > ((pMonitor->rcWork.bottom - pMonitor->rcWork.top) / 4)) 1560 { 1561 /* reset counter and position */ 1562 Cs->x = 0; 1563 Cs->y = 0; 1564 pMonitor->cWndStack = 0; 1565 } 1566 pMonitor->cWndStack++; 1567 } 1568 } 1569 1570 if (IS_DEFAULT(Cs->cx)) 1571 { 1572 if (ProcessParams->WindowFlags & STARTF_USEPOSITION) 1573 { 1574 Cs->cx = ProcessParams->CountX; 1575 Cs->cy = ProcessParams->CountY; 1576 } 1577 else 1578 { 1579 Cs->cx = (pMonitor->rcWork.right - pMonitor->rcWork.left) * 3 / 4; 1580 Cs->cy = (pMonitor->rcWork.bottom - pMonitor->rcWork.top) * 3 / 4; 1581 } 1582 } 1583 /* neither x nor cx are default. Check the y values . 1584 * In the trace we see Outlook and Outlook Express using 1585 * cy set to CW_USEDEFAULT when opening the address book. 1586 */ 1587 else if (IS_DEFAULT(Cs->cy)) 1588 { 1589 TRACE("Strange use of CW_USEDEFAULT in nHeight\n"); 1590 Cs->cy = (pMonitor->rcWork.bottom - pMonitor->rcWork.top) * 3 / 4; 1591 } 1592 } 1593 else 1594 { 1595 /* if CW_USEDEFAULT is set for non-overlapped windows, both values are set to zero */ 1596 if(IS_DEFAULT(Cs->x)) 1597 { 1598 Cs->x = 0; 1599 Cs->y = 0; 1600 } 1601 if(IS_DEFAULT(Cs->cx)) 1602 { 1603 Cs->cx = 0; 1604 Cs->cy = 0; 1605 } 1606 } 1607 1608 #undef IS_DEFAULT 1609 } 1610 1611 /* Allocates and initializes a window */ 1612 PWND FASTCALL IntCreateWindow(CREATESTRUCTW* Cs, 1613 PLARGE_STRING WindowName, 1614 PCLS Class, 1615 PWND ParentWindow, 1616 PWND OwnerWindow, 1617 PVOID acbiBuffer, 1618 PDESKTOP pdeskCreated, 1619 DWORD dwVer ) 1620 { 1621 PWND pWnd = NULL; 1622 HWND hWnd; 1623 PTHREADINFO pti = NULL; 1624 BOOL MenuChanged; 1625 BOOL bUnicodeWindow; 1626 1627 pti = pdeskCreated ? gptiDesktopThread : GetW32ThreadInfo(); 1628 1629 if (!(Cs->dwExStyle & WS_EX_LAYOUTRTL)) 1630 { // Need both here for wine win.c test_CreateWindow. 1631 //if (Cs->hwndParent && ParentWindow) 1632 if (ParentWindow) // It breaks more tests..... WIP. 1633 { 1634 if ( (Cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD && 1635 ParentWindow->ExStyle & WS_EX_LAYOUTRTL && 1636 !(ParentWindow->ExStyle & WS_EX_NOINHERITLAYOUT) ) 1637 Cs->dwExStyle |= WS_EX_LAYOUTRTL; 1638 } 1639 else 1640 { /* 1641 * Note from MSDN <http://msdn.microsoft.com/en-us/library/aa913269.aspx>: 1642 * 1643 * Dialog boxes and message boxes do not inherit layout, so you must 1644 * set the layout explicitly. 1645 */ 1646 if ( Class->fnid != FNID_DIALOG ) 1647 { 1648 if (pti->ppi->dwLayout & LAYOUT_RTL) 1649 { 1650 Cs->dwExStyle |= WS_EX_LAYOUTRTL; 1651 } 1652 } 1653 } 1654 } 1655 1656 /* Automatically add WS_EX_WINDOWEDGE */ 1657 if ((Cs->dwExStyle & WS_EX_DLGMODALFRAME) || 1658 ((!(Cs->dwExStyle & WS_EX_STATICEDGE)) && 1659 (Cs->style & (WS_DLGFRAME | WS_THICKFRAME)))) 1660 Cs->dwExStyle |= WS_EX_WINDOWEDGE; 1661 else 1662 Cs->dwExStyle &= ~WS_EX_WINDOWEDGE; 1663 1664 /* Is it a unicode window? */ 1665 bUnicodeWindow =!(Cs->dwExStyle & WS_EX_SETANSICREATOR); 1666 Cs->dwExStyle &= ~WS_EX_SETANSICREATOR; 1667 1668 /* Allocate the new window */ 1669 pWnd = (PWND) UserCreateObject( gHandleTable, 1670 pdeskCreated ? pdeskCreated : pti->rpdesk, 1671 pti, 1672 (PHANDLE)&hWnd, 1673 TYPE_WINDOW, 1674 sizeof(WND) + Class->cbwndExtra); 1675 1676 if (!pWnd) 1677 { 1678 goto AllocError; 1679 } 1680 1681 TRACE("Created window object with handle %p\n", hWnd); 1682 1683 if (pdeskCreated && pdeskCreated->DesktopWindow == NULL ) 1684 { /* HACK: Helper for win32csr/desktopbg.c */ 1685 /* If there is no desktop window yet, we must be creating it */ 1686 TRACE("CreateWindow setting desktop.\n"); 1687 pdeskCreated->DesktopWindow = hWnd; 1688 pdeskCreated->pDeskInfo->spwnd = pWnd; 1689 } 1690 1691 /* 1692 * Fill out the structure describing it. 1693 */ 1694 /* Remember, pWnd->head is setup in object.c ... */ 1695 pWnd->spwndParent = ParentWindow; 1696 pWnd->spwndOwner = OwnerWindow; 1697 pWnd->fnid = 0; 1698 pWnd->spwndLastActive = pWnd; 1699 // Ramp up compatible version sets. 1700 if ( dwVer >= WINVER_WIN31 ) 1701 { 1702 pWnd->state2 |= WNDS2_WIN31COMPAT; 1703 if ( dwVer >= WINVER_WINNT4 ) 1704 { 1705 pWnd->state2 |= WNDS2_WIN40COMPAT; 1706 if ( dwVer >= WINVER_WIN2K ) 1707 { 1708 pWnd->state2 |= WNDS2_WIN50COMPAT; 1709 } 1710 } 1711 } 1712 pWnd->pcls = Class; 1713 pWnd->hModule = Cs->hInstance; 1714 pWnd->style = Cs->style & ~WS_VISIBLE; 1715 pWnd->ExStyle = Cs->dwExStyle; 1716 pWnd->cbwndExtra = pWnd->pcls->cbwndExtra; 1717 pWnd->pActCtx = acbiBuffer; 1718 pWnd->InternalPos.MaxPos.x = pWnd->InternalPos.MaxPos.y = -1; 1719 pWnd->InternalPos.IconPos.x = pWnd->InternalPos.IconPos.y = -1; 1720 1721 if (pWnd->spwndParent != NULL && Cs->hwndParent != 0) 1722 { 1723 pWnd->HideFocus = pWnd->spwndParent->HideFocus; 1724 pWnd->HideAccel = pWnd->spwndParent->HideAccel; 1725 } 1726 1727 pWnd->head.pti->cWindows++; 1728 1729 if (Class->spicn && !Class->spicnSm) 1730 { 1731 HICON IconSmHandle = NULL; 1732 if((Class->spicn->CURSORF_flags & (CURSORF_LRSHARED | CURSORF_FROMRESOURCE)) 1733 == (CURSORF_LRSHARED | CURSORF_FROMRESOURCE)) 1734 { 1735 IconSmHandle = co_IntCopyImage( 1736 UserHMGetHandle(Class->spicn), 1737 IMAGE_ICON, 1738 UserGetSystemMetrics( SM_CXSMICON ), 1739 UserGetSystemMetrics( SM_CYSMICON ), 1740 LR_COPYFROMRESOURCE); 1741 } 1742 if (!IconSmHandle) 1743 { 1744 /* Retry without copying from resource */ 1745 IconSmHandle = co_IntCopyImage( 1746 UserHMGetHandle(Class->spicn), 1747 IMAGE_ICON, 1748 UserGetSystemMetrics( SM_CXSMICON ), 1749 UserGetSystemMetrics( SM_CYSMICON ), 1750 0); 1751 } 1752 1753 if (IconSmHandle) 1754 { 1755 Class->spicnSm = UserGetCurIconObject(IconSmHandle); 1756 Class->CSF_flags |= CSF_CACHEDSMICON; 1757 } 1758 } 1759 1760 if (pWnd->pcls->CSF_flags & CSF_SERVERSIDEPROC) 1761 pWnd->state |= WNDS_SERVERSIDEWINDOWPROC; 1762 1763 /* BugBoy Comments: Comment below say that System classes are always created 1764 as UNICODE. In windows, creating a window with the ANSI version of CreateWindow 1765 sets the window to ansi as verified by testing with IsUnicodeWindow API. 1766 1767 No where can I see in code or through testing does the window change back 1768 to ANSI after being created as UNICODE in ROS. I didnt do more testing to 1769 see what problems this would cause. */ 1770 1771 // Set WndProc from Class. 1772 pWnd->lpfnWndProc = pWnd->pcls->lpfnWndProc; 1773 1774 // GetWindowProc, test for non server side default classes and set WndProc. 1775 if ( pWnd->pcls->fnid <= FNID_GHOST && pWnd->pcls->fnid >= FNID_BUTTON ) 1776 { 1777 if (bUnicodeWindow) 1778 { 1779 if (GETPFNCLIENTA(pWnd->pcls->fnid) == pWnd->lpfnWndProc) 1780 pWnd->lpfnWndProc = GETPFNCLIENTW(pWnd->pcls->fnid); 1781 } 1782 else 1783 { 1784 if (GETPFNCLIENTW(pWnd->pcls->fnid) == pWnd->lpfnWndProc) 1785 pWnd->lpfnWndProc = GETPFNCLIENTA(pWnd->pcls->fnid); 1786 } 1787 } 1788 1789 // If not an Unicode caller, set Ansi creator bit. 1790 if (!bUnicodeWindow) pWnd->state |= WNDS_ANSICREATOR; 1791 1792 // Clone Class Ansi/Unicode proc type. 1793 if (pWnd->pcls->CSF_flags & CSF_ANSIPROC) 1794 { 1795 pWnd->state |= WNDS_ANSIWINDOWPROC; 1796 pWnd->Unicode = FALSE; 1797 } 1798 else 1799 { /* 1800 * It seems there can be both an Ansi creator and Unicode Class Window 1801 * WndProc, unless the following overriding conditions occur: 1802 */ 1803 if ( !bUnicodeWindow && 1804 ( Class->atomClassName == gpsi->atomSysClass[ICLS_BUTTON] || 1805 Class->atomClassName == gpsi->atomSysClass[ICLS_COMBOBOX] || 1806 Class->atomClassName == gpsi->atomSysClass[ICLS_COMBOLBOX] || 1807 Class->atomClassName == gpsi->atomSysClass[ICLS_DIALOG] || 1808 Class->atomClassName == gpsi->atomSysClass[ICLS_EDIT] || 1809 Class->atomClassName == gpsi->atomSysClass[ICLS_IME] || 1810 Class->atomClassName == gpsi->atomSysClass[ICLS_LISTBOX] || 1811 Class->atomClassName == gpsi->atomSysClass[ICLS_MDICLIENT] || 1812 Class->atomClassName == gpsi->atomSysClass[ICLS_STATIC] ) ) 1813 { // Override Class and set the window Ansi WndProc. 1814 pWnd->state |= WNDS_ANSIWINDOWPROC; 1815 pWnd->Unicode = FALSE; 1816 } 1817 else 1818 { // Set the window Unicode WndProc. 1819 pWnd->state &= ~WNDS_ANSIWINDOWPROC; 1820 pWnd->Unicode = TRUE; 1821 } 1822 } 1823 1824 /* BugBoy Comments: if the window being created is a edit control, ATOM 0xCxxx, 1825 then my testing shows that windows (2k and XP) creates a CallProc for it immediately 1826 Dont understand why it does this. */ 1827 if (Class->atomClassName == gpsi->atomSysClass[ICLS_EDIT]) 1828 { 1829 PCALLPROCDATA CallProc; 1830 CallProc = CreateCallProc(pWnd->head.rpdesk, pWnd->lpfnWndProc, pWnd->Unicode , pWnd->head.pti->ppi); 1831 1832 if (!CallProc) 1833 { 1834 EngSetLastError(ERROR_NOT_ENOUGH_MEMORY); 1835 ERR("Warning: Unable to create CallProc for edit control. Control may not operate correctly! hwnd %p\n", hWnd); 1836 } 1837 else 1838 { 1839 UserAddCallProcToClass(pWnd->pcls, CallProc); 1840 } 1841 } 1842 1843 InitializeListHead(&pWnd->PropListHead); 1844 pWnd->PropListItems = 0; 1845 1846 if ( WindowName->Buffer != NULL && WindowName->Length > 0 ) 1847 { 1848 pWnd->strName.Buffer = DesktopHeapAlloc(pWnd->head.rpdesk, 1849 WindowName->Length + sizeof(UNICODE_NULL)); 1850 if (pWnd->strName.Buffer == NULL) 1851 { 1852 goto AllocError; 1853 } 1854 1855 RtlCopyMemory(pWnd->strName.Buffer, WindowName->Buffer, WindowName->Length); 1856 pWnd->strName.Buffer[WindowName->Length / sizeof(WCHAR)] = L'\0'; 1857 pWnd->strName.Length = WindowName->Length; 1858 pWnd->strName.MaximumLength = WindowName->Length + sizeof(UNICODE_NULL); 1859 } 1860 1861 /* Correct the window style. */ 1862 if ((pWnd->style & (WS_CHILD | WS_POPUP)) != WS_CHILD) 1863 { 1864 pWnd->style |= WS_CLIPSIBLINGS; 1865 if (!(pWnd->style & WS_POPUP)) 1866 { 1867 pWnd->style |= WS_CAPTION; 1868 } 1869 } 1870 1871 /* WS_EX_WINDOWEDGE depends on some other styles */ 1872 if (pWnd->ExStyle & WS_EX_DLGMODALFRAME) 1873 pWnd->ExStyle |= WS_EX_WINDOWEDGE; 1874 else if (pWnd->style & (WS_DLGFRAME | WS_THICKFRAME)) 1875 { 1876 if (!((pWnd->ExStyle & WS_EX_STATICEDGE) && 1877 (pWnd->style & (WS_CHILD | WS_POPUP)))) 1878 pWnd->ExStyle |= WS_EX_WINDOWEDGE; 1879 } 1880 else 1881 pWnd->ExStyle &= ~WS_EX_WINDOWEDGE; 1882 1883 if (!(pWnd->style & (WS_CHILD | WS_POPUP))) 1884 pWnd->state |= WNDS_SENDSIZEMOVEMSGS; 1885 1886 /* Set the window menu */ 1887 if ((Cs->style & (WS_CHILD | WS_POPUP)) != WS_CHILD) 1888 { 1889 if (Cs->hMenu) 1890 { 1891 IntSetMenu(pWnd, Cs->hMenu, &MenuChanged); 1892 } 1893 else if (pWnd->pcls->lpszMenuName) // Take it from the parent. 1894 { 1895 UNICODE_STRING MenuName; 1896 HMENU hMenu; 1897 1898 if (IS_INTRESOURCE(pWnd->pcls->lpszMenuName)) 1899 { 1900 MenuName.Length = 0; 1901 MenuName.MaximumLength = 0; 1902 MenuName.Buffer = pWnd->pcls->lpszMenuName; 1903 } 1904 else 1905 { 1906 RtlInitUnicodeString( &MenuName, pWnd->pcls->lpszMenuName); 1907 } 1908 hMenu = co_IntCallLoadMenu( pWnd->pcls->hModule, &MenuName); 1909 if (hMenu) IntSetMenu(pWnd, hMenu, &MenuChanged); 1910 } 1911 } 1912 else // Not a child 1913 pWnd->IDMenu = (UINT_PTR)Cs->hMenu; 1914 1915 1916 if ( ParentWindow && 1917 ParentWindow != ParentWindow->head.rpdesk->spwndMessage && 1918 ParentWindow != ParentWindow->head.rpdesk->pDeskInfo->spwnd ) 1919 { 1920 PWND Owner = IntGetNonChildAncestor(ParentWindow); 1921 1922 if (!IntValidateOwnerDepth(pWnd, Owner)) 1923 { 1924 EngSetLastError(ERROR_INVALID_PARAMETER); 1925 goto Error; 1926 } 1927 if ( pWnd->spwndOwner && 1928 pWnd->spwndOwner->ExStyle & WS_EX_TOPMOST ) 1929 { 1930 pWnd->ExStyle |= WS_EX_TOPMOST; 1931 } 1932 if ( pWnd->spwndOwner && 1933 Class->atomClassName != gpsi->atomSysClass[ICLS_IME] && 1934 pti != pWnd->spwndOwner->head.pti) 1935 { 1936 //ERR("CreateWindow Owner in.\n"); 1937 UserAttachThreadInput(pti, pWnd->spwndOwner->head.pti, TRUE); 1938 } 1939 } 1940 1941 /* Insert the window into the thread's window list. */ 1942 InsertTailList (&pti->WindowListHead, &pWnd->ThreadListEntry); 1943 1944 /* Handle "CS_CLASSDC", it is tested first. */ 1945 if ( (pWnd->pcls->style & CS_CLASSDC) && !(pWnd->pcls->pdce) ) 1946 { /* One DCE per class to have CLASS. */ 1947 pWnd->pcls->pdce = DceAllocDCE( pWnd, DCE_CLASS_DC ); 1948 } 1949 else if ( pWnd->pcls->style & CS_OWNDC) 1950 { /* Allocate a DCE for this window. */ 1951 DceAllocDCE(pWnd, DCE_WINDOW_DC); 1952 } 1953 1954 return pWnd; 1955 1956 AllocError: 1957 ERR("IntCreateWindow Allocation Error.\n"); 1958 SetLastNtError(STATUS_INSUFFICIENT_RESOURCES); 1959 Error: 1960 if(pWnd) 1961 UserDereferenceObject(pWnd); 1962 return NULL; 1963 } 1964 1965 /* 1966 * @implemented 1967 */ 1968 PWND FASTCALL 1969 co_UserCreateWindowEx(CREATESTRUCTW* Cs, 1970 PUNICODE_STRING ClassName, 1971 PLARGE_STRING WindowName, 1972 PVOID acbiBuffer, 1973 DWORD dwVer ) 1974 { 1975 ULONG style; 1976 PWND Window = NULL, ParentWindow = NULL, OwnerWindow; 1977 HWND hWnd, hWndParent, hWndOwner, hwndInsertAfter; 1978 PWINSTATION_OBJECT WinSta; 1979 PCLS Class = NULL; 1980 SIZE Size; 1981 POINT MaxSize, MaxPos, MinTrack, MaxTrack; 1982 CBT_CREATEWNDW * pCbtCreate; 1983 LRESULT Result; 1984 USER_REFERENCE_ENTRY ParentRef, Ref; 1985 PTHREADINFO pti; 1986 DWORD dwShowMode = SW_SHOW; 1987 CREATESTRUCTW *pCsw = NULL; 1988 PVOID pszClass = NULL, pszName = NULL; 1989 PWND ret = NULL; 1990 1991 /* Get the current window station and reference it */ 1992 pti = GetW32ThreadInfo(); 1993 if (pti == NULL || pti->rpdesk == NULL) 1994 { 1995 ERR("Thread is not attached to a desktop! Cannot create window!\n"); 1996 return NULL; // There is nothing to cleanup. 1997 } 1998 WinSta = pti->rpdesk->rpwinstaParent; 1999 ObReferenceObjectByPointer(WinSta, KernelMode, ExWindowStationObjectType, 0); 2000 2001 pCsw = NULL; 2002 pCbtCreate = NULL; 2003 2004 /* Get the class and reference it */ 2005 Class = IntGetAndReferenceClass(ClassName, Cs->hInstance, FALSE); 2006 if(!Class) 2007 { 2008 EngSetLastError(ERROR_CANNOT_FIND_WND_CLASS); 2009 ERR("Failed to find class %wZ\n", ClassName); 2010 goto cleanup; 2011 } 2012 2013 /* Now find the parent and the owner window */ 2014 hWndParent = pti->rpdesk->pDeskInfo->spwnd->head.h; 2015 hWndOwner = NULL; 2016 2017 if (Cs->hwndParent == HWND_MESSAGE) 2018 { 2019 Cs->hwndParent = hWndParent = pti->rpdesk->spwndMessage->head.h; 2020 } 2021 else if (Cs->hwndParent) 2022 { 2023 if ((Cs->style & (WS_CHILD|WS_POPUP)) != WS_CHILD) 2024 hWndOwner = Cs->hwndParent; 2025 else 2026 hWndParent = Cs->hwndParent; 2027 } 2028 else if ((Cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD) 2029 { 2030 ERR("Cannot create a child window without a parent!\n"); 2031 EngSetLastError(ERROR_TLW_WITH_WSCHILD); 2032 goto cleanup; /* WS_CHILD needs a parent, but WS_POPUP doesn't */ 2033 } 2034 else if (Cs->lpszClass != (LPCWSTR)MAKEINTATOM(gpsi->atomSysClass[ICLS_DESKTOP]) && 2035 (IS_INTRESOURCE(Cs->lpszClass) || 2036 Cs->lpszClass != (LPCWSTR)MAKEINTATOM(gpsi->atomSysClass[ICLS_HWNDMESSAGE]) || 2037 _wcsicmp(Cs->lpszClass, L"Message") != 0)) 2038 { 2039 if (pti->ppi->dwLayout & LAYOUT_RTL) 2040 { 2041 Cs->dwExStyle |= WS_EX_LAYOUTRTL; 2042 } 2043 } 2044 2045 ParentWindow = hWndParent ? UserGetWindowObject(hWndParent): NULL; 2046 OwnerWindow = hWndOwner ? UserGetWindowObject(hWndOwner): NULL; 2047 2048 if (hWndParent && !ParentWindow) 2049 { 2050 ERR("Got invalid parent window handle\n"); 2051 goto cleanup; 2052 } 2053 else if (hWndOwner && !OwnerWindow) 2054 { 2055 ERR("Got invalid owner window handle\n"); 2056 ParentWindow = NULL; 2057 goto cleanup; 2058 } 2059 2060 if(OwnerWindow) 2061 { 2062 if (IntIsDesktopWindow(OwnerWindow)) OwnerWindow = NULL; 2063 else if (ParentWindow && !IntIsDesktopWindow(ParentWindow)) 2064 { 2065 ERR("an owned window must be created as top-level\n"); 2066 EngSetLastError( STATUS_ACCESS_DENIED ); 2067 goto cleanup; 2068 } 2069 else /* owner must be a top-level window */ 2070 { 2071 while ((OwnerWindow->style & (WS_POPUP|WS_CHILD)) == WS_CHILD && !IntIsDesktopWindow(OwnerWindow->spwndParent)) 2072 OwnerWindow = OwnerWindow->spwndParent; 2073 } 2074 } 2075 2076 /* Fix the position and the size of the window */ 2077 if (ParentWindow) 2078 { 2079 UserRefObjectCo(ParentWindow, &ParentRef); 2080 IntFixWindowCoordinates(Cs, ParentWindow, &dwShowMode); 2081 } 2082 2083 /* Allocate and initialize the new window */ 2084 Window = IntCreateWindow(Cs, 2085 WindowName, 2086 Class, 2087 ParentWindow, 2088 OwnerWindow, 2089 acbiBuffer, 2090 NULL, 2091 dwVer ); 2092 if(!Window) 2093 { 2094 ERR("IntCreateWindow failed!\n"); 2095 goto cleanup; 2096 } 2097 2098 hWnd = UserHMGetHandle(Window); 2099 hwndInsertAfter = HWND_TOP; 2100 2101 UserRefObjectCo(Window, &Ref); 2102 UserDereferenceObject(Window); 2103 ObDereferenceObject(WinSta); 2104 2105 //// Check for a hook to eliminate overhead. //// 2106 if ( ISITHOOKED(WH_CBT) || (pti->rpdesk->pDeskInfo->fsHooks & HOOKID_TO_FLAG(WH_CBT)) ) 2107 { 2108 // Allocate the calling structures Justin Case this goes Global. 2109 pCsw = ExAllocatePoolWithTag(NonPagedPool, sizeof(CREATESTRUCTW), TAG_HOOK); 2110 pCbtCreate = ExAllocatePoolWithTag(NonPagedPool, sizeof(CBT_CREATEWNDW), TAG_HOOK); 2111 if (!pCsw || !pCbtCreate) 2112 { 2113 ERR("UserHeapAlloc() failed!\n"); 2114 goto cleanup; 2115 } 2116 2117 /* Fill the new CREATESTRUCTW */ 2118 RtlCopyMemory(pCsw, Cs, sizeof(CREATESTRUCTW)); 2119 pCsw->style = Window->style; /* HCBT_CREATEWND needs the real window style */ 2120 2121 // Based on the assumption this is from "unicode source" user32, ReactOS, answer is yes. 2122 if (!IS_ATOM(ClassName->Buffer)) 2123 { 2124 if (Window->state & WNDS_ANSICREATOR) 2125 { 2126 ANSI_STRING AnsiString; 2127 AnsiString.MaximumLength = (USHORT)RtlUnicodeStringToAnsiSize(ClassName)+sizeof(CHAR); 2128 pszClass = UserHeapAlloc(AnsiString.MaximumLength); 2129 if (!pszClass) 2130 { 2131 ERR("UserHeapAlloc() failed!\n"); 2132 goto cleanup; 2133 } 2134 RtlZeroMemory(pszClass, AnsiString.MaximumLength); 2135 AnsiString.Buffer = (PCHAR)pszClass; 2136 RtlUnicodeStringToAnsiString(&AnsiString, ClassName, FALSE); 2137 } 2138 else 2139 { 2140 UNICODE_STRING UnicodeString; 2141 UnicodeString.MaximumLength = ClassName->Length + sizeof(UNICODE_NULL); 2142 pszClass = UserHeapAlloc(UnicodeString.MaximumLength); 2143 if (!pszClass) 2144 { 2145 ERR("UserHeapAlloc() failed!\n"); 2146 goto cleanup; 2147 } 2148 RtlZeroMemory(pszClass, UnicodeString.MaximumLength); 2149 UnicodeString.Buffer = (PWSTR)pszClass; 2150 RtlCopyUnicodeString(&UnicodeString, ClassName); 2151 } 2152 pCsw->lpszClass = UserHeapAddressToUser(pszClass); 2153 } 2154 if (WindowName->Length) 2155 { 2156 UNICODE_STRING Name; 2157 Name.Buffer = WindowName->Buffer; 2158 Name.Length = (USHORT)min(WindowName->Length, MAXUSHORT); // FIXME: LARGE_STRING truncated 2159 Name.MaximumLength = (USHORT)min(WindowName->MaximumLength, MAXUSHORT); 2160 2161 if (Window->state & WNDS_ANSICREATOR) 2162 { 2163 ANSI_STRING AnsiString; 2164 AnsiString.MaximumLength = (USHORT)RtlUnicodeStringToAnsiSize(&Name) + sizeof(CHAR); 2165 pszName = UserHeapAlloc(AnsiString.MaximumLength); 2166 if (!pszName) 2167 { 2168 ERR("UserHeapAlloc() failed!\n"); 2169 goto cleanup; 2170 } 2171 RtlZeroMemory(pszName, AnsiString.MaximumLength); 2172 AnsiString.Buffer = (PCHAR)pszName; 2173 RtlUnicodeStringToAnsiString(&AnsiString, &Name, FALSE); 2174 } 2175 else 2176 { 2177 UNICODE_STRING UnicodeString; 2178 UnicodeString.MaximumLength = Name.Length + sizeof(UNICODE_NULL); 2179 pszName = UserHeapAlloc(UnicodeString.MaximumLength); 2180 if (!pszName) 2181 { 2182 ERR("UserHeapAlloc() failed!\n"); 2183 goto cleanup; 2184 } 2185 RtlZeroMemory(pszName, UnicodeString.MaximumLength); 2186 UnicodeString.Buffer = (PWSTR)pszName; 2187 RtlCopyUnicodeString(&UnicodeString, &Name); 2188 } 2189 pCsw->lpszName = UserHeapAddressToUser(pszName); 2190 } 2191 2192 pCbtCreate->lpcs = pCsw; 2193 pCbtCreate->hwndInsertAfter = hwndInsertAfter; 2194 2195 //// Call the WH_CBT hook //// 2196 Result = co_HOOK_CallHooks(WH_CBT, HCBT_CREATEWND, (WPARAM) hWnd, (LPARAM) pCbtCreate); 2197 if (Result != 0) 2198 { 2199 ERR("WH_CBT HCBT_CREATEWND hook failed! 0x%x\n", Result); 2200 goto cleanup; 2201 } 2202 // Write back changes. 2203 Cs->cx = pCsw->cx; 2204 Cs->cy = pCsw->cy; 2205 Cs->x = pCsw->x; 2206 Cs->y = pCsw->y; 2207 hwndInsertAfter = pCbtCreate->hwndInsertAfter; 2208 } 2209 2210 /* NCCREATE and WM_NCCALCSIZE need the original values */ 2211 Cs->lpszName = (LPCWSTR) WindowName; 2212 Cs->lpszClass = (LPCWSTR) ClassName; 2213 2214 if ((Cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD) 2215 { 2216 if (ParentWindow != co_GetDesktopWindow(Window)) 2217 { 2218 Cs->x += ParentWindow->rcClient.left; 2219 Cs->y += ParentWindow->rcClient.top; 2220 } 2221 } 2222 2223 /* Send the WM_GETMINMAXINFO message */ 2224 Size.cx = Cs->cx; 2225 Size.cy = Cs->cy; 2226 2227 if ((Cs->style & WS_THICKFRAME) || !(Cs->style & (WS_POPUP | WS_CHILD))) 2228 { 2229 co_WinPosGetMinMaxInfo(Window, &MaxSize, &MaxPos, &MinTrack, &MaxTrack); 2230 if (Size.cx > MaxTrack.x) Size.cx = MaxTrack.x; 2231 if (Size.cy > MaxTrack.y) Size.cy = MaxTrack.y; 2232 if (Size.cx < MinTrack.x) Size.cx = MinTrack.x; 2233 if (Size.cy < MinTrack.y) Size.cy = MinTrack.y; 2234 } 2235 2236 Window->rcWindow.left = Cs->x; 2237 Window->rcWindow.top = Cs->y; 2238 Window->rcWindow.right = Cs->x + Size.cx; 2239 Window->rcWindow.bottom = Cs->y + Size.cy; 2240 /* 2241 if (0 != (Window->style & WS_CHILD) && ParentWindow) 2242 { 2243 ERR("co_UserCreateWindowEx(): Offset rcWindow\n"); 2244 RECTL_vOffsetRect(&Window->rcWindow, 2245 ParentWindow->rcClient.left, 2246 ParentWindow->rcClient.top); 2247 } 2248 */ 2249 /* correct child window coordinates if mirroring on parent is enabled */ 2250 if (ParentWindow != NULL) 2251 { 2252 if ( ((Cs->style & WS_CHILD) == WS_CHILD) && 2253 ((ParentWindow->ExStyle & WS_EX_LAYOUTRTL) == WS_EX_LAYOUTRTL)) 2254 { 2255 Window->rcWindow.right = ParentWindow->rcClient.right - (Window->rcWindow.left - ParentWindow->rcClient.left); 2256 Window->rcWindow.left = Window->rcWindow.right - Size.cx; 2257 } 2258 } 2259 2260 Window->rcClient = Window->rcWindow; 2261 2262 /* Link the window */ 2263 if (NULL != ParentWindow) 2264 { 2265 /* Link the window into the siblings list */ 2266 if ((Cs->style & (WS_CHILD|WS_MAXIMIZE)) == WS_CHILD) 2267 IntLinkHwnd(Window, HWND_BOTTOM); 2268 else 2269 IntLinkHwnd(Window, hwndInsertAfter); 2270 } 2271 2272 if (!(Window->state2 & WNDS2_WIN31COMPAT)) 2273 { 2274 if (Class->style & CS_PARENTDC && !(ParentWindow->style & WS_CLIPCHILDREN)) 2275 Window->style &= ~(WS_CLIPSIBLINGS | WS_CLIPCHILDREN); 2276 } 2277 2278 if ((Window->style & (WS_CHILD | WS_POPUP)) == WS_CHILD) 2279 { 2280 if ( !IntIsTopLevelWindow(Window) ) 2281 { 2282 if (pti != Window->spwndParent->head.pti) 2283 { 2284 //ERR("CreateWindow Parent in.\n"); 2285 UserAttachThreadInput(pti, Window->spwndParent->head.pti, TRUE); 2286 } 2287 } 2288 } 2289 2290 /* Send the NCCREATE message */ 2291 Result = co_IntSendMessage(UserHMGetHandle(Window), WM_NCCREATE, 0, (LPARAM) Cs); 2292 if (!Result) 2293 { 2294 ERR("co_UserCreateWindowEx(): NCCREATE message failed\n"); 2295 goto cleanup; 2296 } 2297 2298 /* Send the WM_NCCALCSIZE message */ 2299 { 2300 // RECT rc; 2301 MaxPos.x = Window->rcWindow.left; 2302 MaxPos.y = Window->rcWindow.top; 2303 2304 Result = co_WinPosGetNonClientSize(Window, &Window->rcWindow, &Window->rcClient); 2305 //rc = Window->rcWindow; 2306 //Result = co_IntSendMessageNoWait(Window->head.h, WM_NCCALCSIZE, FALSE, (LPARAM)&rc); 2307 //Window->rcClient = rc; 2308 2309 RECTL_vOffsetRect(&Window->rcWindow, MaxPos.x - Window->rcWindow.left, 2310 MaxPos.y - Window->rcWindow.top); 2311 } 2312 2313 /* Send the WM_CREATE message. */ 2314 Result = co_IntSendMessage(UserHMGetHandle(Window), WM_CREATE, 0, (LPARAM) Cs); 2315 if (Result == (LRESULT)-1) 2316 { 2317 ERR("co_UserCreateWindowEx(): WM_CREATE message failed\n"); 2318 goto cleanup; 2319 } 2320 2321 /* Send the EVENT_OBJECT_CREATE event */ 2322 IntNotifyWinEvent(EVENT_OBJECT_CREATE, Window, OBJID_WINDOW, CHILDID_SELF, 0); 2323 2324 /* By setting the flag below it can be examined to determine if the window 2325 was created successfully and a valid pwnd was passed back to caller since 2326 from here the function has to succeed. */ 2327 Window->state2 |= WNDS2_WMCREATEMSGPROCESSED; 2328 2329 /* Send the WM_SIZE and WM_MOVE messages. */ 2330 if (!(Window->state & WNDS_SENDSIZEMOVEMSGS)) 2331 { 2332 co_WinPosSendSizeMove(Window); 2333 } 2334 2335 /* Show or maybe minimize or maximize the window. */ 2336 2337 style = IntSetStyle( Window, 0, WS_MAXIMIZE | WS_MINIMIZE ); 2338 if (style & (WS_MINIMIZE | WS_MAXIMIZE)) 2339 { 2340 RECTL NewPos; 2341 UINT SwFlag = (style & WS_MINIMIZE) ? SW_MINIMIZE : SW_MAXIMIZE; 2342 2343 SwFlag = co_WinPosMinMaximize(Window, SwFlag, &NewPos); 2344 SwFlag |= SWP_NOZORDER|SWP_FRAMECHANGED; /* Frame always gets changed */ 2345 if (!(style & WS_VISIBLE) || (style & WS_CHILD) || UserGetActiveWindow()) SwFlag |= SWP_NOACTIVATE; 2346 co_WinPosSetWindowPos(Window, 0, NewPos.left, NewPos.top, 2347 NewPos.right, NewPos.bottom, SwFlag); 2348 } 2349 2350 /* Send the WM_PARENTNOTIFY message */ 2351 IntSendParentNotify(Window, WM_CREATE); 2352 2353 /* Notify the shell that a new window was created */ 2354 if (UserIsDesktopWindow(Window->spwndParent) && 2355 Window->spwndOwner == NULL && 2356 (Window->style & WS_VISIBLE) && 2357 (!(Window->ExStyle & WS_EX_TOOLWINDOW) || 2358 (Window->ExStyle & WS_EX_APPWINDOW))) 2359 { 2360 co_IntShellHookNotify(HSHELL_WINDOWCREATED, (WPARAM)hWnd, 0); 2361 } 2362 2363 /* Initialize and show the window's scrollbars */ 2364 if (Window->style & WS_VSCROLL) 2365 { 2366 co_UserShowScrollBar(Window, SB_VERT, FALSE, TRUE); 2367 } 2368 if (Window->style & WS_HSCROLL) 2369 { 2370 co_UserShowScrollBar(Window, SB_HORZ, TRUE, FALSE); 2371 } 2372 2373 /* Show the new window */ 2374 if (Cs->style & WS_VISIBLE) 2375 { 2376 if (Window->style & WS_MAXIMIZE) 2377 dwShowMode = SW_SHOW; 2378 else if (Window->style & WS_MINIMIZE) 2379 dwShowMode = SW_SHOWMINIMIZED; 2380 2381 co_WinPosShowWindow(Window, dwShowMode); 2382 2383 if (Window->ExStyle & WS_EX_MDICHILD) 2384 { 2385 ASSERT(ParentWindow); 2386 if(!ParentWindow) 2387 goto cleanup; 2388 co_IntSendMessage(UserHMGetHandle(ParentWindow), WM_MDIREFRESHMENU, 0, 0); 2389 /* ShowWindow won't activate child windows */ 2390 co_WinPosSetWindowPos(Window, HWND_TOP, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE); 2391 } 2392 } 2393 2394 if (Class->atomClassName == gaGuiConsoleWndClass) 2395 { 2396 /* Count only console windows manually */ 2397 co_IntUserManualGuiCheck(TRUE); 2398 } 2399 2400 TRACE("co_UserCreateWindowEx(): Created window %p\n", hWnd); 2401 ret = Window; 2402 2403 cleanup: 2404 if (!ret) 2405 { 2406 TRACE("co_UserCreateWindowEx(): Error Created window!\n"); 2407 /* If the window was created, the class will be dereferenced by co_UserDestroyWindow */ 2408 if (Window) 2409 co_UserDestroyWindow(Window); 2410 else if (Class) 2411 IntDereferenceClass(Class, pti->pDeskInfo, pti->ppi); 2412 } 2413 2414 if (pCsw) ExFreePoolWithTag(pCsw, TAG_HOOK); 2415 if (pCbtCreate) ExFreePoolWithTag(pCbtCreate, TAG_HOOK); 2416 if (pszName) UserHeapFree(pszName); 2417 if (pszClass) UserHeapFree(pszClass); 2418 2419 if (Window) 2420 { 2421 UserDerefObjectCo(Window); 2422 } 2423 if (ParentWindow) UserDerefObjectCo(ParentWindow); 2424 2425 // See CORE-13717, not setting error on success. 2426 if (ret) 2427 EngSetLastError(ERROR_SUCCESS); 2428 2429 return ret; 2430 } 2431 2432 NTSTATUS 2433 NTAPI 2434 ProbeAndCaptureLargeString( 2435 OUT PLARGE_STRING plstrSafe, 2436 IN PLARGE_STRING plstrUnsafe) 2437 { 2438 LARGE_STRING lstrTemp; 2439 PVOID pvBuffer = NULL; 2440 2441 _SEH2_TRY 2442 { 2443 /* Probe and copy the string */ 2444 ProbeForRead(plstrUnsafe, sizeof(LARGE_STRING), sizeof(ULONG)); 2445 lstrTemp = *plstrUnsafe; 2446 } 2447 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) 2448 { 2449 /* Fail */ 2450 _SEH2_YIELD(return _SEH2_GetExceptionCode();) 2451 } 2452 _SEH2_END 2453 2454 if (lstrTemp.Length != 0) 2455 { 2456 /* Allocate a buffer from paged pool */ 2457 pvBuffer = ExAllocatePoolWithTag(PagedPool, lstrTemp.Length, TAG_STRING); 2458 if (!pvBuffer) 2459 { 2460 return STATUS_NO_MEMORY; 2461 } 2462 2463 _SEH2_TRY 2464 { 2465 /* Probe and copy the buffer */ 2466 ProbeForRead(lstrTemp.Buffer, lstrTemp.Length, sizeof(WCHAR)); 2467 RtlCopyMemory(pvBuffer, lstrTemp.Buffer, lstrTemp.Length); 2468 } 2469 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) 2470 { 2471 /* Cleanup and fail */ 2472 ExFreePoolWithTag(pvBuffer, TAG_STRING); 2473 _SEH2_YIELD(return _SEH2_GetExceptionCode();) 2474 } 2475 _SEH2_END 2476 } 2477 2478 /* Set the output string */ 2479 plstrSafe->Buffer = pvBuffer; 2480 plstrSafe->Length = lstrTemp.Length; 2481 plstrSafe->MaximumLength = lstrTemp.Length; 2482 2483 return STATUS_SUCCESS; 2484 } 2485 2486 /** 2487 * \todo Allow passing plstrClassName as ANSI. 2488 */ 2489 HWND 2490 NTAPI 2491 NtUserCreateWindowEx( 2492 DWORD dwExStyle, 2493 PLARGE_STRING plstrClassName, 2494 PLARGE_STRING plstrClsVersion, 2495 PLARGE_STRING plstrWindowName, 2496 DWORD dwStyle, 2497 int x, 2498 int y, 2499 int nWidth, 2500 int nHeight, 2501 HWND hWndParent, 2502 HMENU hMenu, 2503 HINSTANCE hInstance, 2504 LPVOID lpParam, 2505 DWORD dwFlags, 2506 PVOID acbiBuffer) 2507 { 2508 NTSTATUS Status; 2509 LARGE_STRING lstrWindowName; 2510 LARGE_STRING lstrClassName; 2511 LARGE_STRING lstrClsVersion; 2512 UNICODE_STRING ustrClassName; 2513 UNICODE_STRING ustrClsVersion; 2514 CREATESTRUCTW Cs; 2515 HWND hwnd = NULL; 2516 PWND pwnd; 2517 2518 lstrWindowName.Buffer = NULL; 2519 lstrClassName.Buffer = NULL; 2520 lstrClsVersion.Buffer = NULL; 2521 2522 ASSERT(plstrWindowName); 2523 2524 if ( (dwStyle & (WS_POPUP|WS_CHILD)) != WS_CHILD) 2525 { 2526 /* check hMenu is valid handle */ 2527 if (hMenu && !UserGetMenuObject(hMenu)) 2528 { 2529 ERR("NtUserCreateWindowEx: Got an invalid menu handle!\n"); 2530 EngSetLastError(ERROR_INVALID_MENU_HANDLE); 2531 return NULL; 2532 } 2533 } 2534 2535 /* Copy the window name to kernel mode */ 2536 Status = ProbeAndCaptureLargeString(&lstrWindowName, plstrWindowName); 2537 if (!NT_SUCCESS(Status)) 2538 { 2539 ERR("NtUserCreateWindowEx: failed to capture plstrWindowName\n"); 2540 SetLastNtError(Status); 2541 return NULL; 2542 } 2543 2544 plstrWindowName = &lstrWindowName; 2545 2546 /* Check if the class is an atom */ 2547 if (IS_ATOM(plstrClassName)) 2548 { 2549 /* It is, pass the atom in the UNICODE_STRING */ 2550 ustrClassName.Buffer = (PVOID)plstrClassName; 2551 ustrClassName.Length = 0; 2552 ustrClassName.MaximumLength = 0; 2553 } 2554 else 2555 { 2556 /* It's not, capture the class name */ 2557 Status = ProbeAndCaptureLargeString(&lstrClassName, plstrClassName); 2558 if (!NT_SUCCESS(Status)) 2559 { 2560 ERR("NtUserCreateWindowEx: failed to capture plstrClassName\n"); 2561 /* Set last error, cleanup and return */ 2562 SetLastNtError(Status); 2563 goto cleanup; 2564 } 2565 2566 /* We pass it on as a UNICODE_STRING */ 2567 ustrClassName.Buffer = lstrClassName.Buffer; 2568 ustrClassName.Length = (USHORT)min(lstrClassName.Length, MAXUSHORT); // FIXME: LARGE_STRING truncated 2569 ustrClassName.MaximumLength = (USHORT)min(lstrClassName.MaximumLength, MAXUSHORT); 2570 } 2571 2572 /* Check if the class version is an atom */ 2573 if (IS_ATOM(plstrClsVersion)) 2574 { 2575 /* It is, pass the atom in the UNICODE_STRING */ 2576 ustrClsVersion.Buffer = (PVOID)plstrClsVersion; 2577 ustrClsVersion.Length = 0; 2578 ustrClsVersion.MaximumLength = 0; 2579 } 2580 else 2581 { 2582 /* It's not, capture the class name */ 2583 Status = ProbeAndCaptureLargeString(&lstrClsVersion, plstrClsVersion); 2584 if (!NT_SUCCESS(Status)) 2585 { 2586 ERR("NtUserCreateWindowEx: failed to capture plstrClsVersion\n"); 2587 /* Set last error, cleanup and return */ 2588 SetLastNtError(Status); 2589 goto cleanup; 2590 } 2591 2592 /* We pass it on as a UNICODE_STRING */ 2593 ustrClsVersion.Buffer = lstrClsVersion.Buffer; 2594 ustrClsVersion.Length = (USHORT)min(lstrClsVersion.Length, MAXUSHORT); // FIXME: LARGE_STRING truncated 2595 ustrClsVersion.MaximumLength = (USHORT)min(lstrClsVersion.MaximumLength, MAXUSHORT); 2596 } 2597 2598 /* Fill the CREATESTRUCTW */ 2599 /* we will keep here the original parameters */ 2600 Cs.style = dwStyle; 2601 Cs.lpCreateParams = lpParam; 2602 Cs.hInstance = hInstance; 2603 Cs.hMenu = hMenu; 2604 Cs.hwndParent = hWndParent; 2605 Cs.cx = nWidth; 2606 Cs.cy = nHeight; 2607 Cs.x = x; 2608 Cs.y = y; 2609 Cs.lpszName = (LPCWSTR) plstrWindowName->Buffer; 2610 Cs.lpszClass = ustrClassName.Buffer; 2611 Cs.dwExStyle = dwExStyle; 2612 2613 UserEnterExclusive(); 2614 2615 /* Call the internal function */ 2616 pwnd = co_UserCreateWindowEx(&Cs, &ustrClsVersion, plstrWindowName, acbiBuffer, dwFlags); 2617 2618 if(!pwnd) 2619 { 2620 ERR("co_UserCreateWindowEx failed!\n"); 2621 } 2622 hwnd = pwnd ? UserHMGetHandle(pwnd) : NULL; 2623 2624 UserLeave(); 2625 2626 cleanup: 2627 if (lstrWindowName.Buffer) 2628 { 2629 ExFreePoolWithTag(lstrWindowName.Buffer, TAG_STRING); 2630 } 2631 if (lstrClassName.Buffer) 2632 { 2633 ExFreePoolWithTag(lstrClassName.Buffer, TAG_STRING); 2634 } 2635 if (lstrClsVersion.Buffer) 2636 { 2637 ExFreePoolWithTag(lstrClsVersion.Buffer, TAG_STRING); 2638 } 2639 2640 return hwnd; 2641 } 2642 2643 2644 BOOLEAN co_UserDestroyWindow(PVOID Object) 2645 { 2646 HWND hWnd; 2647 PWND pwndTemp; 2648 PTHREADINFO ti; 2649 MSG msg; 2650 PWND Window = Object; 2651 2652 ASSERT_REFS_CO(Window); // FIXME: Temp HACK? 2653 2654 hWnd = Window->head.h; 2655 ti = PsGetCurrentThreadWin32Thread(); 2656 2657 TRACE("co_UserDestroyWindow(Window = 0x%p, hWnd = 0x%p)\n", Window, hWnd); 2658 2659 /* Check for owner thread */ 2660 if ( Window->head.pti != PsGetCurrentThreadWin32Thread()) 2661 { 2662 /* Check if we are destroying the desktop window */ 2663 if (! ((Window->head.rpdesk->dwDTFlags & DF_DESTROYED) && Window == Window->head.rpdesk->pDeskInfo->spwnd)) 2664 { 2665 EngSetLastError(ERROR_ACCESS_DENIED); 2666 return FALSE; 2667 } 2668 } 2669 2670 /* If window was created successfully and it is hooked */ 2671 if ((Window->state2 & WNDS2_WMCREATEMSGPROCESSED)) 2672 { 2673 if (co_HOOK_CallHooks(WH_CBT, HCBT_DESTROYWND, (WPARAM) hWnd, 0)) 2674 { 2675 ERR("Destroy Window WH_CBT Call Hook return!\n"); 2676 return FALSE; 2677 } 2678 } 2679 2680 if (Window->pcls->atomClassName != gpsi->atomSysClass[ICLS_IME]) 2681 { 2682 if ((Window->style & (WS_POPUP|WS_CHILD)) != WS_CHILD) 2683 { 2684 if (Window->spwndOwner) 2685 { 2686 //ERR("DestroyWindow Owner out.\n"); 2687 UserAttachThreadInput(Window->head.pti, Window->spwndOwner->head.pti, FALSE); 2688 } 2689 } 2690 } 2691 2692 /* Inform the parent */ 2693 if (Window->style & WS_CHILD) 2694 { 2695 IntSendParentNotify(Window, WM_DESTROY); 2696 } 2697 2698 if (!Window->spwndOwner && !IntGetParent(Window)) 2699 { 2700 co_IntShellHookNotify(HSHELL_WINDOWDESTROYED, (WPARAM) hWnd, 0); 2701 } 2702 2703 /* Hide the window */ 2704 if (Window->style & WS_VISIBLE) 2705 { 2706 if (Window->style & WS_CHILD) 2707 { 2708 /* Only child windows receive WM_SHOWWINDOW in DestroyWindow() */ 2709 co_WinPosShowWindow(Window, SW_HIDE); 2710 } 2711 else 2712 { 2713 co_WinPosSetWindowPos(Window, 0, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_HIDEWINDOW ); 2714 } 2715 } 2716 2717 /* Adjust last active */ 2718 if ((pwndTemp = Window->spwndOwner)) 2719 { 2720 while (pwndTemp->spwndOwner) 2721 pwndTemp = pwndTemp->spwndOwner; 2722 2723 if (pwndTemp->spwndLastActive == Window) 2724 pwndTemp->spwndLastActive = Window->spwndOwner; 2725 } 2726 2727 if (Window->spwndParent && IntIsWindow(UserHMGetHandle(Window))) 2728 { 2729 if ((Window->style & (WS_POPUP | WS_CHILD)) == WS_CHILD) 2730 { 2731 if (!IntIsTopLevelWindow(Window)) 2732 { 2733 //ERR("DestroyWindow Parent out.\n"); 2734 UserAttachThreadInput(Window->head.pti, Window->spwndParent->head.pti, FALSE); 2735 } 2736 } 2737 } 2738 2739 if (Window->head.pti->MessageQueue->spwndActive == Window) 2740 Window->head.pti->MessageQueue->spwndActive = NULL; 2741 if (Window->head.pti->MessageQueue->spwndFocus == Window) 2742 Window->head.pti->MessageQueue->spwndFocus = NULL; 2743 if (Window->head.pti->MessageQueue->spwndActivePrev == Window) 2744 Window->head.pti->MessageQueue->spwndActivePrev = NULL; 2745 if (Window->head.pti->MessageQueue->spwndCapture == Window) 2746 Window->head.pti->MessageQueue->spwndCapture = NULL; 2747 2748 /* 2749 * Check if this window is the Shell's Desktop Window. If so set hShellWindow to NULL 2750 */ 2751 2752 if ((ti != NULL) && (ti->pDeskInfo != NULL)) 2753 { 2754 if (ti->pDeskInfo->hShellWindow == hWnd) 2755 { 2756 ERR("Destroying the ShellWindow!\n"); 2757 ti->pDeskInfo->hShellWindow = NULL; 2758 } 2759 } 2760 2761 IntEngWindowChanged(Window, WOC_DELETE); 2762 2763 if (!IntIsWindow(UserHMGetHandle(Window))) 2764 { 2765 return TRUE; 2766 } 2767 2768 /* Recursively destroy owned windows */ 2769 if (!(Window->style & WS_CHILD)) 2770 { 2771 HWND* List; 2772 HWND* phWnd; 2773 PWND pWnd; 2774 2775 List = IntWinListOwnedPopups(Window); 2776 if (List) 2777 { 2778 for (phWnd = List; *phWnd; ++phWnd) 2779 { 2780 pWnd = ValidateHwndNoErr(*phWnd); 2781 if (pWnd == NULL) 2782 continue; 2783 ASSERT(pWnd->spwndOwner == Window); 2784 ASSERT(pWnd != Window); 2785 2786 pWnd->spwndOwner = NULL; 2787 if (IntWndBelongsToThread(pWnd, PsGetCurrentThreadWin32Thread())) 2788 { 2789 USER_REFERENCE_ENTRY Ref; 2790 UserRefObjectCo(pWnd, &Ref); // Temp HACK? 2791 co_UserDestroyWindow(pWnd); 2792 UserDerefObjectCo(pWnd); // Temp HACK? 2793 } 2794 else 2795 { 2796 ERR("IntWndBelongsToThread(0x%p) is FALSE, ignoring.\n", pWnd); 2797 } 2798 } 2799 2800 ExFreePoolWithTag(List, USERTAG_WINDOWLIST); 2801 } 2802 } 2803 2804 /* Generate mouse move message for the next window */ 2805 msg.message = WM_MOUSEMOVE; 2806 msg.wParam = UserGetMouseButtonsState(); 2807 msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y); 2808 msg.pt = gpsi->ptCursor; 2809 co_MsqInsertMouseMessage(&msg, 0, 0, TRUE); 2810 2811 IntNotifyWinEvent(EVENT_OBJECT_DESTROY, Window, OBJID_WINDOW, CHILDID_SELF, 0); 2812 2813 /* Send destroy messages */ 2814 IntSendDestroyMsg(UserHMGetHandle(Window)); 2815 2816 if (!IntIsWindow(UserHMGetHandle(Window))) 2817 { 2818 return TRUE; 2819 } 2820 2821 /* Destroy the window storage */ 2822 co_UserFreeWindow(Window, PsGetCurrentProcessWin32Process(), PsGetCurrentThreadWin32Thread(), TRUE); 2823 2824 return TRUE; 2825 } 2826 2827 2828 /* 2829 * @implemented 2830 */ 2831 BOOLEAN APIENTRY 2832 NtUserDestroyWindow(HWND Wnd) 2833 { 2834 PWND Window; 2835 DECLARE_RETURN(BOOLEAN); 2836 BOOLEAN ret; 2837 USER_REFERENCE_ENTRY Ref; 2838 2839 TRACE("Enter NtUserDestroyWindow\n"); 2840 UserEnterExclusive(); 2841 2842 if (!(Window = UserGetWindowObject(Wnd))) 2843 { 2844 RETURN(FALSE); 2845 } 2846 2847 UserRefObjectCo(Window, &Ref); // FIXME: Dunno if win should be reffed during destroy... 2848 ret = co_UserDestroyWindow(Window); 2849 UserDerefObjectCo(Window); // FIXME: Dunno if win should be reffed during destroy... 2850 2851 RETURN(ret); 2852 2853 CLEANUP: 2854 TRACE("Leave NtUserDestroyWindow, ret=%u\n", _ret_); 2855 UserLeave(); 2856 END_CLEANUP; 2857 } 2858 2859 2860 static HWND FASTCALL 2861 IntFindWindow(PWND Parent, 2862 PWND ChildAfter, 2863 RTL_ATOM ClassAtom, 2864 PUNICODE_STRING WindowName) 2865 { 2866 BOOL CheckWindowName; 2867 HWND *List, *phWnd; 2868 HWND Ret = NULL; 2869 UNICODE_STRING CurrentWindowName; 2870 2871 ASSERT(Parent); 2872 2873 CheckWindowName = WindowName->Buffer != 0; 2874 2875 if((List = IntWinListChildren(Parent))) 2876 { 2877 phWnd = List; 2878 if(ChildAfter) 2879 { 2880 /* skip handles before and including ChildAfter */ 2881 while(*phWnd && (*(phWnd++) != ChildAfter->head.h)) 2882 ; 2883 } 2884 2885 /* search children */ 2886 while(*phWnd) 2887 { 2888 PWND Child; 2889 if(!(Child = UserGetWindowObject(*(phWnd++)))) 2890 { 2891 continue; 2892 } 2893 2894 /* Do not send WM_GETTEXT messages in the kernel mode version! 2895 The user mode version however calls GetWindowText() which will 2896 send WM_GETTEXT messages to windows belonging to its processes */ 2897 if (!ClassAtom || Child->pcls->atomNVClassName == ClassAtom) 2898 { 2899 // FIXME: LARGE_STRING truncated 2900 CurrentWindowName.Buffer = Child->strName.Buffer; 2901 CurrentWindowName.Length = (USHORT)min(Child->strName.Length, MAXUSHORT); 2902 CurrentWindowName.MaximumLength = (USHORT)min(Child->strName.MaximumLength, MAXUSHORT); 2903 if(!CheckWindowName || 2904 (Child->strName.Length < 0xFFFF && 2905 !RtlCompareUnicodeString(WindowName, &CurrentWindowName, TRUE))) 2906 { 2907 Ret = Child->head.h; 2908 break; 2909 } 2910 } 2911 } 2912 ExFreePoolWithTag(List, USERTAG_WINDOWLIST); 2913 } 2914 2915 return Ret; 2916 } 2917 2918 /* 2919 * FUNCTION: 2920 * Searches a window's children for a window with the specified 2921 * class and name 2922 * ARGUMENTS: 2923 * hwndParent = The window whose childs are to be searched. 2924 * NULL = desktop 2925 * HWND_MESSAGE = message-only windows 2926 * 2927 * hwndChildAfter = Search starts after this child window. 2928 * NULL = start from beginning 2929 * 2930 * ucClassName = Class name to search for 2931 * Reguired parameter. 2932 * 2933 * ucWindowName = Window name 2934 * ->Buffer == NULL = don't care 2935 * 2936 * RETURNS: 2937 * The HWND of the window if it was found, otherwise NULL 2938 */ 2939 /* 2940 * @implemented 2941 */ 2942 HWND APIENTRY 2943 NtUserFindWindowEx(HWND hwndParent, 2944 HWND hwndChildAfter, 2945 PUNICODE_STRING ucClassName, 2946 PUNICODE_STRING ucWindowName, 2947 DWORD dwUnknown) 2948 { 2949 PWND Parent, ChildAfter; 2950 UNICODE_STRING ClassName = {0}, WindowName = {0}; 2951 HWND Desktop, Ret = NULL; 2952 BOOL DoMessageWnd = FALSE; 2953 RTL_ATOM ClassAtom = (RTL_ATOM)0; 2954 DECLARE_RETURN(HWND); 2955 2956 TRACE("Enter NtUserFindWindowEx\n"); 2957 UserEnterShared(); 2958 2959 if (ucClassName != NULL || ucWindowName != NULL) 2960 { 2961 _SEH2_TRY 2962 { 2963 if (ucClassName != NULL) 2964 { 2965 ClassName = ProbeForReadUnicodeString(ucClassName); 2966 if (ClassName.Length != 0) 2967 { 2968 ProbeForRead(ClassName.Buffer, 2969 ClassName.Length, 2970 sizeof(WCHAR)); 2971 } 2972 else if (!IS_ATOM(ClassName.Buffer)) 2973 { 2974 EngSetLastError(ERROR_INVALID_PARAMETER); 2975 _SEH2_LEAVE; 2976 } 2977 2978 if (!IntGetAtomFromStringOrAtom(&ClassName, 2979 &ClassAtom)) 2980 { 2981 EngSetLastError(ERROR_CANNOT_FIND_WND_CLASS); 2982 _SEH2_LEAVE; 2983 } 2984 } 2985 2986 if (ucWindowName != NULL) 2987 { 2988 WindowName = ProbeForReadUnicodeString(ucWindowName); 2989 if (WindowName.Length != 0) 2990 { 2991 ProbeForRead(WindowName.Buffer, 2992 WindowName.Length, 2993 sizeof(WCHAR)); 2994 } 2995 } 2996 } 2997 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) 2998 { 2999 SetLastNtError(_SEH2_GetExceptionCode()); 3000 _SEH2_YIELD(RETURN(NULL)); 3001 } 3002 _SEH2_END; 3003 3004 if (ucClassName != NULL) 3005 { 3006 if (ClassName.Length == 0 && ClassName.Buffer != NULL && 3007 !IS_ATOM(ClassName.Buffer)) 3008 { 3009 EngSetLastError(ERROR_INVALID_PARAMETER); 3010 RETURN(NULL); 3011 } 3012 else if (ClassAtom == (RTL_ATOM)0) 3013 { 3014 /* LastError code was set by IntGetAtomFromStringOrAtom */ 3015 RETURN(NULL); 3016 } 3017 } 3018 } 3019 3020 Desktop = IntGetCurrentThreadDesktopWindow(); 3021 3022 if(hwndParent == NULL) 3023 { 3024 hwndParent = Desktop; 3025 DoMessageWnd = TRUE; 3026 } 3027 else if(hwndParent == HWND_MESSAGE) 3028 { 3029 hwndParent = IntGetMessageWindow(); 3030 } 3031 3032 if(!(Parent = UserGetWindowObject(hwndParent))) 3033 { 3034 RETURN( NULL); 3035 } 3036 3037 ChildAfter = NULL; 3038 if(hwndChildAfter && !(ChildAfter = UserGetWindowObject(hwndChildAfter))) 3039 { 3040 RETURN( NULL); 3041 } 3042 3043 _SEH2_TRY 3044 { 3045 if(Parent->head.h == Desktop) 3046 { 3047 HWND *List, *phWnd; 3048 PWND TopLevelWindow; 3049 BOOLEAN CheckWindowName; 3050 BOOLEAN WindowMatches; 3051 BOOLEAN ClassMatches; 3052 3053 /* windows searches through all top-level windows if the parent is the desktop 3054 window */ 3055 3056 if((List = IntWinListChildren(Parent))) 3057 { 3058 phWnd = List; 3059 3060 if(ChildAfter) 3061 { 3062 /* skip handles before and including ChildAfter */ 3063 while(*phWnd && (*(phWnd++) != ChildAfter->head.h)) 3064 ; 3065 } 3066 3067 CheckWindowName = WindowName.Buffer != 0; 3068 3069 /* search children */ 3070 while(*phWnd) 3071 { 3072 UNICODE_STRING ustr; 3073 3074 if(!(TopLevelWindow = UserGetWindowObject(*(phWnd++)))) 3075 { 3076 continue; 3077 } 3078 3079 /* Do not send WM_GETTEXT messages in the kernel mode version! 3080 The user mode version however calls GetWindowText() which will 3081 send WM_GETTEXT messages to windows belonging to its processes */ 3082 ustr.Buffer = TopLevelWindow->strName.Buffer; 3083 ustr.Length = (USHORT)min(TopLevelWindow->strName.Length, MAXUSHORT); // FIXME:LARGE_STRING truncated 3084 ustr.MaximumLength = (USHORT)min(TopLevelWindow->strName.MaximumLength, MAXUSHORT); 3085 WindowMatches = !CheckWindowName || 3086 (TopLevelWindow->strName.Length < 0xFFFF && 3087 !RtlCompareUnicodeString(&WindowName, &ustr, TRUE)); 3088 ClassMatches = (ClassAtom == (RTL_ATOM)0) || 3089 ClassAtom == TopLevelWindow->pcls->atomNVClassName; 3090 3091 if (WindowMatches && ClassMatches) 3092 { 3093 Ret = TopLevelWindow->head.h; 3094 break; 3095 } 3096 3097 if (IntFindWindow(TopLevelWindow, NULL, ClassAtom, &WindowName)) 3098 { 3099 /* window returns the handle of the top-level window, in case it found 3100 the child window */ 3101 Ret = TopLevelWindow->head.h; 3102 break; 3103 } 3104 3105 } 3106 ExFreePoolWithTag(List, USERTAG_WINDOWLIST); 3107 } 3108 } 3109 else 3110 { 3111 TRACE("FindWindowEx: Not Desktop Parent!\n"); 3112 Ret = IntFindWindow(Parent, ChildAfter, ClassAtom, &WindowName); 3113 } 3114 3115 if (Ret == NULL && DoMessageWnd) 3116 { 3117 PWND MsgWindows; 3118 3119 if((MsgWindows = UserGetWindowObject(IntGetMessageWindow()))) 3120 { 3121 Ret = IntFindWindow(MsgWindows, ChildAfter, ClassAtom, &WindowName); 3122 } 3123 } 3124 } 3125 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) 3126 { 3127 SetLastNtError(_SEH2_GetExceptionCode()); 3128 Ret = NULL; 3129 } 3130 _SEH2_END; 3131 3132 RETURN( Ret); 3133 3134 CLEANUP: 3135 TRACE("Leave NtUserFindWindowEx, ret %p\n", _ret_); 3136 UserLeave(); 3137 END_CLEANUP; 3138 } 3139 3140 3141 /* 3142 * @implemented 3143 */ 3144 PWND FASTCALL UserGetAncestor(PWND Wnd, UINT Type) 3145 { 3146 PWND WndAncestor, Parent; 3147 3148 if (Wnd->head.h == IntGetDesktopWindow()) 3149 { 3150 return NULL; 3151 } 3152 3153 switch (Type) 3154 { 3155 case GA_PARENT: 3156 { 3157 WndAncestor = Wnd->spwndParent; 3158 break; 3159 } 3160 3161 case GA_ROOT: 3162 { 3163 WndAncestor = Wnd; 3164 Parent = NULL; 3165 3166 for(;;) 3167 { 3168 if(!(Parent = WndAncestor->spwndParent)) 3169 { 3170 break; 3171 } 3172 if(IntIsDesktopWindow(Parent)) 3173 { 3174 break; 3175 } 3176 3177 WndAncestor = Parent; 3178 } 3179 break; 3180 } 3181 3182 case GA_ROOTOWNER: 3183 { 3184 WndAncestor = Wnd; 3185 3186 for (;;) 3187 { 3188 Parent = IntGetParent(WndAncestor); 3189 3190 if (!Parent) 3191 { 3192 break; 3193 } 3194 3195 WndAncestor = Parent; 3196 } 3197 break; 3198 } 3199 3200 default: 3201 { 3202 return NULL; 3203 } 3204 } 3205 3206 return WndAncestor; 3207 } 3208 3209 /* 3210 * @implemented 3211 */ 3212 HWND APIENTRY 3213 NtUserGetAncestor(HWND hWnd, UINT Type) 3214 { 3215 PWND Window, Ancestor; 3216 DECLARE_RETURN(HWND); 3217 3218 TRACE("Enter NtUserGetAncestor\n"); 3219 UserEnterExclusive(); 3220 3221 if (!(Window = UserGetWindowObject(hWnd))) 3222 { 3223 RETURN(NULL); 3224 } 3225 3226 Ancestor = UserGetAncestor(Window, Type); 3227 /* faxme: can UserGetAncestor ever return NULL for a valid window? */ 3228 3229 RETURN(Ancestor ? Ancestor->head.h : NULL); 3230 3231 CLEANUP: 3232 TRACE("Leave NtUserGetAncestor, ret=%p\n", _ret_); 3233 UserLeave(); 3234 END_CLEANUP; 3235 } 3236 3237 //// 3238 //// ReactOS work around! Keep it the sames as in Combo.c and Controls.h 3239 //// 3240 /* combo state struct */ 3241 typedef struct 3242 { 3243 HWND self; 3244 HWND owner; 3245 UINT dwStyle; 3246 HWND hWndEdit; 3247 HWND hWndLBox; 3248 UINT wState; 3249 HFONT hFont; 3250 RECT textRect; 3251 RECT buttonRect; 3252 RECT droppedRect; 3253 INT droppedIndex; 3254 INT fixedOwnerDrawHeight; 3255 INT droppedWidth; /* last two are not used unless set */ 3256 INT editHeight; /* explicitly */ 3257 LONG UIState; 3258 } HEADCOMBO,*LPHEADCOMBO; 3259 3260 // Window Extra data container. 3261 typedef struct _WND2CBOX 3262 { 3263 WND; 3264 LPHEADCOMBO pCBox; 3265 } WND2CBOX, *PWND2CBOX; 3266 3267 #define CBF_BUTTONDOWN 0x0002 3268 //// 3269 //// 3270 //// 3271 BOOL 3272 APIENTRY 3273 NtUserGetComboBoxInfo( 3274 HWND hWnd, 3275 PCOMBOBOXINFO pcbi) 3276 { 3277 PWND Wnd; 3278 PPROCESSINFO ppi; 3279 BOOL NotSameppi = FALSE; 3280 BOOL Ret = TRUE; 3281 DECLARE_RETURN(BOOL); 3282 3283 TRACE("Enter NtUserGetComboBoxInfo\n"); 3284 UserEnterShared(); 3285 3286 if (!(Wnd = UserGetWindowObject(hWnd))) 3287 { 3288 RETURN( FALSE ); 3289 } 3290 _SEH2_TRY 3291 { 3292 ProbeForWrite(pcbi, sizeof(COMBOBOXINFO), 1); 3293 } 3294 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) 3295 { 3296 SetLastNtError(_SEH2_GetExceptionCode()); 3297 _SEH2_YIELD(RETURN(FALSE)); 3298 } 3299 _SEH2_END; 3300 3301 if (pcbi->cbSize < sizeof(COMBOBOXINFO)) 3302 { 3303 EngSetLastError(ERROR_INVALID_PARAMETER); 3304 RETURN(FALSE); 3305 } 3306 3307 // Pass the user pointer, it was already probed. 3308 if ((Wnd->pcls->atomClassName != gpsi->atomSysClass[ICLS_COMBOBOX]) && Wnd->fnid != FNID_COMBOBOX) 3309 { 3310 RETURN( (BOOL) co_IntSendMessage( Wnd->head.h, CB_GETCOMBOBOXINFO, 0, (LPARAM)pcbi)); 3311 } 3312 3313 ppi = PsGetCurrentProcessWin32Process(); 3314 NotSameppi = ppi != Wnd->head.pti->ppi; 3315 if (NotSameppi) 3316 { 3317 KeAttachProcess(&Wnd->head.pti->ppi->peProcess->Pcb); 3318 } 3319 3320 _SEH2_TRY 3321 { 3322 LPHEADCOMBO lphc = ((PWND2CBOX)Wnd)->pCBox; 3323 pcbi->rcItem = lphc->textRect; 3324 pcbi->rcButton = lphc->buttonRect; 3325 pcbi->stateButton = 0; 3326 if (lphc->wState & CBF_BUTTONDOWN) 3327 pcbi->stateButton |= STATE_SYSTEM_PRESSED; 3328 if (RECTL_bIsEmptyRect(&lphc->buttonRect)) 3329 pcbi->stateButton |= STATE_SYSTEM_INVISIBLE; 3330 pcbi->hwndCombo = lphc->self; 3331 pcbi->hwndItem = lphc->hWndEdit; 3332 pcbi->hwndList = lphc->hWndLBox; 3333 } 3334 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) 3335 { 3336 Ret = FALSE; 3337 SetLastNtError(_SEH2_GetExceptionCode()); 3338 } 3339 _SEH2_END; 3340 3341 RETURN( Ret); 3342 3343 CLEANUP: 3344 if (NotSameppi) KeDetachProcess(); 3345 TRACE("Leave NtUserGetComboBoxInfo, ret=%i\n",_ret_); 3346 UserLeave(); 3347 END_CLEANUP; 3348 } 3349 3350 //// 3351 //// ReactOS work around! Keep it the sames as in Listbox.c 3352 //// 3353 /* Listbox structure */ 3354 typedef struct 3355 { 3356 HWND self; /* Our own window handle */ 3357 HWND owner; /* Owner window to send notifications to */ 3358 UINT style; /* Window style */ 3359 INT width; /* Window width */ 3360 INT height; /* Window height */ 3361 VOID *items; /* Array of items */ 3362 INT nb_items; /* Number of items */ 3363 INT top_item; /* Top visible item */ 3364 INT selected_item; /* Selected item */ 3365 INT focus_item; /* Item that has the focus */ 3366 INT anchor_item; /* Anchor item for extended selection */ 3367 INT item_height; /* Default item height */ 3368 INT page_size; /* Items per listbox page */ 3369 INT column_width; /* Column width for multi-column listboxes */ 3370 } LB_DESCR; 3371 3372 // Window Extra data container. 3373 typedef struct _WND2LB 3374 { 3375 WND; 3376 LB_DESCR * pLBiv; 3377 } WND2LB, *PWND2LB; 3378 //// 3379 //// 3380 //// 3381 DWORD 3382 APIENTRY 3383 NtUserGetListBoxInfo( 3384 HWND hWnd) 3385 { 3386 PWND Wnd; 3387 PPROCESSINFO ppi; 3388 BOOL NotSameppi = FALSE; 3389 DWORD Ret = 0; 3390 DECLARE_RETURN(DWORD); 3391 3392 TRACE("Enter NtUserGetListBoxInfo\n"); 3393 UserEnterShared(); 3394 3395 if (!(Wnd = UserGetWindowObject(hWnd))) 3396 { 3397 RETURN( 0 ); 3398 } 3399 3400 if ((Wnd->pcls->atomClassName != gpsi->atomSysClass[ICLS_LISTBOX]) && Wnd->fnid != FNID_LISTBOX) 3401 { 3402 RETURN( (DWORD) co_IntSendMessage( Wnd->head.h, LB_GETLISTBOXINFO, 0, 0 )); 3403 } 3404 3405 // wine lisbox:test_GetListBoxInfo lb_getlistboxinfo = 0, should not send a message! 3406 ppi = PsGetCurrentProcessWin32Process(); 3407 NotSameppi = ppi != Wnd->head.pti->ppi; 3408 if (NotSameppi) 3409 { 3410 KeAttachProcess(&Wnd->head.pti->ppi->peProcess->Pcb); 3411 } 3412 3413 _SEH2_TRY 3414 { 3415 LB_DESCR *descr = ((PWND2LB)Wnd)->pLBiv; 3416 // See Controls ListBox.c:LB_GETLISTBOXINFO must match... 3417 if (descr->style & LBS_MULTICOLUMN) //// ReactOS 3418 Ret = descr->page_size * descr->column_width; 3419 else 3420 Ret = descr->page_size; 3421 } 3422 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) 3423 { 3424 Ret = 0; 3425 SetLastNtError(_SEH2_GetExceptionCode()); 3426 } 3427 _SEH2_END; 3428 3429 RETURN( Ret); 3430 3431 CLEANUP: 3432 if (NotSameppi) KeDetachProcess(); 3433 TRACE("Leave NtUserGetListBoxInfo, ret=%lu\n", _ret_); 3434 UserLeave(); 3435 END_CLEANUP; 3436 } 3437 3438 /* 3439 * NtUserSetParent 3440 * 3441 * The NtUserSetParent function changes the parent window of the specified 3442 * child window. 3443 * 3444 * Remarks 3445 * The new parent window and the child window must belong to the same 3446 * application. If the window identified by the hWndChild parameter is 3447 * visible, the system performs the appropriate redrawing and repainting. 3448 * For compatibility reasons, NtUserSetParent does not modify the WS_CHILD 3449 * or WS_POPUP window styles of the window whose parent is being changed. 3450 * 3451 * Status 3452 * @implemented 3453 */ 3454 3455 HWND APIENTRY 3456 NtUserSetParent(HWND hWndChild, HWND hWndNewParent) 3457 { 3458 DECLARE_RETURN(HWND); 3459 3460 TRACE("Enter NtUserSetParent\n"); 3461 UserEnterExclusive(); 3462 3463 /* 3464 Check Parent first from user space, set it here. 3465 */ 3466 if (!hWndNewParent) 3467 { 3468 hWndNewParent = IntGetDesktopWindow(); 3469 } 3470 else if (hWndNewParent == HWND_MESSAGE) 3471 { 3472 hWndNewParent = IntGetMessageWindow(); 3473 } 3474 3475 RETURN( co_UserSetParent(hWndChild, hWndNewParent)); 3476 3477 CLEANUP: 3478 TRACE("Leave NtUserSetParent, ret=%p\n", _ret_); 3479 UserLeave(); 3480 END_CLEANUP; 3481 } 3482 3483 /* 3484 * UserGetShellWindow 3485 * 3486 * Returns a handle to shell window that was set by NtUserSetShellWindowEx. 3487 * 3488 * Status 3489 * @implemented 3490 */ 3491 HWND FASTCALL UserGetShellWindow(VOID) 3492 { 3493 PWINSTATION_OBJECT WinStaObject; 3494 HWND Ret; 3495 3496 NTSTATUS Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation, 3497 UserMode, 3498 0, 3499 &WinStaObject, 3500 0); 3501 3502 if (!NT_SUCCESS(Status)) 3503 { 3504 SetLastNtError(Status); 3505 return( (HWND)0); 3506 } 3507 3508 Ret = (HWND)WinStaObject->ShellWindow; 3509 3510 ObDereferenceObject(WinStaObject); 3511 return( Ret); 3512 } 3513 3514 /* 3515 * NtUserSetShellWindowEx 3516 * 3517 * This is undocumented function to set global shell window. The global 3518 * shell window has special handling of window position. 3519 * 3520 * Status 3521 * @implemented 3522 */ 3523 BOOL APIENTRY 3524 NtUserSetShellWindowEx(HWND hwndShell, HWND hwndListView) 3525 { 3526 PWINSTATION_OBJECT WinStaObject; 3527 PWND WndShell, WndListView; 3528 DECLARE_RETURN(BOOL); 3529 USER_REFERENCE_ENTRY Ref; 3530 NTSTATUS Status; 3531 PTHREADINFO ti; 3532 3533 TRACE("Enter NtUserSetShellWindowEx\n"); 3534 UserEnterExclusive(); 3535 3536 if (!(WndShell = UserGetWindowObject(hwndShell))) 3537 { 3538 RETURN(FALSE); 3539 } 3540 3541 if (!(WndListView = UserGetWindowObject(hwndListView))) 3542 { 3543 RETURN(FALSE); 3544 } 3545 3546 Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation, 3547 UserMode, 3548 0, 3549 &WinStaObject, 3550 0); 3551 3552 if (!NT_SUCCESS(Status)) 3553 { 3554 SetLastNtError(Status); 3555 RETURN( FALSE); 3556 } 3557 3558 /* 3559 * Test if we are permitted to change the shell window. 3560 */ 3561 if (WinStaObject->ShellWindow) 3562 { 3563 ObDereferenceObject(WinStaObject); 3564 RETURN( FALSE); 3565 } 3566 3567 /* 3568 * Move shell window into background. 3569 */ 3570 if (hwndListView && hwndListView != hwndShell) 3571 { 3572 /* 3573 * Disabled for now to get Explorer working. 3574 * -- Filip, 01/nov/2003 3575 */ 3576 #if 0 3577 co_WinPosSetWindowPos(WndListView, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE); 3578 #endif 3579 3580 if (WndListView->ExStyle & WS_EX_TOPMOST) 3581 { 3582 ObDereferenceObject(WinStaObject); 3583 RETURN( FALSE); 3584 } 3585 } 3586 3587 if (WndShell->ExStyle & WS_EX_TOPMOST) 3588 { 3589 ObDereferenceObject(WinStaObject); 3590 RETURN( FALSE); 3591 } 3592 3593 UserRefObjectCo(WndShell, &Ref); 3594 WndShell->state2 |= WNDS2_BOTTOMMOST; 3595 co_WinPosSetWindowPos(WndShell, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE); 3596 3597 WinStaObject->ShellWindow = hwndShell; 3598 WinStaObject->ShellListView = hwndListView; 3599 3600 ti = GetW32ThreadInfo(); 3601 if (ti->pDeskInfo) 3602 { 3603 ti->pDeskInfo->hShellWindow = hwndShell; 3604 ti->pDeskInfo->spwndShell = WndShell; 3605 ti->pDeskInfo->spwndBkGnd = WndListView; 3606 ti->pDeskInfo->ppiShellProcess = ti->ppi; 3607 } 3608 3609 UserRegisterHotKey(WndShell, SC_TASKLIST, MOD_CONTROL, VK_ESCAPE); 3610 3611 UserDerefObjectCo(WndShell); 3612 3613 ObDereferenceObject(WinStaObject); 3614 RETURN( TRUE); 3615 3616 CLEANUP: 3617 TRACE("Leave NtUserSetShellWindowEx, ret=%i\n",_ret_); 3618 UserLeave(); 3619 END_CLEANUP; 3620 } 3621 3622 // Fixes wine Win test_window_styles and todo tests... 3623 static BOOL FASTCALL 3624 IntCheckFrameEdge(ULONG Style, ULONG ExStyle) 3625 { 3626 if (ExStyle & WS_EX_DLGMODALFRAME) 3627 return TRUE; 3628 else if (!(ExStyle & WS_EX_STATICEDGE) && (Style & (WS_DLGFRAME | WS_THICKFRAME))) 3629 return TRUE; 3630 else 3631 return FALSE; 3632 } 3633 3634 static LONG_PTR 3635 co_IntSetWindowLongPtr(HWND hWnd, DWORD Index, LONG_PTR NewValue, BOOL Ansi, ULONG Size, BOOL bAlter) 3636 { 3637 PWND Window, Parent; 3638 PWINSTATION_OBJECT WindowStation; 3639 LONG_PTR OldValue; 3640 STYLESTRUCT Style; 3641 3642 if (!(Window = UserGetWindowObject(hWnd))) 3643 { 3644 return( 0); 3645 } 3646 3647 if ((INT)Index >= 0) 3648 { 3649 if ((Index + Size) > Window->cbwndExtra) 3650 { 3651 EngSetLastError(ERROR_INVALID_INDEX); 3652 return( 0); 3653 } 3654 3655 #ifdef _WIN64 3656 if (Size == sizeof(LONG)) 3657 { 3658 OldValue = *((LONG *)((PCHAR)(Window + 1) + Index)); 3659 *((LONG*)((PCHAR)(Window + 1) + Index)) = (LONG)NewValue; 3660 } 3661 else 3662 #endif 3663 { 3664 OldValue = *((LONG_PTR *)((PCHAR)(Window + 1) + Index)); 3665 /* 3666 if ( Index == DWLP_DLGPROC && Wnd->state & WNDS_DIALOGWINDOW) 3667 { 3668 OldValue = (LONG_PTR)IntSetWindowProc( Wnd, (WNDPROC)NewValue, Ansi); 3669 if (!OldValue) return 0; 3670 } 3671 */ 3672 *((LONG_PTR*)((PCHAR)(Window + 1) + Index)) = NewValue; 3673 } 3674 3675 } 3676 else 3677 { 3678 #ifdef _WIN64 3679 if (Size == sizeof(LONG)) 3680 { 3681 if ((Index != GWL_STYLE) && 3682 (Index != GWL_EXSTYLE) && 3683 (Index != GWL_ID) && 3684 (Index != GWL_USERDATA)) 3685 { 3686 ERR("NtUserSetWindowLong(): Index requires pointer size: %lu\n", Index); 3687 EngSetLastError(ERROR_INVALID_INDEX); 3688 return 0; 3689 } 3690 } 3691 #endif 3692 3693 switch (Index) 3694 { 3695 case GWL_EXSTYLE: // LONG 3696 OldValue = (LONG) Window->ExStyle; 3697 Style.styleOld = OldValue; 3698 Style.styleNew = NewValue; 3699 3700 co_IntSendMessage(hWnd, WM_STYLECHANGING, GWL_EXSTYLE, (LPARAM) &Style); 3701 3702 /* 3703 * Remove extended window style bit WS_EX_TOPMOST for shell windows. 3704 */ 3705 WindowStation = Window->head.pti->rpdesk->rpwinstaParent; 3706 if(WindowStation) 3707 { 3708 if (hWnd == WindowStation->ShellWindow || hWnd == WindowStation->ShellListView) 3709 Style.styleNew &= ~WS_EX_TOPMOST; 3710 } 3711 /* WS_EX_WINDOWEDGE depends on some other styles */ 3712 if (IntCheckFrameEdge(Window->style, NewValue)) 3713 Style.styleNew |= WS_EX_WINDOWEDGE; 3714 else 3715 Style.styleNew &= ~WS_EX_WINDOWEDGE; 3716 3717 if (!(Window->ExStyle & WS_EX_LAYERED)) 3718 { 3719 SetLayeredStatus(Window, 0); 3720 } 3721 3722 Window->ExStyle = (DWORD)Style.styleNew; 3723 3724 co_IntSendMessage(hWnd, WM_STYLECHANGED, GWL_EXSTYLE, (LPARAM) &Style); 3725 break; 3726 3727 case GWL_STYLE: // LONG 3728 OldValue = (LONG) Window->style; 3729 Style.styleOld = OldValue; 3730 Style.styleNew = NewValue; 3731 3732 if (!bAlter) 3733 co_IntSendMessage(hWnd, WM_STYLECHANGING, GWL_STYLE, (LPARAM) &Style); 3734 3735 /* WS_CLIPSIBLINGS can't be reset on top-level windows */ 3736 if (UserIsDesktopWindow(Window->spwndParent)) Style.styleNew |= WS_CLIPSIBLINGS; 3737 /* WS_MINIMIZE can't be reset */ 3738 if (OldValue & WS_MINIMIZE) Style.styleNew |= WS_MINIMIZE; 3739 /* Fixes wine FIXME: changing WS_DLGFRAME | WS_THICKFRAME is supposed to change WS_EX_WINDOWEDGE too */ 3740 if (IntCheckFrameEdge(NewValue, Window->ExStyle)) 3741 Window->ExStyle |= WS_EX_WINDOWEDGE; 3742 else 3743 Window->ExStyle &= ~WS_EX_WINDOWEDGE; 3744 3745 if ((OldValue & (WS_CHILD | WS_POPUP)) == WS_CHILD) 3746 { 3747 if ((NewValue & (WS_CHILD | WS_POPUP)) != WS_CHILD) 3748 { 3749 //// From child to non-child it should be null already. 3750 ERR("IDMenu going null! %d\n",Window->IDMenu); 3751 Window->IDMenu = 0; // Window->spmenu = 0; 3752 } 3753 } 3754 else 3755 { 3756 if ((NewValue & (WS_CHILD | WS_POPUP)) == WS_CHILD) 3757 { 3758 PMENU pMenu = UserGetMenuObject(UlongToHandle(Window->IDMenu)); 3759 Window->state &= ~WNDS_HASMENU; 3760 if (pMenu) 3761 { 3762 ERR("IDMenu released 0x%p\n",pMenu); 3763 // ROS may not hold a lock after setting menu to window. But it should! 3764 //IntReleaseMenuObject(pMenu); 3765 } 3766 } 3767 } 3768 3769 if ((Style.styleOld ^ Style.styleNew) & WS_VISIBLE) 3770 { 3771 if (Style.styleOld & WS_VISIBLE) Window->head.pti->cVisWindows--; 3772 if (Style.styleNew & WS_VISIBLE) Window->head.pti->cVisWindows++; 3773 DceResetActiveDCEs( Window ); 3774 } 3775 Window->style = (DWORD)Style.styleNew; 3776 3777 if (!bAlter) 3778 co_IntSendMessage(hWnd, WM_STYLECHANGED, GWL_STYLE, (LPARAM) &Style); 3779 break; 3780 3781 case GWLP_WNDPROC: // LONG_PTR 3782 { 3783 if ( Window->head.pti->ppi != PsGetCurrentProcessWin32Process() || 3784 Window->fnid & FNID_FREED) 3785 { 3786 EngSetLastError(ERROR_ACCESS_DENIED); 3787 return( 0); 3788 } 3789 OldValue = (LONG_PTR)IntSetWindowProc(Window, 3790 (WNDPROC)NewValue, 3791 Ansi); 3792 break; 3793 } 3794 3795 case GWLP_HINSTANCE: // LONG_PTR 3796 OldValue = (LONG_PTR) Window->hModule; 3797 Window->hModule = (HINSTANCE) NewValue; 3798 break; 3799 3800 case GWLP_HWNDPARENT: // LONG_PTR 3801 Parent = Window->spwndParent; 3802 if (Parent && (Parent->head.h == IntGetDesktopWindow())) 3803 OldValue = (LONG_PTR) IntSetOwner(Window->head.h, (HWND) NewValue); 3804 else 3805 OldValue = (LONG_PTR) co_UserSetParent(Window->head.h, (HWND) NewValue); 3806 break; 3807 3808 case GWLP_ID: // LONG 3809 OldValue = (LONG) Window->IDMenu; 3810 Window->IDMenu = (UINT) NewValue; 3811 break; 3812 3813 case GWLP_USERDATA: // LONG or LONG_PTR 3814 OldValue = Window->dwUserData; 3815 Window->dwUserData = NewValue; 3816 break; 3817 3818 default: 3819 ERR("NtUserSetWindowLong(): Unsupported index %lu\n", Index); 3820 EngSetLastError(ERROR_INVALID_INDEX); 3821 OldValue = 0; 3822 break; 3823 } 3824 } 3825 3826 return( OldValue); 3827 } 3828 3829 LONG FASTCALL 3830 co_UserSetWindowLong(HWND hWnd, DWORD Index, LONG NewValue, BOOL Ansi) 3831 { 3832 return (LONG)co_IntSetWindowLongPtr(hWnd, Index, NewValue, Ansi, sizeof(LONG), FALSE); 3833 } 3834 3835 LONG_PTR FASTCALL 3836 co_UserSetWindowLongPtr(HWND hWnd, DWORD Index, LONG_PTR NewValue, BOOL Ansi) 3837 { 3838 return co_IntSetWindowLongPtr(hWnd, Index, NewValue, Ansi, sizeof(LONG_PTR), FALSE); 3839 } 3840 3841 /* 3842 * NtUserSetWindowLong 3843 * 3844 * The NtUserSetWindowLong function changes an attribute of the specified 3845 * window. The function also sets the 32-bit (long) value at the specified 3846 * offset into the extra window memory. 3847 * 3848 * Status 3849 * @implemented 3850 */ 3851 3852 LONG APIENTRY 3853 NtUserSetWindowLong(HWND hWnd, DWORD Index, LONG NewValue, BOOL Ansi) 3854 { 3855 LONG ret; 3856 3857 UserEnterExclusive(); 3858 3859 if (hWnd == IntGetDesktopWindow()) 3860 { 3861 EngSetLastError(STATUS_ACCESS_DENIED); 3862 UserLeave(); 3863 return 0; 3864 } 3865 3866 ret = (LONG)co_IntSetWindowLongPtr(hWnd, Index, NewValue, Ansi, sizeof(LONG), FALSE); 3867 3868 UserLeave(); 3869 3870 return ret; 3871 } 3872 3873 #ifdef _WIN64 3874 LONG_PTR APIENTRY 3875 NtUserSetWindowLongPtr(HWND hWnd, DWORD Index, LONG_PTR NewValue, BOOL Ansi) 3876 { 3877 LONG_PTR ret; 3878 3879 UserEnterExclusive(); 3880 3881 if (hWnd == IntGetDesktopWindow()) 3882 { 3883 EngSetLastError(STATUS_ACCESS_DENIED); 3884 UserLeave(); 3885 return 0; 3886 } 3887 3888 ret = co_IntSetWindowLongPtr(hWnd, Index, NewValue, Ansi, sizeof(LONG_PTR), FALSE); 3889 3890 UserLeave(); 3891 3892 return ret; 3893 } 3894 #endif // _WIN64 3895 3896 DWORD APIENTRY 3897 NtUserAlterWindowStyle(HWND hWnd, DWORD Index, LONG NewValue) 3898 { 3899 LONG ret; 3900 3901 UserEnterExclusive(); 3902 3903 if (hWnd == IntGetDesktopWindow()) 3904 { 3905 EngSetLastError(STATUS_ACCESS_DENIED); 3906 UserLeave(); 3907 return 0; 3908 } 3909 3910 ret = co_IntSetWindowLongPtr(hWnd, Index, NewValue, FALSE, sizeof(LONG), TRUE); 3911 3912 UserLeave(); 3913 3914 return ret; 3915 } 3916 3917 3918 /* 3919 * NtUserSetWindowWord 3920 * 3921 * Legacy function similar to NtUserSetWindowLong. 3922 * 3923 * Status 3924 * @implemented 3925 */ 3926 3927 WORD APIENTRY 3928 NtUserSetWindowWord(HWND hWnd, INT Index, WORD NewValue) 3929 { 3930 PWND Window; 3931 WORD OldValue; 3932 DECLARE_RETURN(WORD); 3933 3934 TRACE("Enter NtUserSetWindowWord\n"); 3935 UserEnterExclusive(); 3936 3937 if (hWnd == IntGetDesktopWindow()) 3938 { 3939 EngSetLastError(STATUS_ACCESS_DENIED); 3940 RETURN( 0); 3941 } 3942 3943 if (!(Window = UserGetWindowObject(hWnd))) 3944 { 3945 RETURN( 0); 3946 } 3947 3948 switch (Index) 3949 { 3950 case GWL_ID: 3951 case GWL_HINSTANCE: 3952 case GWL_HWNDPARENT: 3953 RETURN( (WORD)co_UserSetWindowLong(UserHMGetHandle(Window), Index, (UINT)NewValue, TRUE)); 3954 default: 3955 if (Index < 0) 3956 { 3957 EngSetLastError(ERROR_INVALID_INDEX); 3958 RETURN( 0); 3959 } 3960 } 3961 3962 if ((ULONG)Index > (Window->cbwndExtra - sizeof(WORD))) 3963 { 3964 EngSetLastError(ERROR_INVALID_PARAMETER); 3965 RETURN( 0); 3966 } 3967 3968 OldValue = *((WORD *)((PCHAR)(Window + 1) + Index)); 3969 *((WORD *)((PCHAR)(Window + 1) + Index)) = NewValue; 3970 3971 RETURN( OldValue); 3972 3973 CLEANUP: 3974 TRACE("Leave NtUserSetWindowWord, ret=%u\n", _ret_); 3975 UserLeave(); 3976 END_CLEANUP; 3977 } 3978 3979 /* 3980 QueryWindow based on KJK::Hyperion and James Tabor. 3981 3982 0 = QWUniqueProcessId 3983 1 = QWUniqueThreadId 3984 2 = QWActiveWindow 3985 3 = QWFocusWindow 3986 4 = QWIsHung Implements IsHungAppWindow found 3987 by KJK::Hyperion. 3988 3989 9 = QWKillWindow When I called this with hWnd == 3990 DesktopWindow, it shutdown the system 3991 and rebooted. 3992 */ 3993 /* 3994 * @implemented 3995 */ 3996 DWORD_PTR APIENTRY 3997 NtUserQueryWindow(HWND hWnd, DWORD Index) 3998 { 3999 /* Console Leader Process CID Window offsets */ 4000 #define GWLP_CONSOLE_LEADER_PID 0 4001 #define GWLP_CONSOLE_LEADER_TID 4 4002 4003 PWND pWnd; 4004 DWORD_PTR Result; 4005 DECLARE_RETURN(UINT); 4006 4007 TRACE("Enter NtUserQueryWindow\n"); 4008 UserEnterShared(); 4009 4010 if (!(pWnd = UserGetWindowObject(hWnd))) 4011 { 4012 RETURN( 0); 4013 } 4014 4015 switch(Index) 4016 { 4017 case QUERY_WINDOW_UNIQUE_PROCESS_ID: 4018 { 4019 if ( (pWnd->head.pti->TIF_flags & TIF_CSRSSTHREAD) && 4020 (pWnd->pcls->atomClassName == gaGuiConsoleWndClass) ) 4021 { 4022 // IntGetWindowLong(offset == GWLP_CONSOLE_LEADER_PID) 4023 Result = (DWORD_PTR)(*((LONG_PTR*)((PCHAR)(pWnd + 1) + GWLP_CONSOLE_LEADER_PID))); 4024 } 4025 else 4026 { 4027 Result = (DWORD_PTR)IntGetWndProcessId(pWnd); 4028 } 4029 break; 4030 } 4031 4032 case QUERY_WINDOW_UNIQUE_THREAD_ID: 4033 { 4034 if ( (pWnd->head.pti->TIF_flags & TIF_CSRSSTHREAD) && 4035 (pWnd->pcls->atomClassName == gaGuiConsoleWndClass) ) 4036 { 4037 // IntGetWindowLong(offset == GWLP_CONSOLE_LEADER_TID) 4038 Result = (DWORD_PTR)(*((LONG_PTR*)((PCHAR)(pWnd + 1) + GWLP_CONSOLE_LEADER_TID))); 4039 } 4040 else 4041 { 4042 Result = (DWORD_PTR)IntGetWndThreadId(pWnd); 4043 } 4044 break; 4045 } 4046 4047 case QUERY_WINDOW_ACTIVE: 4048 Result = (DWORD_PTR)(pWnd->head.pti->MessageQueue->spwndActive ? UserHMGetHandle(pWnd->head.pti->MessageQueue->spwndActive) : 0); 4049 break; 4050 4051 case QUERY_WINDOW_FOCUS: 4052 Result = (DWORD_PTR)(pWnd->head.pti->MessageQueue->spwndFocus ? UserHMGetHandle(pWnd->head.pti->MessageQueue->spwndFocus) : 0); 4053 break; 4054 4055 case QUERY_WINDOW_ISHUNG: 4056 Result = (DWORD_PTR)MsqIsHung(pWnd->head.pti); 4057 break; 4058 4059 case QUERY_WINDOW_REAL_ID: 4060 Result = (DWORD_PTR)pWnd->head.pti->pEThread->Cid.UniqueProcess; 4061 break; 4062 4063 case QUERY_WINDOW_FOREGROUND: 4064 Result = (pWnd->head.pti->MessageQueue == gpqForeground); 4065 break; 4066 4067 default: 4068 Result = 0; 4069 break; 4070 } 4071 4072 RETURN( Result); 4073 4074 CLEANUP: 4075 TRACE("Leave NtUserQueryWindow, ret=%u\n", _ret_); 4076 UserLeave(); 4077 END_CLEANUP; 4078 } 4079 4080 /* 4081 * @implemented 4082 */ 4083 UINT APIENTRY 4084 NtUserRegisterWindowMessage(PUNICODE_STRING MessageNameUnsafe) 4085 { 4086 UNICODE_STRING SafeMessageName; 4087 NTSTATUS Status; 4088 UINT Ret; 4089 DECLARE_RETURN(UINT); 4090 4091 TRACE("Enter NtUserRegisterWindowMessage\n"); 4092 UserEnterExclusive(); 4093 4094 if(MessageNameUnsafe == NULL) 4095 { 4096 EngSetLastError(ERROR_INVALID_PARAMETER); 4097 RETURN( 0); 4098 } 4099 4100 Status = IntSafeCopyUnicodeStringTerminateNULL(&SafeMessageName, MessageNameUnsafe); 4101 if(!NT_SUCCESS(Status)) 4102 { 4103 SetLastNtError(Status); 4104 RETURN( 0); 4105 } 4106 4107 Ret = (UINT)IntAddAtom(SafeMessageName.Buffer); 4108 if (SafeMessageName.Buffer) 4109 ExFreePoolWithTag(SafeMessageName.Buffer, TAG_STRING); 4110 RETURN( Ret); 4111 4112 CLEANUP: 4113 TRACE("Leave NtUserRegisterWindowMessage, ret=%u\n", _ret_); 4114 UserLeave(); 4115 END_CLEANUP; 4116 } 4117 4118 /* 4119 * @implemented 4120 */ 4121 BOOL APIENTRY 4122 NtUserSetWindowFNID(HWND hWnd, 4123 WORD fnID) 4124 { 4125 PWND Wnd; 4126 DECLARE_RETURN(BOOL); 4127 4128 TRACE("Enter NtUserSetWindowFNID\n"); 4129 UserEnterExclusive(); 4130 4131 if (!(Wnd = UserGetWindowObject(hWnd))) 4132 { 4133 RETURN( FALSE); 4134 } 4135 4136 if (Wnd->head.pti->ppi != PsGetCurrentProcessWin32Process()) 4137 { 4138 EngSetLastError(ERROR_ACCESS_DENIED); 4139 RETURN( FALSE); 4140 } 4141 4142 // From user land we only set these. 4143 if (fnID != FNID_DESTROY) 4144 { 4145 /* HACK: The minimum should be FNID_BUTTON, but menu code relies on this */ 4146 if (fnID < FNID_FIRST || fnID > FNID_GHOST || 4147 Wnd->fnid != 0) 4148 { 4149 EngSetLastError(ERROR_INVALID_PARAMETER); 4150 RETURN( FALSE); 4151 } 4152 } 4153 4154 Wnd->fnid |= fnID; 4155 RETURN( TRUE); 4156 4157 CLEANUP: 4158 TRACE("Leave NtUserSetWindowFNID\n"); 4159 UserLeave(); 4160 END_CLEANUP; 4161 } 4162 4163 BOOL APIENTRY 4164 DefSetText(PWND Wnd, PCWSTR WindowText) 4165 { 4166 UNICODE_STRING UnicodeString; 4167 BOOL Ret = FALSE; 4168 4169 RtlInitUnicodeString(&UnicodeString, WindowText); 4170 4171 if (UnicodeString.Length != 0) 4172 { 4173 if (Wnd->strName.MaximumLength > 0 && 4174 UnicodeString.Length <= Wnd->strName.MaximumLength - sizeof(UNICODE_NULL)) 4175 { 4176 ASSERT(Wnd->strName.Buffer != NULL); 4177 4178 Wnd->strName.Length = UnicodeString.Length; 4179 Wnd->strName.Buffer[UnicodeString.Length / sizeof(WCHAR)] = L'\0'; 4180 RtlCopyMemory(Wnd->strName.Buffer, 4181 UnicodeString.Buffer, 4182 UnicodeString.Length); 4183 } 4184 else 4185 { 4186 PWCHAR buf; 4187 Wnd->strName.MaximumLength = Wnd->strName.Length = 0; 4188 buf = Wnd->strName.Buffer; 4189 Wnd->strName.Buffer = NULL; 4190 if (buf != NULL) 4191 { 4192 DesktopHeapFree(Wnd->head.rpdesk, buf); 4193 } 4194 4195 Wnd->strName.Buffer = DesktopHeapAlloc(Wnd->head.rpdesk, 4196 UnicodeString.Length + sizeof(UNICODE_NULL)); 4197 if (Wnd->strName.Buffer != NULL) 4198 { 4199 Wnd->strName.Buffer[UnicodeString.Length / sizeof(WCHAR)] = L'\0'; 4200 RtlCopyMemory(Wnd->strName.Buffer, 4201 UnicodeString.Buffer, 4202 UnicodeString.Length); 4203 Wnd->strName.MaximumLength = UnicodeString.Length + sizeof(UNICODE_NULL); 4204 Wnd->strName.Length = UnicodeString.Length; 4205 } 4206 else 4207 { 4208 EngSetLastError(ERROR_NOT_ENOUGH_MEMORY); 4209 goto Exit; 4210 } 4211 } 4212 } 4213 else 4214 { 4215 Wnd->strName.Length = 0; 4216 if (Wnd->strName.Buffer != NULL) 4217 Wnd->strName.Buffer[0] = L'\0'; 4218 } 4219 4220 // FIXME: HAX! Windows does not do this in here! 4221 // In User32, these are called after: NotifyWinEvent EVENT_OBJECT_NAMECHANGE than 4222 // RepaintButton, StaticRepaint, NtUserCallHwndLock HWNDLOCK_ROUTINE_REDRAWFRAMEANDHOOK, etc. 4223 /* Send shell notifications */ 4224 if (!Wnd->spwndOwner && !IntGetParent(Wnd)) 4225 { 4226 co_IntShellHookNotify(HSHELL_REDRAW, (WPARAM) UserHMGetHandle(Wnd), FALSE); // FIXME Flashing? 4227 } 4228 4229 Ret = TRUE; 4230 Exit: 4231 if (UnicodeString.Buffer) RtlFreeUnicodeString(&UnicodeString); 4232 return Ret; 4233 } 4234 4235 /* 4236 * NtUserDefSetText 4237 * 4238 * Undocumented function that is called from DefWindowProc to set 4239 * window text. 4240 * 4241 * Status 4242 * @implemented 4243 */ 4244 BOOL APIENTRY 4245 NtUserDefSetText(HWND hWnd, PLARGE_STRING WindowText) 4246 { 4247 PWND Wnd; 4248 LARGE_STRING SafeText; 4249 UNICODE_STRING UnicodeString; 4250 BOOL Ret = TRUE; 4251 4252 TRACE("Enter NtUserDefSetText\n"); 4253 4254 if (WindowText != NULL) 4255 { 4256 _SEH2_TRY 4257 { 4258 SafeText = ProbeForReadLargeString(WindowText); 4259 } 4260 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) 4261 { 4262 Ret = FALSE; 4263 SetLastNtError(_SEH2_GetExceptionCode()); 4264 } 4265 _SEH2_END; 4266 4267 if (!Ret) 4268 return FALSE; 4269 } 4270 else 4271 return TRUE; 4272 4273 UserEnterExclusive(); 4274 4275 if(!(Wnd = UserGetWindowObject(hWnd))) 4276 { 4277 UserLeave(); 4278 return FALSE; 4279 } 4280 4281 // ReactOS uses Unicode and not mixed. Up/Down converting will take time. 4282 // Brought to you by: The Wine Project! Dysfunctional Thought Processes! 4283 // Now we know what the bAnsi is for. 4284 RtlInitUnicodeString(&UnicodeString, NULL); 4285 if (SafeText.Buffer) 4286 { 4287 _SEH2_TRY 4288 { 4289 if (SafeText.bAnsi) 4290 ProbeForRead(SafeText.Buffer, SafeText.Length, sizeof(CHAR)); 4291 else 4292 ProbeForRead(SafeText.Buffer, SafeText.Length, sizeof(WCHAR)); 4293 Ret = RtlLargeStringToUnicodeString(&UnicodeString, &SafeText); 4294 } 4295 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) 4296 { 4297 Ret = FALSE; 4298 SetLastNtError(_SEH2_GetExceptionCode()); 4299 } 4300 _SEH2_END; 4301 if (!Ret) goto Exit; 4302 } 4303 4304 if (UnicodeString.Length != 0) 4305 { 4306 if (Wnd->strName.MaximumLength > 0 && 4307 UnicodeString.Length <= Wnd->strName.MaximumLength - sizeof(UNICODE_NULL)) 4308 { 4309 ASSERT(Wnd->strName.Buffer != NULL); 4310 4311 Wnd->strName.Length = UnicodeString.Length; 4312 Wnd->strName.Buffer[UnicodeString.Length / sizeof(WCHAR)] = L'\0'; 4313 RtlCopyMemory(Wnd->strName.Buffer, 4314 UnicodeString.Buffer, 4315 UnicodeString.Length); 4316 } 4317 else 4318 { 4319 PWCHAR buf; 4320 Wnd->strName.MaximumLength = Wnd->strName.Length = 0; 4321 buf = Wnd->strName.Buffer; 4322 Wnd->strName.Buffer = NULL; 4323 if (buf != NULL) 4324 { 4325 DesktopHeapFree(Wnd->head.rpdesk, buf); 4326 } 4327 4328 Wnd->strName.Buffer = DesktopHeapAlloc(Wnd->head.rpdesk, 4329 UnicodeString.Length + sizeof(UNICODE_NULL)); 4330 if (Wnd->strName.Buffer != NULL) 4331 { 4332 Wnd->strName.Buffer[UnicodeString.Length / sizeof(WCHAR)] = L'\0'; 4333 RtlCopyMemory(Wnd->strName.Buffer, 4334 UnicodeString.Buffer, 4335 UnicodeString.Length); 4336 Wnd->strName.MaximumLength = UnicodeString.Length + sizeof(UNICODE_NULL); 4337 Wnd->strName.Length = UnicodeString.Length; 4338 } 4339 else 4340 { 4341 EngSetLastError(ERROR_NOT_ENOUGH_MEMORY); 4342 Ret = FALSE; 4343 goto Exit; 4344 } 4345 } 4346 } 4347 else 4348 { 4349 Wnd->strName.Length = 0; 4350 if (Wnd->strName.Buffer != NULL) 4351 Wnd->strName.Buffer[0] = L'\0'; 4352 } 4353 4354 // FIXME: HAX! Windows does not do this in here! 4355 // In User32, these are called after: NotifyWinEvent EVENT_OBJECT_NAMECHANGE than 4356 // RepaintButton, StaticRepaint, NtUserCallHwndLock HWNDLOCK_ROUTINE_REDRAWFRAMEANDHOOK, etc. 4357 /* Send shell notifications */ 4358 if (!Wnd->spwndOwner && !IntGetParent(Wnd)) 4359 { 4360 co_IntShellHookNotify(HSHELL_REDRAW, (WPARAM) hWnd, FALSE); // FIXME Flashing? 4361 } 4362 4363 Ret = TRUE; 4364 Exit: 4365 if (UnicodeString.Buffer) RtlFreeUnicodeString(&UnicodeString); 4366 TRACE("Leave NtUserDefSetText, ret=%i\n", Ret); 4367 UserLeave(); 4368 return Ret; 4369 } 4370 4371 /* 4372 * NtUserInternalGetWindowText 4373 * 4374 * Status 4375 * @implemented 4376 */ 4377 4378 INT APIENTRY 4379 NtUserInternalGetWindowText(HWND hWnd, LPWSTR lpString, INT nMaxCount) 4380 { 4381 PWND Wnd; 4382 NTSTATUS Status; 4383 INT Result; 4384 DECLARE_RETURN(INT); 4385 4386 TRACE("Enter NtUserInternalGetWindowText\n"); 4387 UserEnterShared(); 4388 4389 if(lpString && (nMaxCount <= 1)) 4390 { 4391 EngSetLastError(ERROR_INVALID_PARAMETER); 4392 RETURN( 0); 4393 } 4394 4395 if(!(Wnd = UserGetWindowObject(hWnd))) 4396 { 4397 RETURN( 0); 4398 } 4399 4400 Result = Wnd->strName.Length / sizeof(WCHAR); 4401 if(lpString) 4402 { 4403 const WCHAR Terminator = L'\0'; 4404 INT Copy; 4405 WCHAR *Buffer = (WCHAR*)lpString; 4406 4407 Copy = min(nMaxCount - 1, Result); 4408 if(Copy > 0) 4409 { 4410 Status = MmCopyToCaller(Buffer, Wnd->strName.Buffer, Copy * sizeof(WCHAR)); 4411 if(!NT_SUCCESS(Status)) 4412 { 4413 SetLastNtError(Status); 4414 RETURN( 0); 4415 } 4416 Buffer += Copy; 4417 } 4418 4419 Status = MmCopyToCaller(Buffer, &Terminator, sizeof(WCHAR)); 4420 if(!NT_SUCCESS(Status)) 4421 { 4422 SetLastNtError(Status); 4423 RETURN( 0); 4424 } 4425 4426 Result = Copy; 4427 } 4428 4429 RETURN( Result); 4430 4431 CLEANUP: 4432 TRACE("Leave NtUserInternalGetWindowText, ret=%i\n",_ret_); 4433 UserLeave(); 4434 END_CLEANUP; 4435 } 4436 4437 /* 4438 API Call 4439 */ 4440 BOOL 4441 FASTCALL 4442 IntShowOwnedPopups(PWND OwnerWnd, BOOL fShow ) 4443 { 4444 int count = 0; 4445 PWND pWnd; 4446 HWND *win_array; 4447 4448 // ASSERT(OwnerWnd); 4449 4450 TRACE("Enter ShowOwnedPopups Show: %s\n", (fShow ? "TRUE" : "FALSE")); 4451 4452 /* NOTE: Popups are not children */ 4453 win_array = IntWinListOwnedPopups(OwnerWnd); 4454 4455 if (!win_array) 4456 return TRUE; 4457 4458 while (win_array[count]) 4459 count++; 4460 while (--count >= 0) 4461 { 4462 if (!(pWnd = ValidateHwndNoErr( win_array[count] ))) 4463 continue; 4464 if (pWnd->spwndOwner != OwnerWnd) 4465 continue; 4466 4467 if (fShow) 4468 { 4469 if (pWnd->state & WNDS_HIDDENPOPUP) 4470 { 4471 /* In Windows, ShowOwnedPopups(TRUE) generates 4472 * WM_SHOWWINDOW messages with SW_PARENTOPENING, 4473 * regardless of the state of the owner 4474 */ 4475 co_IntSendMessage(win_array[count], WM_SHOWWINDOW, SW_SHOWNORMAL, SW_PARENTOPENING); 4476 pWnd->state &= ~WNDS_HIDDENPOPUP; 4477 continue; 4478 } 4479 } 4480 else 4481 { 4482 if (pWnd->style & WS_VISIBLE) 4483 { 4484 /* In Windows, ShowOwnedPopups(FALSE) generates 4485 * WM_SHOWWINDOW messages with SW_PARENTCLOSING, 4486 * regardless of the state of the owner 4487 */ 4488 co_IntSendMessage(win_array[count], WM_SHOWWINDOW, SW_HIDE, SW_PARENTCLOSING); 4489 pWnd->state |= WNDS_HIDDENPOPUP; 4490 continue; 4491 } 4492 } 4493 } 4494 ExFreePoolWithTag(win_array, USERTAG_WINDOWLIST); 4495 TRACE("Leave ShowOwnedPopups\n"); 4496 return TRUE; 4497 } 4498 4499 /* EOF */ 4500