git.oblomov.eu Git - wine/blob - dlls/user32/nonclient.c

   1 /*
   2  * Non-client area window functions
   3  *
   4  * Copyright 1994 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "wingdi.h"
  28 #include "winnls.h"
  29 #include "win.h"
  30 #include "user_private.h"
  31 #include "controls.h"
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(nonclient);
  35
  36 #define SC_ABOUTWINE            (SC_SCREENSAVE+1)
  37
  38   /* Some useful macros */
  39 #define HAS_DLGFRAME(style,exStyle) \
  40     (((exStyle) & WS_EX_DLGMODALFRAME) || \
  41      (((style) & WS_DLGFRAME) && !((style) & WS_THICKFRAME)))
  42
  43 #define HAS_THICKFRAME(style,exStyle) \
  44     (((style) & WS_THICKFRAME) && \
  45      !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
  46
  47 #define HAS_THINFRAME(style) \
  48     (((style) & WS_BORDER) || !((style) & (WS_CHILD | WS_POPUP)))
  49
  50 #define HAS_BIGFRAME(style,exStyle) \
  51     (((style) & (WS_THICKFRAME | WS_DLGFRAME)) || \
  52      ((exStyle) & WS_EX_DLGMODALFRAME))
  53
  54 #define HAS_STATICOUTERFRAME(style,exStyle) \
  55     (((exStyle) & (WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) == \
  56      WS_EX_STATICEDGE)
  57
  58 #define HAS_ANYFRAME(style,exStyle) \
  59     (((style) & (WS_THICKFRAME | WS_DLGFRAME | WS_BORDER)) || \
  60      ((exStyle) & WS_EX_DLGMODALFRAME) || \
  61      !((style) & (WS_CHILD | WS_POPUP)))
  62
  63 #define HAS_MENU(hwnd,style)  ((((style) & (WS_CHILD | WS_POPUP)) != WS_CHILD) && GetMenu(hwnd))
  64
  65
  66 /******************************************************************************
  67  * NC_AdjustRectOuter
  68  *
  69  * Computes the size of the "outside" parts of the window based on the
  70  * parameters of the client area.
  71  *
  72  * PARAMS
  73  *     LPRECT  rect
  74  *     DWORD  style
  75  *     BOOL  menu
  76  *     DWORD  exStyle
  77  *
  78  * NOTES
  79  *     "Outer" parts of a window means the whole window frame, caption and
  80  *     menu bar. It does not include "inner" parts of the frame like client
  81  *     edge, static edge or scroll bars.
  82  *
  83  *****************************************************************************/
  84
  85 static void
  86 NC_AdjustRectOuter (LPRECT rect, DWORD style, BOOL menu, DWORD exStyle)
  87 {
  88     int adjust;
  89
  90     if ((exStyle & (WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) ==
  91         WS_EX_STATICEDGE)
  92     {
  93         adjust = 1; /* for the outer frame always present */
  94     }
  95     else
  96     {
  97         adjust = 0;
  98         if ((exStyle & WS_EX_DLGMODALFRAME) ||
  99             (style & (WS_THICKFRAME|WS_DLGFRAME))) adjust = 2; /* outer */
 100     }
 101     if ((style & WS_THICKFRAME) && !(exStyle & WS_EX_DLGMODALFRAME))
 102         adjust +=  ( GetSystemMetrics (SM_CXFRAME)
 103                    - GetSystemMetrics (SM_CXDLGFRAME)); /* The resize border */
 104     if ((style & (WS_BORDER|WS_DLGFRAME)) ||
 105         (exStyle & WS_EX_DLGMODALFRAME))
 106         adjust++; /* The other border */
 107
 108     InflateRect (rect, adjust, adjust);
 109
 110     if ((style & WS_CAPTION) == WS_CAPTION)
 111     {
 112         if (exStyle & WS_EX_TOOLWINDOW)
 113             rect->top -= GetSystemMetrics(SM_CYSMCAPTION);
 114         else
 115             rect->top -= GetSystemMetrics(SM_CYCAPTION);
 116     }
 117     if (menu) rect->top -= GetSystemMetrics(SM_CYMENU);
 118 }
 119
 120
 121 /******************************************************************************
 122  * NC_AdjustRectInner
 123  *
 124  * Computes the size of the "inside" part of the window based on the
 125  * parameters of the client area.
 126  *
 127  * PARAMS
 128  *     LPRECT   rect
 129  *     DWORD    style
 130  *     DWORD    exStyle
 131  *
 132  * NOTES
 133  *     "Inner" part of a window means the window frame inside of the flat
 134  *     window frame. It includes the client edge, the static edge and the
 135  *     scroll bars.
 136  *
 137  *****************************************************************************/
 138
 139 static void
 140 NC_AdjustRectInner (LPRECT rect, DWORD style, DWORD exStyle)
 141 {
 142     if (exStyle & WS_EX_CLIENTEDGE)
 143         InflateRect(rect, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
 144
 145     if (style & WS_VSCROLL)
 146     {
 147         if((exStyle & WS_EX_LEFTSCROLLBAR) != 0)
 148             rect->left  -= GetSystemMetrics(SM_CXVSCROLL);
 149         else
 150             rect->right += GetSystemMetrics(SM_CXVSCROLL);
 151     }
 152     if (style & WS_HSCROLL) rect->bottom += GetSystemMetrics(SM_CYHSCROLL);
 153 }
 154
 155
 156
 157 static HICON NC_IconForWindow( HWND hwnd )
 158 {
 159     HICON hIcon = 0;
 160     WND *wndPtr = WIN_GetPtr( hwnd );
 161
 162     if (wndPtr && wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
 163     {
 164         hIcon = wndPtr->hIconSmall;
 165         if (!hIcon) hIcon = wndPtr->hIcon;
 166         WIN_ReleasePtr( wndPtr );
 167     }
 168     if (!hIcon) hIcon = (HICON) GetClassLongPtrW( hwnd, GCLP_HICONSM );
 169     if (!hIcon) hIcon = (HICON) GetClassLongPtrW( hwnd, GCLP_HICON );
 170
 171     /* If there is no hIcon specified and this is a modal dialog,
 172      * get the default one.
 173      */
 174     if (!hIcon && (GetWindowLongW( hwnd, GWL_STYLE ) & DS_MODALFRAME))
 175         hIcon = LoadImageW(0, (LPCWSTR)IDI_WINLOGO, IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
 176     return hIcon;
 177 }
 178
 179 /* Draws the bar part(ie the big rectangle) of the caption */
 180 static void NC_DrawCaptionBar (HDC hdc, const RECT *rect, DWORD dwStyle,
 181                                BOOL active, BOOL gradient)
 182 {
 183     if (gradient)
 184     {
 185         TRIVERTEX vertices[6];
 186         DWORD colLeft =
 187             GetSysColor (active ? COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION);
 188         DWORD colRight =
 189             GetSysColor (active ? COLOR_GRADIENTACTIVECAPTION
 190                                 : COLOR_GRADIENTINACTIVECAPTION);
 191         int v;
 192         int buttonsAreaSize = GetSystemMetrics(SM_CYCAPTION) - 1;
 193         static GRADIENT_RECT mesh[] = {{0, 1}, {2, 3}, {4, 5}};
 194
 195         for (v = 0; v < 3; v++)
 196         {
 197             vertices[v].Red = GetRValue (colLeft) << 8;
 198             vertices[v].Green = GetGValue (colLeft) << 8;
 199             vertices[v].Blue = GetBValue (colLeft) << 8;
 200             vertices[v].Alpha = 0x8000;
 201             vertices[v+3].Red = GetRValue (colRight) << 8;
 202             vertices[v+3].Green = GetGValue (colRight) << 8;
 203             vertices[v+3].Blue = GetBValue (colRight) << 8;
 204             vertices[v+3].Alpha = 0x8000;
 205         }
 206
 207         if ((dwStyle & WS_SYSMENU)
 208             && ((dwStyle & WS_MAXIMIZEBOX) || (dwStyle & WS_MINIMIZEBOX)))
 209             buttonsAreaSize += 2 * (GetSystemMetrics(SM_CXSIZE) + 1);
 210
 211         /* area behind icon; solid filled with left color */
 212         vertices[0].x = rect->left;
 213         vertices[0].y = rect->top;
 214         if (dwStyle & WS_SYSMENU)
 215             vertices[1].x =
 216                 min (rect->left + GetSystemMetrics(SM_CXSMICON), rect->right);
 217         else
 218             vertices[1].x = vertices[0].x;
 219         vertices[1].y = rect->bottom;
 220
 221         /* area behind text; gradient */
 222         vertices[2].x = vertices[1].x;
 223         vertices[2].y = rect->top;
 224         vertices[3].x = max (vertices[2].x, rect->right - buttonsAreaSize);
 225         vertices[3].y = rect->bottom;
 226
 227         /* area behind buttons; solid filled with right color */
 228         vertices[4].x = vertices[3].x;
 229         vertices[4].y = rect->top;
 230         vertices[5].x = rect->right;
 231         vertices[5].y = rect->bottom;
 232
 233         GdiGradientFill (hdc, vertices, 6, mesh, 3, GRADIENT_FILL_RECT_H);
 234     }
 235     else
 236         FillRect (hdc, rect, GetSysColorBrush (active ?
 237                   COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION));
 238 }
 239
 240 /***********************************************************************
 241  *              DrawCaption (USER32.@) Draws a caption bar
 242  *
 243  * PARAMS
 244  *     hwnd   [I]
 245  *     hdc    [I]
 246  *     lpRect [I]
 247  *     uFlags [I]
 248  *
 249  * RETURNS
 250  *     Success:
 251  *     Failure:
 252  */
 253
 254 BOOL WINAPI
 255 DrawCaption (HWND hwnd, HDC hdc, const RECT *lpRect, UINT uFlags)
 256 {
 257     return DrawCaptionTempW (hwnd, hdc, lpRect, 0, 0, NULL, uFlags & 0x103F);
 258 }
 259
 260
 261 /***********************************************************************
 262  *              DrawCaptionTempA (USER32.@)
 263  */
 264 BOOL WINAPI DrawCaptionTempA (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
 265                               HICON hIcon, LPCSTR str, UINT uFlags)
 266 {
 267     LPWSTR strW;
 268     INT len;
 269     BOOL ret = FALSE;
 270
 271     if (!(uFlags & DC_TEXT) || !str)
 272         return DrawCaptionTempW( hwnd, hdc, rect, hFont, hIcon, NULL, uFlags );
 273
 274     len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
 275     if ((strW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
 276     {
 277         MultiByteToWideChar( CP_ACP, 0, str, -1, strW, len );
 278         ret = DrawCaptionTempW (hwnd, hdc, rect, hFont, hIcon, strW, uFlags);
 279         HeapFree( GetProcessHeap (), 0, strW );
 280     }
 281     return ret;
 282 }
 283
 284
 285 /***********************************************************************
 286  *              DrawCaptionTempW (USER32.@)
 287  */
 288 BOOL WINAPI DrawCaptionTempW (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
 289                               HICON hIcon, LPCWSTR str, UINT uFlags)
 290 {
 291     RECT   rc = *rect;
 292
 293     TRACE("(%p,%p,%p,%p,%p,%s,%08x)\n",
 294           hwnd, hdc, rect, hFont, hIcon, debugstr_w(str), uFlags);
 295
 296     /* drawing background */
 297     if (uFlags & DC_INBUTTON) {
 298         FillRect (hdc, &rc, GetSysColorBrush (COLOR_3DFACE));
 299
 300         if (uFlags & DC_ACTIVE) {
 301             HBRUSH hbr = SelectObject (hdc, SYSCOLOR_55AABrush);
 302             PatBlt (hdc, rc.left, rc.top,
 303                       rc.right-rc.left, rc.bottom-rc.top, 0xFA0089);
 304             SelectObject (hdc, hbr);
 305         }
 306     }
 307     else {
 308         DWORD style = GetWindowLongW (hwnd, GWL_STYLE);
 309         NC_DrawCaptionBar (hdc, &rc, style, uFlags & DC_ACTIVE, uFlags & DC_GRADIENT);
 310     }
 311
 312
 313     /* drawing icon */
 314     if ((uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP)) {
 315         POINT pt;
 316
 317         pt.x = rc.left + 2;
 318         pt.y = (rc.bottom + rc.top - GetSystemMetrics(SM_CYSMICON)) / 2;
 319
 320         if (!hIcon) hIcon = NC_IconForWindow(hwnd);
 321         DrawIconEx (hdc, pt.x, pt.y, hIcon, GetSystemMetrics(SM_CXSMICON),
 322                     GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
 323         rc.left += (rc.bottom - rc.top);
 324     }
 325
 326     /* drawing text */
 327     if (uFlags & DC_TEXT) {
 328         HFONT hOldFont;
 329
 330         if (uFlags & DC_INBUTTON)
 331             SetTextColor (hdc, GetSysColor (COLOR_BTNTEXT));
 332         else if (uFlags & DC_ACTIVE)
 333             SetTextColor (hdc, GetSysColor (COLOR_CAPTIONTEXT));
 334         else
 335             SetTextColor (hdc, GetSysColor (COLOR_INACTIVECAPTIONTEXT));
 336
 337         SetBkMode (hdc, TRANSPARENT);
 338
 339         if (hFont)
 340             hOldFont = SelectObject (hdc, hFont);
 341         else {
 342             NONCLIENTMETRICSW nclm;
 343             HFONT hNewFont;
 344             nclm.cbSize = sizeof(NONCLIENTMETRICSW);
 345             SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
 346             hNewFont = CreateFontIndirectW ((uFlags & DC_SMALLCAP) ?
 347                 &nclm.lfSmCaptionFont : &nclm.lfCaptionFont);
 348             hOldFont = SelectObject (hdc, hNewFont);
 349         }
 350
 351         if (str)
 352             DrawTextW (hdc, str, -1, &rc,
 353                          DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
 354         else {
 355             WCHAR szText[128];
 356             INT nLen;
 357             nLen = GetWindowTextW (hwnd, szText, 128);
 358             DrawTextW (hdc, szText, nLen, &rc,
 359                          DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
 360         }
 361
 362         if (hFont)
 363             SelectObject (hdc, hOldFont);
 364         else
 365             DeleteObject (SelectObject (hdc, hOldFont));
 366     }
 367
 368     /* drawing focus ??? */
 369     if (uFlags & 0x2000)
 370         FIXME("undocumented flag (0x2000)!\n");
 371
 372     return 0;
 373 }
 374
 375
 376 /***********************************************************************
 377  *              AdjustWindowRect (USER32.@)
 378  */
 379 BOOL WINAPI AdjustWindowRect( LPRECT rect, DWORD style, BOOL menu )
 380 {
 381     return AdjustWindowRectEx( rect, style, menu, 0 );
 382 }
 383
 384
 385 /***********************************************************************
 386  *              AdjustWindowRectEx (USER32.@)
 387  */
 388 BOOL WINAPI AdjustWindowRectEx( LPRECT rect, DWORD style, BOOL menu, DWORD exStyle )
 389 {
 390     if (style & WS_ICONIC) return TRUE;
 391     style &= ~(WS_HSCROLL | WS_VSCROLL);
 392
 393     TRACE("(%s) %08x %d %08x\n", wine_dbgstr_rect(rect), style, menu, exStyle );
 394
 395     NC_AdjustRectOuter( rect, style, menu, exStyle );
 396     NC_AdjustRectInner( rect, style, exStyle );
 397
 398     return TRUE;
 399 }
 400
 401
 402 /***********************************************************************
 403  *           NC_HandleNCCalcSize
 404  *
 405  * Handle a WM_NCCALCSIZE message. Called from DefWindowProc().
 406  */
 407 LRESULT NC_HandleNCCalcSize( HWND hwnd, WPARAM wparam, RECT *winRect )
 408 {
 409     RECT tmpRect = { 0, 0, 0, 0 };
 410     LRESULT result = 0;
 411     LONG cls_style = GetClassLongW(hwnd, GCL_STYLE);
 412     LONG style = GetWindowLongW( hwnd, GWL_STYLE );
 413     LONG exStyle = GetWindowLongW( hwnd, GWL_EXSTYLE );
 414
 415     if (winRect == NULL)
 416         return 0;
 417
 418     if (cls_style & CS_VREDRAW) result |= WVR_VREDRAW;
 419     if (cls_style & CS_HREDRAW) result |= WVR_HREDRAW;
 420
 421     if (!(style & WS_ICONIC))
 422     {
 423         NC_AdjustRectOuter( &tmpRect, style, FALSE, exStyle );
 424
 425         winRect->left   -= tmpRect.left;
 426         winRect->top    -= tmpRect.top;
 427         winRect->right  -= tmpRect.right;
 428         winRect->bottom -= tmpRect.bottom;
 429
 430         if (((style & (WS_CHILD | WS_POPUP)) != WS_CHILD) && GetMenu(hwnd))
 431         {
 432             TRACE("Calling GetMenuBarHeight with hwnd %p, width %d, at (%d, %d).\n",
 433                   hwnd, winRect->right - winRect->left, -tmpRect.left, -tmpRect.top );
 434
 435             winRect->top +=
 436                 MENU_GetMenuBarHeight( hwnd,
 437                                        winRect->right - winRect->left,
 438                                        -tmpRect.left, -tmpRect.top );
 439         }
 440
 441         if( exStyle & WS_EX_CLIENTEDGE)
 442             if( winRect->right - winRect->left > 2 * GetSystemMetrics(SM_CXEDGE) &&
 443                    winRect->bottom - winRect->top > 2 * GetSystemMetrics(SM_CYEDGE))
 444                 InflateRect( winRect, - GetSystemMetrics(SM_CXEDGE),
 445                         - GetSystemMetrics(SM_CYEDGE));
 446
 447         if (style & WS_VSCROLL)
 448             if (winRect->right - winRect->left >= GetSystemMetrics(SM_CXVSCROLL))
 449             {
 450                 /* rectangle is in screen coords when wparam is false */
 451                 if (!wparam && (exStyle & WS_EX_LAYOUTRTL)) exStyle ^= WS_EX_LEFTSCROLLBAR;
 452
 453                 if((exStyle & WS_EX_LEFTSCROLLBAR) != 0)
 454                     winRect->left  += GetSystemMetrics(SM_CXVSCROLL);
 455                 else
 456                     winRect->right -= GetSystemMetrics(SM_CXVSCROLL);
 457             }
 458
 459         if (style & WS_HSCROLL)
 460             if( winRect->bottom - winRect->top > GetSystemMetrics(SM_CYHSCROLL))
 461                     winRect->bottom -= GetSystemMetrics(SM_CYHSCROLL);
 462
 463         if (winRect->top > winRect->bottom)
 464             winRect->bottom = winRect->top;
 465
 466         if (winRect->left > winRect->right)
 467             winRect->right = winRect->left;
 468     }
 469     return result;
 470 }
 471
 472
 473 /***********************************************************************
 474  *           NC_GetInsideRect
 475  *
 476  * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
 477  * but without the borders (if any).
 478  */
 479 static void NC_GetInsideRect( HWND hwnd, enum coords_relative relative, RECT *rect,
 480                               DWORD style, DWORD ex_style )
 481 {
 482     WIN_GetRectangles( hwnd, relative, rect, NULL );
 483
 484     if (style & WS_ICONIC) return;
 485
 486     /* Remove frame from rectangle */
 487     if (HAS_THICKFRAME( style, ex_style ))
 488     {
 489         InflateRect( rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
 490     }
 491     else if (HAS_DLGFRAME( style, ex_style ))
 492     {
 493         InflateRect( rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
 494     }
 495     else if (HAS_THINFRAME( style ))
 496     {
 497         InflateRect( rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER) );
 498     }
 499
 500     /* We have additional border information if the window
 501      * is a child (but not an MDI child) */
 502     if ((style & WS_CHILD) && !(ex_style & WS_EX_MDICHILD))
 503     {
 504         if (ex_style & WS_EX_CLIENTEDGE)
 505             InflateRect (rect, -GetSystemMetrics(SM_CXEDGE), -GetSystemMetrics(SM_CYEDGE));
 506         if (ex_style & WS_EX_STATICEDGE)
 507             InflateRect (rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
 508     }
 509 }
 510
 511
 512 /***********************************************************************
 513  * NC_HandleNCHitTest
 514  *
 515  * Handle a WM_NCHITTEST message. Called from DefWindowProc().
 516  */
 517 LRESULT NC_HandleNCHitTest( HWND hwnd, POINT pt )
 518 {
 519     RECT rect, rcClient;
 520     DWORD style, ex_style;
 521
 522     TRACE("hwnd=%p pt=%d,%d\n", hwnd, pt.x, pt.y );
 523
 524     WIN_GetRectangles( hwnd, COORDS_SCREEN, &rect, &rcClient );
 525     if (!PtInRect( &rect, pt )) return HTNOWHERE;
 526
 527     style = GetWindowLongW( hwnd, GWL_STYLE );
 528     ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
 529     if (style & WS_MINIMIZE) return HTCAPTION;
 530
 531     if (PtInRect( &rcClient, pt )) return HTCLIENT;
 532
 533     /* Check borders */
 534     if (HAS_THICKFRAME( style, ex_style ))
 535     {
 536         InflateRect( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
 537         if (!PtInRect( &rect, pt ))
 538         {
 539             /* Check top sizing border */
 540             if (pt.y < rect.top)
 541             {
 542                 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
 543                 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
 544                 return HTTOP;
 545             }
 546             /* Check bottom sizing border */
 547             if (pt.y >= rect.bottom)
 548             {
 549                 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
 550                 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
 551                 return HTBOTTOM;
 552             }
 553             /* Check left sizing border */
 554             if (pt.x < rect.left)
 555             {
 556                 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
 557                 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
 558                 return HTLEFT;
 559             }
 560             /* Check right sizing border */
 561             if (pt.x >= rect.right)
 562             {
 563                 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
 564                 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
 565                 return HTRIGHT;
 566             }
 567         }
 568     }
 569     else  /* No thick frame */
 570     {
 571         if (HAS_DLGFRAME( style, ex_style ))
 572             InflateRect(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
 573         else if (HAS_THINFRAME( style ))
 574             InflateRect(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
 575         if (!PtInRect( &rect, pt )) return HTBORDER;
 576     }
 577
 578     /* Check caption */
 579
 580     if ((style & WS_CAPTION) == WS_CAPTION)
 581     {
 582         if (ex_style & WS_EX_TOOLWINDOW)
 583             rect.top += GetSystemMetrics(SM_CYSMCAPTION) - 1;
 584         else
 585             rect.top += GetSystemMetrics(SM_CYCAPTION) - 1;
 586         if (!PtInRect( &rect, pt ))
 587         {
 588             BOOL min_or_max_box = (style & WS_MAXIMIZEBOX) ||
 589                                   (style & WS_MINIMIZEBOX);
 590             if (ex_style & WS_EX_LAYOUTRTL)
 591             {
 592                 /* Check system menu */
 593                 if ((style & WS_SYSMENU) && !(ex_style & WS_EX_TOOLWINDOW) && NC_IconForWindow(hwnd))
 594                 {
 595                     rect.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
 596                     if (pt.x > rect.right) return HTSYSMENU;
 597                 }
 598
 599                 /* Check close button */
 600                 if (style & WS_SYSMENU)
 601                 {
 602                     rect.left += GetSystemMetrics(SM_CYCAPTION);
 603                     if (pt.x < rect.left) return HTCLOSE;
 604                 }
 605
 606                 /* Check maximize box */
 607                 /* In win95 there is automatically a Maximize button when there is a minimize one*/
 608                 if (min_or_max_box && !(ex_style & WS_EX_TOOLWINDOW))
 609                 {
 610                     rect.left += GetSystemMetrics(SM_CXSIZE);
 611                     if (pt.x < rect.left) return HTMAXBUTTON;
 612                 }
 613
 614                 /* Check minimize box */
 615                 if (min_or_max_box && !(ex_style & WS_EX_TOOLWINDOW))
 616                 {
 617                     rect.left += GetSystemMetrics(SM_CXSIZE);
 618                     if (pt.x < rect.left) return HTMINBUTTON;
 619                 }
 620             }
 621             else
 622             {
 623                 /* Check system menu */
 624                 if ((style & WS_SYSMENU) && !(ex_style & WS_EX_TOOLWINDOW) && NC_IconForWindow(hwnd))
 625                 {
 626                     rect.left += GetSystemMetrics(SM_CYCAPTION) - 1;
 627                     if (pt.x < rect.left) return HTSYSMENU;
 628                 }
 629
 630                 /* Check close button */
 631                 if (style & WS_SYSMENU)
 632                 {
 633                     rect.right -= GetSystemMetrics(SM_CYCAPTION);
 634                     if (pt.x > rect.right) return HTCLOSE;
 635                 }
 636
 637                 /* Check maximize box */
 638                 /* In win95 there is automatically a Maximize button when there is a minimize one*/
 639                 if (min_or_max_box && !(ex_style & WS_EX_TOOLWINDOW))
 640                 {
 641                     rect.right -= GetSystemMetrics(SM_CXSIZE);
 642                     if (pt.x > rect.right) return HTMAXBUTTON;
 643                 }
 644
 645                 /* Check minimize box */
 646                 if (min_or_max_box && !(ex_style & WS_EX_TOOLWINDOW))
 647                 {
 648                     rect.right -= GetSystemMetrics(SM_CXSIZE);
 649                     if (pt.x > rect.right) return HTMINBUTTON;
 650                 }
 651             }
 652             return HTCAPTION;
 653         }
 654     }
 655
 656       /* Check menu bar */
 657
 658     if (HAS_MENU( hwnd, style ) && (pt.y < rcClient.top) &&
 659         (pt.x >= rcClient.left) && (pt.x < rcClient.right))
 660         return HTMENU;
 661
 662       /* Check vertical scroll bar */
 663
 664     if (ex_style & WS_EX_LAYOUTRTL) ex_style ^= WS_EX_LEFTSCROLLBAR;
 665     if (style & WS_VSCROLL)
 666     {
 667         if((ex_style & WS_EX_LEFTSCROLLBAR) != 0)
 668             rcClient.left -= GetSystemMetrics(SM_CXVSCROLL);
 669         else
 670             rcClient.right += GetSystemMetrics(SM_CXVSCROLL);
 671         if (PtInRect( &rcClient, pt )) return HTVSCROLL;
 672     }
 673
 674       /* Check horizontal scroll bar */
 675
 676     if (style & WS_HSCROLL)
 677     {
 678         rcClient.bottom += GetSystemMetrics(SM_CYHSCROLL);
 679         if (PtInRect( &rcClient, pt ))
 680         {
 681             /* Check size box */
 682             if ((style & WS_VSCROLL) &&
 683                 ((((ex_style & WS_EX_LEFTSCROLLBAR) != 0) && (pt.x <= rcClient.left + GetSystemMetrics(SM_CXVSCROLL))) ||
 684                 (((ex_style & WS_EX_LEFTSCROLLBAR) == 0) && (pt.x >= rcClient.right - GetSystemMetrics(SM_CXVSCROLL)))))
 685                 return HTSIZE;
 686             return HTHSCROLL;
 687         }
 688     }
 689
 690     /* Has to return HTNOWHERE if nothing was found
 691        Could happen when a window has a customized non client area */
 692     return HTNOWHERE;
 693 }
 694
 695
 696 /******************************************************************************
 697  *
 698  *   NC_DrawSysButton
 699  *
 700  *   Draws the system icon.
 701  *
 702  *****************************************************************************/
 703 BOOL NC_DrawSysButton (HWND hwnd, HDC hdc, BOOL down)
 704 {
 705     HICON hIcon = NC_IconForWindow( hwnd );
 706
 707     if (hIcon)
 708     {
 709         RECT rect;
 710         DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
 711         DWORD ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
 712
 713         NC_GetInsideRect( hwnd, COORDS_WINDOW, &rect, style, ex_style );
 714         DrawIconEx (hdc, rect.left + 2, rect.top + 1, hIcon,
 715                     GetSystemMetrics(SM_CXSMICON),
 716                     GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
 717     }
 718     return (hIcon != 0);
 719 }
 720
 721
 722 /******************************************************************************
 723  *
 724  *   NC_DrawCloseButton
 725  *
 726  *   Draws the close button.
 727  *
 728  *   If bGrayed is true, then draw a disabled Close button
 729  *
 730  *****************************************************************************/
 731
 732 static void NC_DrawCloseButton (HWND hwnd, HDC hdc, BOOL down, BOOL bGrayed)
 733 {
 734     RECT rect;
 735     DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
 736     DWORD ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
 737
 738     NC_GetInsideRect( hwnd, COORDS_WINDOW, &rect, style, ex_style );
 739
 740     /* A tool window has a smaller Close button */
 741     if (ex_style & WS_EX_TOOLWINDOW)
 742     {
 743         INT iBmpHeight = 11; /* Windows does not use SM_CXSMSIZE and SM_CYSMSIZE   */
 744         INT iBmpWidth = 11;  /* it uses 11x11 for  the close button in tool window */
 745         INT iCaptionHeight = GetSystemMetrics(SM_CYSMCAPTION);
 746
 747         rect.top = rect.top + (iCaptionHeight - 1 - iBmpHeight) / 2;
 748         rect.left = rect.right - (iCaptionHeight + 1 + iBmpWidth) / 2;
 749         rect.bottom = rect.top + iBmpHeight;
 750         rect.right = rect.left + iBmpWidth;
 751     }
 752     else
 753     {
 754         rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
 755         rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 2;
 756         rect.top += 2;
 757         rect.right -= 2;
 758     }
 759     DrawFrameControl( hdc, &rect, DFC_CAPTION,
 760                       (DFCS_CAPTIONCLOSE |
 761                        (down ? DFCS_PUSHED : 0) |
 762                        (bGrayed ? DFCS_INACTIVE : 0)) );
 763 }
 764
 765 /******************************************************************************
 766  *   NC_DrawMaxButton
 767  *
 768  *   Draws the maximize button for windows.
 769  *   If bGrayed is true, then draw a disabled Maximize button
 770  */
 771 static void NC_DrawMaxButton(HWND hwnd,HDC hdc,BOOL down, BOOL bGrayed)
 772 {
 773     RECT rect;
 774     UINT flags;
 775     DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
 776     DWORD ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
 777
 778     /* never draw maximize box when window has WS_EX_TOOLWINDOW style */
 779     if (ex_style & WS_EX_TOOLWINDOW) return;
 780
 781     flags = (style & WS_MAXIMIZE) ? DFCS_CAPTIONRESTORE : DFCS_CAPTIONMAX;
 782
 783     NC_GetInsideRect( hwnd, COORDS_WINDOW, &rect, style, ex_style );
 784     if (style & WS_SYSMENU)
 785         rect.right -= GetSystemMetrics(SM_CXSIZE);
 786     rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
 787     rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 2;
 788     rect.top += 2;
 789     rect.right -= 2;
 790     if (down) flags |= DFCS_PUSHED;
 791     if (bGrayed) flags |= DFCS_INACTIVE;
 792     DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
 793 }
 794
 795 /******************************************************************************
 796  *   NC_DrawMinButton
 797  *
 798  *   Draws the minimize button for windows.
 799  *   If bGrayed is true, then draw a disabled Minimize button
 800  */
 801 static void  NC_DrawMinButton(HWND hwnd,HDC hdc,BOOL down, BOOL bGrayed)
 802 {
 803     RECT rect;
 804     UINT flags = DFCS_CAPTIONMIN;
 805     DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
 806     DWORD ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
 807
 808     /* never draw minimize box when window has WS_EX_TOOLWINDOW style */
 809     if (ex_style & WS_EX_TOOLWINDOW) return;
 810
 811     NC_GetInsideRect( hwnd, COORDS_WINDOW, &rect, style, ex_style );
 812     if (style & WS_SYSMENU)
 813         rect.right -= GetSystemMetrics(SM_CXSIZE);
 814     if (style & (WS_MAXIMIZEBOX|WS_MINIMIZEBOX))
 815         rect.right -= GetSystemMetrics(SM_CXSIZE) - 2;
 816     rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
 817     rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 2;
 818     rect.top += 2;
 819     rect.right -= 2;
 820     if (down) flags |= DFCS_PUSHED;
 821     if (bGrayed) flags |= DFCS_INACTIVE;
 822     DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
 823 }
 824
 825 /******************************************************************************
 826  *
 827  *   NC_DrawFrame
 828  *
 829  *   Draw a window frame inside the given rectangle, and update the rectangle.
 830  *
 831  *   Bugs
 832  *        Many.  First, just what IS a frame in Win95?  Note that the 3D look
 833  *        on the outer edge is handled by NC_DoNCPaint.  As is the inner
 834  *        edge.  The inner rectangle just inside the frame is handled by the
 835  *        Caption code.
 836  *
 837  *        In short, for most people, this function should be a nop (unless
 838  *        you LIKE thick borders in Win95/NT4.0 -- I've been working with
 839  *        them lately, but just to get this code right).  Even so, it doesn't
 840  *        appear to be so.  It's being worked on...
 841  *
 842  *****************************************************************************/
 843
 844 static void  NC_DrawFrame( HDC  hdc, RECT  *rect, BOOL  active, DWORD style, DWORD exStyle)
 845 {
 846     INT width, height;
 847
 848     /* Firstly the "thick" frame */
 849     if (style & WS_THICKFRAME)
 850     {
 851         width = GetSystemMetrics(SM_CXFRAME) - GetSystemMetrics(SM_CXDLGFRAME);
 852         height = GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYDLGFRAME);
 853
 854         SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
 855                                             COLOR_INACTIVEBORDER) );
 856         /* Draw frame */
 857         PatBlt( hdc, rect->left, rect->top,
 858                   rect->right - rect->left, height, PATCOPY );
 859         PatBlt( hdc, rect->left, rect->top,
 860                   width, rect->bottom - rect->top, PATCOPY );
 861         PatBlt( hdc, rect->left, rect->bottom - 1,
 862                   rect->right - rect->left, -height, PATCOPY );
 863         PatBlt( hdc, rect->right - 1, rect->top,
 864                   -width, rect->bottom - rect->top, PATCOPY );
 865
 866         InflateRect( rect, -width, -height );
 867     }
 868
 869     /* Now the other bit of the frame */
 870     if ((style & (WS_BORDER|WS_DLGFRAME)) ||
 871         (exStyle & WS_EX_DLGMODALFRAME))
 872     {
 873         width = GetSystemMetrics(SM_CXDLGFRAME) - GetSystemMetrics(SM_CXEDGE);
 874         height = GetSystemMetrics(SM_CYDLGFRAME) - GetSystemMetrics(SM_CYEDGE);
 875         /* This should give a value of 1 that should also work for a border */
 876
 877         SelectObject( hdc, GetSysColorBrush(
 878                       (exStyle & (WS_EX_DLGMODALFRAME|WS_EX_CLIENTEDGE)) ?
 879                           COLOR_3DFACE :
 880                       (exStyle & WS_EX_STATICEDGE) ?
 881                           COLOR_WINDOWFRAME :
 882                       (style & (WS_DLGFRAME|WS_THICKFRAME)) ?
 883                           COLOR_3DFACE :
 884                       /* else */
 885                           COLOR_WINDOWFRAME));
 886
 887         /* Draw frame */
 888         PatBlt( hdc, rect->left, rect->top,
 889                   rect->right - rect->left, height, PATCOPY );
 890         PatBlt( hdc, rect->left, rect->top,
 891                   width, rect->bottom - rect->top, PATCOPY );
 892         PatBlt( hdc, rect->left, rect->bottom - 1,
 893                   rect->right - rect->left, -height, PATCOPY );
 894         PatBlt( hdc, rect->right - 1, rect->top,
 895                   -width, rect->bottom - rect->top, PATCOPY );
 896
 897         InflateRect( rect, -width, -height );
 898     }
 899 }
 900
 901
 902 /******************************************************************************
 903  *
 904  *   NC_DrawCaption
 905  *
 906  *   Draw the window caption for windows.
 907  *   The correct pen for the window frame must be selected in the DC.
 908  *
 909  *****************************************************************************/
 910
 911 static void  NC_DrawCaption( HDC  hdc, RECT *rect, HWND hwnd, DWORD  style,
 912                              DWORD  exStyle, BOOL active )
 913 {
 914     RECT  r = *rect;
 915     WCHAR buffer[256];
 916     HPEN  hPrevPen;
 917     HMENU hSysMenu;
 918     BOOL gradient = FALSE;
 919
 920     hPrevPen = SelectObject( hdc, SYSCOLOR_GetPen(
 921                      ((exStyle & (WS_EX_STATICEDGE|WS_EX_CLIENTEDGE|
 922                                  WS_EX_DLGMODALFRAME)) == WS_EX_STATICEDGE) ?
 923                       COLOR_WINDOWFRAME : COLOR_3DFACE) );
 924     MoveToEx( hdc, r.left, r.bottom - 1, NULL );
 925     LineTo( hdc, r.right, r.bottom - 1 );
 926     SelectObject( hdc, hPrevPen );
 927     r.bottom--;
 928
 929     SystemParametersInfoW (SPI_GETGRADIENTCAPTIONS, 0, &gradient, 0);
 930     NC_DrawCaptionBar (hdc, &r, style, active, gradient);
 931
 932     if ((style & WS_SYSMENU) && !(exStyle & WS_EX_TOOLWINDOW)) {
 933         if (NC_DrawSysButton (hwnd, hdc, FALSE))
 934             r.left += GetSystemMetrics(SM_CXSMICON) + 2;
 935     }
 936
 937     if (style & WS_SYSMENU)
 938     {
 939         UINT state;
 940
 941         /* Go get the sysmenu */
 942         hSysMenu = GetSystemMenu(hwnd, FALSE);
 943         state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
 944
 945         /* Draw a grayed close button if disabled or if SC_CLOSE is not there */
 946         NC_DrawCloseButton (hwnd, hdc, FALSE,
 947                             (state & (MF_DISABLED | MF_GRAYED)) || (state == 0xFFFFFFFF));
 948         r.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
 949
 950         if ((style & WS_MAXIMIZEBOX) || (style & WS_MINIMIZEBOX))
 951         {
 952             /* In win95 the two buttons are always there */
 953             /* But if the menu item is not in the menu they're disabled*/
 954
 955             NC_DrawMaxButton( hwnd, hdc, FALSE, (!(style & WS_MAXIMIZEBOX)));
 956             r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
 957
 958             NC_DrawMinButton( hwnd, hdc, FALSE,  (!(style & WS_MINIMIZEBOX)));
 959             r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
 960         }
 961     }
 962
 963     if (GetWindowTextW( hwnd, buffer, sizeof(buffer)/sizeof(WCHAR) ))
 964     {
 965         NONCLIENTMETRICSW nclm;
 966         HFONT hFont, hOldFont;
 967         nclm.cbSize = sizeof(nclm);
 968         SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
 969         if (exStyle & WS_EX_TOOLWINDOW)
 970             hFont = CreateFontIndirectW (&nclm.lfSmCaptionFont);
 971         else
 972             hFont = CreateFontIndirectW (&nclm.lfCaptionFont);
 973         hOldFont = SelectObject (hdc, hFont);
 974         if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
 975         else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
 976         SetBkMode( hdc, TRANSPARENT );
 977         r.left += 2;
 978         DrawTextW( hdc, buffer, -1, &r,
 979                      DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT );
 980         DeleteObject (SelectObject (hdc, hOldFont));
 981     }
 982 }
 983
 984
 985 /******************************************************************************
 986  *   NC_DoNCPaint
 987  *
 988  *   Paint the non-client area for windows.
 989  */
 990 static void  NC_DoNCPaint( HWND  hwnd, HRGN  clip, BOOL  suppress_menupaint )
 991 {
 992     HDC hdc;
 993     RECT rfuzz, rect, rectClip;
 994     BOOL active;
 995     WND *wndPtr;
 996     DWORD dwStyle, dwExStyle;
 997     WORD flags;
 998     HRGN hrgn;
 999     RECT rectClient;
1000
1001     if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return;
1002     dwStyle = wndPtr->dwStyle;
1003     dwExStyle = wndPtr->dwExStyle;
1004     flags = wndPtr->flags;
1005     WIN_ReleasePtr( wndPtr );
1006
1007     if ( dwStyle & WS_MINIMIZE ||
1008          !WIN_IsWindowDrawable( hwnd, 0 )) return; /* Nothing to do */
1009
1010     active  = flags & WIN_NCACTIVATED;
1011
1012     TRACE("%p %d\n", hwnd, active );
1013
1014     /* MSDN docs are pretty idiotic here, they say app CAN use clipRgn in
1015        the call to GetDCEx implying that it is allowed not to use it either.
1016        However, the suggested GetDCEx(    , DCX_WINDOW | DCX_INTERSECTRGN)
1017        will cause clipRgn to be deleted after ReleaseDC().
1018        Now, how is the "system" supposed to tell what happened?
1019      */
1020
1021     WIN_GetRectangles( hwnd, COORDS_SCREEN, NULL, &rectClient );
1022     hrgn = CreateRectRgnIndirect( &rectClient );
1023
1024     if (clip > (HRGN)1)
1025     {
1026         CombineRgn( hrgn, clip, hrgn, RGN_DIFF );
1027         hdc = GetDCEx( hwnd, hrgn, DCX_USESTYLE | DCX_WINDOW | DCX_INTERSECTRGN );
1028     }
1029     else
1030     {
1031         hdc = GetDCEx( hwnd, hrgn, DCX_USESTYLE | DCX_WINDOW | DCX_EXCLUDERGN );
1032     }
1033
1034     if (!hdc) return;
1035
1036     WIN_GetRectangles( hwnd, COORDS_WINDOW, &rect, NULL );
1037     GetClipBox( hdc, &rectClip );
1038
1039     SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1040
1041     if (HAS_STATICOUTERFRAME(dwStyle, dwExStyle)) {
1042         DrawEdge (hdc, &rect, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
1043     }
1044     else if (HAS_BIGFRAME( dwStyle, dwExStyle)) {
1045         DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT | BF_ADJUST);
1046     }
1047
1048     NC_DrawFrame(hdc, &rect, active, dwStyle, dwExStyle );
1049
1050     if ((dwStyle & WS_CAPTION) == WS_CAPTION)
1051     {
1052         RECT  r = rect;
1053         if (dwExStyle & WS_EX_TOOLWINDOW) {
1054             r.bottom = rect.top + GetSystemMetrics(SM_CYSMCAPTION);
1055             rect.top += GetSystemMetrics(SM_CYSMCAPTION);
1056         }
1057         else {
1058             r.bottom = rect.top + GetSystemMetrics(SM_CYCAPTION);
1059             rect.top += GetSystemMetrics(SM_CYCAPTION);
1060         }
1061         if( IntersectRect( &rfuzz, &r, &rectClip ) )
1062             NC_DrawCaption(hdc, &r, hwnd, dwStyle, dwExStyle, active);
1063     }
1064
1065     if (HAS_MENU( hwnd, dwStyle ))
1066     {
1067         RECT r = rect;
1068         r.bottom = rect.top + GetSystemMetrics(SM_CYMENU);
1069
1070         TRACE("Calling DrawMenuBar with rect (%s)\n", wine_dbgstr_rect(&r));
1071
1072         rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint ) + 1;
1073     }
1074
1075     TRACE("After MenuBar, rect is (%s).\n", wine_dbgstr_rect(&rect));
1076
1077     if (dwExStyle & WS_EX_CLIENTEDGE)
1078         DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1079
1080     /* Draw the scroll-bars */
1081
1082     if (dwStyle & WS_VSCROLL)
1083         SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1084     if (dwStyle & WS_HSCROLL)
1085         SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1086
1087     /* Draw the "size-box" */
1088     if ((dwStyle & WS_VSCROLL) && (dwStyle & WS_HSCROLL))
1089     {
1090         RECT r = rect;
1091         if((dwExStyle & WS_EX_LEFTSCROLLBAR) != 0)
1092             r.right = r.left + GetSystemMetrics(SM_CXVSCROLL) + 1;
1093         else
1094             r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1095         r.top  = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1096         FillRect( hdc, &r,  GetSysColorBrush(COLOR_SCROLLBAR) );
1097     }
1098
1099     ReleaseDC( hwnd, hdc );
1100 }
1101
1102
1103
1104
1105 /***********************************************************************
1106  *           NC_HandleNCPaint
1107  *
1108  * Handle a WM_NCPAINT message. Called from DefWindowProc().
1109  */
1110 LRESULT NC_HandleNCPaint( HWND hwnd , HRGN clip)
1111 {
1112     DWORD dwStyle = GetWindowLongW( hwnd, GWL_STYLE );
1113
1114     if( dwStyle & WS_VISIBLE )
1115     {
1116         if( dwStyle & WS_MINIMIZE )
1117             WINPOS_RedrawIconTitle( hwnd );
1118         else
1119             NC_DoNCPaint( hwnd, clip, FALSE );
1120     }
1121     return 0;
1122 }
1123
1124
1125 /***********************************************************************
1126  *           NC_HandleNCActivate
1127  *
1128  * Handle a WM_NCACTIVATE message. Called from DefWindowProc().
1129  */
1130 LRESULT NC_HandleNCActivate( HWND hwnd, WPARAM wParam, LPARAM lParam )
1131 {
1132     WND* wndPtr = WIN_GetPtr( hwnd );
1133
1134     if (!wndPtr || wndPtr == WND_OTHER_PROCESS) return FALSE;
1135
1136     /* Lotus Notes draws menu descriptions in the caption of its main
1137      * window. When it wants to restore original "system" view, it just
1138      * sends WM_NCACTIVATE message to itself. Any optimizations here in
1139      * attempt to minimize redrawings lead to a not restored caption.
1140      */
1141     if (wParam) wndPtr->flags |= WIN_NCACTIVATED;
1142     else wndPtr->flags &= ~WIN_NCACTIVATED;
1143     WIN_ReleasePtr( wndPtr );
1144
1145     /* This isn't documented but is reproducible in at least XP SP2 and
1146      * Outlook 2007 depends on it
1147      */
1148     if (lParam != -1)
1149     {
1150         if (IsIconic(hwnd))
1151             WINPOS_RedrawIconTitle( hwnd );
1152         else
1153             NC_DoNCPaint( hwnd, (HRGN)1, FALSE );
1154     }
1155
1156     return TRUE;
1157 }
1158
1159
1160 /***********************************************************************
1161  *           NC_HandleSetCursor
1162  *
1163  * Handle a WM_SETCURSOR message. Called from DefWindowProc().
1164  */
1165 LRESULT NC_HandleSetCursor( HWND hwnd, WPARAM wParam, LPARAM lParam )
1166 {
1167     hwnd = WIN_GetFullHandle( (HWND)wParam );
1168
1169     switch((short)LOWORD(lParam))
1170     {
1171     case HTERROR:
1172         {
1173             WORD msg = HIWORD( lParam );
1174             if ((msg == WM_LBUTTONDOWN) || (msg == WM_MBUTTONDOWN) ||
1175                 (msg == WM_RBUTTONDOWN) || (msg == WM_XBUTTONDOWN))
1176                 MessageBeep(0);
1177         }
1178         break;
1179
1180     case HTCLIENT:
1181         {
1182             HCURSOR hCursor = (HCURSOR)GetClassLongPtrW(hwnd, GCLP_HCURSOR);
1183             if(hCursor) {
1184                 SetCursor(hCursor);
1185                 return TRUE;
1186             }
1187             return FALSE;
1188         }
1189
1190     case HTLEFT:
1191     case HTRIGHT:
1192         return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_SIZEWE ) );
1193
1194     case HTTOP:
1195     case HTBOTTOM:
1196         return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_SIZENS ) );
1197
1198     case HTTOPLEFT:
1199     case HTBOTTOMRIGHT:
1200         return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_SIZENWSE ) );
1201
1202     case HTTOPRIGHT:
1203     case HTBOTTOMLEFT:
1204         return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_SIZENESW ) );
1205     }
1206
1207     /* Default cursor: arrow */
1208     return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_ARROW ) );
1209 }
1210
1211 /***********************************************************************
1212  *           NC_GetSysPopupPos
1213  */
1214 void NC_GetSysPopupPos( HWND hwnd, RECT* rect )
1215 {
1216     if (IsIconic(hwnd)) GetWindowRect( hwnd, rect );
1217     else
1218     {
1219         DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
1220         DWORD ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
1221
1222         NC_GetInsideRect( hwnd, COORDS_CLIENT, rect, style, ex_style );
1223         rect->right = rect->left + GetSystemMetrics(SM_CYCAPTION) - 1;
1224         rect->bottom = rect->top + GetSystemMetrics(SM_CYCAPTION) - 1;
1225         MapWindowPoints( hwnd, 0, (POINT *)rect, 2 );
1226     }
1227 }
1228
1229 /***********************************************************************
1230  *           NC_TrackMinMaxBox
1231  *
1232  * Track a mouse button press on the minimize or maximize box.
1233  *
1234  * The big difference between 3.1 and 95 is the disabled button state.
1235  * In win95 the system button can be disabled, so it can ignore the mouse
1236  * event.
1237  *
1238  */
1239 static void NC_TrackMinMaxBox( HWND hwnd, WORD wParam )
1240 {
1241     MSG msg;
1242     HDC hdc = GetWindowDC( hwnd );
1243     BOOL pressed = TRUE;
1244     UINT state;
1245     DWORD wndStyle = GetWindowLongW( hwnd, GWL_STYLE);
1246     HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
1247
1248     void  (*paintButton)(HWND, HDC, BOOL, BOOL);
1249
1250     if (wParam == HTMINBUTTON)
1251     {
1252         /* If the style is not present, do nothing */
1253         if (!(wndStyle & WS_MINIMIZEBOX))
1254             return;
1255
1256         /* Check if the sysmenu item for minimize is there  */
1257         state = GetMenuState(hSysMenu, SC_MINIMIZE, MF_BYCOMMAND);
1258
1259         paintButton = NC_DrawMinButton;
1260     }
1261     else
1262     {
1263         /* If the style is not present, do nothing */
1264         if (!(wndStyle & WS_MAXIMIZEBOX))
1265             return;
1266
1267         /* Check if the sysmenu item for maximize is there  */
1268         state = GetMenuState(hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND);
1269
1270         paintButton = NC_DrawMaxButton;
1271     }
1272
1273     SetCapture( hwnd );
1274
1275     (*paintButton)( hwnd, hdc, TRUE, FALSE);
1276
1277     while(1)
1278     {
1279         BOOL oldstate = pressed;
1280
1281         if (!GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST )) break;
1282         if (CallMsgFilterW( &msg, MSGF_MAX )) continue;
1283
1284         if(msg.message == WM_LBUTTONUP)
1285             break;
1286
1287         if(msg.message != WM_MOUSEMOVE)
1288             continue;
1289
1290         pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1291         if (pressed != oldstate)
1292            (*paintButton)( hwnd, hdc, pressed, FALSE);
1293     }
1294
1295     if(pressed)
1296         (*paintButton)(hwnd, hdc, FALSE, FALSE);
1297
1298     ReleaseCapture();
1299     ReleaseDC( hwnd, hdc );
1300
1301     /* If the item minimize or maximize of the sysmenu are not there */
1302     /* or if the style is not present, do nothing */
1303     if ((!pressed) || (state == 0xFFFFFFFF))
1304         return;
1305
1306     if (wParam == HTMINBUTTON)
1307         SendMessageW( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1308     else
1309         SendMessageW( hwnd, WM_SYSCOMMAND,
1310                       IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1311 }
1312
1313 /***********************************************************************
1314  * NC_TrackCloseButton
1315  *
1316  * Track a mouse button press on the Win95 close button.
1317  */
1318 static void NC_TrackCloseButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
1319 {
1320     MSG msg;
1321     HDC hdc;
1322     BOOL pressed = TRUE;
1323     HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
1324     UINT state;
1325
1326     if(hSysMenu == 0)
1327         return;
1328
1329     state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1330
1331     /* If the item close of the sysmenu is disabled or not there do nothing */
1332     if((state & MF_DISABLED) || (state & MF_GRAYED) || (state == 0xFFFFFFFF))
1333         return;
1334
1335     hdc = GetWindowDC( hwnd );
1336
1337     SetCapture( hwnd );
1338
1339     NC_DrawCloseButton (hwnd, hdc, TRUE, FALSE);
1340
1341     while(1)
1342     {
1343         BOOL oldstate = pressed;
1344
1345         if (!GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST )) break;
1346         if (CallMsgFilterW( &msg, MSGF_MAX )) continue;
1347
1348         if(msg.message == WM_LBUTTONUP)
1349             break;
1350
1351         if(msg.message != WM_MOUSEMOVE)
1352             continue;
1353
1354         pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1355         if (pressed != oldstate)
1356            NC_DrawCloseButton (hwnd, hdc, pressed, FALSE);
1357     }
1358
1359     if(pressed)
1360         NC_DrawCloseButton (hwnd, hdc, FALSE, FALSE);
1361
1362     ReleaseCapture();
1363     ReleaseDC( hwnd, hdc );
1364     if (!pressed) return;
1365
1366     SendMessageW( hwnd, WM_SYSCOMMAND, SC_CLOSE, lParam );
1367 }
1368
1369
1370 /***********************************************************************
1371  *           NC_TrackScrollBar
1372  *
1373  * Track a mouse button press on the horizontal or vertical scroll-bar.
1374  */
1375 static void NC_TrackScrollBar( HWND hwnd, WPARAM wParam, POINT pt )
1376 {
1377     INT scrollbar;
1378
1379     if ((wParam & 0xfff0) == SC_HSCROLL)
1380     {
1381         if ((wParam & 0x0f) != HTHSCROLL) return;
1382         scrollbar = SB_HORZ;
1383     }
1384     else  /* SC_VSCROLL */
1385     {
1386         if ((wParam & 0x0f) != HTVSCROLL) return;
1387         scrollbar = SB_VERT;
1388     }
1389     SCROLL_TrackScrollBar( hwnd, scrollbar, pt );
1390 }
1391
1392
1393 /***********************************************************************
1394  *           NC_HandleNCLButtonDown
1395  *
1396  * Handle a WM_NCLBUTTONDOWN message. Called from DefWindowProc().
1397  */
1398 LRESULT NC_HandleNCLButtonDown( HWND hwnd, WPARAM wParam, LPARAM lParam )
1399 {
1400     LONG style = GetWindowLongW( hwnd, GWL_STYLE );
1401
1402     switch(wParam)  /* Hit test */
1403     {
1404     case HTCAPTION:
1405         {
1406             HWND top = GetAncestor( hwnd, GA_ROOT );
1407
1408             if (FOCUS_MouseActivate( top ) || (GetActiveWindow() == top))
1409                 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam );
1410             break;
1411         }
1412
1413     case HTSYSMENU:
1414          if( style & WS_SYSMENU )
1415          {
1416              if( !(style & WS_MINIMIZE) )
1417              {
1418                 HDC hDC = GetWindowDC(hwnd);
1419                 NC_DrawSysButton( hwnd, hDC, TRUE );
1420                 ReleaseDC( hwnd, hDC );
1421              }
1422              SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, lParam );
1423          }
1424          break;
1425
1426     case HTMENU:
1427         SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU, lParam );
1428         break;
1429
1430     case HTHSCROLL:
1431         SendMessageW( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
1432         break;
1433
1434     case HTVSCROLL:
1435         SendMessageW( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
1436         break;
1437
1438     case HTMINBUTTON:
1439     case HTMAXBUTTON:
1440         NC_TrackMinMaxBox( hwnd, wParam );
1441         break;
1442
1443     case HTCLOSE:
1444         NC_TrackCloseButton (hwnd, wParam, lParam);
1445         break;
1446
1447     case HTLEFT:
1448     case HTRIGHT:
1449     case HTTOP:
1450     case HTTOPLEFT:
1451     case HTTOPRIGHT:
1452     case HTBOTTOM:
1453     case HTBOTTOMLEFT:
1454     case HTBOTTOMRIGHT:
1455         /* Old comment:
1456          * "make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU"
1457          * This was previously done by setting wParam=SC_SIZE + wParam - 2
1458          */
1459         /* But that is not what WinNT does. Instead it sends this. This
1460          * is easy to differentiate from HTSYSMENU, because HTSYSMENU adds
1461          * SC_MOUSEMENU into wParam.
1462          */
1463         SendMessageW( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - (HTLEFT-WMSZ_LEFT), lParam);
1464         break;
1465
1466     case HTBORDER:
1467         break;
1468     }
1469     return 0;
1470 }
1471
1472
1473 /***********************************************************************
1474  *           NC_HandleNCLButtonDblClk
1475  *
1476  * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
1477  */
1478 LRESULT NC_HandleNCLButtonDblClk( HWND hwnd, WPARAM wParam, LPARAM lParam )
1479 {
1480     /*
1481      * if this is an icon, send a restore since we are handling
1482      * a double click
1483      */
1484     if (IsIconic(hwnd))
1485     {
1486         SendMessageW( hwnd, WM_SYSCOMMAND, SC_RESTORE, lParam );
1487         return 0;
1488     }
1489
1490     switch(wParam)  /* Hit test */
1491     {
1492     case HTCAPTION:
1493         /* stop processing if WS_MAXIMIZEBOX is missing */
1494         if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_MAXIMIZEBOX)
1495             SendMessageW( hwnd, WM_SYSCOMMAND,
1496                           IsZoomed(hwnd) ? SC_RESTORE : SC_MAXIMIZE, lParam );
1497         break;
1498
1499     case HTSYSMENU:
1500         {
1501             HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
1502             UINT state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1503
1504             /* If the item close of the sysmenu is disabled or not there do nothing */
1505             if ((state & (MF_DISABLED | MF_GRAYED)) || (state == 0xFFFFFFFF))
1506                 break;
1507
1508             SendMessageW( hwnd, WM_SYSCOMMAND, SC_CLOSE, lParam );
1509             break;
1510         }
1511
1512     case HTHSCROLL:
1513         SendMessageW( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
1514         break;
1515
1516     case HTVSCROLL:
1517         SendMessageW( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
1518         break;
1519     }
1520     return 0;
1521 }
1522
1523
1524 /***********************************************************************
1525  *           NC_HandleSysCommand
1526  *
1527  * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
1528  */
1529 LRESULT NC_HandleSysCommand( HWND hwnd, WPARAM wParam, LPARAM lParam )
1530 {
1531     TRACE("hwnd %p WM_SYSCOMMAND %lx %lx\n", hwnd, wParam, lParam );
1532
1533     if (!IsWindowEnabled( hwnd )) return 0;
1534
1535     if (HOOK_CallHooks( WH_CBT, HCBT_SYSCOMMAND, wParam, lParam, TRUE ))
1536         return 0;
1537
1538     if (!USER_Driver->pSysCommand( hwnd, wParam, lParam ))
1539         return 0;
1540
1541     switch (wParam & 0xfff0)
1542     {
1543     case SC_SIZE:
1544     case SC_MOVE:
1545         WINPOS_SysCommandSizeMove( hwnd, wParam );
1546         break;
1547
1548     case SC_MINIMIZE:
1549         if (hwnd == GetActiveWindow())
1550             ShowOwnedPopups(hwnd,FALSE);
1551         ShowWindow( hwnd, SW_MINIMIZE );
1552         break;
1553
1554     case SC_MAXIMIZE:
1555         if (IsIconic(hwnd) && hwnd == GetActiveWindow())
1556             ShowOwnedPopups(hwnd,TRUE);
1557         ShowWindow( hwnd, SW_MAXIMIZE );
1558         break;
1559
1560     case SC_RESTORE:
1561         if (IsIconic(hwnd) && hwnd == GetActiveWindow())
1562             ShowOwnedPopups(hwnd,TRUE);
1563         ShowWindow( hwnd, SW_RESTORE );
1564         break;
1565
1566     case SC_CLOSE:
1567         return SendMessageW( hwnd, WM_CLOSE, 0, 0 );
1568
1569     case SC_VSCROLL:
1570     case SC_HSCROLL:
1571         {
1572             POINT pt;
1573             pt.x = (short)LOWORD(lParam);
1574             pt.y = (short)HIWORD(lParam);
1575             NC_TrackScrollBar( hwnd, wParam, pt );
1576         }
1577         break;
1578
1579     case SC_MOUSEMENU:
1580         {
1581             POINT pt;
1582             pt.x = (short)LOWORD(lParam);
1583             pt.y = (short)HIWORD(lParam);
1584             MENU_TrackMouseMenuBar( hwnd, wParam & 0x000F, pt );
1585         }
1586         break;
1587
1588     case SC_KEYMENU:
1589         MENU_TrackKbdMenuBar( hwnd, wParam, (WCHAR)lParam );
1590         break;
1591
1592     case SC_TASKLIST:
1593         WinExec( "taskman.exe", SW_SHOWNORMAL );
1594         break;
1595
1596     case SC_SCREENSAVE:
1597         if (wParam == SC_ABOUTWINE)
1598         {
1599             HMODULE hmodule = LoadLibraryA( "shell32.dll" );
1600             if (hmodule)
1601             {
1602                 BOOL (WINAPI *aboutproc)(HWND, LPCSTR, LPCSTR, HICON);
1603
1604                 aboutproc = (void *)GetProcAddress( hmodule, "ShellAboutA" );
1605                 if (aboutproc) aboutproc( hwnd, PACKAGE_STRING, NULL, 0 );
1606                 FreeLibrary( hmodule );
1607             }
1608         }
1609         break;
1610
1611     case SC_HOTKEY:
1612     case SC_ARRANGE:
1613     case SC_NEXTWINDOW:
1614     case SC_PREVWINDOW:
1615         FIXME("unimplemented WM_SYSCOMMAND %04lx!\n", wParam);
1616         break;
1617     }
1618     return 0;
1619 }
1620
1621 /***********************************************************************
1622  *              GetTitleBarInfo (USER32.@)
1623  * TODO: Handle STATE_SYSTEM_PRESSED
1624  */
1625 BOOL WINAPI GetTitleBarInfo(HWND hwnd, PTITLEBARINFO tbi) {
1626     DWORD dwStyle;
1627     DWORD dwExStyle;
1628
1629     TRACE("(%p %p)\n", hwnd, tbi);
1630
1631     if(!tbi) {
1632         SetLastError(ERROR_NOACCESS);
1633         return FALSE;
1634     }
1635
1636     if(tbi->cbSize != sizeof(TITLEBARINFO)) {
1637         TRACE("Invalid TITLEBARINFO size: %d\n", tbi->cbSize);
1638         SetLastError(ERROR_INVALID_PARAMETER);
1639         return FALSE;
1640     }
1641     dwStyle = GetWindowLongW(hwnd, GWL_STYLE);
1642     dwExStyle = GetWindowLongW(hwnd, GWL_EXSTYLE);
1643     NC_GetInsideRect(hwnd, COORDS_SCREEN, &tbi->rcTitleBar, dwStyle, dwExStyle);
1644
1645     tbi->rcTitleBar.bottom = tbi->rcTitleBar.top;
1646     if(dwExStyle & WS_EX_TOOLWINDOW)
1647         tbi->rcTitleBar.bottom += GetSystemMetrics(SM_CYSMCAPTION);
1648     else {
1649         tbi->rcTitleBar.bottom += GetSystemMetrics(SM_CYCAPTION);
1650         tbi->rcTitleBar.left += GetSystemMetrics(SM_CXSIZE);
1651     }
1652
1653     ZeroMemory(tbi->rgstate, sizeof(tbi->rgstate));
1654     /* Does the title bar always have STATE_SYSTEM_FOCUSABLE?
1655      * Under XP it seems to
1656      */
1657     tbi->rgstate[0] = STATE_SYSTEM_FOCUSABLE;
1658     if(dwStyle & WS_CAPTION) {
1659         tbi->rgstate[1] = STATE_SYSTEM_INVISIBLE;
1660         if(dwStyle & WS_SYSMENU) {
1661             if(!(dwStyle & (WS_MINIMIZEBOX|WS_MAXIMIZEBOX))) {
1662                 tbi->rgstate[2] = STATE_SYSTEM_INVISIBLE;
1663                 tbi->rgstate[3] = STATE_SYSTEM_INVISIBLE;
1664             }
1665             else {
1666                 if(!(dwStyle & WS_MINIMIZEBOX))
1667                     tbi->rgstate[2] = STATE_SYSTEM_UNAVAILABLE;
1668                 if(!(dwStyle & WS_MAXIMIZEBOX))
1669                     tbi->rgstate[3] = STATE_SYSTEM_UNAVAILABLE;
1670             }
1671             if(!(dwExStyle & WS_EX_CONTEXTHELP))
1672                 tbi->rgstate[4] = STATE_SYSTEM_INVISIBLE;
1673             if(GetClassLongW(hwnd, GCL_STYLE) & CS_NOCLOSE)
1674                 tbi->rgstate[5] = STATE_SYSTEM_UNAVAILABLE;
1675         }
1676         else {
1677             tbi->rgstate[2] = STATE_SYSTEM_INVISIBLE;
1678             tbi->rgstate[3] = STATE_SYSTEM_INVISIBLE;
1679             tbi->rgstate[4] = STATE_SYSTEM_INVISIBLE;
1680             tbi->rgstate[5] = STATE_SYSTEM_INVISIBLE;
1681         }
1682     }
1683     else
1684         tbi->rgstate[0] |= STATE_SYSTEM_INVISIBLE;
1685     return TRUE;
1686 }