reactos/dll/win32/user32/windows/nonclient.c

   1 /*
   2  * ReactOS User32 Library
   3  * - Window non-client area management
   4  *
   5  * Copyright (C) 2003 ReactOS Team
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 /* INCLUDES *******************************************************************/
  23
  24 #include <user32.h>
  25
  26 #include <wine/debug.h>
  27
  28 #define HAS_DLGFRAME(Style, ExStyle) \
  29             (((ExStyle) & WS_EX_DLGMODALFRAME) || \
  30             (((Style) & WS_DLGFRAME) && (!((Style) & (WS_THICKFRAME | WS_MINIMIZE)))))
  31
  32 #define HAS_THICKFRAME(Style, ExStyle) \
  33             (((Style) & WS_THICKFRAME) && !((Style) & WS_MINIMIZE) && \
  34             (!(((Style) & (WS_DLGFRAME | WS_BORDER)) == WS_DLGFRAME)))
  35
  36 #define HAS_THINFRAME(Style, ExStyle) \
  37             (((Style) & (WS_BORDER | WS_MINIMIZE)) || (!((Style) & (WS_CHILD | WS_POPUP))))
  38
  39 #define HASSIZEGRIP(Style, ExStyle, ParentStyle, WindowRect, ParentClientRect) \
  40             ((!(Style & WS_CHILD) && (Style & WS_THICKFRAME) && !(Style & WS_MAXIMIZE))  || \
  41              ((Style & WS_CHILD) && (ParentStyle & WS_THICKFRAME) && !(ParentStyle & WS_MAXIMIZE) && \
  42              (WindowRect.right - WindowRect.left == ParentClientRect.right) && \
  43              (WindowRect.bottom - WindowRect.top == ParentClientRect.bottom)))
  44
  45 #ifndef STATE_SYSTEM_OFFSCREEN
  46 #define STATE_SYSTEM_OFFSCREEN  0x00010000
  47 #endif
  48
  49 /*
  50  * FIXME: This should be moved to a header
  51  */
  52 VOID
  53 IntDrawScrollBar(HWND hWnd, HDC hDC, INT nBar);
  54 DWORD
  55 IntScrollHitTest(HWND hWnd, INT nBar, POINT pt, BOOL bDragging);
  56
  57 BOOL WINAPI GdiGradientFill(HDC,PTRIVERTEX,ULONG,PVOID,ULONG,ULONG);
  58
  59 extern ATOM AtomInternalPos;
  60
  61 /* PRIVATE FUNCTIONS **********************************************************/
  62
  63 BOOL
  64 IntIsScrollBarVisible(HWND hWnd, INT hBar)
  65 {
  66   SCROLLBARINFO sbi;
  67   sbi.cbSize = sizeof(SCROLLBARINFO);
  68   if(!NtUserGetScrollBarInfo(hWnd, hBar, &sbi))
  69     return FALSE;
  70
  71   return !(sbi.rgstate[0] & STATE_SYSTEM_OFFSCREEN);
  72 }
  73
  74 BOOL
  75 UserHasWindowEdge(DWORD Style, DWORD ExStyle)
  76 {
  77    if (Style & WS_MINIMIZE)
  78       return TRUE;
  79    if (ExStyle & WS_EX_DLGMODALFRAME)
  80       return TRUE;
  81    if (ExStyle & WS_EX_STATICEDGE)
  82       return FALSE;
  83    if (Style & WS_THICKFRAME)
  84       return TRUE;
  85    Style &= WS_CAPTION;
  86    if (Style == WS_DLGFRAME || Style == WS_CAPTION)
  87       return TRUE;
  88    return FALSE;
  89 }
  90
  91 VOID
  92 UserGetWindowBorders(DWORD Style, DWORD ExStyle, SIZE *Size, BOOL WithClient)
  93 {
  94    DWORD Border = 0;
  95
  96    if (UserHasWindowEdge(Style, ExStyle))
  97       Border += 2;
  98    else if (ExStyle & WS_EX_STATICEDGE)
  99       Border += 1;
 100    if ((ExStyle & WS_EX_CLIENTEDGE) && WithClient)
 101       Border += 2;
 102    if (Style & WS_CAPTION || ExStyle & WS_EX_DLGMODALFRAME)
 103       Border ++;
 104    Size->cx = Size->cy = Border;
 105    if ((Style & WS_THICKFRAME) && !(Style & WS_MINIMIZE))
 106    {
 107       Size->cx += GetSystemMetrics(SM_CXFRAME) - GetSystemMetrics(SM_CXDLGFRAME);
 108       Size->cy += GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYDLGFRAME);
 109    }
 110    Size->cx *= GetSystemMetrics(SM_CXBORDER);
 111    Size->cy *= GetSystemMetrics(SM_CYBORDER);
 112 }
 113
 114 BOOL
 115 UserHasMenu(HWND hWnd, ULONG Style)
 116 {
 117    return (!(Style & WS_CHILD) && GetMenu(hWnd) != 0);
 118 }
 119
 120 HICON
 121 UserGetWindowIcon(HWND hwnd)
 122 {
 123    HICON hIcon = 0;
 124
 125    SendMessageTimeout(hwnd, WM_GETICON, ICON_SMALL2, 0, SMTO_ABORTIFHUNG, 1000, (LPDWORD)&hIcon);
 126
 127    if (!hIcon)
 128       SendMessageTimeout(hwnd, WM_GETICON, ICON_SMALL, 0, SMTO_ABORTIFHUNG, 1000, (LPDWORD)&hIcon);
 129
 130    if (!hIcon)
 131       SendMessageTimeout(hwnd, WM_GETICON, ICON_BIG, 0, SMTO_ABORTIFHUNG, 1000, (LPDWORD)&hIcon);
 132
 133    if (!hIcon)
 134       hIcon = (HICON)GetClassLongPtr(hwnd, GCL_HICONSM);
 135
 136    if (!hIcon)
 137       hIcon = (HICON)GetClassLongPtr(hwnd, GCL_HICON);
 138
 139    return hIcon;
 140 }
 141
 142 BOOL
 143 UserDrawSysMenuButton(HWND hWnd, HDC hDC, LPRECT Rect, BOOL Down)
 144 {
 145    HICON WindowIcon;
 146
 147    if ((WindowIcon = UserGetWindowIcon(hWnd)))
 148    {
 149       return DrawIconEx(hDC, Rect->left + 2, Rect->top + 2, WindowIcon,
 150                         GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON),
 151                         0, NULL, DI_NORMAL);
 152    }
 153
 154    return FALSE;
 155 }
 156
 157 /*
 158  * FIXME:
 159  * - Cache bitmaps, then just bitblt instead of calling DFC() (and
 160  *   wasting precious CPU cycles) every time
 161  * - Center the buttons verticaly in the rect
 162  */
 163 VOID
 164 UserDrawCaptionButton(LPRECT Rect, DWORD Style, DWORD ExStyle, HDC hDC, BOOL bDown, ULONG Type)
 165 {
 166    RECT TempRect;
 167
 168    if (!(Style & WS_SYSMENU))
 169    {
 170       return;
 171    }
 172
 173    TempRect = *Rect;
 174
 175    switch (Type)
 176    {
 177       case DFCS_CAPTIONMIN:
 178       {
 179          if (ExStyle & WS_EX_TOOLWINDOW)
 180             return; /* ToolWindows don't have min/max buttons */
 181
 182          if (Style & WS_SYSMENU)
 183              TempRect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
 184          if (Style & (WS_MAXIMIZEBOX | WS_MINIMIZEBOX))
 185              TempRect.right -= GetSystemMetrics(SM_CXSIZE) - 2;
 186          TempRect.left = TempRect.right - GetSystemMetrics(SM_CXSIZE) + 1;
 187          TempRect.bottom = TempRect.top + GetSystemMetrics(SM_CYSIZE) - 2;
 188          TempRect.top += 2;
 189          TempRect.right -= 1;
 190
 191          DrawFrameControl(hDC, &TempRect, DFC_CAPTION,
 192                           ((Style & WS_MINIMIZE) ? DFCS_CAPTIONRESTORE : DFCS_CAPTIONMIN) |
 193                           (bDown ? DFCS_PUSHED : 0) |
 194                           ((Style & WS_MINIMIZEBOX) ? 0 : DFCS_INACTIVE));
 195          break;
 196       }
 197       case DFCS_CAPTIONMAX:
 198       {
 199          if (ExStyle & WS_EX_TOOLWINDOW)
 200              return; /* ToolWindows don't have min/max buttons */
 201
 202          if (Style & WS_SYSMENU)
 203              TempRect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
 204          TempRect.left = TempRect.right - GetSystemMetrics(SM_CXSIZE) + 1;
 205          TempRect.bottom = TempRect.top + GetSystemMetrics(SM_CYSIZE) - 2;
 206          TempRect.top += 2;
 207          TempRect.right -= 1;
 208
 209          DrawFrameControl(hDC, &TempRect, DFC_CAPTION,
 210                           ((Style & WS_MAXIMIZE) ? DFCS_CAPTIONRESTORE : DFCS_CAPTIONMAX) |
 211                           (bDown ? DFCS_PUSHED : 0) |
 212                           ((Style & WS_MAXIMIZEBOX) ? 0 : DFCS_INACTIVE));
 213          break;
 214       }
 215       case DFCS_CAPTIONCLOSE:
 216       {
 217          /* FIXME: A tool window has a smaller Close button */
 218
 219          if (ExStyle & WS_EX_TOOLWINDOW)
 220          {
 221             TempRect.left = TempRect.right - GetSystemMetrics(SM_CXSMSIZE);
 222             TempRect.bottom = TempRect.top + GetSystemMetrics(SM_CYSMSIZE) - 2;
 223          }
 224          else
 225          {
 226             TempRect.left = TempRect.right - GetSystemMetrics(SM_CXSIZE);
 227             TempRect.bottom = TempRect.top + GetSystemMetrics(SM_CYSIZE) - 2;
 228          }
 229          TempRect.top += 2;
 230          TempRect.right -= 2;
 231
 232          DrawFrameControl(hDC, &TempRect, DFC_CAPTION,
 233                           (DFCS_CAPTIONCLOSE | (bDown ? DFCS_PUSHED : 0) |
 234                           ((Style & WS_SYSMENU) ? 0 : DFCS_INACTIVE)));
 235          break;
 236       }
 237    }
 238 }
 239
 240 VOID
 241 UserDrawCaptionButtonWnd(HWND hWnd, HDC hDC, BOOL bDown, ULONG Type)
 242 {
 243    RECT WindowRect;
 244    SIZE WindowBorder;
 245    DWORD Style, ExStyle;
 246
 247    GetWindowRect(hWnd, &WindowRect);
 248    WindowRect.right -= WindowRect.left;
 249    WindowRect.bottom -= WindowRect.top;
 250    WindowRect.left = WindowRect.top = 0;
 251    Style = GetWindowLongPtrW(hWnd, GWL_STYLE);
 252    ExStyle = GetWindowLongPtrW(hWnd, GWL_EXSTYLE);
 253    UserGetWindowBorders(Style, ExStyle, &WindowBorder, FALSE);
 254    InflateRect(&WindowRect, -WindowBorder.cx, -WindowBorder.cy);
 255    UserDrawCaptionButton(&WindowRect, Style, ExStyle, hDC, bDown, Type);
 256 }
 257
 258 // Note from Wine:
 259 /* MSDN docs are pretty idiotic here, they say app CAN use clipRgn in
 260    the call to GetDCEx implying that it is allowed not to use it either.
 261    However, the suggested GetDCEx(    , DCX_WINDOW | DCX_INTERSECTRGN)
 262    will cause clipRgn to be deleted after ReleaseDC().
 263    Now, how is the "system" supposed to tell what happened?
 264  */
 265 /*
 266  * FIXME:
 267  * - Drawing of WS_BORDER after scrollbars
 268  * - Correct drawing of size-box
 269  */
 270 LRESULT
 271 DefWndNCPaint(HWND hWnd, HRGN hRgn, BOOL Active)
 272 {
 273    HDC hDC;
 274    DWORD Style, ExStyle;
 275    HWND Parent;
 276    RECT ClientRect, WindowRect, CurrentRect, TempRect;
 277
 278    if (!IsWindowVisible(hWnd))
 279       return 0;
 280
 281    Style = GetWindowLongPtrW(hWnd, GWL_STYLE);
 282
 283    hDC = GetDCEx(hWnd, hRgn, DCX_WINDOW | DCX_INTERSECTRGN | DCX_USESTYLE | DCX_KEEPCLIPRGN);
 284    if (hDC == 0)
 285    {
 286       return 0;
 287    }
 288
 289    Parent = GetParent(hWnd);
 290    ExStyle = GetWindowLongPtrW(hWnd, GWL_EXSTYLE);
 291    if (Active == -1)
 292    {
 293       if (ExStyle & WS_EX_MDICHILD)
 294       {
 295          Active = IsChild(GetForegroundWindow(), hWnd);
 296          if (Active)
 297             Active = (hWnd == (HWND)SendMessageW(Parent, WM_MDIGETACTIVE, 0, 0));
 298       }
 299       else
 300       {
 301          Active = (GetForegroundWindow() == hWnd);
 302       }
 303    }
 304    GetWindowRect(hWnd, &WindowRect);
 305    GetClientRect(hWnd, &ClientRect);
 306
 307    CurrentRect.top = CurrentRect.left = 0;
 308    CurrentRect.right = WindowRect.right - WindowRect.left;
 309    CurrentRect.bottom = WindowRect.bottom - WindowRect.top;
 310
 311    /* Draw outer edge */
 312    if (UserHasWindowEdge(Style, ExStyle))
 313    {
 314       DrawEdge(hDC, &CurrentRect, EDGE_RAISED, BF_RECT | BF_ADJUST);
 315    } else
 316    if (ExStyle & WS_EX_STATICEDGE)
 317    {
 318 #if 0
 319       DrawEdge(hDC, &CurrentRect, BDR_SUNKENINNER, BF_RECT | BF_ADJUST | BF_FLAT);
 320 #else
 321       SelectObject(hDC, GetSysColorBrush(COLOR_BTNSHADOW));
 322       PatBlt(hDC, CurrentRect.left, CurrentRect.top, CurrentRect.right - CurrentRect.left, 1, PATCOPY);
 323       PatBlt(hDC, CurrentRect.left, CurrentRect.top, 1, CurrentRect.bottom - CurrentRect.top, PATCOPY);
 324
 325       SelectObject(hDC, GetSysColorBrush(COLOR_BTNHIGHLIGHT));
 326       PatBlt(hDC, CurrentRect.left, CurrentRect.bottom - 1, CurrentRect.right - CurrentRect.left, 1, PATCOPY);
 327       PatBlt(hDC, CurrentRect.right - 1, CurrentRect.top, 1, CurrentRect.bottom - CurrentRect.top, PATCOPY);
 328
 329       InflateRect(&CurrentRect, -1, -1);
 330 #endif
 331    }
 332
 333    /* Firstly the "thick" frame */
 334    if ((Style & WS_THICKFRAME) && !(Style & WS_MINIMIZE))
 335    {
 336       DWORD Width =
 337          (GetSystemMetrics(SM_CXFRAME) - GetSystemMetrics(SM_CXDLGFRAME)) *
 338          GetSystemMetrics(SM_CXBORDER);
 339       DWORD Height =
 340          (GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYDLGFRAME)) *
 341          GetSystemMetrics(SM_CYBORDER);
 342
 343       SelectObject(hDC, GetSysColorBrush(Active ? COLOR_ACTIVEBORDER :
 344          COLOR_INACTIVEBORDER));
 345
 346       /* Draw frame */
 347       PatBlt(hDC, CurrentRect.left, CurrentRect.top, CurrentRect.right - CurrentRect.left, Height, PATCOPY);
 348       PatBlt(hDC, CurrentRect.left, CurrentRect.top, Width, CurrentRect.bottom - CurrentRect.top, PATCOPY);
 349 #ifdef __REACTOS__
 350       PatBlt(hDC, CurrentRect.left, CurrentRect.bottom - 1, CurrentRect.right - CurrentRect.left, -Height, PATCOPY);
 351       PatBlt(hDC, CurrentRect.right - 1, CurrentRect.top, -Width, CurrentRect.bottom - CurrentRect.top, PATCOPY);
 352 #else
 353       PatBlt(hDC, CurrentRect.left, CurrentRect.bottom, CurrentRect.right - CurrentRect.left, -Height, PATCOPY);
 354       PatBlt(hDC, CurrentRect.right, CurrentRect.top, -Width, CurrentRect.bottom - CurrentRect.top, PATCOPY);
 355 #endif
 356
 357       InflateRect(&CurrentRect, -Width, -Height);
 358    }
 359
 360    /* Now the other bit of the frame */
 361    if (Style & (WS_DLGFRAME | WS_BORDER) || ExStyle & WS_EX_DLGMODALFRAME)
 362    {
 363       DWORD Width = GetSystemMetrics(SM_CXBORDER);
 364       DWORD Height = GetSystemMetrics(SM_CYBORDER);
 365
 366       SelectObject(hDC, GetSysColorBrush(
 367          (ExStyle & (WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE)) ? COLOR_3DFACE :
 368          (ExStyle & WS_EX_STATICEDGE) ? COLOR_WINDOWFRAME :
 369          (Style & (WS_DLGFRAME | WS_THICKFRAME)) ? COLOR_3DFACE :
 370          COLOR_WINDOWFRAME));
 371
 372       /* Draw frame */
 373       PatBlt(hDC, CurrentRect.left, CurrentRect.top, CurrentRect.right - CurrentRect.left, Height, PATCOPY);
 374       PatBlt(hDC, CurrentRect.left, CurrentRect.top, Width, CurrentRect.bottom - CurrentRect.top, PATCOPY);
 375 #ifdef __REACTOS__
 376       PatBlt(hDC, CurrentRect.left, CurrentRect.bottom - 1, CurrentRect.right - CurrentRect.left, -Height, PATCOPY);
 377       PatBlt(hDC, CurrentRect.right - 1, CurrentRect.top, -Width, CurrentRect.bottom - CurrentRect.top, PATCOPY);
 378 #else
 379       PatBlt(hDC, CurrentRect.left, CurrentRect.bottom, CurrentRect.right - CurrentRect.left, -Height, PATCOPY);
 380       PatBlt(hDC, CurrentRect.right, CurrentRect.top, -Width, CurrentRect.bottom - CurrentRect.top, PATCOPY);
 381 #endif
 382
 383       InflateRect(&CurrentRect, -Width, -Height);
 384    }
 385
 386    /* Draw caption */
 387    if ((Style & WS_CAPTION) == WS_CAPTION)
 388    {
 389       DWORD CaptionFlags = DC_ICON | DC_TEXT | DC_BUTTONS;
 390       HPEN PreviousPen;
 391       BOOL Gradient = FALSE;
 392
 393       if(SystemParametersInfoW(SPI_GETGRADIENTCAPTIONS, 0, &Gradient, 0) && Gradient)
 394       {
 395         CaptionFlags |= DC_GRADIENT;
 396       }
 397
 398       TempRect = CurrentRect;
 399
 400       if (Active)
 401       {
 402          CaptionFlags |= DC_ACTIVE;
 403       }
 404
 405       if (ExStyle & WS_EX_TOOLWINDOW)
 406       {
 407          CaptionFlags |= DC_SMALLCAP;
 408          TempRect.bottom = TempRect.top + GetSystemMetrics(SM_CYSMCAPTION) - 1;
 409          CurrentRect.top += GetSystemMetrics(SM_CYSMCAPTION);
 410       }
 411       else
 412       {
 413          TempRect.bottom = TempRect.top + GetSystemMetrics(SM_CYCAPTION) - 1;
 414          CurrentRect.top += GetSystemMetrics(SM_CYCAPTION);
 415       }
 416
 417       NtUserDrawCaption(hWnd, hDC, &TempRect, CaptionFlags);
 418
 419       /* Draw buttons */
 420       if (Style & WS_SYSMENU)
 421       {
 422          UserDrawCaptionButton(&TempRect, Style, ExStyle, hDC, FALSE, DFCS_CAPTIONCLOSE);
 423          if ((Style & (WS_MAXIMIZEBOX | WS_MINIMIZEBOX)) && !(ExStyle & WS_EX_TOOLWINDOW))
 424          {
 425             UserDrawCaptionButton(&TempRect, Style, ExStyle, hDC, FALSE, DFCS_CAPTIONMIN);
 426             UserDrawCaptionButton(&TempRect, Style, ExStyle, hDC, FALSE, DFCS_CAPTIONMAX);
 427          }
 428       }
 429       if(!(Style & WS_MINIMIZE))
 430       {
 431         /* Line under caption */
 432         PreviousPen = SelectObject(hDC, GetStockObject(DC_PEN));
 433         SetDCPenColor(hDC, GetSysColor(
 434            ((ExStyle & (WS_EX_STATICEDGE | WS_EX_CLIENTEDGE |
 435                         WS_EX_DLGMODALFRAME)) == WS_EX_STATICEDGE) ?
 436            COLOR_WINDOWFRAME : COLOR_3DFACE));
 437         MoveToEx(hDC, TempRect.left, TempRect.bottom, NULL);
 438         LineTo(hDC, TempRect.right, TempRect.bottom);
 439         SelectObject(hDC, PreviousPen);
 440       }
 441    }
 442
 443    if(!(Style & WS_MINIMIZE))
 444    {
 445      HMENU menu = GetMenu(hWnd);
 446      /* Draw menu bar */
 447      if (menu && !(Style & WS_CHILD))
 448      {
 449         TempRect = CurrentRect;
 450         TempRect.bottom = TempRect.top + (UINT)NtUserSetMenuBarHeight(menu, 0);
 451         CurrentRect.top += MenuDrawMenuBar(hDC, &TempRect, hWnd, FALSE);
 452      }
 453
 454      if (ExStyle & WS_EX_CLIENTEDGE)
 455      {
 456         DrawEdge(hDC, &CurrentRect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
 457      }
 458
 459      /* Draw the scrollbars */
 460      if ((Style & WS_VSCROLL) && (Style & WS_HSCROLL) &&
 461          IntIsScrollBarVisible(hWnd, OBJID_VSCROLL) && IntIsScrollBarVisible(hWnd, OBJID_HSCROLL))
 462      {
 463         RECT ParentClientRect;
 464
 465         TempRect = CurrentRect;
 466         if (ExStyle & WS_EX_LEFTSCROLLBAR)
 467            TempRect.right = TempRect.left + GetSystemMetrics(SM_CXVSCROLL);
 468         else
 469            TempRect.left = TempRect.right - GetSystemMetrics(SM_CXVSCROLL);
 470         TempRect.top = TempRect.bottom - GetSystemMetrics(SM_CYHSCROLL);
 471         FillRect(hDC, &TempRect, GetSysColorBrush(COLOR_BTNFACE));
 472         /* FIXME: Correct drawing of size-box with WS_EX_LEFTSCROLLBAR */
 473         if(Parent)
 474           GetClientRect(Parent, &ParentClientRect);
 475         if (HASSIZEGRIP(Style, ExStyle, GetWindowLongPtrW(Parent, GWL_STYLE), WindowRect, ParentClientRect))
 476         {
 477            DrawFrameControl(hDC, &TempRect, DFC_SCROLL, DFCS_SCROLLSIZEGRIP);
 478         }
 479         IntDrawScrollBar(hWnd, hDC, SB_VERT);
 480         IntDrawScrollBar(hWnd, hDC, SB_HORZ);
 481      }
 482      else
 483      {
 484         if (Style & WS_VSCROLL && IntIsScrollBarVisible(hWnd, OBJID_VSCROLL))
 485            IntDrawScrollBar(hWnd, hDC, SB_VERT);
 486         else if (Style & WS_HSCROLL && IntIsScrollBarVisible(hWnd, OBJID_HSCROLL))
 487            IntDrawScrollBar(hWnd, hDC, SB_HORZ);
 488      }
 489    }
 490
 491    ReleaseDC(hWnd, hDC);
 492    DeleteObject(hRgn); // We use DCX_KEEPCLIPRGN
 493
 494    return 0;
 495 }
 496
 497 LRESULT
 498 DefWndNCCalcSize(HWND hWnd, BOOL CalcSizeStruct, RECT *Rect)
 499 {
 500    LRESULT Result = 0;
 501    DWORD Style = GetClassLongPtrW(hWnd, GCL_STYLE);
 502    DWORD ExStyle;
 503    SIZE WindowBorders;
 504    RECT OrigRect;
 505
 506    if (Rect == NULL)
 507    {
 508       return Result;
 509    }
 510    OrigRect = *Rect;
 511
 512    if (CalcSizeStruct)
 513    {
 514       if (Style & CS_VREDRAW)
 515       {
 516          Result |= WVR_VREDRAW;
 517       }
 518       if (Style & CS_HREDRAW)
 519       {
 520          Result |= WVR_HREDRAW;
 521       }
 522       Result |= WVR_VALIDRECTS;
 523    }
 524
 525    Style = GetWindowLongPtrW(hWnd, GWL_STYLE);
 526    ExStyle = GetWindowLongPtrW(hWnd, GWL_EXSTYLE);
 527
 528    if (!(Style & WS_MINIMIZE))
 529    {
 530       HMENU menu = GetMenu(hWnd);
 531
 532       if (UserHasWindowEdge(Style, ExStyle))
 533       {
 534          UserGetWindowBorders(Style, ExStyle, &WindowBorders, FALSE);
 535          InflateRect(Rect, -WindowBorders.cx, -WindowBorders.cy);
 536       } else
 537       if ((ExStyle & WS_EX_STATICEDGE) || (Style & WS_BORDER))
 538       {
 539          InflateRect(Rect, -1, -1);
 540       }
 541
 542       if ((Style & WS_CAPTION) == WS_CAPTION)
 543       {
 544          if (ExStyle & WS_EX_TOOLWINDOW)
 545             Rect->top += GetSystemMetrics(SM_CYSMCAPTION);
 546          else
 547             Rect->top += GetSystemMetrics(SM_CYCAPTION);
 548       }
 549
 550       if (menu && !(Style & WS_CHILD))
 551       {
 552          HDC hDC = GetWindowDC(hWnd);
 553          if(hDC)
 554          {
 555            RECT CliRect = *Rect;
 556            CliRect.bottom -= OrigRect.top;
 557            CliRect.right -= OrigRect.left;
 558            CliRect.left -= OrigRect.left;
 559            CliRect.top -= OrigRect.top;
 560            Rect->top += MenuDrawMenuBar(hDC, &CliRect, hWnd, TRUE);
 561            ReleaseDC(hWnd, hDC);
 562          }
 563       }
 564
 565       if (ExStyle & WS_EX_CLIENTEDGE)
 566       {
 567          InflateRect(Rect, -2 * GetSystemMetrics(SM_CXBORDER),
 568             -2 * GetSystemMetrics(SM_CYBORDER));
 569       }
 570
 571       if(Style & (WS_VSCROLL | WS_HSCROLL))
 572       {
 573         SCROLLBARINFO sbi;
 574         SETSCROLLBARINFO ssbi;
 575
 576         sbi.cbSize = sizeof(SCROLLBARINFO);
 577         if((Style & WS_VSCROLL) && NtUserGetScrollBarInfo(hWnd, OBJID_VSCROLL, &sbi))
 578         {
 579           int i;
 580           LONG sx = Rect->right;
 581
 582           sx -= GetSystemMetrics(SM_CXVSCROLL);
 583           for(i = 0; i <= CCHILDREN_SCROLLBAR; i++)
 584             ssbi.rgstate[i] = sbi.rgstate[i];
 585           if(sx <= Rect->left)
 586             ssbi.rgstate[0] |= STATE_SYSTEM_OFFSCREEN;
 587           else
 588             ssbi.rgstate[0] &= ~STATE_SYSTEM_OFFSCREEN;
 589           NtUserSetScrollBarInfo(hWnd, OBJID_VSCROLL, &ssbi);
 590           if(ssbi.rgstate[0] & STATE_SYSTEM_OFFSCREEN)
 591             Style &= ~WS_VSCROLL;
 592         }
 593         else
 594           Style &= ~WS_VSCROLL;
 595
 596         if((Style & WS_HSCROLL) && NtUserGetScrollBarInfo(hWnd, OBJID_HSCROLL, &sbi))
 597         {
 598           int i;
 599           LONG sy = Rect->bottom;
 600
 601           sy -= GetSystemMetrics(SM_CYHSCROLL);
 602           for(i = 0; i <= CCHILDREN_SCROLLBAR; i++)
 603             ssbi.rgstate[i] = sbi.rgstate[i];
 604           if(sy <= Rect->top)
 605             ssbi.rgstate[0] |= STATE_SYSTEM_OFFSCREEN;
 606           else
 607             ssbi.rgstate[0] &= ~STATE_SYSTEM_OFFSCREEN;
 608           NtUserSetScrollBarInfo(hWnd, OBJID_HSCROLL, &ssbi);
 609           if(ssbi.rgstate[0] & STATE_SYSTEM_OFFSCREEN)
 610             Style &= ~WS_HSCROLL;
 611         }
 612         else
 613           Style &= ~WS_HSCROLL;
 614       }
 615
 616       if ((Style & WS_VSCROLL) && (Style & WS_HSCROLL))
 617       {
 618          if ((ExStyle & WS_EX_LEFTSCROLLBAR) != 0)
 619             Rect->left += GetSystemMetrics(SM_CXVSCROLL);
 620          else
 621             Rect->right -= GetSystemMetrics(SM_CXVSCROLL);
 622          Rect->bottom -= GetSystemMetrics(SM_CYHSCROLL);
 623       }
 624       else
 625       {
 626          if (Style & WS_VSCROLL)
 627          {
 628             if ((ExStyle & WS_EX_LEFTSCROLLBAR) != 0)
 629                Rect->left += GetSystemMetrics(SM_CXVSCROLL);
 630             else
 631                Rect->right -= GetSystemMetrics(SM_CXVSCROLL);
 632          }
 633          else if (Style & WS_HSCROLL)
 634             Rect->bottom -= GetSystemMetrics(SM_CYHSCROLL);
 635       }
 636       if (Rect->top > Rect->bottom)
 637          Rect->bottom = Rect->top;
 638       if (Rect->left > Rect->right)
 639          Rect->right = Rect->left;
 640    }
 641    else
 642    {
 643       Rect->right = Rect->left;
 644       Rect->bottom = Rect->top;
 645    }
 646
 647    return Result;
 648 }
 649
 650 LRESULT
 651 DefWndNCActivate(HWND hWnd, WPARAM wParam)
 652 {
 653    DefWndNCPaint(hWnd, (HRGN)1, wParam);
 654    return TRUE;
 655 }
 656
 657 /*
 658  * FIXME:
 659  * - Check the scrollbar handling
 660  */
 661 LRESULT
 662 DefWndNCHitTest(HWND hWnd, POINT Point)
 663 {
 664    RECT WindowRect, ClientRect, OrigWndRect;
 665    POINT ClientPoint;
 666    SIZE WindowBorders;
 667    ULONG Style = GetWindowLongPtrW(hWnd, GWL_STYLE);
 668    ULONG ExStyle = GetWindowLongPtrW(hWnd, GWL_EXSTYLE);
 669
 670    GetWindowRect(hWnd, &WindowRect);
 671    if (!PtInRect(&WindowRect, Point))
 672    {
 673       return HTNOWHERE;
 674    }
 675    OrigWndRect = WindowRect;
 676
 677    if (UserHasWindowEdge(Style, ExStyle))
 678    {
 679       LONG XSize, YSize;
 680
 681       UserGetWindowBorders(Style, ExStyle, &WindowBorders, FALSE);
 682       InflateRect(&WindowRect, -WindowBorders.cx, -WindowBorders.cy);
 683       XSize = GetSystemMetrics(SM_CXSIZE) * GetSystemMetrics(SM_CXBORDER);
 684       YSize = GetSystemMetrics(SM_CYSIZE) * GetSystemMetrics(SM_CYBORDER);
 685       if (!PtInRect(&WindowRect, Point))
 686       {
 687          BOOL ThickFrame;
 688
 689          ThickFrame = (Style & WS_THICKFRAME);
 690          if (Point.y < WindowRect.top)
 691          {
 692             if(Style & WS_MINIMIZE)
 693               return HTCAPTION;
 694             if(!ThickFrame)
 695               return HTBORDER;
 696             if (Point.x < (WindowRect.left + XSize))
 697                return HTTOPLEFT;
 698             if (Point.x >= (WindowRect.right - XSize))
 699                return HTTOPRIGHT;
 700             return HTTOP;
 701          }
 702          if (Point.y >= WindowRect.bottom)
 703          {
 704             if(Style & WS_MINIMIZE)
 705               return HTCAPTION;
 706             if(!ThickFrame)
 707               return HTBORDER;
 708             if (Point.x < (WindowRect.left + XSize))
 709                return HTBOTTOMLEFT;
 710             if (Point.x >= (WindowRect.right - XSize))
 711                return HTBOTTOMRIGHT;
 712             return HTBOTTOM;
 713          }
 714          if (Point.x < WindowRect.left)
 715          {
 716             if(Style & WS_MINIMIZE)
 717               return HTCAPTION;
 718             if(!ThickFrame)
 719               return HTBORDER;
 720             if (Point.y < (WindowRect.top + YSize))
 721                return HTTOPLEFT;
 722             if (Point.y >= (WindowRect.bottom - YSize))
 723                return HTBOTTOMLEFT;
 724             return HTLEFT;
 725          }
 726          if (Point.x >= WindowRect.right)
 727          {
 728             if(Style & WS_MINIMIZE)
 729               return HTCAPTION;
 730             if(!ThickFrame)
 731               return HTBORDER;
 732             if (Point.y < (WindowRect.top + YSize))
 733                return HTTOPRIGHT;
 734             if (Point.y >= (WindowRect.bottom - YSize))
 735                return HTBOTTOMRIGHT;
 736             return HTRIGHT;
 737          }
 738       }
 739    }
 740    else
 741    {
 742       if (ExStyle & WS_EX_STATICEDGE)
 743          InflateRect(&WindowRect,
 744             -GetSystemMetrics(SM_CXBORDER),
 745             -GetSystemMetrics(SM_CYBORDER));
 746       if (!PtInRect(&WindowRect, Point))
 747          return HTBORDER;
 748    }
 749
 750    if ((Style & WS_CAPTION) == WS_CAPTION)
 751    {
 752       if (ExStyle & WS_EX_TOOLWINDOW)
 753          WindowRect.top += GetSystemMetrics(SM_CYSMCAPTION);
 754       else
 755          WindowRect.top += GetSystemMetrics(SM_CYCAPTION);
 756       if (!PtInRect(&WindowRect, Point))
 757       {
 758          if (Style & WS_SYSMENU)
 759          {
 760             if (ExStyle & WS_EX_TOOLWINDOW)
 761             {
 762                WindowRect.right -= GetSystemMetrics(SM_CXSMSIZE);
 763             }
 764             else
 765             {
 766                if(!(ExStyle & WS_EX_DLGMODALFRAME))
 767                   WindowRect.left += GetSystemMetrics(SM_CXSIZE);
 768                WindowRect.right -= GetSystemMetrics(SM_CXSIZE);
 769             }
 770          }
 771          if (Point.x < WindowRect.left)
 772             return HTSYSMENU;
 773          if (WindowRect.right <= Point.x)
 774             return HTCLOSE;
 775          if (Style & WS_MAXIMIZEBOX || Style & WS_MINIMIZEBOX)
 776             WindowRect.right -= GetSystemMetrics(SM_CXSIZE);
 777          if (Point.x >= WindowRect.right)
 778             return HTMAXBUTTON;
 779          if (Style & WS_MINIMIZEBOX)
 780             WindowRect.right -= GetSystemMetrics(SM_CXSIZE);
 781          if (Point.x >= WindowRect.right)
 782             return HTMINBUTTON;
 783          return HTCAPTION;
 784       }
 785    }
 786
 787    if(!(Style & WS_MINIMIZE))
 788    {
 789      HMENU menu;
 790
 791      ClientPoint = Point;
 792      ScreenToClient(hWnd, &ClientPoint);
 793      GetClientRect(hWnd, &ClientRect);
 794
 795      if (PtInRect(&ClientRect, ClientPoint))
 796      {
 797         return HTCLIENT;
 798      }
 799
 800      if ((menu = GetMenu(hWnd)) && !(Style & WS_CHILD))
 801      {
 802         if (Point.x > 0 && Point.x < WindowRect.right && ClientPoint.y < 0)
 803            return HTMENU;
 804      }
 805
 806      if (ExStyle & WS_EX_CLIENTEDGE)
 807      {
 808         InflateRect(&WindowRect, -2 * GetSystemMetrics(SM_CXBORDER),
 809            -2 * GetSystemMetrics(SM_CYBORDER));
 810      }
 811
 812      if ((Style & WS_VSCROLL) && (Style & WS_HSCROLL) &&
 813          (WindowRect.bottom - WindowRect.top) > GetSystemMetrics(SM_CYHSCROLL))
 814      {
 815         RECT ParentRect, TempRect = WindowRect, TempRect2 = WindowRect;
 816         HWND Parent = GetParent(hWnd);
 817
 818         TempRect.bottom -= GetSystemMetrics(SM_CYHSCROLL);
 819         if ((ExStyle & WS_EX_LEFTSCROLLBAR) != 0)
 820            TempRect.right = TempRect.left + GetSystemMetrics(SM_CXVSCROLL);
 821         else
 822            TempRect.left = TempRect.right - GetSystemMetrics(SM_CXVSCROLL);
 823         if (PtInRect(&TempRect, Point))
 824            return HTVSCROLL;
 825
 826         TempRect2.top = TempRect2.bottom - GetSystemMetrics(SM_CYHSCROLL);
 827         if ((ExStyle & WS_EX_LEFTSCROLLBAR) != 0)
 828            TempRect2.left += GetSystemMetrics(SM_CXVSCROLL);
 829         else
 830            TempRect2.right -= GetSystemMetrics(SM_CXVSCROLL);
 831         if (PtInRect(&TempRect2, Point))
 832            return HTHSCROLL;
 833
 834         TempRect.top = TempRect2.top;
 835         TempRect.bottom = TempRect2.bottom;
 836         if(Parent)
 837           GetClientRect(Parent, &ParentRect);
 838         if (PtInRect(&TempRect, Point) && HASSIZEGRIP(Style, ExStyle,
 839             GetWindowLongPtrW(Parent, GWL_STYLE), OrigWndRect, ParentRect))
 840         {
 841            if ((ExStyle & WS_EX_LEFTSCROLLBAR) != 0)
 842               return HTBOTTOMLEFT;
 843            else
 844               return HTBOTTOMRIGHT;
 845         }
 846      }
 847      else
 848      {
 849         if (Style & WS_VSCROLL)
 850         {
 851            RECT TempRect = WindowRect;
 852
 853            if ((ExStyle & WS_EX_LEFTSCROLLBAR) != 0)
 854               TempRect.right = TempRect.left + GetSystemMetrics(SM_CXVSCROLL);
 855            else
 856               TempRect.left = TempRect.right - GetSystemMetrics(SM_CXVSCROLL);
 857            if (PtInRect(&TempRect, Point))
 858               return HTVSCROLL;
 859         } else
 860         if (Style & WS_HSCROLL)
 861         {
 862            RECT TempRect = WindowRect;
 863            TempRect.top = TempRect.bottom - GetSystemMetrics(SM_CYHSCROLL);
 864            if (PtInRect(&TempRect, Point))
 865               return HTHSCROLL;
 866         }
 867      }
 868    }
 869
 870    return HTNOWHERE;
 871 }
 872
 873 VOID
 874 DefWndDoButton(HWND hWnd, WPARAM wParam)
 875 {
 876    MSG Msg;
 877    HDC WindowDC;
 878    BOOL Pressed = TRUE, OldState;
 879    WPARAM SCMsg;
 880    ULONG ButtonType, Style;
 881
 882    Style = GetWindowLongPtrW(hWnd, GWL_STYLE);
 883    switch (wParam)
 884    {
 885       case HTCLOSE:
 886          if (!(Style & WS_SYSMENU))
 887             return;
 888          ButtonType = DFCS_CAPTIONCLOSE;
 889          SCMsg = SC_CLOSE;
 890          break;
 891       case HTMINBUTTON:
 892          if (!(Style & WS_MINIMIZEBOX))
 893             return;
 894          ButtonType = DFCS_CAPTIONMIN;
 895          SCMsg = ((Style & WS_MINIMIZE) ? SC_RESTORE : SC_MINIMIZE);
 896          break;
 897       case HTMAXBUTTON:
 898          if (!(Style & WS_MAXIMIZEBOX))
 899             return;
 900          ButtonType = DFCS_CAPTIONMAX;
 901          SCMsg = ((Style & WS_MAXIMIZE) ? SC_RESTORE : SC_MAXIMIZE);
 902          break;
 903
 904       default:
 905          ASSERT(FALSE);
 906          return;
 907    }
 908
 909    /*
 910     * FIXME: Not sure where to do this, but we must flush the pending
 911     * window updates when someone clicks on the close button and at
 912     * the same time the window is overlapped with another one. This
 913     * looks like a good place for now...
 914     */
 915    UpdateWindow(hWnd);
 916
 917    WindowDC = GetWindowDC(hWnd);
 918    UserDrawCaptionButtonWnd(hWnd, WindowDC, TRUE, ButtonType);
 919
 920    SetCapture(hWnd);
 921
 922    for (;;)
 923    {
 924       if (GetMessageW(&Msg, 0, WM_MOUSEFIRST, WM_MOUSELAST) <= 0)
 925          break;
 926
 927       if (Msg.message == WM_LBUTTONUP)
 928          break;
 929
 930       if (Msg.message != WM_MOUSEMOVE)
 931          continue;
 932
 933       OldState = Pressed;
 934       Pressed = (DefWndNCHitTest(hWnd, Msg.pt) == wParam);
 935       if (Pressed != OldState)
 936          UserDrawCaptionButtonWnd(hWnd, WindowDC, Pressed, ButtonType);
 937    }
 938
 939    if (Pressed)
 940       UserDrawCaptionButtonWnd(hWnd, WindowDC, FALSE, ButtonType);
 941    ReleaseCapture();
 942    ReleaseDC(hWnd, WindowDC);
 943    if (Pressed)
 944       SendMessageW(hWnd, WM_SYSCOMMAND, SCMsg, 0);
 945 }
 946
 947
 948 LRESULT
 949 DefWndNCLButtonDown(HWND hWnd, WPARAM wParam, LPARAM lParam)
 950 {
 951     switch (wParam)
 952     {
 953         case HTCAPTION:
 954         {
 955                 HWND hTopWnd = GetAncestor(hWnd, GA_ROOT);
 956                 if (SetActiveWindow(hTopWnd) || GetActiveWindow() == hTopWnd)
 957                 {
 958                     SendMessageW(hWnd, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam);
 959                 }
 960                 break;
 961         }
 962         case HTSYSMENU:
 963         {
 964           if (GetWindowLongPtrW(hWnd, GWL_STYLE) & WS_SYSMENU)
 965             {
 966               SendMessageW(hWnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU,
 967                            lParam);
 968             }
 969           break;
 970         }
 971         case HTMENU:
 972         {
 973             SendMessageW(hWnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTMENU, lParam);
 974             break;
 975         }
 976         case HTHSCROLL:
 977         {
 978             SendMessageW(hWnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam);
 979             break;
 980         }
 981         case HTVSCROLL:
 982         {
 983             SendMessageW(hWnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam);
 984             break;
 985         }
 986         case HTMINBUTTON:
 987         case HTMAXBUTTON:
 988         case HTCLOSE:
 989         {
 990           DefWndDoButton(hWnd, wParam);
 991           break;
 992         }
 993         case HTLEFT:
 994         case HTRIGHT:
 995         case HTTOP:
 996         case HTBOTTOM:
 997         case HTTOPLEFT:
 998         case HTTOPRIGHT:
 999         case HTBOTTOMLEFT:
1000         case HTBOTTOMRIGHT:
1001         {
1002             SendMessageW(hWnd, WM_SYSCOMMAND, SC_SIZE + wParam - (HTLEFT - WMSZ_LEFT), lParam);
1003             break;
1004         }
1005     }
1006     return(0);
1007 }
1008
1009
1010 LRESULT
1011 DefWndNCLButtonDblClk(HWND hWnd, WPARAM wParam, LPARAM lParam)
1012 {
1013   ULONG Style;
1014
1015   Style = GetWindowLongPtrW(hWnd, GWL_STYLE);
1016   switch(wParam)
1017   {
1018     case HTCAPTION:
1019     {
1020       /* Maximize/Restore the window */
1021       if((Style & WS_CAPTION) == WS_CAPTION && (Style & WS_MAXIMIZEBOX))
1022       {
1023         SendMessageW(hWnd, WM_SYSCOMMAND, ((Style & (WS_MINIMIZE | WS_MAXIMIZE)) ? SC_RESTORE : SC_MAXIMIZE), 0);
1024       }
1025       break;
1026     }
1027     case HTSYSMENU:
1028     {
1029       SendMessageW(hWnd, WM_SYSCOMMAND, SC_CLOSE, 0);
1030       break;
1031     }
1032     default:
1033       return DefWndNCLButtonDown(hWnd, wParam, lParam);
1034   }
1035   return(0);
1036 }
1037
1038 VOID
1039 DefWndTrackScrollBar(HWND hWnd, WPARAM wParam, POINT Point)
1040 {
1041    INT ScrollBar;
1042
1043    if ((wParam & 0xfff0) == SC_HSCROLL)
1044    {
1045       if ((wParam & 0x0f) != HTHSCROLL)
1046          return;
1047       ScrollBar = SB_HORZ;
1048    }
1049    else
1050    {
1051       if ((wParam & 0x0f) != HTVSCROLL)
1052          return;
1053       ScrollBar = SB_VERT;
1054    }
1055
1056    /* FIXME */
1057 }
1058
1059 /* PUBLIC FUNCTIONS ***********************************************************/
1060
1061 BOOL WINAPI
1062 RealAdjustWindowRectEx(LPRECT lpRect,
1063                        DWORD dwStyle,
1064                        BOOL bMenu,
1065                        DWORD dwExStyle)
1066 {
1067    SIZE BorderSize;
1068
1069    if (bMenu)
1070    {
1071       lpRect->top -= GetSystemMetrics(SM_CYMENU);
1072    }
1073    if ((dwStyle & WS_CAPTION) == WS_CAPTION)
1074    {
1075       if (dwExStyle & WS_EX_TOOLWINDOW)
1076          lpRect->top -= GetSystemMetrics(SM_CYSMCAPTION);
1077       else
1078          lpRect->top -= GetSystemMetrics(SM_CYCAPTION);
1079    }
1080    UserGetWindowBorders(dwStyle, dwExStyle, &BorderSize, TRUE);
1081    InflateRect(
1082       lpRect,
1083       BorderSize.cx,
1084       BorderSize.cy);
1085
1086    return TRUE;
1087 }
1088
1089 /*
1090  * @implemented
1091  */
1092 BOOL WINAPI
1093 AdjustWindowRectEx(LPRECT lpRect,
1094                    DWORD dwStyle,
1095                    BOOL bMenu,
1096                    DWORD dwExStyle)
1097 {
1098    BOOL Hook, Ret = FALSE;
1099
1100    LOADUSERAPIHOOK
1101
1102    Hook = BeginIfHookedUserApiHook();
1103
1104      /* Bypass SEH and go direct. */
1105    if (!Hook) return RealAdjustWindowRectEx(lpRect, dwStyle, bMenu, dwExStyle);
1106
1107    _SEH2_TRY
1108    {
1109       Ret = guah.AdjustWindowRectEx(lpRect, dwStyle, bMenu, dwExStyle);
1110    }
1111    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1112    {
1113    }
1114    _SEH2_END;
1115
1116    EndUserApiHook();
1117
1118    return Ret;
1119 }
1120
1121
1122 /*
1123  * @implemented
1124  */
1125 BOOL WINAPI
1126 AdjustWindowRect(LPRECT lpRect,
1127                  DWORD dwStyle,
1128                  BOOL bMenu)
1129 {
1130    return AdjustWindowRectEx(lpRect, dwStyle, bMenu, 0);
1131 }
1132
1133 // Enabling this will cause captions to draw smoother, but slower:
1134 #define DOUBLE_BUFFER_CAPTION
1135
1136 /*
1137  * @implemented
1138  */
1139 BOOL WINAPI
1140 DrawCaption(HWND hWnd, HDC hDC, LPCRECT lprc, UINT uFlags)
1141 {
1142    BOOL Hook, Ret = FALSE;
1143
1144    LOADUSERAPIHOOK
1145
1146    Hook = BeginIfHookedUserApiHook();
1147
1148    /* Bypass SEH and go direct. */
1149    if (!Hook) return NtUserDrawCaption(hWnd, hDC, lprc, uFlags);
1150
1151    _SEH2_TRY
1152    {
1153       Ret = guah.DrawCaption(hWnd, hDC, lprc, uFlags);
1154    }
1155    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1156    {
1157    }
1158    _SEH2_END;
1159
1160    EndUserApiHook();
1161
1162    return Ret;
1163 }
1164
1165 /*
1166  * @implemented
1167  */
1168 BOOL
1169 WINAPI
1170 DrawCaptionTempW(
1171                  HWND        hWnd,
1172                  HDC         hDC,
1173                  const RECT *rect,
1174                  HFONT       hFont,
1175                  HICON       hIcon,
1176                  LPCWSTR     str,
1177                  UINT        uFlags
1178                  )
1179 {
1180    UNICODE_STRING Text = {0};
1181    RtlInitUnicodeString(&Text, str);
1182    return NtUserDrawCaptionTemp(hWnd, hDC, rect, hFont, hIcon, &Text, uFlags);
1183 }
1184
1185 /*
1186  * @implemented
1187  */
1188 BOOL
1189 WINAPI
1190 DrawCaptionTempA(
1191                  HWND        hwnd,
1192                  HDC         hdc,
1193                  const RECT *rect,
1194                  HFONT       hFont,
1195                  HICON       hIcon,
1196                  LPCSTR      str,
1197                  UINT        uFlags
1198                  )
1199 {
1200   LPWSTR strW;
1201   INT len;
1202   BOOL ret = FALSE;
1203
1204   if (!(uFlags & DC_TEXT) || !str)
1205     return DrawCaptionTempW(hwnd, hdc, rect, hFont, hIcon, NULL, uFlags);
1206
1207   len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
1208   if ((strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
1209   {
1210     MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len );
1211     ret = DrawCaptionTempW(hwnd, hdc, rect, hFont, hIcon, strW, uFlags);
1212     HeapFree(GetProcessHeap(), 0, strW);
1213   }
1214   return ret;
1215 }
1216
1217 /***********************************************************************
1218  *           NcGetInsideRect
1219  *
1220  * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
1221  * but without the borders (if any).
1222  * The rectangle is in window coordinates (for drawing with GetWindowDC()).
1223  */
1224 static void FASTCALL
1225 NcGetInsideRect(HWND Wnd, RECT *Rect)
1226 {
1227   DWORD Style;
1228   DWORD ExStyle;
1229
1230   GetWindowRect(Wnd, Rect);
1231   Rect->right = Rect->right - Rect->left;
1232   Rect->left = 0;
1233   Rect->bottom = Rect->bottom - Rect->top;
1234   Rect->top = 0;
1235
1236   Style = GetWindowLongPtrW(Wnd, GWL_STYLE);
1237   if (0 != (Style & WS_ICONIC))
1238     {
1239       return;
1240     }
1241
1242   /* Remove frame from rectangle */
1243   ExStyle = GetWindowLongPtrW(Wnd, GWL_EXSTYLE);
1244   if (HAS_THICKFRAME(Style, ExStyle))
1245     {
1246       InflateRect(Rect, - GetSystemMetrics(SM_CXFRAME), - GetSystemMetrics(SM_CYFRAME));
1247     }
1248   else if (HAS_DLGFRAME(Style, ExStyle))
1249     {
1250       InflateRect(Rect, - GetSystemMetrics(SM_CXDLGFRAME), - GetSystemMetrics(SM_CYDLGFRAME));
1251     }
1252   else if (HAS_THINFRAME(Style, ExStyle))
1253     {
1254       InflateRect(Rect, - GetSystemMetrics(SM_CXBORDER), - GetSystemMetrics(SM_CYBORDER));
1255     }
1256
1257   /* We have additional border information if the window
1258    * is a child (but not an MDI child) */
1259   if (0 != (Style & WS_CHILD)
1260       && 0 == (ExStyle & WS_EX_MDICHILD))
1261     {
1262       if (0 != (ExStyle & WS_EX_CLIENTEDGE))
1263         {
1264           InflateRect(Rect, - GetSystemMetrics(SM_CXEDGE), - GetSystemMetrics(SM_CYEDGE));
1265         }
1266       if (0 != (ExStyle & WS_EX_STATICEDGE))
1267         {
1268           InflateRect(Rect, - GetSystemMetrics(SM_CXBORDER), - GetSystemMetrics(SM_CYBORDER));
1269         }
1270     }
1271 }
1272
1273 /***********************************************************************
1274  *           NcGetSysPopupPos
1275  */
1276 void FASTCALL
1277 NcGetSysPopupPos(HWND Wnd, RECT *Rect)
1278 {
1279   RECT WindowRect;
1280
1281   if (IsIconic(Wnd))
1282     {
1283       GetWindowRect(Wnd, Rect);
1284     }
1285   else
1286     {
1287       NcGetInsideRect(Wnd, Rect);
1288       GetWindowRect(Wnd, &WindowRect);
1289       OffsetRect(Rect, WindowRect.left, WindowRect.top);
1290       if (0 != (GetWindowLongPtrW(Wnd, GWL_STYLE) & WS_CHILD))
1291         {
1292           ClientToScreen(GetParent(Wnd), (POINT *) Rect);
1293         }
1294       Rect->right = Rect->left + GetSystemMetrics(SM_CYCAPTION) - 1;
1295       Rect->bottom = Rect->top + GetSystemMetrics(SM_CYCAPTION) - 1;
1296     }
1297 }