1 /* 2 * COPYRIGHT: See COPYING in the top level directory 3 * PROJECT: ReactOS Win32k subsystem 4 * PURPOSE: Miscellaneous User functions 5 * FILE: win32ss/user/ntuser/defwnd.c 6 * PROGRAMER: 7 */ 8 9 #include <win32k.h> 10 #include <windowsx.h> 11 12 DBG_DEFAULT_CHANNEL(UserDefwnd); 13 14 INT WINAPI DrawTextExWorker( HDC hdc, LPWSTR str, INT i_count, 15 LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp ); 16 17 INT WINAPI DrawTextW( HDC hdc, LPCWSTR str, INT count, LPRECT rect, UINT flags ) 18 { 19 DRAWTEXTPARAMS dtp; 20 21 memset (&dtp, 0, sizeof(dtp)); 22 dtp.cbSize = sizeof(dtp); 23 if (flags & DT_TABSTOP) 24 { 25 dtp.iTabLength = (flags >> 8) & 0xff; 26 flags &= 0xffff00ff; 27 } 28 return DrawTextExWorker(hdc, (LPWSTR)str, count, rect, flags, &dtp); 29 } 30 31 32 HBRUSH FASTCALL 33 DefWndControlColor(HDC hDC, UINT ctlType) 34 { 35 if (ctlType == CTLCOLOR_SCROLLBAR) 36 { 37 HBRUSH hb = IntGetSysColorBrush(COLOR_SCROLLBAR); 38 COLORREF bk = IntGetSysColor(COLOR_3DHILIGHT); 39 IntGdiSetTextColor(hDC, IntGetSysColor(COLOR_3DFACE)); 40 IntGdiSetBkColor(hDC, bk); 41 42 /* if COLOR_WINDOW happens to be the same as COLOR_3DHILIGHT 43 * we better use 0x55aa bitmap brush to make scrollbar's background 44 * look different from the window background. 45 */ 46 if ( bk == IntGetSysColor(COLOR_WINDOW)) 47 return gpsi->hbrGray; 48 49 NtGdiUnrealizeObject( hb ); 50 return hb; 51 } 52 53 IntGdiSetTextColor(hDC, IntGetSysColor(COLOR_WINDOWTEXT)); 54 55 if ((ctlType == CTLCOLOR_EDIT) || (ctlType == CTLCOLOR_LISTBOX)) 56 { 57 IntGdiSetBkColor(hDC, IntGetSysColor(COLOR_WINDOW)); 58 } 59 else 60 { 61 IntGdiSetBkColor(hDC, IntGetSysColor(COLOR_3DFACE)); 62 return IntGetSysColorBrush(COLOR_3DFACE); 63 } 64 65 return IntGetSysColorBrush(COLOR_WINDOW); 66 } 67 68 LRESULT FASTCALL 69 DefWndHandleWindowPosChanging(PWND pWnd, WINDOWPOS* Pos) 70 { 71 POINT maxTrack, minTrack; 72 LONG style = pWnd->style; 73 74 if (Pos->flags & SWP_NOSIZE) return 0; 75 if ((style & WS_THICKFRAME) || ((style & (WS_POPUP | WS_CHILD)) == 0)) 76 { 77 co_WinPosGetMinMaxInfo(pWnd, NULL, NULL, &minTrack, &maxTrack); 78 Pos->cx = min(Pos->cx, maxTrack.x); 79 Pos->cy = min(Pos->cy, maxTrack.y); 80 if (!(style & WS_MINIMIZE)) 81 { 82 if (Pos->cx < minTrack.x) Pos->cx = minTrack.x; 83 if (Pos->cy < minTrack.y) Pos->cy = minTrack.y; 84 } 85 } 86 else 87 { 88 Pos->cx = max(Pos->cx, 0); 89 Pos->cy = max(Pos->cy, 0); 90 } 91 return 0; 92 } 93 94 LRESULT FASTCALL 95 DefWndHandleWindowPosChanged(PWND pWnd, WINDOWPOS* Pos) 96 { 97 RECT Rect; 98 LONG style = pWnd->style; 99 100 IntGetClientRect(pWnd, &Rect); 101 IntMapWindowPoints(pWnd, (style & WS_CHILD ? IntGetParent(pWnd) : NULL), (LPPOINT) &Rect, 2); 102 103 if (!(Pos->flags & SWP_NOCLIENTMOVE)) 104 { 105 co_IntSendMessage(UserHMGetHandle(pWnd), WM_MOVE, 0, MAKELONG(Rect.left, Rect.top)); 106 } 107 108 if (!(Pos->flags & SWP_NOCLIENTSIZE) || (Pos->flags & SWP_STATECHANGED)) 109 { 110 if (style & WS_MINIMIZE) co_IntSendMessage(UserHMGetHandle(pWnd), WM_SIZE, SIZE_MINIMIZED, 0 ); 111 else 112 { 113 WPARAM wp = (style & WS_MAXIMIZE) ? SIZE_MAXIMIZED : SIZE_RESTORED; 114 co_IntSendMessage(UserHMGetHandle(pWnd), WM_SIZE, wp, MAKELONG(Rect.right - Rect.left, Rect.bottom - Rect.top)); 115 } 116 } 117 return 0; 118 } 119 120 // 121 // Handle a WM_SYSCOMMAND message. Called from DefWindowProc(). 122 // 123 LRESULT FASTCALL 124 DefWndHandleSysCommand(PWND pWnd, WPARAM wParam, LPARAM lParam) 125 { 126 LRESULT lResult = 0; 127 BOOL Hook = FALSE; 128 129 if (ISITHOOKED(WH_CBT) || (pWnd->head.rpdesk->pDeskInfo->fsHooks & HOOKID_TO_FLAG(WH_CBT))) 130 { 131 Hook = TRUE; 132 lResult = co_HOOK_CallHooks(WH_CBT, HCBT_SYSCOMMAND, wParam, lParam); 133 134 if (lResult) return lResult; 135 } 136 137 switch (wParam & 0xfff0) 138 { 139 case SC_MOVE: 140 case SC_SIZE: 141 DefWndDoSizeMove(pWnd, wParam); 142 break; 143 144 case SC_MINIMIZE: 145 if (UserHMGetHandle(pWnd) == UserGetActiveWindow()) 146 IntShowOwnedPopups(pWnd,FALSE); // This is done in ShowWindow! Need to retest! 147 co_WinPosShowWindow( pWnd, SW_MINIMIZE ); 148 break; 149 150 case SC_MAXIMIZE: 151 if (((pWnd->style & WS_MINIMIZE) != 0) && UserHMGetHandle(pWnd) == UserGetActiveWindow()) 152 IntShowOwnedPopups(pWnd,TRUE); 153 co_WinPosShowWindow( pWnd, SW_MAXIMIZE ); 154 break; 155 156 case SC_RESTORE: 157 if (((pWnd->style & WS_MINIMIZE) != 0) && UserHMGetHandle(pWnd) == UserGetActiveWindow()) 158 IntShowOwnedPopups(pWnd,TRUE); 159 co_WinPosShowWindow( pWnd, SW_RESTORE ); 160 break; 161 162 case SC_CLOSE: 163 return co_IntSendMessage(UserHMGetHandle(pWnd), WM_CLOSE, 0, 0); 164 165 case SC_SCREENSAVE: 166 ERR("Screensaver Called!\n"); 167 UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_START_SCREENSAVE, 0); // always lParam 0 == not Secure 168 break; 169 170 case SC_HOTKEY: 171 { 172 USER_REFERENCE_ENTRY Ref; 173 174 pWnd = ValidateHwndNoErr((HWND)lParam); 175 if (pWnd) 176 { 177 if (pWnd->spwndLastActive) 178 { 179 pWnd = pWnd->spwndLastActive; 180 } 181 UserRefObjectCo(pWnd, &Ref); 182 co_IntSetForegroundWindow(pWnd); 183 UserDerefObjectCo(pWnd); 184 if (pWnd->style & WS_MINIMIZE) 185 { 186 UserPostMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_RESTORE, 0); 187 } 188 } 189 } 190 break; 191 // case SC_DEFAULT: 192 case SC_MOUSEMENU: 193 { 194 POINT Pt; 195 Pt.x = (short)LOWORD(lParam); 196 Pt.y = (short)HIWORD(lParam); 197 MENU_TrackMouseMenuBar(pWnd, wParam & 0x000f, Pt); 198 } 199 break; 200 201 case SC_KEYMENU: 202 MENU_TrackKbdMenuBar(pWnd, wParam, (WCHAR)lParam); 203 break; 204 205 206 default: 207 // We do not support anything else here so we should return normal even when sending a hook. 208 return 0; 209 } 210 211 return(Hook ? 1 : 0); // Don't call us again from user space. 212 } 213 214 PWND FASTCALL 215 co_IntFindChildWindowToOwner(PWND Root, PWND Owner) 216 { 217 PWND Ret; 218 PWND Child, OwnerWnd; 219 220 for(Child = Root->spwndChild; Child; Child = Child->spwndNext) 221 { 222 OwnerWnd = Child->spwndOwner; 223 if(!OwnerWnd) 224 continue; 225 226 if (!(Child->style & WS_POPUP) || 227 !(Child->style & WS_VISIBLE) || 228 /* Fixes CMD pop up properties window from having foreground. */ 229 Owner->head.pti->MessageQueue != Child->head.pti->MessageQueue) 230 continue; 231 232 if(OwnerWnd == Owner) 233 { 234 Ret = Child; 235 return Ret; 236 } 237 } 238 return NULL; 239 } 240 241 LRESULT 242 DefWndHandleSetCursor(PWND pWnd, WPARAM wParam, LPARAM lParam) 243 { 244 PWND pwndPopUP = NULL; 245 WORD Msg = HIWORD(lParam); 246 247 /* Not for child windows. */ 248 if (UserHMGetHandle(pWnd) != (HWND)wParam) 249 { 250 return FALSE; 251 } 252 253 switch((short)LOWORD(lParam)) 254 { 255 case HTERROR: 256 { 257 //// This is the real fix for CORE-6129! This was a "Code hole". 258 USER_REFERENCE_ENTRY Ref; 259 260 if (Msg == WM_LBUTTONDOWN) 261 { 262 // Find a pop up window to bring active. 263 pwndPopUP = co_IntFindChildWindowToOwner(UserGetDesktopWindow(), pWnd); 264 if (pwndPopUP) 265 { 266 // Not a child pop up from desktop. 267 if ( pwndPopUP != UserGetDesktopWindow()->spwndChild ) 268 { 269 // Get original active window. 270 PWND pwndOrigActive = gpqForeground->spwndActive; 271 272 co_WinPosSetWindowPos(pWnd, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE); 273 274 UserRefObjectCo(pwndPopUP, &Ref); 275 //UserSetActiveWindow(pwndPopUP); 276 co_IntSetForegroundWindow(pwndPopUP); // HACK 277 UserDerefObjectCo(pwndPopUP); 278 279 // If the change was made, break out. 280 if (pwndOrigActive != gpqForeground->spwndActive) 281 break; 282 } 283 } 284 } 285 //// 286 if (Msg == WM_LBUTTONDOWN || Msg == WM_MBUTTONDOWN || 287 Msg == WM_RBUTTONDOWN || Msg == WM_XBUTTONDOWN) 288 { 289 if (pwndPopUP) 290 { 291 FLASHWINFO fwi = 292 {sizeof(FLASHWINFO), 293 UserHMGetHandle(pwndPopUP), 294 FLASHW_ALL, 295 gspv.dwForegroundFlashCount, 296 (gpsi->dtCaretBlink >> 3)}; 297 298 // Now shake that window! 299 IntFlashWindowEx(pwndPopUP, &fwi); 300 } 301 UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, 0); 302 } 303 break; 304 } 305 306 case HTCLIENT: 307 { 308 if (pWnd->pcls->spcur) 309 { 310 IntSystemSetCursor(pWnd->pcls->spcur); 311 } 312 return FALSE; 313 } 314 315 case HTLEFT: 316 case HTRIGHT: 317 { 318 if (pWnd->style & WS_MAXIMIZE) 319 { 320 break; 321 } 322 IntSystemSetCursor(SYSTEMCUR(SIZEWE)); 323 return TRUE; 324 } 325 326 case HTTOP: 327 case HTBOTTOM: 328 { 329 if (pWnd->style & WS_MAXIMIZE) 330 { 331 break; 332 } 333 IntSystemSetCursor(SYSTEMCUR(SIZENS)); 334 return TRUE; 335 } 336 337 case HTTOPLEFT: 338 case HTBOTTOMRIGHT: 339 { 340 if (pWnd->style & WS_MAXIMIZE) 341 { 342 break; 343 } 344 IntSystemSetCursor(SYSTEMCUR(SIZENWSE)); 345 return TRUE; 346 } 347 348 case HTBOTTOMLEFT: 349 case HTTOPRIGHT: 350 { 351 if (pWnd->style & WS_MAXIMIZE) 352 { 353 break; 354 } 355 IntSystemSetCursor(SYSTEMCUR(SIZENESW)); 356 return TRUE; 357 } 358 } 359 IntSystemSetCursor(SYSTEMCUR(ARROW)); 360 return FALSE; 361 } 362 363 VOID FASTCALL DefWndPrint( PWND pwnd, HDC hdc, ULONG uFlags) 364 { 365 /* 366 * Visibility flag. 367 */ 368 if ( (uFlags & PRF_CHECKVISIBLE) && 369 !IntIsWindowVisible(pwnd) ) 370 return; 371 372 /* 373 * Unimplemented flags. 374 */ 375 if ( (uFlags & PRF_CHILDREN) || 376 (uFlags & PRF_OWNED) || 377 (uFlags & PRF_NONCLIENT) ) 378 { 379 FIXME("WM_PRINT message with unsupported flags\n"); 380 } 381 382 /* 383 * Background 384 */ 385 if ( uFlags & PRF_ERASEBKGND) 386 co_IntSendMessage(UserHMGetHandle(pwnd), WM_ERASEBKGND, (WPARAM)hdc, 0); 387 388 /* 389 * Client area 390 */ 391 if ( uFlags & PRF_CLIENT) 392 co_IntSendMessage(UserHMGetHandle(pwnd), WM_PRINTCLIENT, (WPARAM)hdc, uFlags); 393 } 394 395 BOOL 396 UserPaintCaption(PWND pWnd, INT Flags) 397 { 398 BOOL Ret = FALSE; 399 400 if ( (pWnd->style & WS_VISIBLE) && ((pWnd->style & WS_CAPTION) == WS_CAPTION) ) 401 { 402 if (pWnd->state & WNDS_HASCAPTION && pWnd->head.pti->MessageQueue == gpqForeground) 403 Flags |= DC_ACTIVE; 404 /* 405 * When themes are not enabled we can go on and paint the non client area. 406 * However if we do that with themes enabled we will draw a classic frame. 407 * This is solved by sending a themes specific message to notify the themes 408 * engine that the caption needs to be redrawn 409 */ 410 if (gpsi->dwSRVIFlags & SRVINFO_APIHOOK) 411 { 412 /* 413 * This will cause uxtheme to either paint the themed caption or call 414 * RealUserDrawCaption in order to draw the classic caption when themes 415 * are disabled but the themes service is enabled 416 */ 417 TRACE("UDCB Flags %08x\n"); 418 co_IntSendMessage(UserHMGetHandle(pWnd), WM_NCUAHDRAWCAPTION, Flags, 0); 419 } 420 else 421 { 422 HDC hDC = UserGetDCEx(pWnd, NULL, DCX_WINDOW|DCX_USESTYLE); 423 UserDrawCaptionBar(pWnd, hDC, Flags); 424 UserReleaseDC(pWnd, hDC, FALSE); 425 } 426 Ret = TRUE; 427 } 428 // Support window tray 429 return Ret; 430 } 431 432 // WM_SETICON 433 LRESULT FASTCALL 434 DefWndSetIcon(PWND pWnd, WPARAM wParam, LPARAM lParam) 435 { 436 HICON hIcon, hIconSmall, hIconOld; 437 438 if ( wParam > ICON_SMALL2 ) 439 { 440 EngSetLastError(ERROR_INVALID_PARAMETER); 441 return 0; 442 } 443 hIconSmall = UserGetProp(pWnd, gpsi->atomIconSmProp, TRUE); 444 hIcon = UserGetProp(pWnd, gpsi->atomIconProp, TRUE); 445 446 hIconOld = wParam == ICON_BIG ? hIcon : hIconSmall; 447 448 switch(wParam) 449 { 450 case ICON_BIG: 451 hIcon = (HICON)lParam; 452 break; 453 case ICON_SMALL: 454 hIconSmall = (HICON)lParam; 455 break; 456 case ICON_SMALL2: 457 ERR("FIXME: Set ICON_SMALL2 support!\n"); 458 default: 459 break; 460 } 461 462 UserSetProp(pWnd, gpsi->atomIconProp, hIcon, TRUE); 463 UserSetProp(pWnd, gpsi->atomIconSmProp, hIconSmall, TRUE); 464 465 if ((pWnd->style & WS_CAPTION ) == WS_CAPTION) 466 UserPaintCaption(pWnd, DC_ICON); 467 468 return (LRESULT)hIconOld; 469 } 470 471 LRESULT FASTCALL 472 DefWndGetIcon(PWND pWnd, WPARAM wParam, LPARAM lParam) 473 { 474 HICON hIconRet; 475 if ( wParam > ICON_SMALL2 ) 476 { 477 EngSetLastError(ERROR_INVALID_PARAMETER); 478 return 0; 479 } 480 switch(wParam) 481 { 482 case ICON_BIG: 483 hIconRet = UserGetProp(pWnd, gpsi->atomIconProp, TRUE); 484 break; 485 case ICON_SMALL: 486 case ICON_SMALL2: 487 hIconRet = UserGetProp(pWnd, gpsi->atomIconSmProp, TRUE); 488 break; 489 default: 490 break; 491 } 492 return (LRESULT)hIconRet; 493 } 494 495 VOID FASTCALL 496 DefWndScreenshot(PWND pWnd) 497 { 498 RECT rect; 499 HDC hdc; 500 INT w; 501 INT h; 502 HBITMAP hbitmap; 503 HDC hdc2; 504 SETCLIPBDATA scd = {FALSE, FALSE}; 505 506 UserOpenClipboard(UserHMGetHandle(pWnd)); 507 UserEmptyClipboard(); 508 509 hdc = UserGetWindowDC(pWnd); 510 IntGetWindowRect(pWnd, &rect); 511 w = rect.right - rect.left; 512 h = rect.bottom - rect.top; 513 514 hbitmap = NtGdiCreateCompatibleBitmap(hdc, w, h); 515 hdc2 = NtGdiCreateCompatibleDC(hdc); 516 NtGdiSelectBitmap(hdc2, hbitmap); 517 518 NtGdiBitBlt(hdc2, 0, 0, w, h, hdc, 0, 0, SRCCOPY, 0, 0); 519 520 UserSetClipboardData(CF_BITMAP, hbitmap, &scd); 521 522 UserReleaseDC(pWnd, hdc, FALSE); 523 UserReleaseDC(pWnd, hdc2, FALSE); 524 525 UserCloseClipboard(); 526 } 527 528 /* 529 Win32k counterpart of User DefWindowProc 530 */ 531 LRESULT FASTCALL 532 IntDefWindowProc( 533 PWND Wnd, 534 UINT Msg, 535 WPARAM wParam, 536 LPARAM lParam, 537 BOOL Ansi) 538 { 539 PTHREADINFO pti = PsGetCurrentThreadWin32Thread(); 540 LRESULT lResult = 0; 541 USER_REFERENCE_ENTRY Ref; 542 BOOL IsTaskBar; 543 DWORD Style; 544 DWORD ExStyle; 545 546 if (Msg > WM_USER) return 0; 547 548 switch (Msg) 549 { 550 case WM_GETTEXTLENGTH: 551 { 552 PWSTR buf; 553 ULONG len; 554 555 if (Wnd != NULL && Wnd->strName.Length != 0) 556 { 557 buf = Wnd->strName.Buffer; 558 if (buf != NULL && 559 NT_SUCCESS(RtlUnicodeToMultiByteSize(&len, 560 buf, 561 Wnd->strName.Length))) 562 { 563 lResult = (LRESULT) (Wnd->strName.Length / sizeof(WCHAR)); 564 } 565 } 566 else lResult = 0L; 567 568 break; 569 } 570 571 case WM_GETTEXT: // FIXME: Handle Ansi 572 { 573 PWSTR buf = NULL; 574 PWSTR outbuf = (PWSTR)lParam; 575 576 if (Wnd != NULL && wParam != 0) 577 { 578 if (Wnd->strName.Buffer != NULL) 579 buf = Wnd->strName.Buffer; 580 else 581 outbuf[0] = L'\0'; 582 583 if (buf != NULL) 584 { 585 if (Wnd->strName.Length != 0) 586 { 587 lResult = min(Wnd->strName.Length / sizeof(WCHAR), wParam - 1); 588 RtlCopyMemory(outbuf, 589 buf, 590 lResult * sizeof(WCHAR)); 591 outbuf[lResult] = L'\0'; 592 } 593 else 594 outbuf[0] = L'\0'; 595 } 596 } 597 break; 598 } 599 600 case WM_SETTEXT: // FIXME: Handle Ansi 601 { 602 DefSetText(Wnd, (PCWSTR)lParam); 603 604 if ((Wnd->style & WS_CAPTION) == WS_CAPTION) 605 UserPaintCaption(Wnd, DC_TEXT); 606 IntNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, Wnd, OBJID_WINDOW, CHILDID_SELF, 0); 607 lResult = 1; 608 break; 609 } 610 611 case WM_SYSCOMMAND: 612 { 613 TRACE("hwnd %p WM_SYSCOMMAND %lx %lx\n", Wnd->head.h, wParam, lParam ); 614 lResult = DefWndHandleSysCommand(Wnd, wParam, lParam); 615 break; 616 } 617 618 case WM_SHOWWINDOW: 619 { 620 if ((Wnd->style & WS_VISIBLE) && wParam) break; 621 if (!(Wnd->style & WS_VISIBLE) && !wParam) break; 622 if (!Wnd->spwndOwner) break; 623 if (LOWORD(lParam)) 624 { 625 co_WinPosShowWindow(Wnd, wParam ? SW_SHOWNOACTIVATE : SW_HIDE); 626 } 627 break; 628 } 629 630 case WM_CLIENTSHUTDOWN: 631 return IntClientShutdown(Wnd, wParam, lParam); 632 633 case WM_APPCOMMAND: 634 if ( (Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD && 635 Wnd != co_GetDesktopWindow(Wnd) ) 636 { 637 if (!co_HOOK_CallHooks(WH_SHELL, HSHELL_APPCOMMAND, wParam, lParam)) 638 co_IntShellHookNotify(HSHELL_APPCOMMAND, wParam, lParam); 639 break; 640 } 641 UserRefObjectCo(Wnd->spwndParent, &Ref); 642 lResult = co_IntSendMessage(UserHMGetHandle(Wnd->spwndParent), WM_APPCOMMAND, wParam, lParam); 643 UserDerefObjectCo(Wnd->spwndParent); 644 break; 645 646 case WM_KEYF1: 647 { 648 HELPINFO hi; 649 HMENU hMenu = UlongToHandle(Wnd->IDMenu); 650 PWND pwndActive = MENU_IsMenuActive(); 651 hi.cbSize = sizeof(HELPINFO); 652 hi.MousePos = gpsi->ptCursor; 653 hi.iContextType = HELPINFO_MENUITEM; 654 hi.hItemHandle = pwndActive ? UserHMGetHandle(pwndActive) : UserHMGetHandle(Wnd); 655 hi.iCtrlId = (Wnd->style & (WS_POPUP|WS_CHILD)) == WS_CHILD ? IntMenuItemFromPoint(Wnd, hMenu, hi.MousePos) : 0; 656 hi.dwContextId = IntGetWindowContextHelpId(Wnd); 657 658 co_IntSendMessage( UserHMGetHandle(Wnd), WM_HELP, 0, (LPARAM)&hi ); 659 break; 660 } 661 662 case WM_SETICON: 663 { 664 return DefWndSetIcon(Wnd, wParam, lParam); 665 } 666 667 case WM_GETICON: 668 { 669 return DefWndGetIcon(Wnd, wParam, lParam); 670 } 671 672 case WM_HELP: 673 { 674 PWND Parent = IntGetParent(Wnd); 675 co_IntSendMessage(UserHMGetHandle(Parent), Msg, wParam, lParam); 676 break; 677 } 678 679 case WM_LBUTTONDOWN: 680 case WM_RBUTTONDOWN: 681 case WM_MBUTTONDOWN: 682 pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK); 683 break; 684 685 case WM_NCLBUTTONDOWN: 686 return NC_HandleNCLButtonDown(Wnd, wParam, lParam); 687 688 case WM_NCRBUTTONDOWN: 689 return NC_HandleNCRButtonDown(Wnd, wParam, lParam); 690 691 case WM_LBUTTONDBLCLK: 692 return NC_HandleNCLButtonDblClk(Wnd, HTCLIENT, lParam); 693 694 case WM_NCLBUTTONDBLCLK: 695 return NC_HandleNCLButtonDblClk(Wnd, wParam, lParam); 696 697 case WM_RBUTTONUP: 698 { 699 POINT Pt; 700 701 Pt.x = GET_X_LPARAM(lParam); 702 Pt.y = GET_Y_LPARAM(lParam); 703 IntClientToScreen(Wnd, &Pt); 704 lParam = MAKELPARAM(Pt.x, Pt.y); 705 co_IntSendMessage(UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), lParam); 706 break; 707 } 708 709 case WM_NCRBUTTONUP: 710 /* 711 * FIXME : we must NOT send WM_CONTEXTMENU on a WM_NCRBUTTONUP (checked 712 * in Windows), but what _should_ we do? According to MSDN : 713 * "If it is appropriate to do so, the system sends the WM_SYSCOMMAND 714 * message to the window". When is it appropriate? 715 */ 716 ERR("WM_NCRBUTTONUP\n"); 717 break; 718 719 case WM_XBUTTONUP: 720 case WM_NCXBUTTONUP: 721 if (HIWORD(wParam) == XBUTTON1 || HIWORD(wParam) == XBUTTON2) 722 { 723 co_IntSendMessage(UserHMGetHandle(Wnd), WM_APPCOMMAND, (WPARAM)UserHMGetHandle(Wnd), 724 MAKELPARAM(LOWORD(wParam), FAPPCOMMAND_MOUSE | HIWORD(wParam))); 725 } 726 break; 727 728 729 case WM_CONTEXTMENU: 730 { 731 if (Wnd->style & WS_CHILD) 732 { 733 co_IntSendMessage(UserHMGetHandle(IntGetParent(Wnd)), Msg, wParam, lParam); 734 } 735 else 736 { 737 POINT Pt; 738 LONG_PTR Style; 739 LONG HitCode; 740 741 Style = Wnd->style; 742 743 Pt.x = GET_X_LPARAM(lParam); 744 Pt.y = GET_Y_LPARAM(lParam); 745 if (Style & WS_CHILD) 746 { 747 IntScreenToClient(IntGetParent(Wnd), &Pt); 748 } 749 750 HitCode = GetNCHitEx(Wnd, Pt); 751 752 if (HitCode == HTCAPTION || HitCode == HTSYSMENU) 753 { 754 PMENU SystemMenu; 755 UINT Flags; 756 757 if((SystemMenu = IntGetSystemMenu(Wnd, FALSE))) 758 { 759 MENU_InitSysMenuPopup(SystemMenu, Wnd->style, Wnd->pcls->style, HitCode); 760 761 if(HitCode == HTCAPTION) 762 Flags = TPM_LEFTBUTTON | TPM_RIGHTBUTTON; 763 else 764 Flags = TPM_LEFTBUTTON; 765 766 IntTrackPopupMenuEx(SystemMenu, Flags|TPM_SYSTEM_MENU, Pt.x, Pt.y, Wnd, NULL); 767 } 768 } 769 if (HitCode == HTHSCROLL || HitCode == HTVSCROLL) 770 { 771 WARN("Scroll Menu Not Supported\n"); 772 } 773 } 774 break; 775 } 776 777 case WM_KEYDOWN: 778 if (wParam == VK_F10) 779 { 780 pti->MessageQueue->QF_flags |= QF_FF10STATUS; 781 782 if (UserGetKeyState(VK_SHIFT) & 0x8000) 783 { 784 co_IntSendMessage(UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), MAKELPARAM(-1, -1)); 785 } 786 } 787 if (IS_KEY_DOWN(gafAsyncKeyState, VK_LWIN) || IS_KEY_DOWN(gafAsyncKeyState, VK_RWIN)) 788 { 789 HWND hwndTop = UserGetForegroundWindow(); 790 PWND topWnd = UserGetWindowObject(hwndTop); 791 792 /* Test for typical TaskBar ExStyle Values */ 793 ExStyle = (topWnd->ExStyle & WS_EX_TOOLWINDOW); 794 TRACE("ExStyle is '%x'.\n", ExStyle); 795 796 /* Test for typical TaskBar Style Values */ 797 Style = (topWnd->style & (WS_POPUP | WS_VISIBLE | 798 WS_CLIPSIBLINGS | WS_CLIPCHILDREN)); 799 TRACE("Style is '%x'.\n", Style); 800 801 /* Test for masked typical TaskBar Style and ExStyles to detect TaskBar */ 802 IsTaskBar = (Style == (WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN)) 803 && (ExStyle == WS_EX_TOOLWINDOW); 804 TRACE("This %s the TaskBar.\n", IsTaskBar ? "is" : "is not"); 805 806 if (topWnd && !IsTaskBar) /* Second test is so we are not touching the Taskbar */ 807 { 808 if ((topWnd->style & WS_THICKFRAME) == 0) 809 { 810 return 0; 811 } 812 813 if (wParam == VK_DOWN) 814 { 815 if (topWnd->style & WS_MAXIMIZE) 816 co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_RESTORE, lParam); 817 else 818 co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_MINIMIZE, lParam); 819 } 820 else if (wParam == VK_UP) 821 { 822 RECT currentRect; 823 if ((topWnd->InternalPos.NormalRect.right == topWnd->InternalPos.NormalRect.left) || 824 (topWnd->InternalPos.NormalRect.top == topWnd->InternalPos.NormalRect.bottom)) 825 { 826 currentRect = topWnd->rcWindow; 827 } 828 else 829 { 830 currentRect = topWnd->InternalPos.NormalRect; 831 } 832 co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_MAXIMIZE, 0); 833 834 // save normal rect if maximazing snapped window 835 topWnd->InternalPos.NormalRect = currentRect; 836 } 837 else if (wParam == VK_LEFT || wParam == VK_RIGHT) 838 { 839 RECT snapRect, normalRect, windowRect; 840 BOOL snapped; 841 normalRect = topWnd->InternalPos.NormalRect; 842 snapped = (normalRect.left != 0 && normalRect.right != 0 && 843 normalRect.top != 0 && normalRect.bottom != 0); 844 845 if (topWnd->style & WS_MAXIMIZE) 846 { 847 co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_RESTORE, lParam); 848 snapped = FALSE; 849 } 850 windowRect = topWnd->rcWindow; 851 852 UserSystemParametersInfo(SPI_GETWORKAREA, 0, &snapRect, 0); 853 if (wParam == VK_LEFT) 854 { 855 snapRect.right = (snapRect.left + snapRect.right) / 2; 856 } 857 else // VK_RIGHT 858 { 859 snapRect.left = (snapRect.left + snapRect.right) / 2; 860 } 861 862 if (snapped) 863 { 864 // if window was snapped but moved to other location - restore normal size 865 if (!IntEqualRect(&snapRect, &windowRect)) 866 { 867 RECT empty = {0, 0, 0, 0}; 868 co_WinPosSetWindowPos(topWnd, 869 0, 870 normalRect.left, 871 normalRect.top, 872 normalRect.right - normalRect.left, 873 normalRect.bottom - normalRect.top, 874 0); 875 topWnd->InternalPos.NormalRect = empty; 876 } 877 } 878 else 879 { 880 co_WinPosSetWindowPos(topWnd, 881 0, 882 snapRect.left, 883 snapRect.top, 884 snapRect.right - snapRect.left, 885 snapRect.bottom - snapRect.top, 886 0); 887 topWnd->InternalPos.NormalRect = windowRect; 888 } 889 } 890 } 891 } 892 break; 893 894 case WM_SYSKEYDOWN: 895 { 896 if (HIWORD(lParam) & KF_ALTDOWN) 897 { /* Previous state, if the key was down before this message, 898 this is a cheap way to ignore autorepeat keys. */ 899 if ( !(HIWORD(lParam) & KF_REPEAT) ) 900 { 901 if ( ( wParam == VK_MENU || 902 wParam == VK_LMENU || 903 wParam == VK_RMENU ) && !(pti->MessageQueue->QF_flags & QF_FMENUSTATUS)) //iMenuSysKey ) 904 pti->MessageQueue->QF_flags |= QF_FMENUSTATUS; //iMenuSysKey = 1; 905 else 906 pti->MessageQueue->QF_flags &= ~QF_FMENUSTATUS; //iMenuSysKey = 0; 907 } 908 909 pti->MessageQueue->QF_flags &= ~QF_FF10STATUS; //iF10Key = 0; 910 911 if (wParam == VK_F4) /* Try to close the window */ 912 { 913 PWND top = UserGetAncestor(Wnd, GA_ROOT); 914 if (!(top->style & CS_NOCLOSE)) 915 UserPostMessage(UserHMGetHandle(top), WM_SYSCOMMAND, SC_CLOSE, 0); 916 } 917 else if (wParam == VK_SNAPSHOT) // Alt-VK_SNAPSHOT? 918 { 919 PWND pwnd = Wnd; 920 while (IntGetParent(pwnd) != NULL) 921 { 922 pwnd = IntGetParent(pwnd); 923 } 924 ERR("DefWndScreenshot\n"); 925 DefWndScreenshot(pwnd); 926 } 927 else if ( wParam == VK_ESCAPE || wParam == VK_TAB ) // Alt-Tab/ESC Alt-Shift-Tab/ESC 928 { 929 WPARAM wParamTmp; 930 HWND Active = UserGetActiveWindow(); // Noticed MDI problem. 931 if (!Active) 932 { 933 FIXME("WM_SYSKEYDOWN VK_ESCAPE no active\n"); 934 break; 935 } 936 wParamTmp = UserGetKeyState(VK_SHIFT) & 0x8000 ? SC_PREVWINDOW : SC_NEXTWINDOW; 937 co_IntSendMessage( Active, WM_SYSCOMMAND, wParamTmp, wParam ); 938 } 939 } 940 else if( wParam == VK_F10 ) 941 { 942 if (UserGetKeyState(VK_SHIFT) & 0x8000) 943 co_IntSendMessage( UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), MAKELPARAM(-1, -1) ); 944 pti->MessageQueue->QF_flags |= QF_FF10STATUS; //iF10Key = 1; 945 } 946 else if( wParam == VK_ESCAPE && (UserGetKeyState(VK_SHIFT) & 0x8000)) 947 co_IntSendMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_KEYMENU, ' ' ); 948 break; 949 } 950 951 case WM_KEYUP: 952 case WM_SYSKEYUP: 953 { 954 /* Press and release F10 or ALT */ 955 if (((wParam == VK_MENU || wParam == VK_LMENU || wParam == VK_RMENU) 956 && (pti->MessageQueue->QF_flags & (QF_FMENUSTATUS|QF_FMENUSTATUSBREAK)) == QF_FMENUSTATUS /*iMenuSysKey*/) || 957 ((wParam == VK_F10) && pti->MessageQueue->QF_flags & QF_FF10STATUS /*iF10Key*/)) 958 co_IntSendMessage( UserHMGetHandle(UserGetAncestor( Wnd, GA_ROOT )), WM_SYSCOMMAND, SC_KEYMENU, 0L ); 959 pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK|QF_FF10STATUS); //iMenuSysKey = iF10Key = 0; 960 break; 961 } 962 963 case WM_SYSCHAR: 964 { 965 pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK); //iMenuSysKey = 0; 966 if (wParam == VK_RETURN && (Wnd->style & WS_MINIMIZE) != 0) 967 { 968 UserPostMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_RESTORE, 0L ); 969 break; 970 } 971 if ((HIWORD(lParam) & KF_ALTDOWN) && wParam) 972 { 973 if (wParam == VK_TAB || wParam == VK_ESCAPE) break; 974 if (wParam == VK_SPACE && Wnd->style & WS_CHILD) 975 co_IntSendMessage( UserHMGetHandle(IntGetParent(Wnd)), Msg, wParam, lParam ); 976 else 977 co_IntSendMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_KEYMENU, wParam ); 978 } 979 else /* check for Ctrl-Esc */ 980 if (wParam != VK_ESCAPE) UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, 0); //MessageBeep(0); 981 break; 982 } 983 984 case WM_CANCELMODE: 985 { 986 pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK); 987 988 MENU_EndMenu( Wnd ); 989 if (IntGetCaptureWindow() == UserHMGetHandle(Wnd)) 990 { 991 IntReleaseCapture(); 992 } 993 break; 994 } 995 996 case WM_CLOSE: 997 co_UserDestroyWindow(Wnd); 998 break; 999 1000 case WM_CTLCOLORMSGBOX: 1001 case WM_CTLCOLOREDIT: 1002 case WM_CTLCOLORLISTBOX: 1003 case WM_CTLCOLORBTN: 1004 case WM_CTLCOLORDLG: 1005 case WM_CTLCOLORSTATIC: 1006 case WM_CTLCOLORSCROLLBAR: 1007 return (LRESULT) DefWndControlColor((HDC)wParam, Msg - WM_CTLCOLORMSGBOX); 1008 1009 case WM_CTLCOLOR: 1010 return (LRESULT) DefWndControlColor((HDC)wParam, HIWORD(lParam)); 1011 1012 case WM_SETCURSOR: 1013 { 1014 if (Wnd->style & WS_CHILD) 1015 { 1016 /* with the exception of the border around a resizable wnd, 1017 * give the parent first chance to set the cursor */ 1018 if (LOWORD(lParam) < HTLEFT || LOWORD(lParam) > HTBOTTOMRIGHT) 1019 { 1020 PWND parent = Wnd->spwndParent;//IntGetParent( Wnd ); 1021 if (parent != UserGetDesktopWindow() && 1022 co_IntSendMessage( UserHMGetHandle(parent), WM_SETCURSOR, wParam, lParam)) 1023 return TRUE; 1024 } 1025 } 1026 return DefWndHandleSetCursor(Wnd, wParam, lParam); 1027 } 1028 1029 case WM_MOUSEACTIVATE: 1030 if (Wnd->style & WS_CHILD) 1031 { 1032 LONG Ret; 1033 HWND hwndParent; 1034 PWND pwndParent = IntGetParent(Wnd); 1035 hwndParent = pwndParent ? UserHMGetHandle(pwndParent) : NULL; 1036 if (hwndParent) Ret = co_IntSendMessage(hwndParent, WM_MOUSEACTIVATE, wParam, lParam); 1037 if (Ret) return (Ret); 1038 } 1039 return ( (HIWORD(lParam) == WM_LBUTTONDOWN && LOWORD(lParam) == HTCAPTION) ? MA_NOACTIVATE : MA_ACTIVATE ); 1040 1041 case WM_ACTIVATE: 1042 /* The default action in Windows is to set the keyboard focus to 1043 * the window, if it's being activated and not minimized */ 1044 if (LOWORD(wParam) != WA_INACTIVE && 1045 !(Wnd->style & WS_MINIMIZE)) 1046 { 1047 //ERR("WM_ACTIVATE %p\n",hWnd); 1048 co_UserSetFocus(Wnd); 1049 } 1050 break; 1051 1052 case WM_MOUSEWHEEL: 1053 if (Wnd->style & WS_CHILD) 1054 { 1055 HWND hwndParent; 1056 PWND pwndParent = IntGetParent(Wnd); 1057 hwndParent = pwndParent ? UserHMGetHandle(pwndParent) : NULL; 1058 return co_IntSendMessage( hwndParent, WM_MOUSEWHEEL, wParam, lParam); 1059 } 1060 break; 1061 1062 case WM_ERASEBKGND: 1063 case WM_ICONERASEBKGND: 1064 { 1065 RECT Rect; 1066 HBRUSH hBrush = Wnd->pcls->hbrBackground; 1067 if (!hBrush) return 0; 1068 if (hBrush <= (HBRUSH)COLOR_MENUBAR) 1069 { 1070 hBrush = IntGetSysColorBrush(HandleToUlong(hBrush)); 1071 } 1072 if (Wnd->pcls->style & CS_PARENTDC) 1073 { 1074 /* can't use GetClipBox with a parent DC or we fill the whole parent */ 1075 IntGetClientRect(Wnd, &Rect); 1076 GreDPtoLP((HDC)wParam, (LPPOINT)&Rect, 2); 1077 } 1078 else 1079 { 1080 GdiGetClipBox((HDC)wParam, &Rect); 1081 } 1082 FillRect((HDC)wParam, &Rect, hBrush); 1083 return (1); 1084 } 1085 1086 case WM_GETHOTKEY: 1087 //ERR("WM_GETHOTKEY\n"); 1088 return DefWndGetHotKey(Wnd); 1089 case WM_SETHOTKEY: 1090 //ERR("WM_SETHOTKEY\n"); 1091 return DefWndSetHotKey(Wnd, wParam); 1092 1093 case WM_NCHITTEST: 1094 { 1095 POINT Point; 1096 Point.x = GET_X_LPARAM(lParam); 1097 Point.y = GET_Y_LPARAM(lParam); 1098 return GetNCHitEx(Wnd, Point); 1099 } 1100 1101 case WM_PRINT: 1102 { 1103 DefWndPrint(Wnd, (HDC)wParam, lParam); 1104 return (0); 1105 } 1106 1107 case WM_SYSCOLORCHANGE: 1108 { 1109 /* force to redraw non-client area */ 1110 UserPaintCaption(Wnd, DC_NC); 1111 /* Use InvalidateRect to redraw client area, enable 1112 * erase to redraw all subcontrols otherwise send the 1113 * WM_SYSCOLORCHANGE to child windows/controls is required 1114 */ 1115 co_UserRedrawWindow( Wnd, NULL, NULL, RDW_ALLCHILDREN|RDW_INVALIDATE|RDW_ERASE); 1116 return (0); 1117 } 1118 1119 case WM_PAINTICON: 1120 case WM_PAINT: 1121 { 1122 PAINTSTRUCT Ps; 1123 HDC hDC; 1124 1125 /* If already in Paint and Client area is not empty just return. */ 1126 if (Wnd->state2 & WNDS2_STARTPAINT && !RECTL_bIsEmptyRect(&Wnd->rcClient)) 1127 { 1128 ERR("In Paint and Client area is not empty!\n"); 1129 return 0; 1130 } 1131 1132 hDC = IntBeginPaint(Wnd, &Ps); 1133 if (hDC) 1134 { 1135 if (((Wnd->style & WS_MINIMIZE) != 0) && (Wnd->pcls->spicn)) 1136 { 1137 RECT ClientRect; 1138 INT x, y; 1139 1140 ERR("Doing Paint and Client area is empty!\n"); 1141 IntGetClientRect(Wnd, &ClientRect); 1142 x = (ClientRect.right - ClientRect.left - UserGetSystemMetrics(SM_CXICON)) / 2; 1143 y = (ClientRect.bottom - ClientRect.top - UserGetSystemMetrics(SM_CYICON)) / 2; 1144 UserReferenceObject(Wnd->pcls->spicn); 1145 UserDrawIconEx(hDC, x, y, Wnd->pcls->spicn, 0, 0, 0, 0, DI_NORMAL | DI_COMPAT | DI_DEFAULTSIZE); 1146 UserDereferenceObject(Wnd->pcls->spicn); 1147 } 1148 1149 IntEndPaint(Wnd, &Ps); 1150 } 1151 return (0); 1152 } 1153 1154 case WM_SYNCPAINT: 1155 { 1156 HRGN hRgn; 1157 Wnd->state &= ~WNDS_SYNCPAINTPENDING; 1158 TRACE("WM_SYNCPAINT\n"); 1159 hRgn = NtGdiCreateRectRgn(0, 0, 0, 0); 1160 if (hRgn) 1161 { 1162 if (co_UserGetUpdateRgn(Wnd, hRgn, FALSE) != NULLREGION) 1163 { 1164 PREGION pRgn = REGION_LockRgn(hRgn); 1165 if (pRgn) REGION_UnlockRgn(pRgn); 1166 if (!wParam) 1167 wParam = (RDW_ERASENOW | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN); 1168 co_UserRedrawWindow(Wnd, NULL, pRgn, wParam); 1169 } 1170 GreDeleteObject(hRgn); 1171 } 1172 return 0; 1173 } 1174 1175 case WM_SETREDRAW: 1176 if (wParam) 1177 { 1178 if (!(Wnd->style & WS_VISIBLE)) 1179 { 1180 IntSetStyle( Wnd, WS_VISIBLE, 0 ); 1181 Wnd->state |= WNDS_SENDNCPAINT; 1182 } 1183 } 1184 else 1185 { 1186 if (Wnd->style & WS_VISIBLE) 1187 { 1188 co_UserRedrawWindow( Wnd, NULL, NULL, RDW_ALLCHILDREN | RDW_VALIDATE ); 1189 IntSetStyle( Wnd, 0, WS_VISIBLE ); 1190 } 1191 } 1192 return 0; 1193 1194 case WM_WINDOWPOSCHANGING: 1195 { 1196 return (DefWndHandleWindowPosChanging(Wnd, (WINDOWPOS*)lParam)); 1197 } 1198 1199 case WM_WINDOWPOSCHANGED: 1200 { 1201 return (DefWndHandleWindowPosChanged(Wnd, (WINDOWPOS*)lParam)); 1202 } 1203 1204 case WM_NCCALCSIZE: 1205 { 1206 return NC_HandleNCCalcSize( Wnd, wParam, (RECTL *)lParam, FALSE ); 1207 } 1208 1209 case WM_NCACTIVATE: 1210 { 1211 return NC_HandleNCActivate( Wnd, wParam, lParam ); 1212 } 1213 1214 // 1215 // NC Paint mode. 1216 // 1217 case WM_NCPAINT: 1218 { 1219 HDC hDC = UserGetDCEx(Wnd, (HRGN)wParam, DCX_WINDOW | DCX_INTERSECTRGN | DCX_USESTYLE | DCX_KEEPCLIPRGN); 1220 Wnd->state |= WNDS_FORCEMENUDRAW; 1221 NC_DoNCPaint(Wnd, hDC, -1); 1222 Wnd->state &= ~WNDS_FORCEMENUDRAW; 1223 UserReleaseDC(Wnd, hDC, FALSE); 1224 return 0; 1225 } 1226 // 1227 // Draw Caption mode. 1228 // 1229 // wParam are DC_* flags. 1230 // 1231 case WM_NCUAHDRAWCAPTION: 1232 { 1233 HDC hDC = UserGetDCEx(Wnd, NULL, DCX_WINDOW|DCX_USESTYLE); 1234 TRACE("WM_NCUAHDRAWCAPTION: wParam DC_ flags %08x\n",wParam); 1235 UserDrawCaptionBar(Wnd, hDC, wParam|DC_FRAME); // Include DC_FRAME to comp for drawing glich. 1236 UserReleaseDC(Wnd, hDC, FALSE); 1237 return 0; 1238 } 1239 // 1240 // Draw Frame mode. 1241 // 1242 // wParam is HDC, lParam are DC_ACTIVE and or DC_REDRAWHUNGWND. 1243 // 1244 case WM_NCUAHDRAWFRAME: 1245 { 1246 TRACE("WM_NCUAHDRAWFRAME: wParam hDC %p lParam DC_ flags %08x\n",wParam,lParam); 1247 NC_DoNCPaint(Wnd, (HDC)wParam, lParam|DC_NC); 1248 return 0; 1249 } 1250 1251 /* ReactOS only. */ 1252 case WM_CBT: 1253 { 1254 switch (wParam) 1255 { 1256 case HCBT_MOVESIZE: 1257 { 1258 RECTL rt; 1259 1260 if (lParam) 1261 { 1262 _SEH2_TRY 1263 { 1264 ProbeForRead((PVOID)lParam, 1265 sizeof(RECT), 1266 1); 1267 1268 RtlCopyMemory(&rt, 1269 (PVOID)lParam, 1270 sizeof(RECT)); 1271 } 1272 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) 1273 { 1274 lResult = 1; 1275 } 1276 _SEH2_END; 1277 } 1278 if (!lResult) 1279 lResult = co_HOOK_CallHooks(WH_CBT, HCBT_MOVESIZE, (WPARAM)Wnd->head.h, lParam ? (LPARAM)&rt : 0); 1280 } 1281 break; 1282 } 1283 break; 1284 } 1285 break; 1286 } 1287 return lResult; 1288 } 1289 1290 /* EOF */ 1291