win32ss/user/ntuser/defwnd.c

   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
 543    if (Msg > WM_USER) return 0;
 544
 545    switch (Msg)
 546    {
 547       case WM_GETTEXTLENGTH:
 548       {
 549             PWSTR buf;
 550             ULONG len;
 551
 552             if (Wnd != NULL && Wnd->strName.Length != 0)
 553             {
 554                 buf = Wnd->strName.Buffer;
 555                 if (buf != NULL &&
 556                     NT_SUCCESS(RtlUnicodeToMultiByteSize(&len,
 557                                                          buf,
 558                                                          Wnd->strName.Length)))
 559                 {
 560                     lResult = (LRESULT) (Wnd->strName.Length / sizeof(WCHAR));
 561                 }
 562             }
 563             else lResult = 0L;
 564
 565             break;
 566       }
 567
 568       case WM_GETTEXT: // FIXME: Handle Ansi
 569       {
 570             PWSTR buf = NULL;
 571             PWSTR outbuf = (PWSTR)lParam;
 572
 573             if (Wnd != NULL && wParam != 0)
 574             {
 575                 if (Wnd->strName.Buffer != NULL)
 576                     buf = Wnd->strName.Buffer;
 577                 else
 578                     outbuf[0] = L'\0';
 579
 580                 if (buf != NULL)
 581                 {
 582                     if (Wnd->strName.Length != 0)
 583                     {
 584                         lResult = min(Wnd->strName.Length / sizeof(WCHAR), wParam - 1);
 585                         RtlCopyMemory(outbuf,
 586                                       buf,
 587                                       lResult * sizeof(WCHAR));
 588                         outbuf[lResult] = L'\0';
 589                     }
 590                     else
 591                         outbuf[0] = L'\0';
 592                 }
 593             }
 594             break;
 595       }
 596
 597       case WM_SETTEXT: // FIXME: Handle Ansi
 598       {
 599             DefSetText(Wnd, (PCWSTR)lParam);
 600
 601             if ((Wnd->style & WS_CAPTION) == WS_CAPTION)
 602                 UserPaintCaption(Wnd, DC_TEXT);
 603             IntNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, Wnd, OBJID_WINDOW, CHILDID_SELF, 0);
 604             lResult = 1;
 605             break;
 606       }
 607
 608       case WM_SYSCOMMAND:
 609       {
 610          TRACE("hwnd %p WM_SYSCOMMAND %lx %lx\n", Wnd->head.h, wParam, lParam );
 611          lResult = DefWndHandleSysCommand(Wnd, wParam, lParam);
 612          break;
 613       }
 614
 615       case WM_SHOWWINDOW:
 616       {
 617          if ((Wnd->style & WS_VISIBLE) && wParam) break;
 618          if (!(Wnd->style & WS_VISIBLE) && !wParam) break;
 619          if (!Wnd->spwndOwner) break;
 620          if (LOWORD(lParam))
 621          {
 622             co_WinPosShowWindow(Wnd, wParam ? SW_SHOWNOACTIVATE : SW_HIDE);
 623          }
 624          break;
 625       }
 626
 627       case WM_CLIENTSHUTDOWN:
 628          return IntClientShutdown(Wnd, wParam, lParam);
 629
 630       case WM_APPCOMMAND:
 631          if ( (Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD &&
 632                Wnd != co_GetDesktopWindow(Wnd) )
 633          {
 634             if (!co_HOOK_CallHooks(WH_SHELL, HSHELL_APPCOMMAND, wParam, lParam))
 635                co_IntShellHookNotify(HSHELL_APPCOMMAND, wParam, lParam);
 636             break;
 637          }
 638          UserRefObjectCo(Wnd->spwndParent, &Ref);
 639          lResult = co_IntSendMessage(UserHMGetHandle(Wnd->spwndParent), WM_APPCOMMAND, wParam, lParam);
 640          UserDerefObjectCo(Wnd->spwndParent);
 641          break;
 642
 643       case WM_KEYF1:
 644       {
 645          HELPINFO hi;
 646          HMENU hMenu = UlongToHandle(Wnd->IDMenu);
 647          PWND pwndActive = MENU_IsMenuActive();
 648          hi.cbSize = sizeof(HELPINFO);
 649          hi.MousePos = gpsi->ptCursor;
 650          hi.iContextType = HELPINFO_MENUITEM;
 651          hi.hItemHandle = pwndActive ? UserHMGetHandle(pwndActive) : UserHMGetHandle(Wnd);
 652          hi.iCtrlId = (Wnd->style & (WS_POPUP|WS_CHILD)) == WS_CHILD ? IntMenuItemFromPoint(Wnd, hMenu, hi.MousePos) : 0;
 653          hi.dwContextId = IntGetWindowContextHelpId(Wnd);
 654
 655          co_IntSendMessage( UserHMGetHandle(Wnd), WM_HELP, 0, (LPARAM)&hi );
 656          break;
 657       }
 658
 659       case WM_SETICON:
 660       {
 661          return DefWndSetIcon(Wnd, wParam, lParam);
 662       }
 663
 664       case WM_GETICON:
 665       {
 666          return DefWndGetIcon(Wnd, wParam, lParam);
 667       }
 668
 669       case WM_HELP:
 670       {
 671          PWND Parent = IntGetParent(Wnd);
 672          co_IntSendMessage(UserHMGetHandle(Parent), Msg, wParam, lParam);
 673          break;
 674       }
 675
 676       case WM_LBUTTONDOWN:
 677       case WM_RBUTTONDOWN:
 678       case WM_MBUTTONDOWN:
 679           pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK);
 680           break;
 681
 682       case WM_NCLBUTTONDOWN:
 683           return NC_HandleNCLButtonDown(Wnd, wParam, lParam);
 684
 685       case WM_NCRBUTTONDOWN:
 686           return NC_HandleNCRButtonDown(Wnd, wParam, lParam);
 687
 688       case WM_LBUTTONDBLCLK:
 689           return NC_HandleNCLButtonDblClk(Wnd, HTCLIENT, lParam);
 690
 691       case WM_NCLBUTTONDBLCLK:
 692           return NC_HandleNCLButtonDblClk(Wnd, wParam, lParam);
 693
 694       case WM_RBUTTONUP:
 695       {
 696             POINT Pt;
 697
 698             Pt.x = GET_X_LPARAM(lParam);
 699             Pt.y = GET_Y_LPARAM(lParam);
 700             IntClientToScreen(Wnd, &Pt);
 701             lParam = MAKELPARAM(Pt.x, Pt.y);
 702             co_IntSendMessage(UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), lParam);
 703             break;
 704       }
 705
 706       case WM_NCRBUTTONUP:
 707           /*
 708            * FIXME : we must NOT send WM_CONTEXTMENU on a WM_NCRBUTTONUP (checked
 709            * in Windows), but what _should_ we do? According to MSDN :
 710            * "If it is appropriate to do so, the system sends the WM_SYSCOMMAND
 711            * message to the window". When is it appropriate?
 712            */
 713            ERR("WM_NCRBUTTONUP\n");
 714           break;
 715
 716       case WM_XBUTTONUP:
 717       case WM_NCXBUTTONUP:
 718           if (HIWORD(wParam) == XBUTTON1 || HIWORD(wParam) == XBUTTON2)
 719           {
 720               co_IntSendMessage(UserHMGetHandle(Wnd), WM_APPCOMMAND, (WPARAM)UserHMGetHandle(Wnd),
 721                                 MAKELPARAM(LOWORD(wParam), FAPPCOMMAND_MOUSE | HIWORD(wParam)));
 722           }
 723           break;
 724
 725
 726       case WM_CONTEXTMENU:
 727       {
 728             if (Wnd->style & WS_CHILD)
 729             {
 730                 co_IntSendMessage(UserHMGetHandle(IntGetParent(Wnd)), Msg, wParam, lParam);
 731             }
 732             else
 733             {
 734                 POINT Pt;
 735                 LONG_PTR Style;
 736                 LONG HitCode;
 737
 738                 Style = Wnd->style;
 739
 740                 Pt.x = GET_X_LPARAM(lParam);
 741                 Pt.y = GET_Y_LPARAM(lParam);
 742                 if (Style & WS_CHILD)
 743                 {
 744                     IntScreenToClient(IntGetParent(Wnd), &Pt);
 745                 }
 746
 747                 HitCode = GetNCHitEx(Wnd, Pt);
 748
 749                 if (HitCode == HTCAPTION || HitCode == HTSYSMENU)
 750                 {
 751                     PMENU SystemMenu;
 752                     UINT Flags;
 753
 754                     if((SystemMenu = IntGetSystemMenu(Wnd, FALSE)))
 755                     {
 756                       MENU_InitSysMenuPopup(SystemMenu, Wnd->style, Wnd->pcls->style, HitCode);
 757
 758                       if(HitCode == HTCAPTION)
 759                         Flags = TPM_LEFTBUTTON | TPM_RIGHTBUTTON;
 760                       else
 761                         Flags = TPM_LEFTBUTTON;
 762
 763                       IntTrackPopupMenuEx(SystemMenu, Flags|TPM_SYSTEM_MENU, Pt.x, Pt.y, Wnd, NULL);
 764                     }
 765                 }
 766                 if (HitCode == HTHSCROLL || HitCode == HTVSCROLL)
 767                 {
 768                    WARN("Scroll Menu Not Supported\n");
 769                 }
 770             }
 771             break;
 772       }
 773
 774       case WM_KEYDOWN:
 775          if (wParam == VK_F10)
 776          {
 777             pti->MessageQueue->QF_flags |= QF_FF10STATUS;
 778
 779             if (UserGetKeyState(VK_SHIFT) & 0x8000)
 780             {
 781                co_IntSendMessage(UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), MAKELPARAM(-1, -1));
 782             }
 783          }
 784          if (IS_KEY_DOWN(gafAsyncKeyState, VK_LWIN) || IS_KEY_DOWN(gafAsyncKeyState, VK_RWIN))
 785          {
 786             HWND hwndTop = UserGetForegroundWindow();
 787             PWND topWnd = UserGetWindowObject(hwndTop);
 788             if (topWnd)
 789             {
 790                if (wParam == VK_DOWN)
 791                {
 792                    if (topWnd->style & WS_MAXIMIZE)
 793                        co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_RESTORE, lParam);
 794                    else
 795                        co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_MINIMIZE, lParam);
 796                }
 797                else if (wParam == VK_UP)
 798                {
 799                   RECT currentRect;
 800                   if ((topWnd->InternalPos.NormalRect.right == topWnd->InternalPos.NormalRect.left) ||
 801                       (topWnd->InternalPos.NormalRect.top == topWnd->InternalPos.NormalRect.bottom))
 802                   {
 803                       currentRect = topWnd->rcWindow;
 804                   }
 805                   else
 806                   {
 807                       currentRect = topWnd->InternalPos.NormalRect;
 808                   }
 809                   co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_MAXIMIZE, 0);
 810
 811                   // save normal rect if maximazing snapped window
 812                   topWnd->InternalPos.NormalRect = currentRect;
 813                }
 814                else if (wParam == VK_LEFT || wParam == VK_RIGHT)
 815                {
 816                   RECT snapRect, normalRect, windowRect;
 817                   BOOL snapped;
 818                   normalRect = topWnd->InternalPos.NormalRect;
 819                   snapped = (normalRect.left != 0 && normalRect.right != 0 &&
 820                              normalRect.top != 0 && normalRect.bottom != 0);
 821
 822                   if (topWnd->style & WS_MAXIMIZE)
 823                   {
 824                      co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_RESTORE, lParam);
 825                      snapped = FALSE;
 826                   }
 827                   windowRect = topWnd->rcWindow;
 828
 829                   UserSystemParametersInfo(SPI_GETWORKAREA, 0, &snapRect, 0);
 830                   if (wParam == VK_LEFT)
 831                   {
 832                      snapRect.right = (snapRect.left + snapRect.right) / 2;
 833                   }
 834                   else // VK_RIGHT
 835                   {
 836                      snapRect.left = (snapRect.left + snapRect.right) / 2;
 837                   }
 838
 839                   if (snapped)
 840                   {
 841                      // if window was snapped but moved to other location - restore normal size
 842                      if (!IntEqualRect(&snapRect, &windowRect))
 843                      {
 844                         RECT empty = {0, 0, 0, 0};
 845                         co_WinPosSetWindowPos(topWnd,
 846                                               0,
 847                                               normalRect.left,
 848                                               normalRect.top,
 849                                               normalRect.right - normalRect.left,
 850                                               normalRect.bottom - normalRect.top,
 851                                               0);
 852                         topWnd->InternalPos.NormalRect = empty;
 853                      }
 854                   }
 855                   else
 856                   {
 857                      co_WinPosSetWindowPos(topWnd,
 858                                            0,
 859                                            snapRect.left,
 860                                            snapRect.top,
 861                                            snapRect.right - snapRect.left,
 862                                            snapRect.bottom - snapRect.top,
 863                                            0);
 864                      topWnd->InternalPos.NormalRect = windowRect;
 865                   }
 866                }
 867             }
 868          }
 869          break;
 870
 871       case WM_SYSKEYDOWN:
 872       {
 873             if (HIWORD(lParam) & KF_ALTDOWN)
 874             {   /* Previous state, if the key was down before this message,
 875                    this is a cheap way to ignore autorepeat keys. */
 876                 if ( !(HIWORD(lParam) & KF_REPEAT) )
 877                 {
 878                    if ( ( wParam == VK_MENU  ||
 879                           wParam == VK_LMENU ||
 880                           wParam == VK_RMENU ) && !(pti->MessageQueue->QF_flags & QF_FMENUSTATUS)) //iMenuSysKey )
 881                        pti->MessageQueue->QF_flags |= QF_FMENUSTATUS; //iMenuSysKey = 1;
 882                    else
 883                        pti->MessageQueue->QF_flags &= ~QF_FMENUSTATUS; //iMenuSysKey = 0;
 884                 }
 885
 886                 pti->MessageQueue->QF_flags &= ~QF_FF10STATUS; //iF10Key = 0;
 887
 888                 if (wParam == VK_F4) /* Try to close the window */
 889                 {
 890                    PWND top = UserGetAncestor(Wnd, GA_ROOT);
 891                    if (!(top->style & CS_NOCLOSE))
 892                       UserPostMessage(UserHMGetHandle(top), WM_SYSCOMMAND, SC_CLOSE, 0);
 893                 }
 894                 else if (wParam == VK_SNAPSHOT) // Alt-VK_SNAPSHOT?
 895                 {
 896                    PWND pwnd = Wnd;
 897                    while (IntGetParent(pwnd) != NULL)
 898                    {
 899                        pwnd = IntGetParent(pwnd);
 900                    }
 901                    ERR("DefWndScreenshot\n");
 902                    DefWndScreenshot(pwnd);
 903                 }
 904                 else if ( wParam == VK_ESCAPE || wParam == VK_TAB ) // Alt-Tab/ESC Alt-Shift-Tab/ESC
 905                 {
 906                    WPARAM wParamTmp;
 907                    HWND Active = UserGetActiveWindow(); // Noticed MDI problem.
 908                    if (!Active)
 909                    {
 910                       FIXME("WM_SYSKEYDOWN VK_ESCAPE no active\n");
 911                       break;
 912                    }
 913                    wParamTmp = UserGetKeyState(VK_SHIFT) & 0x8000 ? SC_PREVWINDOW : SC_NEXTWINDOW;
 914                    co_IntSendMessage( Active, WM_SYSCOMMAND, wParamTmp, wParam );
 915                 }
 916             }
 917             else if( wParam == VK_F10 )
 918             {
 919                 if (UserGetKeyState(VK_SHIFT) & 0x8000)
 920                     co_IntSendMessage( UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), MAKELPARAM(-1, -1) );
 921                 pti->MessageQueue->QF_flags |= QF_FF10STATUS; //iF10Key = 1;
 922             }
 923             else if( wParam == VK_ESCAPE && (UserGetKeyState(VK_SHIFT) & 0x8000))
 924                   co_IntSendMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_KEYMENU, ' ' );
 925             break;
 926       }
 927
 928       case WM_KEYUP:
 929       case WM_SYSKEYUP:
 930       {
 931            /* Press and release F10 or ALT */
 932             if (((wParam == VK_MENU || wParam == VK_LMENU || wParam == VK_RMENU)
 933                  && (pti->MessageQueue->QF_flags & (QF_FMENUSTATUS|QF_FMENUSTATUSBREAK)) == QF_FMENUSTATUS /*iMenuSysKey*/) ||
 934                  ((wParam == VK_F10) && pti->MessageQueue->QF_flags & QF_FF10STATUS /*iF10Key*/))
 935                 co_IntSendMessage( UserHMGetHandle(UserGetAncestor( Wnd, GA_ROOT )), WM_SYSCOMMAND, SC_KEYMENU, 0L );
 936             pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK|QF_FF10STATUS); //iMenuSysKey = iF10Key = 0;
 937             break;
 938       }
 939
 940       case WM_SYSCHAR:
 941       {
 942             pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK); //iMenuSysKey = 0;
 943             if (wParam == VK_RETURN && (Wnd->style & WS_MINIMIZE) != 0)
 944             {
 945                 UserPostMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_RESTORE, 0L );
 946                 break;
 947             }
 948             if ((HIWORD(lParam) & KF_ALTDOWN) && wParam)
 949             {
 950                 if (wParam == VK_TAB || wParam == VK_ESCAPE) break;
 951                 if (wParam == VK_SPACE && Wnd->style & WS_CHILD)
 952                     co_IntSendMessage( UserHMGetHandle(IntGetParent(Wnd)), Msg, wParam, lParam );
 953                 else
 954                     co_IntSendMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_KEYMENU, wParam );
 955             }
 956             else /* check for Ctrl-Esc */
 957                 if (wParam != VK_ESCAPE) UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, 0); //MessageBeep(0);
 958             break;
 959       }
 960
 961       case WM_CANCELMODE:
 962       {
 963          pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK);
 964
 965          MENU_EndMenu( Wnd );
 966          if (IntGetCaptureWindow() == UserHMGetHandle(Wnd))
 967          {
 968             IntReleaseCapture();
 969          }
 970          break;
 971       }
 972
 973       case WM_CLOSE:
 974          co_UserDestroyWindow(Wnd);
 975          break;
 976
 977       case WM_CTLCOLORMSGBOX:
 978       case WM_CTLCOLOREDIT:
 979       case WM_CTLCOLORLISTBOX:
 980       case WM_CTLCOLORBTN:
 981       case WM_CTLCOLORDLG:
 982       case WM_CTLCOLORSTATIC:
 983       case WM_CTLCOLORSCROLLBAR:
 984            return (LRESULT) DefWndControlColor((HDC)wParam, Msg - WM_CTLCOLORMSGBOX);
 985
 986       case WM_CTLCOLOR:
 987            return (LRESULT) DefWndControlColor((HDC)wParam, HIWORD(lParam));
 988
 989       case WM_SETCURSOR:
 990       {
 991          if (Wnd->style & WS_CHILD)
 992          {
 993              /* with the exception of the border around a resizable wnd,
 994               * give the parent first chance to set the cursor */
 995              if (LOWORD(lParam) < HTLEFT || LOWORD(lParam) > HTBOTTOMRIGHT)
 996              {
 997                  PWND parent = Wnd->spwndParent;//IntGetParent( Wnd );
 998                  if (parent != UserGetDesktopWindow() &&
 999                      co_IntSendMessage( UserHMGetHandle(parent), WM_SETCURSOR, wParam, lParam))
1000                     return TRUE;
1001              }
1002          }
1003          return DefWndHandleSetCursor(Wnd, wParam, lParam);
1004       }
1005
1006       case WM_MOUSEACTIVATE:
1007          if (Wnd->style & WS_CHILD)
1008          {
1009              LONG Ret;
1010              HWND hwndParent;
1011              PWND pwndParent = IntGetParent(Wnd);
1012              hwndParent = pwndParent ? UserHMGetHandle(pwndParent) : NULL;
1013              if (hwndParent) Ret = co_IntSendMessage(hwndParent, WM_MOUSEACTIVATE, wParam, lParam);
1014              if (Ret) return (Ret);
1015          }
1016          return ( (HIWORD(lParam) == WM_LBUTTONDOWN && LOWORD(lParam) == HTCAPTION) ? MA_NOACTIVATE : MA_ACTIVATE );
1017
1018       case WM_ACTIVATE:
1019        /* The default action in Windows is to set the keyboard focus to
1020         * the window, if it's being activated and not minimized */
1021          if (LOWORD(wParam) != WA_INACTIVE &&
1022               !(Wnd->style & WS_MINIMIZE))
1023          {
1024             //ERR("WM_ACTIVATE %p\n",hWnd);
1025             co_UserSetFocus(Wnd);
1026          }
1027          break;
1028
1029       case WM_MOUSEWHEEL:
1030          if (Wnd->style & WS_CHILD)
1031          {
1032             HWND hwndParent;
1033             PWND pwndParent = IntGetParent(Wnd);
1034             hwndParent = pwndParent ? UserHMGetHandle(pwndParent) : NULL;
1035             return co_IntSendMessage( hwndParent, WM_MOUSEWHEEL, wParam, lParam);
1036          }
1037          break;
1038
1039       case WM_ERASEBKGND:
1040       case WM_ICONERASEBKGND:
1041       {
1042          RECT Rect;
1043          HBRUSH hBrush = Wnd->pcls->hbrBackground;
1044          if (!hBrush) return 0;
1045          if (hBrush <= (HBRUSH)COLOR_MENUBAR)
1046          {
1047             hBrush = IntGetSysColorBrush(HandleToUlong(hBrush));
1048          }
1049          if (Wnd->pcls->style & CS_PARENTDC)
1050          {
1051             /* can't use GetClipBox with a parent DC or we fill the whole parent */
1052             IntGetClientRect(Wnd, &Rect);
1053             GreDPtoLP((HDC)wParam, (LPPOINT)&Rect, 2);
1054          }
1055          else
1056          {
1057             GdiGetClipBox((HDC)wParam, &Rect);
1058          }
1059          FillRect((HDC)wParam, &Rect, hBrush);
1060          return (1);
1061       }
1062
1063       case WM_GETHOTKEY:
1064          //ERR("WM_GETHOTKEY\n");
1065          return DefWndGetHotKey(Wnd);
1066       case WM_SETHOTKEY:
1067          //ERR("WM_SETHOTKEY\n");
1068          return DefWndSetHotKey(Wnd, wParam);
1069
1070       case WM_NCHITTEST:
1071       {
1072          POINT Point;
1073          Point.x = GET_X_LPARAM(lParam);
1074          Point.y = GET_Y_LPARAM(lParam);
1075          return GetNCHitEx(Wnd, Point);
1076       }
1077
1078       case WM_PRINT:
1079       {
1080          DefWndPrint(Wnd, (HDC)wParam, lParam);
1081          return (0);
1082       }
1083
1084       case WM_SYSCOLORCHANGE:
1085       {
1086          /* force to redraw non-client area */
1087          UserPaintCaption(Wnd, DC_NC);
1088          /* Use InvalidateRect to redraw client area, enable
1089           * erase to redraw all subcontrols otherwise send the
1090           * WM_SYSCOLORCHANGE to child windows/controls is required
1091           */
1092          co_UserRedrawWindow( Wnd, NULL, NULL, RDW_ALLCHILDREN|RDW_INVALIDATE|RDW_ERASE);
1093          return (0);
1094       }
1095
1096       case WM_PAINTICON:
1097       case WM_PAINT:
1098       {
1099          PAINTSTRUCT Ps;
1100          HDC hDC;
1101
1102          /* If already in Paint and Client area is not empty just return. */
1103          if (Wnd->state2 & WNDS2_STARTPAINT && !RECTL_bIsEmptyRect(&Wnd->rcClient))
1104          {
1105             ERR("In Paint and Client area is not empty!\n");
1106             return 0;
1107          }
1108
1109          hDC = IntBeginPaint(Wnd, &Ps);
1110          if (hDC)
1111          {
1112              if (((Wnd->style & WS_MINIMIZE) != 0) && (Wnd->pcls->spicn))
1113              {
1114                  RECT ClientRect;
1115                  INT x, y;
1116
1117                  ERR("Doing Paint and Client area is empty!\n");
1118                  IntGetClientRect(Wnd, &ClientRect);
1119                  x = (ClientRect.right - ClientRect.left - UserGetSystemMetrics(SM_CXICON)) / 2;
1120                  y = (ClientRect.bottom - ClientRect.top - UserGetSystemMetrics(SM_CYICON)) / 2;
1121                  UserReferenceObject(Wnd->pcls->spicn);
1122                  UserDrawIconEx(hDC, x, y, Wnd->pcls->spicn, 0, 0, 0, 0, DI_NORMAL | DI_COMPAT | DI_DEFAULTSIZE);
1123                  UserDereferenceObject(Wnd->pcls->spicn);
1124              }
1125
1126              IntEndPaint(Wnd, &Ps);
1127          }
1128          return (0);
1129       }
1130
1131       case WM_SYNCPAINT:
1132       {
1133          HRGN hRgn;
1134          Wnd->state &= ~WNDS_SYNCPAINTPENDING;
1135          TRACE("WM_SYNCPAINT\n");
1136          hRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
1137          if (hRgn)
1138          {
1139              if (co_UserGetUpdateRgn(Wnd, hRgn, FALSE) != NULLREGION)
1140              {
1141                 PREGION pRgn = REGION_LockRgn(hRgn);
1142                 if (pRgn) REGION_UnlockRgn(pRgn);
1143                 if (!wParam)
1144                     wParam = (RDW_ERASENOW | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN);
1145                 co_UserRedrawWindow(Wnd, NULL, pRgn, wParam);
1146              }
1147              GreDeleteObject(hRgn);
1148          }
1149          return 0;
1150       }
1151
1152       case WM_SETREDRAW:
1153           if (wParam)
1154           {
1155              if (!(Wnd->style & WS_VISIBLE))
1156              {
1157                 IntSetStyle( Wnd, WS_VISIBLE, 0 );
1158                 Wnd->state |= WNDS_SENDNCPAINT;
1159              }
1160           }
1161           else
1162           {
1163              if (Wnd->style & WS_VISIBLE)
1164              {
1165                 co_UserRedrawWindow( Wnd, NULL, NULL, RDW_ALLCHILDREN | RDW_VALIDATE );
1166                 IntSetStyle( Wnd, 0, WS_VISIBLE );
1167              }
1168           }
1169           return 0;
1170
1171       case WM_WINDOWPOSCHANGING:
1172       {
1173           return (DefWndHandleWindowPosChanging(Wnd, (WINDOWPOS*)lParam));
1174       }
1175
1176       case WM_WINDOWPOSCHANGED:
1177       {
1178           return (DefWndHandleWindowPosChanged(Wnd, (WINDOWPOS*)lParam));
1179       }
1180
1181       case WM_NCCALCSIZE:
1182       {
1183          return NC_HandleNCCalcSize( Wnd, wParam, (RECTL *)lParam, FALSE );
1184       }
1185
1186       case WM_NCACTIVATE:
1187       {
1188           return NC_HandleNCActivate( Wnd, wParam, lParam );
1189       }
1190
1191       //
1192       // NC Paint mode.
1193       //
1194       case WM_NCPAINT:
1195       {
1196           HDC hDC = UserGetDCEx(Wnd, (HRGN)wParam, DCX_WINDOW | DCX_INTERSECTRGN | DCX_USESTYLE | DCX_KEEPCLIPRGN);
1197           Wnd->state |= WNDS_FORCEMENUDRAW;
1198           NC_DoNCPaint(Wnd, hDC, -1);
1199           Wnd->state &= ~WNDS_FORCEMENUDRAW;
1200           UserReleaseDC(Wnd, hDC, FALSE);
1201           return 0;
1202       }
1203       //
1204       //  Draw Caption mode.
1205       //
1206       //  wParam are DC_* flags.
1207       //
1208       case WM_NCUAHDRAWCAPTION:
1209       {
1210           HDC hDC = UserGetDCEx(Wnd, NULL, DCX_WINDOW|DCX_USESTYLE);
1211           TRACE("WM_NCUAHDRAWCAPTION: wParam DC_ flags %08x\n",wParam);
1212           UserDrawCaptionBar(Wnd, hDC, wParam|DC_FRAME); // Include DC_FRAME to comp for drawing glich.
1213           UserReleaseDC(Wnd, hDC, FALSE);
1214           return 0;
1215       }
1216       //
1217       //  Draw Frame mode.
1218       //
1219       //  wParam is HDC, lParam are DC_ACTIVE and or DC_REDRAWHUNGWND.
1220       //
1221       case WM_NCUAHDRAWFRAME:
1222       {
1223           TRACE("WM_NCUAHDRAWFRAME: wParam hDC %p lParam DC_ flags %08x\n",wParam,lParam);
1224           NC_DoNCPaint(Wnd, (HDC)wParam, lParam|DC_NC);
1225           return 0;
1226       }
1227
1228       /* ReactOS only. */
1229       case WM_CBT:
1230       {
1231          switch (wParam)
1232          {
1233             case HCBT_MOVESIZE:
1234             {
1235                RECTL rt;
1236
1237                if (lParam)
1238                {
1239                   _SEH2_TRY
1240                   {
1241                       ProbeForRead((PVOID)lParam,
1242                                    sizeof(RECT),
1243                                    1);
1244
1245                       RtlCopyMemory(&rt,
1246                                     (PVOID)lParam,
1247                                     sizeof(RECT));
1248                   }
1249                   _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1250                   {
1251                       lResult = 1;
1252                   }
1253                   _SEH2_END;
1254                }
1255                if (!lResult)
1256                   lResult = co_HOOK_CallHooks(WH_CBT, HCBT_MOVESIZE, (WPARAM)Wnd->head.h, lParam ? (LPARAM)&rt : 0);
1257            }
1258             break;
1259          }
1260          break;
1261       }
1262       break;
1263    }
1264    return lResult;
1265 }
1266
1267 /* EOF */