git.oblomov.eu Git - wine/blob - windows/nonclient.c

   1 /*
   2  * Non-client area window functions
   3  *
   4  * Copyright 1994 Alexandre Julliard
   5  *
   6  */
   7
   8 #include "wine/winuser16.h"
   9 #include "version.h"
  10 #include "win.h"
  11 #include "message.h"
  12 #include "user.h"
  13 #include "heap.h"
  14 #include "dce.h"
  15 #include "cursoricon.h"
  16 #include "dialog.h"
  17 #include "menu.h"
  18 #include "winpos.h"
  19 #include "hook.h"
  20 #include "scroll.h"
  21 #include "nonclient.h"
  22 #include "queue.h"
  23 #include "selectors.h"
  24 #include "tweak.h"
  25 #include "debugtools.h"
  26 #include "options.h"
  27 #include "shellapi.h"
  28 #include "cache.h"
  29 #include "bitmap.h"
  30
  31 DEFAULT_DEBUG_CHANNEL(nonclient)
  32 DECLARE_DEBUG_CHANNEL(shell)
  33
  34 BOOL NC_DrawGrayButton(HDC hdc, int x, int y);
  35
  36 static HBITMAP16 hbitmapClose = 0;
  37 static HBITMAP16 hbitmapCloseD = 0;
  38 static HBITMAP16 hbitmapMinimize = 0;
  39 static HBITMAP16 hbitmapMinimizeD = 0;
  40 static HBITMAP16 hbitmapMaximize = 0;
  41 static HBITMAP16 hbitmapMaximizeD = 0;
  42 static HBITMAP16 hbitmapRestore = 0;
  43 static HBITMAP16 hbitmapRestoreD = 0;
  44
  45 BYTE lpGrayMask[] = { 0xAA, 0xA0,
  46                       0x55, 0x50,
  47                       0xAA, 0xA0,
  48                       0x55, 0x50,
  49                       0xAA, 0xA0,
  50                       0x55, 0x50,
  51                       0xAA, 0xA0,
  52                       0x55, 0x50,
  53                       0xAA, 0xA0,
  54                       0x55, 0x50};
  55
  56 #define SC_ABOUTWINE            (SC_SCREENSAVE+1)
  57 #define SC_PUTMARK              (SC_SCREENSAVE+2)
  58
  59   /* Some useful macros */
  60 #define HAS_DLGFRAME(style,exStyle) \
  61     (((exStyle) & WS_EX_DLGMODALFRAME) || \
  62      (((style) & WS_DLGFRAME) && !((style) & WS_THICKFRAME)))
  63
  64 #define HAS_THICKFRAME(style,exStyle) \
  65     (((style) & WS_THICKFRAME) && \
  66      !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
  67
  68 #define HAS_THINFRAME(style) \
  69     (((style) & WS_BORDER) || !((style) & (WS_CHILD | WS_POPUP)))
  70
  71 #define HAS_BIGFRAME(style,exStyle) \
  72     (((style) & (WS_THICKFRAME | WS_DLGFRAME)) || \
  73      ((exStyle) & WS_EX_DLGMODALFRAME))
  74
  75 #define HAS_ANYFRAME(style,exStyle) \
  76     (((style) & (WS_THICKFRAME | WS_DLGFRAME | WS_BORDER)) || \
  77      ((exStyle) & WS_EX_DLGMODALFRAME) || \
  78      !((style) & (WS_CHILD | WS_POPUP)))
  79
  80 #define HAS_MENU(w)  (!((w)->dwStyle & WS_CHILD) && ((w)->wIDmenu != 0))
  81
  82 #define ON_LEFT_BORDER(hit) \
  83  (((hit) == HTLEFT) || ((hit) == HTTOPLEFT) || ((hit) == HTBOTTOMLEFT))
  84 #define ON_RIGHT_BORDER(hit) \
  85  (((hit) == HTRIGHT) || ((hit) == HTTOPRIGHT) || ((hit) == HTBOTTOMRIGHT))
  86 #define ON_TOP_BORDER(hit) \
  87  (((hit) == HTTOP) || ((hit) == HTTOPLEFT) || ((hit) == HTTOPRIGHT))
  88 #define ON_BOTTOM_BORDER(hit) \
  89  (((hit) == HTBOTTOM) || ((hit) == HTBOTTOMLEFT) || ((hit) == HTBOTTOMRIGHT))
  90
  91 /***********************************************************************
  92  *           WIN_WindowNeedsWMBorder
  93  *
  94  * This method defines the rules for a window to have a WM border,
  95  * caption...  It is used for consitency purposes.
  96  */
  97 BOOL WIN_WindowNeedsWMBorder( DWORD style, DWORD exStyle )
  98 {
  99     if (!(style & WS_CHILD) &&
 100         Options.managed  &&
 101         !(exStyle & WS_EX_TOOLWINDOW) &&
 102         ( ((style & WS_CAPTION) == WS_CAPTION) ||
 103           (style & WS_THICKFRAME)))
 104         return TRUE;
 105     if (exStyle & WS_EX_TRAYWINDOW)
 106         return TRUE;
 107     return FALSE;
 108 }
 109
 110 /***********************************************************************
 111  *           NC_AdjustRect
 112  *
 113  * Compute the size of the window rectangle from the size of the
 114  * client rectangle.
 115  */
 116 static void NC_AdjustRect( LPRECT16 rect, DWORD style, BOOL menu,
 117                            DWORD exStyle )
 118 {
 119     if (TWEAK_WineLook > WIN31_LOOK)
 120         ERR("Called in Win95 mode. Aiee! Please report this.\n" );
 121
 122     if(style & WS_ICONIC) return;
 123     /* Decide if the window will be managed (see CreateWindowEx) */
 124     if (!WIN_WindowNeedsWMBorder(style, exStyle))
 125     {
 126         if (HAS_THICKFRAME( style, exStyle ))
 127             InflateRect16( rect, GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME) );
 128         else
 129         if (HAS_DLGFRAME( style, exStyle ))
 130             InflateRect16( rect, GetSystemMetrics(SM_CXDLGFRAME), GetSystemMetrics(SM_CYDLGFRAME) );
 131         else
 132         if (HAS_THINFRAME( style ))
 133             InflateRect16( rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
 134
 135         if ((style & WS_CAPTION) == WS_CAPTION)
 136             rect->top -= GetSystemMetrics(SM_CYCAPTION) - GetSystemMetrics(SM_CYBORDER);
 137     }
 138     if (menu) rect->top -= GetSystemMetrics(SM_CYMENU) + GetSystemMetrics(SM_CYBORDER);
 139
 140     if (style & WS_VSCROLL) {
 141       rect->right  += GetSystemMetrics(SM_CXVSCROLL) - 1;
 142       if(!HAS_ANYFRAME( style, exStyle ))
 143          rect->right++;
 144     }
 145
 146     if (style & WS_HSCROLL) {
 147       rect->bottom += GetSystemMetrics(SM_CYHSCROLL) - 1;
 148       if(!HAS_ANYFRAME( style, exStyle ))
 149          rect->bottom++;
 150     }
 151 }
 152
 153
 154 /******************************************************************************
 155  * NC_AdjustRectOuter95
 156  *
 157  * Computes the size of the "outside" parts of the window based on the
 158  * parameters of the client area.
 159  *
 160  + PARAMS
 161  *     LPRECT16  rect
 162  *     DWORD  style
 163  *     BOOL32  menu
 164  *     DWORD  exStyle
 165  *
 166  * NOTES
 167  *     "Outer" parts of a window means the whole window frame, caption and
 168  *     menu bar. It does not include "inner" parts of the frame like client
 169  *     edge, static edge or scroll bars.
 170  *
 171  * Revision history
 172  *     05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
 173  *        Original (NC_AdjustRect95) cut & paste from NC_AdjustRect
 174  *
 175  *     20-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
 176  *        Split NC_AdjustRect95 into NC_AdjustRectOuter95 and
 177  *        NC_AdjustRectInner95 and added handling of Win95 styles.
 178  *
 179  *     28-Jul-1999 Ove Kåven (ovek@arcticnet.no)
 180  *        Streamlined window style checks.
 181  *
 182  *****************************************************************************/
 183
 184 static void
 185 NC_AdjustRectOuter95 (LPRECT16 rect, DWORD style, BOOL menu, DWORD exStyle)
 186 {
 187     if(style & WS_ICONIC) return;
 188
 189     /* Decide if the window will be managed (see CreateWindowEx) */
 190     if (!WIN_WindowNeedsWMBorder(style, exStyle))
 191     {
 192         if (HAS_THICKFRAME( style, exStyle ))
 193             InflateRect16( rect, GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME) );
 194         else
 195         if (HAS_DLGFRAME( style, exStyle ))
 196             InflateRect16(rect, GetSystemMetrics(SM_CXDLGFRAME), GetSystemMetrics(SM_CYDLGFRAME) );
 197         else
 198         if (HAS_THINFRAME( style ))
 199             InflateRect16( rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
 200
 201         if ((style & WS_CAPTION) == WS_CAPTION)
 202         {
 203             if (exStyle & WS_EX_TOOLWINDOW)
 204                 rect->top -= GetSystemMetrics(SM_CYSMCAPTION);
 205             else
 206                 rect->top -= GetSystemMetrics(SM_CYCAPTION);
 207         }
 208     }
 209
 210     if (menu)
 211         rect->top -= GetSystemMetrics(SM_CYMENU);
 212 }
 213
 214
 215 /******************************************************************************
 216  * NC_AdjustRectInner95
 217  *
 218  * Computes the size of the "inside" part of the window based on the
 219  * parameters of the client area.
 220  *
 221  + PARAMS
 222  *     LPRECT16 rect
 223  *     DWORD    style
 224  *     DWORD    exStyle
 225  *
 226  * NOTES
 227  *     "Inner" part of a window means the window frame inside of the flat
 228  *     window frame. It includes the client edge, the static edge and the
 229  *     scroll bars.
 230  *
 231  * Revision history
 232  *     05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
 233  *        Original (NC_AdjustRect95) cut & paste from NC_AdjustRect
 234  *
 235  *     20-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
 236  *        Split NC_AdjustRect95 into NC_AdjustRectOuter95 and
 237  *        NC_AdjustRectInner95 and added handling of Win95 styles.
 238  *
 239  *****************************************************************************/
 240
 241 static void
 242 NC_AdjustRectInner95 (LPRECT16 rect, DWORD style, DWORD exStyle)
 243 {
 244     if(style & WS_ICONIC) return;
 245
 246     if (exStyle & WS_EX_CLIENTEDGE)
 247         InflateRect16 (rect, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
 248
 249     if (exStyle & WS_EX_STATICEDGE)
 250         InflateRect16 (rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
 251
 252     if (style & WS_VSCROLL) rect->right  += GetSystemMetrics(SM_CXVSCROLL);
 253     if (style & WS_HSCROLL) rect->bottom += GetSystemMetrics(SM_CYHSCROLL);
 254 }
 255
 256
 257 /***********************************************************************
 258  * DrawCaption16 [USER.660] Draws a caption bar
 259  *
 260  * PARAMS
 261  *     hwnd   [I]
 262  *     hdc    [I]
 263  *     lpRect [I]
 264  *     uFlags [I]
 265  *
 266  * RETURNS
 267  *     Success:
 268  *     Failure:
 269  */
 270
 271 BOOL16 WINAPI
 272 DrawCaption16 (HWND16 hwnd, HDC16 hdc, const RECT16 *rect, UINT16 uFlags)
 273 {
 274     RECT rect32;
 275
 276     if (rect)
 277         CONV_RECT16TO32 (rect, &rect32);
 278
 279     return (BOOL16)DrawCaptionTempA (hwnd, hdc, rect ? &rect32 : NULL,
 280                                        0, 0, NULL, uFlags & 0x1F);
 281 }
 282
 283
 284 /***********************************************************************
 285  * DrawCaption32 [USER32.154] Draws a caption bar
 286  *
 287  * PARAMS
 288  *     hwnd   [I]
 289  *     hdc    [I]
 290  *     lpRect [I]
 291  *     uFlags [I]
 292  *
 293  * RETURNS
 294  *     Success:
 295  *     Failure:
 296  */
 297
 298 BOOL WINAPI
 299 DrawCaption (HWND hwnd, HDC hdc, const RECT *lpRect, UINT uFlags)
 300 {
 301     return DrawCaptionTempA (hwnd, hdc, lpRect, 0, 0, NULL, uFlags & 0x1F);
 302 }
 303
 304
 305 /***********************************************************************
 306  * DrawCaptionTemp16 [USER.657]
 307  *
 308  * PARAMS
 309  *
 310  * RETURNS
 311  *     Success:
 312  *     Failure:
 313  */
 314
 315 BOOL16 WINAPI
 316 DrawCaptionTemp16 (HWND16 hwnd, HDC16 hdc, const RECT16 *rect, HFONT16 hFont,
 317                    HICON16 hIcon, LPCSTR str, UINT16 uFlags)
 318 {
 319     RECT rect32;
 320
 321     if (rect)
 322         CONV_RECT16TO32(rect,&rect32);
 323
 324     return (BOOL16)DrawCaptionTempA (hwnd, hdc, rect?&rect32:NULL, hFont,
 325                                        hIcon, str, uFlags & 0x1F);
 326 }
 327
 328
 329 /***********************************************************************
 330  * DrawCaptionTemp32A [USER32.599]
 331  *
 332  * PARAMS
 333  *
 334  * RETURNS
 335  *     Success:
 336  *     Failure:
 337  */
 338
 339 BOOL WINAPI
 340 DrawCaptionTempA (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
 341                     HICON hIcon, LPCSTR str, UINT uFlags)
 342 {
 343     RECT   rc = *rect;
 344
 345     TRACE("(%08x,%08x,%p,%08x,%08x,\"%s\",%08x)\n",
 346           hwnd, hdc, rect, hFont, hIcon, str, uFlags);
 347
 348     /* drawing background */
 349     if (uFlags & DC_INBUTTON) {
 350         FillRect (hdc, &rc, GetSysColorBrush (COLOR_3DFACE));
 351
 352         if (uFlags & DC_ACTIVE) {
 353             HBRUSH hbr = SelectObject (hdc, CACHE_GetPattern55AABrush ());
 354             PatBlt (hdc, rc.left, rc.top,
 355                       rc.right-rc.left, rc.bottom-rc.top, 0xFA0089);
 356             SelectObject (hdc, hbr);
 357         }
 358     }
 359     else {
 360         FillRect (hdc, &rc, GetSysColorBrush ((uFlags & DC_ACTIVE) ?
 361                     COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION));
 362     }
 363
 364
 365     /* drawing icon */
 366     if ((uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP)) {
 367         POINT pt;
 368
 369         pt.x = rc.left + 2;
 370         pt.y = (rc.bottom + rc.top - GetSystemMetrics(SM_CYSMICON)) / 2;
 371
 372         if (hIcon) {
 373             DrawIconEx (hdc, pt.x, pt.y, hIcon, GetSystemMetrics(SM_CXSMICON),
 374                           GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
 375         }
 376         else {
 377             HICON hAppIcon = (HICON) GetClassLongA(hwnd, GCL_HICONSM);
 378             if(!hAppIcon) hAppIcon = (HICON) GetClassLongA(hwnd, GCL_HICON);
 379
 380             DrawIconEx (hdc, pt.x, pt.y, hAppIcon, GetSystemMetrics(SM_CXSMICON),
 381                           GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
 382         }
 383
 384         rc.left += (rc.bottom - rc.top);
 385     }
 386
 387     /* drawing text */
 388     if (uFlags & DC_TEXT) {
 389         HFONT hOldFont;
 390
 391         if (uFlags & DC_INBUTTON)
 392             SetTextColor (hdc, GetSysColor (COLOR_BTNTEXT));
 393         else if (uFlags & DC_ACTIVE)
 394             SetTextColor (hdc, GetSysColor (COLOR_CAPTIONTEXT));
 395         else
 396             SetTextColor (hdc, GetSysColor (COLOR_INACTIVECAPTIONTEXT));
 397
 398         SetBkMode (hdc, TRANSPARENT);
 399
 400         if (hFont)
 401             hOldFont = SelectObject (hdc, hFont);
 402         else {
 403             NONCLIENTMETRICSA nclm;
 404             HFONT hNewFont;
 405             nclm.cbSize = sizeof(NONCLIENTMETRICSA);
 406             SystemParametersInfoA (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
 407             hNewFont = CreateFontIndirectA ((uFlags & DC_SMALLCAP) ?
 408                 &nclm.lfSmCaptionFont : &nclm.lfCaptionFont);
 409             hOldFont = SelectObject (hdc, hNewFont);
 410         }
 411
 412         if (str)
 413             DrawTextA (hdc, str, -1, &rc,
 414                          DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
 415         else {
 416             CHAR szText[128];
 417             INT nLen;
 418             nLen = GetWindowTextA (hwnd, szText, 128);
 419             DrawTextA (hdc, szText, nLen, &rc,
 420                          DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
 421         }
 422
 423         if (hFont)
 424             SelectObject (hdc, hOldFont);
 425         else
 426             DeleteObject (SelectObject (hdc, hOldFont));
 427     }
 428
 429     /* drawing focus ??? */
 430     if (uFlags & 0x2000)
 431         FIXME("undocumented flag (0x2000)!\n");
 432
 433     return 0;
 434 }
 435
 436
 437 /***********************************************************************
 438  * DrawCaptionTemp32W [USER32.602]
 439  *
 440  * PARAMS
 441  *
 442  * RETURNS
 443  *     Success:
 444  *     Failure:
 445  */
 446
 447 BOOL WINAPI
 448 DrawCaptionTempW (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
 449                     HICON hIcon, LPCWSTR str, UINT uFlags)
 450 {
 451     LPSTR p = HEAP_strdupWtoA (GetProcessHeap (), 0, str);
 452     BOOL res = DrawCaptionTempA (hwnd, hdc, rect, hFont, hIcon, p, uFlags);
 453     HeapFree (GetProcessHeap (), 0, p);
 454     return res;
 455 }
 456
 457
 458 /***********************************************************************
 459  *           AdjustWindowRect16    (USER.102)
 460  */
 461 BOOL16 WINAPI AdjustWindowRect16( LPRECT16 rect, DWORD style, BOOL16 menu )
 462 {
 463     return AdjustWindowRectEx16( rect, style, menu, 0 );
 464 }
 465
 466
 467 /***********************************************************************
 468  *           AdjustWindowRect32    (USER32.2)
 469  */
 470 BOOL WINAPI AdjustWindowRect( LPRECT rect, DWORD style, BOOL menu )
 471 {
 472     return AdjustWindowRectEx( rect, style, menu, 0 );
 473 }
 474
 475
 476 /***********************************************************************
 477  *           AdjustWindowRectEx16    (USER.454)
 478  */
 479 BOOL16 WINAPI AdjustWindowRectEx16( LPRECT16 rect, DWORD style,
 480                                     BOOL16 menu, DWORD exStyle )
 481 {
 482       /* Correct the window style */
 483
 484     if (!(style & (WS_POPUP | WS_CHILD)))  /* Overlapped window */
 485         style |= WS_CAPTION;
 486     style &= (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME | WS_CHILD);
 487     exStyle &= (WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE |
 488                 WS_EX_STATICEDGE | WS_EX_TOOLWINDOW);
 489     if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
 490
 491     TRACE("(%d,%d)-(%d,%d) %08lx %d %08lx\n",
 492           rect->left, rect->top, rect->right, rect->bottom,
 493           style, menu, exStyle );
 494
 495     if (TWEAK_WineLook == WIN31_LOOK)
 496         NC_AdjustRect( rect, style, menu, exStyle );
 497     else {
 498         NC_AdjustRectOuter95( rect, style, menu, exStyle );
 499         NC_AdjustRectInner95( rect, style, exStyle );
 500     }
 501
 502     return TRUE;
 503 }
 504
 505
 506 /***********************************************************************
 507  *           AdjustWindowRectEx32    (USER32.3)
 508  */
 509 BOOL WINAPI AdjustWindowRectEx( LPRECT rect, DWORD style,
 510                                     BOOL menu, DWORD exStyle )
 511 {
 512     RECT16 rect16;
 513     BOOL ret;
 514
 515     CONV_RECT32TO16( rect, &rect16 );
 516     ret = AdjustWindowRectEx16( &rect16, style, (BOOL16)menu, exStyle );
 517     CONV_RECT16TO32( &rect16, rect );
 518     return ret;
 519 }
 520
 521
 522 /***********************************************************************
 523  *           NC_HandleNCCalcSize
 524  *
 525  * Handle a WM_NCCALCSIZE message. Called from DefWindowProc().
 526  */
 527 LONG NC_HandleNCCalcSize( WND *pWnd, RECT *winRect )
 528 {
 529     RECT16 tmpRect = { 0, 0, 0, 0 };
 530     LONG result = 0;
 531     UINT style = (UINT) GetClassLongA(pWnd->hwndSelf, GCL_STYLE);
 532
 533     if (style & CS_VREDRAW) result |= WVR_VREDRAW;
 534     if (style & CS_HREDRAW) result |= WVR_HREDRAW;
 535
 536     if( !( pWnd->dwStyle & WS_MINIMIZE ) ) {
 537         if (TWEAK_WineLook == WIN31_LOOK)
 538             NC_AdjustRect( &tmpRect, pWnd->dwStyle, FALSE, pWnd->dwExStyle );
 539         else
 540             NC_AdjustRectOuter95( &tmpRect, pWnd->dwStyle, FALSE, pWnd->dwExStyle );
 541
 542         winRect->left   -= tmpRect.left;
 543         winRect->top    -= tmpRect.top;
 544         winRect->right  -= tmpRect.right;
 545         winRect->bottom -= tmpRect.bottom;
 546
 547         if (HAS_MENU(pWnd)) {
 548             TRACE("Calling GetMenuBarHeight with HWND 0x%x, width %d, "
 549                   "at (%d, %d).\n", pWnd->hwndSelf,
 550                   winRect->right - winRect->left,
 551                   -tmpRect.left, -tmpRect.top );
 552
 553             winRect->top +=
 554                 MENU_GetMenuBarHeight( pWnd->hwndSelf,
 555                                        winRect->right - winRect->left,
 556                                        -tmpRect.left, -tmpRect.top ) + 1;
 557         }
 558
 559         if (TWEAK_WineLook > WIN31_LOOK) {
 560             SetRect16 (&tmpRect, 0, 0, 0, 0);
 561             NC_AdjustRectInner95 (&tmpRect, pWnd->dwStyle, pWnd->dwExStyle);
 562             winRect->left   -= tmpRect.left;
 563             winRect->top    -= tmpRect.top;
 564             winRect->right  -= tmpRect.right;
 565             winRect->bottom -= tmpRect.bottom;
 566         }
 567     }
 568     return result;
 569 }
 570
 571
 572 /***********************************************************************
 573  *           NC_GetInsideRect
 574  *
 575  * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
 576  * but without the borders (if any).
 577  * The rectangle is in window coordinates (for drawing with GetWindowDC()).
 578  */
 579 static void NC_GetInsideRect( HWND hwnd, RECT *rect )
 580 {
 581     WND * wndPtr = WIN_FindWndPtr( hwnd );
 582
 583     rect->top    = rect->left = 0;
 584     rect->right  = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
 585     rect->bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
 586
 587     if ((wndPtr->dwStyle & WS_ICONIC) || (wndPtr->flags & WIN_MANAGED)) goto END;
 588
 589     /* Remove frame from rectangle */
 590     if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
 591         InflateRect( rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
 592     else
 593     if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
 594     {
 595         InflateRect( rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
 596         /* FIXME: this isn't in NC_AdjustRect? why not? */
 597         if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME)
 598             InflateRect( rect, -1, 0 );
 599     }
 600     else
 601     if (HAS_THINFRAME( wndPtr->dwStyle ))
 602         InflateRect( rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER) );
 603 END:
 604     WIN_ReleaseWndPtr(wndPtr);
 605     return;
 606 }
 607
 608
 609 /***********************************************************************
 610  *           NC_GetInsideRect95
 611  *
 612  * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
 613  * but without the borders (if any).
 614  * The rectangle is in window coordinates (for drawing with GetWindowDC()).
 615  */
 616
 617 static void
 618 NC_GetInsideRect95 (HWND hwnd, RECT *rect)
 619 {
 620     WND * wndPtr = WIN_FindWndPtr( hwnd );
 621
 622     rect->top    = rect->left = 0;
 623     rect->right  = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
 624     rect->bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
 625
 626     if ((wndPtr->dwStyle & WS_ICONIC) || (wndPtr->flags & WIN_MANAGED)) goto END;
 627
 628     /* Remove frame from rectangle */
 629     if (HAS_THICKFRAME (wndPtr->dwStyle, wndPtr->dwExStyle))
 630     {
 631         InflateRect( rect, -GetSystemMetrics(SM_CXSIZEFRAME), -GetSystemMetrics(SM_CYSIZEFRAME) );
 632     }
 633     else if (HAS_DLGFRAME (wndPtr->dwStyle, wndPtr->dwExStyle ))
 634     {
 635         InflateRect( rect, -GetSystemMetrics(SM_CXFIXEDFRAME), -GetSystemMetrics(SM_CYFIXEDFRAME));
 636     }
 637     else if (HAS_THINFRAME (wndPtr->dwStyle))
 638     {
 639         InflateRect( rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER) );
 640     }
 641
 642     /* We have additional border information if the window
 643      * is a child (but not an MDI child) */
 644     if ( (wndPtr->dwStyle & WS_CHILD)  &&
 645          ( (wndPtr->dwExStyle & WS_EX_MDICHILD) == 0 ) )
 646     {
 647         if (wndPtr->dwExStyle & WS_EX_CLIENTEDGE)
 648             InflateRect (rect, -GetSystemMetrics(SM_CXEDGE), -GetSystemMetrics(SM_CYEDGE));
 649
 650         if (wndPtr->dwExStyle & WS_EX_STATICEDGE)
 651             InflateRect (rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
 652     }
 653 END:
 654     WIN_ReleaseWndPtr(wndPtr);
 655     return;
 656 }
 657
 658
 659 /***********************************************************************
 660  * NC_DoNCHitTest
 661  *
 662  * Handle a WM_NCHITTEST message. Called from NC_HandleNcHitTest().
 663  */
 664
 665 static LONG NC_DoNCHitTest (WND *wndPtr, POINT16 pt )
 666 {
 667     RECT16 rect;
 668
 669     TRACE("hwnd=%04x pt=%d,%d\n", wndPtr->hwndSelf, pt.x, pt.y );
 670
 671     GetWindowRect16 (wndPtr->hwndSelf, &rect );
 672     if (!PtInRect16( &rect, pt )) return HTNOWHERE;
 673
 674     if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
 675
 676     if (!(wndPtr->flags & WIN_MANAGED))
 677     {
 678         /* Check borders */
 679         if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
 680         {
 681             InflateRect16( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
 682             if (!PtInRect16( &rect, pt ))
 683             {
 684                 /* Check top sizing border */
 685                 if (pt.y < rect.top)
 686                 {
 687                     if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
 688                     if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
 689                     return HTTOP;
 690                 }
 691                 /* Check bottom sizing border */
 692                 if (pt.y >= rect.bottom)
 693                 {
 694                     if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
 695                     if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
 696                     return HTBOTTOM;
 697                 }
 698                 /* Check left sizing border */
 699                 if (pt.x < rect.left)
 700                 {
 701                     if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
 702                     if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
 703                     return HTLEFT;
 704                 }
 705                 /* Check right sizing border */
 706                 if (pt.x >= rect.right)
 707                 {
 708                     if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
 709                     if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
 710                     return HTRIGHT;
 711                 }
 712             }
 713         }
 714         else  /* No thick frame */
 715         {
 716             if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
 717                 InflateRect16(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
 718             else if (HAS_THINFRAME( wndPtr->dwStyle ))
 719                 InflateRect16(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
 720             if (!PtInRect16( &rect, pt )) return HTBORDER;
 721         }
 722
 723         /* Check caption */
 724
 725         if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
 726         {
 727             rect.top += GetSystemMetrics(SM_CYCAPTION) - GetSystemMetrics(SM_CYBORDER);
 728             if (!PtInRect16( &rect, pt ))
 729             {
 730                 /* Check system menu */
 731                 if (wndPtr->dwStyle & WS_SYSMENU)
 732                     rect.left += GetSystemMetrics(SM_CXSIZE);
 733                 if (pt.x <= rect.left) return HTSYSMENU;
 734
 735                 /* Check maximize box */
 736                 if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
 737                     rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
 738
 739                 if (pt.x >= rect.right) return HTMAXBUTTON;
 740                 /* Check minimize box */
 741                 if (wndPtr->dwStyle & WS_MINIMIZEBOX)
 742                     rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
 743                 if (pt.x >= rect.right) return HTMINBUTTON;
 744                 return HTCAPTION;
 745             }
 746         }
 747     }
 748
 749       /* Check client area */
 750
 751     ScreenToClient16( wndPtr->hwndSelf, &pt );
 752     GetClientRect16( wndPtr->hwndSelf, &rect );
 753     if (PtInRect16( &rect, pt )) return HTCLIENT;
 754
 755       /* Check vertical scroll bar */
 756
 757     if (wndPtr->dwStyle & WS_VSCROLL)
 758     {
 759         rect.right += GetSystemMetrics(SM_CXVSCROLL);
 760         if (PtInRect16( &rect, pt )) return HTVSCROLL;
 761     }
 762
 763       /* Check horizontal scroll bar */
 764
 765     if (wndPtr->dwStyle & WS_HSCROLL)
 766     {
 767         rect.bottom += GetSystemMetrics(SM_CYHSCROLL);
 768         if (PtInRect16( &rect, pt ))
 769         {
 770               /* Check size box */
 771             if ((wndPtr->dwStyle & WS_VSCROLL) &&
 772                 (pt.x >= rect.right - GetSystemMetrics(SM_CXVSCROLL)))
 773                 return HTSIZE;
 774             return HTHSCROLL;
 775         }
 776     }
 777
 778       /* Check menu bar */
 779
 780     if (HAS_MENU(wndPtr))
 781     {
 782         if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
 783             return HTMENU;
 784     }
 785
 786       /* Should never get here */
 787     return HTERROR;
 788 }
 789
 790
 791 /***********************************************************************
 792  * NC_DoNCHitTest95
 793  *
 794  * Handle a WM_NCHITTEST message. Called from NC_HandleNCHitTest().
 795  *
 796  * FIXME:  Just a modified copy of the Win 3.1 version.
 797  */
 798
 799 static LONG
 800 NC_DoNCHitTest95 (WND *wndPtr, POINT16 pt )
 801 {
 802     RECT16 rect;
 803
 804     TRACE("hwnd=%04x pt=%d,%d\n", wndPtr->hwndSelf, pt.x, pt.y );
 805
 806     GetWindowRect16 (wndPtr->hwndSelf, &rect );
 807     if (!PtInRect16( &rect, pt )) return HTNOWHERE;
 808
 809     if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
 810
 811     if (!(wndPtr->flags & WIN_MANAGED))
 812     {
 813         /* Check borders */
 814         if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
 815         {
 816             InflateRect16( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
 817             if (!PtInRect16( &rect, pt ))
 818             {
 819                 /* Check top sizing border */
 820                 if (pt.y < rect.top)
 821                 {
 822                     if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
 823                     if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
 824                     return HTTOP;
 825                 }
 826                 /* Check bottom sizing border */
 827                 if (pt.y >= rect.bottom)
 828                 {
 829                     if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
 830                     if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
 831                     return HTBOTTOM;
 832                 }
 833                 /* Check left sizing border */
 834                 if (pt.x < rect.left)
 835                 {
 836                     if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
 837                     if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
 838                     return HTLEFT;
 839                 }
 840                 /* Check right sizing border */
 841                 if (pt.x >= rect.right)
 842                 {
 843                     if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
 844                     if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
 845                     return HTRIGHT;
 846                 }
 847             }
 848         }
 849         else  /* No thick frame */
 850         {
 851             if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
 852                 InflateRect16(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
 853             else if (HAS_THINFRAME( wndPtr->dwStyle ))
 854                 InflateRect16(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
 855             if (!PtInRect16( &rect, pt )) return HTBORDER;
 856         }
 857
 858         /* Check caption */
 859
 860         if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
 861         {
 862             if (wndPtr->dwExStyle & WS_EX_TOOLWINDOW)
 863                 rect.top += GetSystemMetrics(SM_CYSMCAPTION) - 1;
 864             else
 865                 rect.top += GetSystemMetrics(SM_CYCAPTION) - 1;
 866             if (!PtInRect16( &rect, pt ))
 867             {
 868                 /* Check system menu */
 869                 if(wndPtr->dwStyle & WS_SYSMENU)
 870                 {
 871                     /* Check if there is an user icon */
 872                     HICON hIcon = (HICON) GetClassLongA(wndPtr->hwndSelf, GCL_HICONSM);
 873                     if(!hIcon) hIcon = (HICON) GetClassLongA(wndPtr->hwndSelf, GCL_HICON);
 874
 875                     /* If there is an icon associated with the window OR              */
 876                     /* If there is no hIcon specified and this is not a modal dialog, */
 877                     /* there is a system menu icon.                                   */
 878                     if((hIcon != 0) || (!(wndPtr->dwStyle & DS_MODALFRAME)))
 879                         rect.left += GetSystemMetrics(SM_CYCAPTION) - 1;
 880                 }
 881                 if (pt.x < rect.left) return HTSYSMENU;
 882
 883                 /* Check close button */
 884                 if (wndPtr->dwStyle & WS_SYSMENU)
 885                     rect.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
 886                 if (pt.x > rect.right) return HTCLOSE;
 887
 888                 /* Check maximize box */
 889                 /* In win95 there is automatically a Maximize button when there is a minimize one*/
 890                 if ((wndPtr->dwStyle & WS_MAXIMIZEBOX)|| (wndPtr->dwStyle & WS_MINIMIZEBOX))
 891                     rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
 892                 if (pt.x > rect.right) return HTMAXBUTTON;
 893
 894                 /* Check minimize box */
 895                 /* In win95 there is automatically a Maximize button when there is a Maximize one*/
 896                 if ((wndPtr->dwStyle & WS_MINIMIZEBOX)||(wndPtr->dwStyle & WS_MAXIMIZEBOX))
 897                     rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
 898
 899                 if (pt.x > rect.right) return HTMINBUTTON;
 900                 return HTCAPTION;
 901             }
 902         }
 903     }
 904
 905       /* Check client area */
 906
 907     ScreenToClient16( wndPtr->hwndSelf, &pt );
 908     GetClientRect16( wndPtr->hwndSelf, &rect );
 909     if (PtInRect16( &rect, pt )) return HTCLIENT;
 910
 911       /* Check vertical scroll bar */
 912
 913     if (wndPtr->dwStyle & WS_VSCROLL)
 914     {
 915         rect.right += GetSystemMetrics(SM_CXVSCROLL);
 916         if (PtInRect16( &rect, pt )) return HTVSCROLL;
 917     }
 918
 919       /* Check horizontal scroll bar */
 920
 921     if (wndPtr->dwStyle & WS_HSCROLL)
 922     {
 923         rect.bottom += GetSystemMetrics(SM_CYHSCROLL);
 924         if (PtInRect16( &rect, pt ))
 925         {
 926               /* Check size box */
 927             if ((wndPtr->dwStyle & WS_VSCROLL) &&
 928                 (pt.x >= rect.right - GetSystemMetrics(SM_CXVSCROLL)))
 929                 return HTSIZE;
 930             return HTHSCROLL;
 931         }
 932     }
 933
 934       /* Check menu bar */
 935
 936     if (HAS_MENU(wndPtr))
 937     {
 938         if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
 939             return HTMENU;
 940     }
 941
 942       /* Should never get here */
 943     return HTERROR;
 944 }
 945
 946
 947 /***********************************************************************
 948  * NC_HandleNCHitTest
 949  *
 950  * Handle a WM_NCHITTEST message. Called from DefWindowProc().
 951  */
 952 LONG
 953 NC_HandleNCHitTest (HWND hwnd , POINT16 pt)
 954 {
 955     LONG retvalue;
 956     WND *wndPtr = WIN_FindWndPtr (hwnd);
 957
 958     if (!wndPtr)
 959         return HTERROR;
 960
 961     if (TWEAK_WineLook == WIN31_LOOK)
 962         retvalue = NC_DoNCHitTest (wndPtr, pt);
 963     else
 964         retvalue = NC_DoNCHitTest95 (wndPtr, pt);
 965     WIN_ReleaseWndPtr(wndPtr);
 966     return retvalue;
 967 }
 968
 969
 970 /***********************************************************************
 971  *           NC_DrawSysButton
 972  */
 973 void NC_DrawSysButton( HWND hwnd, HDC hdc, BOOL down )
 974 {
 975     RECT rect;
 976     HDC hdcMem;
 977     HBITMAP hbitmap;
 978     WND *wndPtr = WIN_FindWndPtr( hwnd );
 979
 980     if( !(wndPtr->flags & WIN_MANAGED) )
 981     {
 982       NC_GetInsideRect( hwnd, &rect );
 983       hdcMem = CreateCompatibleDC( hdc );
 984       hbitmap = SelectObject( hdcMem, hbitmapClose );
 985       BitBlt(hdc, rect.left, rect.top, GetSystemMetrics(SM_CXSIZE), GetSystemMetrics(SM_CYSIZE),
 986                hdcMem, (wndPtr->dwStyle & WS_CHILD) ? GetSystemMetrics(SM_CXSIZE) : 0, 0,
 987                down ? NOTSRCCOPY : SRCCOPY );
 988       SelectObject( hdcMem, hbitmap );
 989       DeleteDC( hdcMem );
 990     }
 991     WIN_ReleaseWndPtr(wndPtr);
 992 }
 993
 994
 995 /***********************************************************************
 996  *           NC_DrawMaxButton
 997  */
 998 static void NC_DrawMaxButton( HWND hwnd, HDC16 hdc, BOOL down )
 999 {
1000     RECT rect;
1001     WND *wndPtr = WIN_FindWndPtr( hwnd );
1002     HDC hdcMem;
1003
1004     if( !(wndPtr->flags & WIN_MANAGED) )
1005     {
1006       NC_GetInsideRect( hwnd, &rect );
1007       hdcMem = CreateCompatibleDC( hdc );
1008       SelectObject( hdcMem,  (IsZoomed(hwnd)
1009                              ? (down ? hbitmapRestoreD : hbitmapRestore)
1010                              : (down ? hbitmapMaximizeD : hbitmapMaximize)) );
1011       BitBlt( hdc, rect.right - GetSystemMetrics(SM_CXSIZE) - 1, rect.top,
1012                 GetSystemMetrics(SM_CXSIZE) + 1, GetSystemMetrics(SM_CYSIZE), hdcMem, 0, 0,
1013                 SRCCOPY );
1014       DeleteDC( hdcMem );
1015     }
1016     WIN_ReleaseWndPtr(wndPtr);
1017
1018 }
1019
1020
1021 /***********************************************************************
1022  *           NC_DrawMinButton
1023  */
1024 static void NC_DrawMinButton( HWND hwnd, HDC16 hdc, BOOL down )
1025 {
1026     RECT rect;
1027     WND *wndPtr = WIN_FindWndPtr( hwnd );
1028     HDC hdcMem;
1029
1030     if( !(wndPtr->flags & WIN_MANAGED) )
1031     {
1032       NC_GetInsideRect( hwnd, &rect );
1033       hdcMem = CreateCompatibleDC( hdc );
1034       SelectObject( hdcMem, (down ? hbitmapMinimizeD : hbitmapMinimize) );
1035       if (wndPtr->dwStyle & WS_MAXIMIZEBOX) rect.right -= GetSystemMetrics(SM_CXSIZE)+1;
1036       BitBlt( hdc, rect.right - GetSystemMetrics(SM_CXSIZE) - 1, rect.top,
1037                 GetSystemMetrics(SM_CXSIZE) + 1, GetSystemMetrics(SM_CYSIZE), hdcMem, 0, 0,
1038                 SRCCOPY );
1039       DeleteDC( hdcMem );
1040     }
1041     WIN_ReleaseWndPtr(wndPtr);
1042 }
1043
1044
1045 /******************************************************************************
1046  *
1047  *   void  NC_DrawSysButton95(
1048  *      HWND32  hwnd,
1049  *      HDC32  hdc,
1050  *      BOOL32  down )
1051  *
1052  *   Draws the Win95 system icon.
1053  *
1054  *   Revision history
1055  *        05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1056  *             Original implementation from NC_DrawSysButton source.
1057  *        11-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1058  *             Fixed most bugs.
1059  *
1060  *****************************************************************************/
1061
1062 BOOL
1063 NC_DrawSysButton95 (HWND hwnd, HDC hdc, BOOL down)
1064 {
1065     WND *wndPtr = WIN_FindWndPtr( hwnd );
1066
1067     if( !(wndPtr->flags & WIN_MANAGED) )
1068     {
1069         HICON  hIcon;
1070         RECT rect;
1071
1072         NC_GetInsideRect95( hwnd, &rect );
1073
1074         hIcon = (HICON) GetClassLongA(wndPtr->hwndSelf, GCL_HICONSM);
1075         if(!hIcon) hIcon = (HICON) GetClassLongA(wndPtr->hwndSelf, GCL_HICON);
1076
1077         /* If there is no hIcon specified or this is not a modal dialog, */
1078         /* get the default one.                                          */
1079         if(hIcon == 0)
1080             if (!(wndPtr->dwStyle & DS_MODALFRAME))
1081                 hIcon = LoadImageA(0, MAKEINTRESOURCEA(OIC_WINEICON), IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
1082
1083         if (hIcon)
1084             DrawIconEx (hdc, rect.left + 2, rect.top + 2, hIcon,
1085                           GetSystemMetrics(SM_CXSMICON),
1086                           GetSystemMetrics(SM_CYSMICON),
1087                           0, 0, DI_NORMAL);
1088
1089         WIN_ReleaseWndPtr(wndPtr);
1090         return (hIcon != 0);
1091     }
1092     WIN_ReleaseWndPtr(wndPtr);
1093     return FALSE;
1094 }
1095
1096
1097 /******************************************************************************
1098  *
1099  *   void  NC_DrawCloseButton95(
1100  *      HWND32  hwnd,
1101  *      HDC32  hdc,
1102  *      BOOL32  down,
1103  *      BOOL    bGrayed )
1104  *
1105  *   Draws the Win95 close button.
1106  *
1107  *   If bGrayed is true, then draw a disabled Close button
1108  *
1109  *   Revision history
1110  *        11-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1111  *             Original implementation from NC_DrawSysButton95 source.
1112  *
1113  *****************************************************************************/
1114
1115 static void NC_DrawCloseButton95 (HWND hwnd, HDC hdc, BOOL down, BOOL bGrayed)
1116 {
1117     RECT rect;
1118     HDC hdcMem;
1119     WND *wndPtr = WIN_FindWndPtr( hwnd );
1120
1121     if( !(wndPtr->flags & WIN_MANAGED) )
1122     {
1123         BITMAP bmp;
1124         HBITMAP hBmp, hOldBmp;
1125
1126         NC_GetInsideRect95( hwnd, &rect );
1127
1128         hdcMem = CreateCompatibleDC( hdc );
1129         hBmp = down ? hbitmapCloseD : hbitmapClose;
1130         hOldBmp = SelectObject (hdcMem, hBmp);
1131         GetObjectA (hBmp, sizeof(BITMAP), &bmp);
1132
1133         BitBlt (hdc, rect.right - (GetSystemMetrics(SM_CYCAPTION) + 1 + bmp.bmWidth) / 2,
1134                   rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2,
1135                   bmp.bmWidth, bmp.bmHeight, hdcMem, 0, 0, SRCCOPY);
1136
1137         if(bGrayed)
1138             NC_DrawGrayButton(hdc,rect.right - (GetSystemMetrics(SM_CYCAPTION) + 1 + bmp.bmWidth) / 2 + 2,
1139                               rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2 + 2);
1140
1141         SelectObject (hdcMem, hOldBmp);
1142         DeleteDC (hdcMem);
1143     }
1144     WIN_ReleaseWndPtr(wndPtr);
1145 }
1146
1147 /******************************************************************************
1148  *
1149  *   NC_DrawMaxButton95(
1150  *      HWND32  hwnd,
1151  *      HDC16  hdc,
1152  *      BOOL32  down
1153  *      BOOL    bGrayed )
1154  *
1155  *   Draws the maximize button for Win95 style windows.
1156  *
1157  *   If bGrayed is true, then draw a disabled Maximize button
1158  *
1159  *   Bugs
1160  *        Many.  Spacing might still be incorrect.  Need to fit a close
1161  *        button between the max button and the edge.
1162  *        Should scale the image with the title bar.  And more...
1163  *
1164  *   Revision history
1165  *        05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1166  *             Original implementation.
1167  *
1168  *****************************************************************************/
1169
1170 static void NC_DrawMaxButton95(HWND hwnd,HDC16 hdc,BOOL down, BOOL bGrayed)
1171 {
1172     RECT rect;
1173     HDC hdcMem;
1174     WND *wndPtr = WIN_FindWndPtr( hwnd );
1175
1176     if( !(wndPtr->flags & WIN_MANAGED))
1177     {
1178         BITMAP  bmp;
1179         HBITMAP  hBmp,hOldBmp;
1180
1181         NC_GetInsideRect95( hwnd, &rect );
1182         hdcMem = CreateCompatibleDC( hdc );
1183         hBmp = IsZoomed(hwnd) ?
1184             (down ? hbitmapRestoreD : hbitmapRestore ) :
1185             (down ? hbitmapMaximizeD: hbitmapMaximize);
1186         hOldBmp=SelectObject( hdcMem, hBmp );
1187         GetObjectA (hBmp, sizeof(BITMAP), &bmp);
1188
1189         if (wndPtr->dwStyle & WS_SYSMENU)
1190             rect.right -= GetSystemMetrics(SM_CYCAPTION) + 1;
1191
1192         BitBlt( hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2,
1193                   rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2,
1194                   bmp.bmWidth, bmp.bmHeight, hdcMem, 0, 0, SRCCOPY );
1195
1196         if(bGrayed)
1197             NC_DrawGrayButton(hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2 + 2,
1198                               rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2 + 2);
1199
1200
1201         SelectObject (hdcMem, hOldBmp);
1202         DeleteDC( hdcMem );
1203     }
1204     WIN_ReleaseWndPtr(wndPtr);
1205 }
1206
1207 /******************************************************************************
1208  *
1209  *   NC_DrawMinButton95(
1210  *      HWND32  hwnd,
1211  *      HDC16  hdc,
1212  *      BOOL32  down,
1213  *      BOOL    bGrayed )
1214  *
1215  *   Draws the minimize button for Win95 style windows.
1216  *
1217  *   If bGrayed is true, then draw a disabled Minimize button
1218  *
1219  *   Bugs
1220  *        Many.  Spacing is still incorrect.  Should scale the image with the
1221  *        title bar.  And more...
1222  *
1223  *   Revision history
1224  *        05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1225  *             Original implementation.
1226  *
1227  *****************************************************************************/
1228
1229 static void  NC_DrawMinButton95(HWND hwnd,HDC16 hdc,BOOL down, BOOL bGrayed)
1230 {
1231     RECT rect;
1232     HDC hdcMem;
1233     WND *wndPtr = WIN_FindWndPtr( hwnd );
1234
1235     if( !(wndPtr->flags & WIN_MANAGED))
1236
1237     {
1238        BITMAP  bmp;
1239        HBITMAP  hBmp,hOldBmp;
1240
1241         NC_GetInsideRect95( hwnd, &rect );
1242
1243        hdcMem = CreateCompatibleDC( hdc );
1244        hBmp = down ? hbitmapMinimizeD : hbitmapMinimize;
1245        hOldBmp= SelectObject( hdcMem, hBmp );
1246         GetObjectA (hBmp, sizeof(BITMAP), &bmp);
1247
1248         if (wndPtr->dwStyle & WS_SYSMENU)
1249             rect.right -= GetSystemMetrics(SM_CYCAPTION) + 1;
1250
1251         /* In win 95 there is always a Maximize box when there is a Minimize one */
1252         if ((wndPtr->dwStyle & WS_MAXIMIZEBOX) || (wndPtr->dwStyle & WS_MINIMIZEBOX))
1253             rect.right += -1 - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2;
1254
1255         BitBlt( hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2,
1256                   rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2,
1257                   bmp.bmWidth, bmp.bmHeight, hdcMem, 0, 0, SRCCOPY );
1258
1259         if(bGrayed)
1260             NC_DrawGrayButton(hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2 + 2,
1261                               rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2 + 2);
1262
1263
1264        SelectObject (hdcMem, hOldBmp);
1265        DeleteDC( hdcMem );
1266     }
1267     WIN_ReleaseWndPtr(wndPtr);
1268 }
1269
1270 /***********************************************************************
1271  *           NC_DrawFrame
1272  *
1273  * Draw a window frame inside the given rectangle, and update the rectangle.
1274  * The correct pen for the frame must be selected in the DC.
1275  */
1276 static void NC_DrawFrame( HDC hdc, RECT *rect, BOOL dlgFrame,
1277                           BOOL active )
1278 {
1279     INT width, height;
1280
1281     if (TWEAK_WineLook != WIN31_LOOK)
1282         ERR("Called in Win95 mode. Aiee! Please report this.\n" );
1283
1284     if (dlgFrame)
1285     {
1286         width = GetSystemMetrics(SM_CXDLGFRAME) - 1;
1287         height = GetSystemMetrics(SM_CYDLGFRAME) - 1;
1288         SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1289                                                 COLOR_INACTIVECAPTION) );
1290     }
1291     else
1292     {
1293         width = GetSystemMetrics(SM_CXFRAME) - 2;
1294         height = GetSystemMetrics(SM_CYFRAME) - 2;
1295         SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
1296                                                 COLOR_INACTIVEBORDER) );
1297     }
1298
1299       /* Draw frame */
1300     PatBlt( hdc, rect->left, rect->top,
1301               rect->right - rect->left, height, PATCOPY );
1302     PatBlt( hdc, rect->left, rect->top,
1303               width, rect->bottom - rect->top, PATCOPY );
1304     PatBlt( hdc, rect->left, rect->bottom - 1,
1305               rect->right - rect->left, -height, PATCOPY );
1306     PatBlt( hdc, rect->right - 1, rect->top,
1307               -width, rect->bottom - rect->top, PATCOPY );
1308
1309     if (dlgFrame)
1310     {
1311         InflateRect( rect, -width, -height );
1312     }
1313     else
1314     {
1315         INT decYOff = GetSystemMetrics(SM_CXFRAME) + GetSystemMetrics(SM_CXSIZE) - 1;
1316         INT decXOff = GetSystemMetrics(SM_CYFRAME) + GetSystemMetrics(SM_CYSIZE) - 1;
1317
1318       /* Draw inner rectangle */
1319
1320         SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1321         Rectangle( hdc, rect->left + width, rect->top + height,
1322                      rect->right - width , rect->bottom - height );
1323
1324       /* Draw the decorations */
1325
1326         MoveToEx( hdc, rect->left, rect->top + decYOff, NULL );
1327         LineTo( hdc, rect->left + width, rect->top + decYOff );
1328         MoveToEx( hdc, rect->right - 1, rect->top + decYOff, NULL );
1329         LineTo( hdc, rect->right - width - 1, rect->top + decYOff );
1330         MoveToEx( hdc, rect->left, rect->bottom - decYOff, NULL );
1331         LineTo( hdc, rect->left + width, rect->bottom - decYOff );
1332         MoveToEx( hdc, rect->right - 1, rect->bottom - decYOff, NULL );
1333         LineTo( hdc, rect->right - width - 1, rect->bottom - decYOff );
1334
1335         MoveToEx( hdc, rect->left + decXOff, rect->top, NULL );
1336         LineTo( hdc, rect->left + decXOff, rect->top + height);
1337         MoveToEx( hdc, rect->left + decXOff, rect->bottom - 1, NULL );
1338         LineTo( hdc, rect->left + decXOff, rect->bottom - height - 1 );
1339         MoveToEx( hdc, rect->right - decXOff, rect->top, NULL );
1340         LineTo( hdc, rect->right - decXOff, rect->top + height );
1341         MoveToEx( hdc, rect->right - decXOff, rect->bottom - 1, NULL );
1342         LineTo( hdc, rect->right - decXOff, rect->bottom - height - 1 );
1343
1344         InflateRect( rect, -width - 1, -height - 1 );
1345     }
1346 }
1347
1348
1349 /******************************************************************************
1350  *
1351  *   void  NC_DrawFrame95(
1352  *      HDC32  hdc,
1353  *      RECT32  *rect,
1354  *      BOOL32  dlgFrame,
1355  *      BOOL32  active )
1356  *
1357  *   Draw a window frame inside the given rectangle, and update the rectangle.
1358  *   The correct pen for the frame must be selected in the DC.
1359  *
1360  *   Bugs
1361  *        Many.  First, just what IS a frame in Win95?  Note that the 3D look
1362  *        on the outer edge is handled by NC_DoNCPaint95.  As is the inner
1363  *        edge.  The inner rectangle just inside the frame is handled by the
1364  *        Caption code.
1365  *
1366  *        In short, for most people, this function should be a nop (unless
1367  *        you LIKE thick borders in Win95/NT4.0 -- I've been working with
1368  *        them lately, but just to get this code right).  Even so, it doesn't
1369  *        appear to be so.  It's being worked on...
1370  *
1371  *   Revision history
1372  *        06-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1373  *             Original implementation (based on NC_DrawFrame)
1374  *        02-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1375  *             Some minor fixes.
1376  *        29-Jun-1999 Ove Kåven (ovek@arcticnet.no)
1377  *             Fixed a fix or something.
1378  *
1379  *****************************************************************************/
1380
1381 static void  NC_DrawFrame95(
1382     HDC  hdc,
1383     RECT  *rect,
1384     BOOL  dlgFrame,
1385     BOOL  active )
1386 {
1387     INT width, height;
1388
1389     if (dlgFrame)
1390     {
1391         width = GetSystemMetrics(SM_CXDLGFRAME) - GetSystemMetrics(SM_CXEDGE);
1392         height = GetSystemMetrics(SM_CYDLGFRAME) - GetSystemMetrics(SM_CYEDGE);
1393     }
1394     else
1395     {
1396         width = GetSystemMetrics(SM_CXFRAME) - GetSystemMetrics(SM_CXEDGE);
1397         height = GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYEDGE);
1398     }
1399
1400     SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
1401                 COLOR_INACTIVEBORDER) );
1402
1403     /* Draw frame */
1404     PatBlt( hdc, rect->left, rect->top,
1405               rect->right - rect->left, height, PATCOPY );
1406     PatBlt( hdc, rect->left, rect->top,
1407               width, rect->bottom - rect->top, PATCOPY );
1408     PatBlt( hdc, rect->left, rect->bottom - 1,
1409               rect->right - rect->left, -height, PATCOPY );
1410     PatBlt( hdc, rect->right - 1, rect->top,
1411               -width, rect->bottom - rect->top, PATCOPY );
1412
1413     InflateRect( rect, -width, -height );
1414 }
1415
1416 /***********************************************************************
1417  *           NC_DrawMovingFrame
1418  *
1419  * Draw the frame used when moving or resizing window.
1420  *
1421  * FIXME:  This causes problems in Win95 mode.  (why?)
1422  */
1423 static void NC_DrawMovingFrame( HDC hdc, RECT *rect, BOOL thickframe )
1424 {
1425     if (thickframe)
1426     {
1427         RECT16 r16;
1428         CONV_RECT32TO16( rect, &r16 );
1429         FastWindowFrame16( hdc, &r16, GetSystemMetrics(SM_CXFRAME),
1430                          GetSystemMetrics(SM_CYFRAME), PATINVERT );
1431     }
1432     else DrawFocusRect( hdc, rect );
1433 }
1434
1435
1436 /***********************************************************************
1437  *           NC_DrawCaption
1438  *
1439  * Draw the window caption.
1440  * The correct pen for the window frame must be selected in the DC.
1441  */
1442 static void NC_DrawCaption( HDC hdc, RECT *rect, HWND hwnd,
1443                             DWORD style, BOOL active )
1444 {
1445     RECT r = *rect;
1446     WND * wndPtr = WIN_FindWndPtr( hwnd );
1447     char buffer[256];
1448
1449     if (wndPtr->flags & WIN_MANAGED)
1450     {
1451         WIN_ReleaseWndPtr(wndPtr);
1452         return;
1453     }
1454
1455     if (!hbitmapClose)
1456     {
1457         if (!(hbitmapClose = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSE) )))
1458         {
1459             WIN_ReleaseWndPtr(wndPtr);
1460             return;
1461         }
1462         hbitmapCloseD    = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSED) );
1463         hbitmapMinimize  = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCE) );
1464         hbitmapMinimizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCED) );
1465         hbitmapMaximize  = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOM) );
1466         hbitmapMaximizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOMD) );
1467         hbitmapRestore   = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORE) );
1468         hbitmapRestoreD  = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORED) );
1469     }
1470
1471     if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME)
1472     {
1473         HBRUSH hbrushOld = SelectObject(hdc, GetSysColorBrush(COLOR_WINDOW) );
1474         PatBlt( hdc, r.left, r.top, 1, r.bottom-r.top+1,PATCOPY );
1475         PatBlt( hdc, r.right-1, r.top, 1, r.bottom-r.top+1, PATCOPY );
1476         PatBlt( hdc, r.left, r.top-1, r.right-r.left, 1, PATCOPY );
1477         r.left++;
1478         r.right--;
1479         SelectObject( hdc, hbrushOld );
1480     }
1481     WIN_ReleaseWndPtr(wndPtr);
1482     MoveTo16( hdc, r.left, r.bottom );
1483     LineTo( hdc, r.right, r.bottom );
1484
1485     if (style & WS_SYSMENU)
1486     {
1487         NC_DrawSysButton( hwnd, hdc, FALSE );
1488         r.left += GetSystemMetrics(SM_CXSIZE) + 1;
1489         MoveTo16( hdc, r.left - 1, r.top );
1490         LineTo( hdc, r.left - 1, r.bottom );
1491     }
1492     if (style & WS_MAXIMIZEBOX)
1493     {
1494         NC_DrawMaxButton( hwnd, hdc, FALSE );
1495         r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1496     }
1497     if (style & WS_MINIMIZEBOX)
1498     {
1499         NC_DrawMinButton( hwnd, hdc, FALSE );
1500         r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1501     }
1502
1503     FillRect( hdc, &r, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1504                                             COLOR_INACTIVECAPTION) );
1505
1506     if (GetWindowTextA( hwnd, buffer, sizeof(buffer) ))
1507     {
1508         if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
1509         else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
1510         SetBkMode( hdc, TRANSPARENT );
1511         DrawTextA( hdc, buffer, -1, &r,
1512                      DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_NOPREFIX );
1513     }
1514 }
1515
1516
1517 /******************************************************************************
1518  *
1519  *   NC_DrawCaption95(
1520  *      HDC32  hdc,
1521  *      RECT32 *rect,
1522  *      HWND32 hwnd,
1523  *      DWORD  style,
1524  *      BOOL32 active )
1525  *
1526  *   Draw the window caption for Win95 style windows.
1527  *   The correct pen for the window frame must be selected in the DC.
1528  *
1529  *   Bugs
1530  *        Hey, a function that finally works!  Well, almost.
1531  *        It's being worked on.
1532  *
1533  *   Revision history
1534  *        05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1535  *             Original implementation.
1536  *        02-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1537  *             Some minor fixes.
1538  *
1539  *****************************************************************************/
1540
1541 static void  NC_DrawCaption95(
1542     HDC  hdc,
1543     RECT *rect,
1544     HWND hwnd,
1545     DWORD  style,
1546     DWORD  exStyle,
1547     BOOL active )
1548 {
1549     RECT  r = *rect;
1550     WND     *wndPtr = WIN_FindWndPtr( hwnd );
1551     char    buffer[256];
1552     HPEN  hPrevPen;
1553     HMENU hSysMenu;
1554
1555     if (wndPtr->flags & WIN_MANAGED)
1556     {
1557         WIN_ReleaseWndPtr(wndPtr);
1558         return;
1559     }
1560     WIN_ReleaseWndPtr(wndPtr);
1561
1562     hPrevPen = SelectObject( hdc, GetSysColorPen(COLOR_3DFACE) );
1563     MoveToEx( hdc, r.left, r.bottom - 1, NULL );
1564     LineTo( hdc, r.right, r.bottom - 1 );
1565     SelectObject( hdc, hPrevPen );
1566     r.bottom--;
1567
1568     FillRect( hdc, &r, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1569                                             COLOR_INACTIVECAPTION) );
1570
1571     if (!hbitmapClose) {
1572         if (!(hbitmapClose = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSE) )))
1573             return;
1574         hbitmapCloseD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSED));
1575         hbitmapMinimize  = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCE) );
1576         hbitmapMinimizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCED) );
1577         hbitmapMaximize  = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOM) );
1578         hbitmapMaximizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOMD) );
1579         hbitmapRestore   = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORE) );
1580         hbitmapRestoreD  = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORED) );
1581     }
1582
1583     if ((style & WS_SYSMENU) && !(exStyle & WS_EX_TOOLWINDOW)) {
1584         if (NC_DrawSysButton95 (hwnd, hdc, FALSE))
1585             r.left += GetSystemMetrics(SM_CYCAPTION) - 1;
1586     }
1587
1588     if (style & WS_SYSMENU)
1589     {
1590         UINT state;
1591
1592         /* Go get the sysmenu */
1593         hSysMenu = GetSystemMenu(hwnd, FALSE);
1594         state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1595
1596         /* Draw a grayed close button if disabled and a normal one if SC_CLOSE is not there */
1597         NC_DrawCloseButton95 (hwnd, hdc, FALSE,
1598                               ((((state & MF_DISABLED) || (state & MF_GRAYED))) && (state != 0xFFFFFFFF)));
1599         r.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
1600
1601         if ((style & WS_MAXIMIZEBOX) || (style & WS_MINIMIZEBOX))
1602         {
1603             /* In win95 the two buttons are always there */
1604             /* But if the menu item is not in the menu they're disabled*/
1605
1606             NC_DrawMaxButton95( hwnd, hdc, FALSE, (!(style & WS_MAXIMIZEBOX)));
1607             r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1608
1609             NC_DrawMinButton95( hwnd, hdc, FALSE,  (!(style & WS_MINIMIZEBOX)));
1610             r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1611         }
1612     }
1613
1614     if (GetWindowTextA( hwnd, buffer, sizeof(buffer) )) {
1615         NONCLIENTMETRICSA nclm;
1616         HFONT hFont, hOldFont;
1617         nclm.cbSize = sizeof(NONCLIENTMETRICSA);
1618         SystemParametersInfoA (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
1619         if (exStyle & WS_EX_TOOLWINDOW)
1620             hFont = CreateFontIndirectA (&nclm.lfSmCaptionFont);
1621         else
1622             hFont = CreateFontIndirectA (&nclm.lfCaptionFont);
1623         hOldFont = SelectObject (hdc, hFont);
1624         if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
1625         else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
1626         SetBkMode( hdc, TRANSPARENT );
1627         r.left += 2;
1628         DrawTextA( hdc, buffer, -1, &r,
1629                      DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT );
1630         DeleteObject (SelectObject (hdc, hOldFont));
1631     }
1632 }
1633
1634
1635
1636 /***********************************************************************
1637  *           NC_DoNCPaint
1638  *
1639  * Paint the non-client area. clip is currently unused.
1640  */
1641 static void NC_DoNCPaint( WND* wndPtr, HRGN clip, BOOL suppress_menupaint )
1642 {
1643     HDC hdc;
1644     RECT rect;
1645     BOOL active;
1646     HWND hwnd = wndPtr->hwndSelf;
1647
1648     if ( wndPtr->dwStyle & WS_MINIMIZE ||
1649         !WIN_IsWindowDrawable( wndPtr, 0 )) return; /* Nothing to do */
1650
1651     active  = wndPtr->flags & WIN_NCACTIVATED;
1652
1653     TRACE("%04x %d\n", hwnd, active );
1654
1655     if (!(hdc = GetDCEx( hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
1656                               ((clip > 1) ? (DCX_INTERSECTRGN | DCX_KEEPCLIPRGN): 0) ))) return;
1657
1658     if (ExcludeVisRect16( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left,
1659                         wndPtr->rectClient.top-wndPtr->rectWindow.top,
1660                         wndPtr->rectClient.right-wndPtr->rectWindow.left,
1661                         wndPtr->rectClient.bottom-wndPtr->rectWindow.top )
1662         == NULLREGION)
1663     {
1664         ReleaseDC( hwnd, hdc );
1665         return;
1666     }
1667
1668     rect.top = rect.left = 0;
1669     rect.right  = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
1670     rect.bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
1671
1672     SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
1673
1674     if (!(wndPtr->flags & WIN_MANAGED))
1675     {
1676         if (HAS_ANYFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1677         {
1678             SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1679             Rectangle( hdc, 0, 0, rect.right, rect.bottom );
1680             InflateRect( &rect, -1, -1 );
1681         }
1682
1683         if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1684             NC_DrawFrame(hdc, &rect, FALSE, active );
1685         else if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1686             NC_DrawFrame( hdc, &rect, TRUE, active );
1687
1688         if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
1689         {
1690             RECT r = rect;
1691             r.bottom = rect.top + GetSystemMetrics(SM_CYSIZE);
1692             rect.top += GetSystemMetrics(SM_CYSIZE) + GetSystemMetrics(SM_CYBORDER);
1693             NC_DrawCaption( hdc, &r, hwnd, wndPtr->dwStyle, active );
1694         }
1695     }
1696
1697     if (HAS_MENU(wndPtr))
1698     {
1699         RECT r = rect;
1700         r.bottom = rect.top + GetSystemMetrics(SM_CYMENU);  /* default height */
1701         rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint );
1702     }
1703
1704       /* Draw the scroll-bars */
1705
1706     if (wndPtr->dwStyle & WS_VSCROLL)
1707         SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1708     if (wndPtr->dwStyle & WS_HSCROLL)
1709         SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1710
1711       /* Draw the "size-box" */
1712
1713     if ((wndPtr->dwStyle & WS_VSCROLL) && (wndPtr->dwStyle & WS_HSCROLL))
1714     {
1715         RECT r = rect;
1716         r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1717         r.top  = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1718         if(wndPtr->dwStyle & WS_BORDER) {
1719           r.left++;
1720           r.top++;
1721         }
1722         FillRect( hdc, &r, GetSysColorBrush(COLOR_SCROLLBAR) );
1723     }
1724
1725     ReleaseDC( hwnd, hdc );
1726 }
1727
1728
1729 /******************************************************************************
1730  *
1731  *   void  NC_DoNCPaint95(
1732  *      WND  *wndPtr,
1733  *      HRGN32  clip,
1734  *      BOOL32  suppress_menupaint )
1735  *
1736  *   Paint the non-client area for Win95 windows.  The clip region is
1737  *   currently ignored.
1738  *
1739  *   Bugs
1740  *        grep -E -A10 -B5 \(95\)\|\(Bugs\)\|\(FIXME\) windows/nonclient.c \
1741  *           misc/tweak.c controls/menu.c  # :-)
1742  *
1743  *   Revision history
1744  *        03-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1745  *             Original implementation
1746  *        10-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1747  *             Fixed some bugs.
1748  *        29-Jun-1999 Ove Kåven (ovek@arcticnet.no)
1749  *             Streamlined window style checks.
1750  *
1751  *****************************************************************************/
1752
1753 static void  NC_DoNCPaint95(
1754     WND  *wndPtr,
1755     HRGN  clip,
1756     BOOL  suppress_menupaint )
1757 {
1758     HDC hdc;
1759     RECT rfuzz, rect, rectClip;
1760     BOOL active;
1761     HWND hwnd = wndPtr->hwndSelf;
1762
1763     if ( wndPtr->dwStyle & WS_MINIMIZE ||
1764         !WIN_IsWindowDrawable( wndPtr, 0 )) return; /* Nothing to do */
1765
1766     active  = wndPtr->flags & WIN_NCACTIVATED;
1767
1768     TRACE("%04x %d\n", hwnd, active );
1769
1770     /* MSDN docs are pretty idiotic here, they say app CAN use clipRgn in
1771        the call to GetDCEx implying that it is allowed not to use it either.
1772        However, the suggested GetDCEx(    , DCX_WINDOW | DCX_INTERSECTRGN)
1773        will cause clipRgn to be deleted after ReleaseDC().
1774        Now, how is the "system" supposed to tell what happened?
1775      */
1776
1777     if (!(hdc = GetDCEx( hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
1778                               ((clip > 1) ?(DCX_INTERSECTRGN | DCX_KEEPCLIPRGN) : 0) ))) return;
1779
1780
1781     if (ExcludeVisRect16( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left,
1782                         wndPtr->rectClient.top-wndPtr->rectWindow.top,
1783                         wndPtr->rectClient.right-wndPtr->rectWindow.left,
1784                         wndPtr->rectClient.bottom-wndPtr->rectWindow.top )
1785         == NULLREGION)
1786     {
1787         ReleaseDC( hwnd, hdc );
1788         return;
1789     }
1790
1791     rect.top = rect.left = 0;
1792     rect.right  = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
1793     rect.bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
1794
1795     if( clip > 1 )
1796         GetRgnBox( clip, &rectClip );
1797     else
1798     {
1799         clip = 0;
1800         rectClip = rect;
1801     }
1802
1803     SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
1804
1805     if(!(wndPtr->flags & WIN_MANAGED)) {
1806         if (HAS_BIGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle)) {
1807             DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT | BF_ADJUST);
1808         }
1809         if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1810             NC_DrawFrame95(hdc, &rect, FALSE, active );
1811         else if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1812             NC_DrawFrame95( hdc, &rect, TRUE, active );
1813         else if (HAS_THINFRAME( wndPtr->dwStyle )) {
1814             SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1815             Rectangle( hdc, 0, 0, rect.right, rect.bottom );
1816         }
1817
1818         if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
1819         {
1820             RECT  r = rect;
1821             if (wndPtr->dwExStyle & WS_EX_TOOLWINDOW) {
1822                 r.bottom = rect.top + GetSystemMetrics(SM_CYSMCAPTION);
1823                 rect.top += GetSystemMetrics(SM_CYSMCAPTION);
1824             }
1825             else {
1826                 r.bottom = rect.top + GetSystemMetrics(SM_CYCAPTION);
1827                 rect.top += GetSystemMetrics(SM_CYCAPTION);
1828             }
1829             if( !clip || IntersectRect( &rfuzz, &r, &rectClip ) )
1830                 NC_DrawCaption95 (hdc, &r, hwnd, wndPtr->dwStyle,
1831                                   wndPtr->dwExStyle, active);
1832         }
1833     }
1834
1835     if (HAS_MENU(wndPtr))
1836     {
1837         RECT r = rect;
1838         r.bottom = rect.top + GetSystemMetrics(SM_CYMENU);
1839
1840         TRACE("Calling DrawMenuBar with rect (%d, %d)-(%d, %d)\n",
1841               r.left, r.top, r.right, r.bottom);
1842
1843         rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint ) + 1;
1844     }
1845
1846     TRACE("After MenuBar, rect is (%d, %d)-(%d, %d).\n",
1847           rect.left, rect.top, rect.right, rect.bottom );
1848
1849     if (wndPtr->dwExStyle & WS_EX_CLIENTEDGE)
1850         DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1851
1852     if (wndPtr->dwExStyle & WS_EX_STATICEDGE)
1853         DrawEdge (hdc, &rect, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
1854
1855     /* Draw the scroll-bars */
1856
1857     if (wndPtr->dwStyle & WS_VSCROLL)
1858         SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1859     if (wndPtr->dwStyle & WS_HSCROLL)
1860         SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1861
1862     /* Draw the "size-box" */
1863     if ((wndPtr->dwStyle & WS_VSCROLL) && (wndPtr->dwStyle & WS_HSCROLL))
1864     {
1865         RECT r = rect;
1866         r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1867         r.top  = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1868         FillRect( hdc, &r,  GetSysColorBrush(COLOR_SCROLLBAR) );
1869     }
1870
1871     ReleaseDC( hwnd, hdc );
1872 }
1873
1874
1875
1876
1877 /***********************************************************************
1878  *           NC_HandleNCPaint
1879  *
1880  * Handle a WM_NCPAINT message. Called from DefWindowProc().
1881  */
1882 LONG NC_HandleNCPaint( HWND hwnd , HRGN clip)
1883 {
1884     WND* wndPtr = WIN_FindWndPtr( hwnd );
1885
1886     if( wndPtr && wndPtr->dwStyle & WS_VISIBLE )
1887     {
1888         if( wndPtr->dwStyle & WS_MINIMIZE )
1889             WINPOS_RedrawIconTitle( hwnd );
1890         else if (TWEAK_WineLook == WIN31_LOOK)
1891             NC_DoNCPaint( wndPtr, clip, FALSE );
1892         else
1893             NC_DoNCPaint95( wndPtr, clip, FALSE );
1894     }
1895     WIN_ReleaseWndPtr(wndPtr);
1896     return 0;
1897 }
1898
1899
1900 /***********************************************************************
1901  *           NC_HandleNCActivate
1902  *
1903  * Handle a WM_NCACTIVATE message. Called from DefWindowProc().
1904  */
1905 LONG NC_HandleNCActivate( WND *wndPtr, WPARAM16 wParam )
1906 {
1907     WORD wStateChange;
1908
1909     if( wParam ) wStateChange = !(wndPtr->flags & WIN_NCACTIVATED);
1910     else wStateChange = wndPtr->flags & WIN_NCACTIVATED;
1911
1912     if( wStateChange )
1913     {
1914         if (wParam) wndPtr->flags |= WIN_NCACTIVATED;
1915         else wndPtr->flags &= ~WIN_NCACTIVATED;
1916
1917         if( wndPtr->dwStyle & WS_MINIMIZE )
1918             WINPOS_RedrawIconTitle( wndPtr->hwndSelf );
1919         else if (TWEAK_WineLook == WIN31_LOOK)
1920             NC_DoNCPaint( wndPtr, (HRGN)1, FALSE );
1921         else
1922             NC_DoNCPaint95( wndPtr, (HRGN)1, FALSE );
1923     }
1924     return TRUE;
1925 }
1926
1927
1928 /***********************************************************************
1929  *           NC_HandleSetCursor
1930  *
1931  * Handle a WM_SETCURSOR message. Called from DefWindowProc().
1932  */
1933 LONG NC_HandleSetCursor( HWND hwnd, WPARAM16 wParam, LPARAM lParam )
1934 {
1935     if (hwnd != (HWND)wParam) return 0;  /* Don't set the cursor for child windows */
1936
1937     switch(LOWORD(lParam))
1938     {
1939     case HTERROR:
1940         {
1941             WORD msg = HIWORD( lParam );
1942             if ((msg == WM_LBUTTONDOWN) || (msg == WM_MBUTTONDOWN) ||
1943                 (msg == WM_RBUTTONDOWN))
1944                 MessageBeep(0);
1945         }
1946         break;
1947
1948     case HTCLIENT:
1949         {
1950             HICON16 hCursor = (HICON16) GetClassWord(hwnd, GCW_HCURSOR);
1951             if(hCursor) {
1952                 SetCursor16(hCursor);
1953                 return TRUE;
1954             }
1955             return FALSE;
1956         }
1957
1958     case HTLEFT:
1959     case HTRIGHT:
1960         return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZEWE16 ) );
1961
1962     case HTTOP:
1963     case HTBOTTOM:
1964         return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENS16 ) );
1965
1966     case HTTOPLEFT:
1967     case HTBOTTOMRIGHT:
1968         return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENWSE16 ) );
1969
1970     case HTTOPRIGHT:
1971     case HTBOTTOMLEFT:
1972         return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENESW16 ) );
1973     }
1974
1975     /* Default cursor: arrow */
1976     return (LONG)SetCursor16( LoadCursor16( 0, IDC_ARROW16 ) );
1977 }
1978
1979 /***********************************************************************
1980  *           NC_GetSysPopupPos
1981  */
1982 BOOL NC_GetSysPopupPos( WND* wndPtr, RECT* rect )
1983 {
1984   if( wndPtr->hSysMenu )
1985   {
1986       if( wndPtr->dwStyle & WS_MINIMIZE )
1987           GetWindowRect( wndPtr->hwndSelf, rect );
1988       else
1989       {
1990           if (TWEAK_WineLook == WIN31_LOOK)
1991               NC_GetInsideRect( wndPtr->hwndSelf, rect );
1992           else
1993               NC_GetInsideRect95( wndPtr->hwndSelf, rect );
1994           OffsetRect( rect, wndPtr->rectWindow.left, wndPtr->rectWindow.top);
1995           if (wndPtr->dwStyle & WS_CHILD)
1996               ClientToScreen( wndPtr->parent->hwndSelf, (POINT *)rect );
1997           if (TWEAK_WineLook == WIN31_LOOK) {
1998             rect->right = rect->left + GetSystemMetrics(SM_CXSIZE);
1999             rect->bottom = rect->top + GetSystemMetrics(SM_CYSIZE);
2000           }
2001           else {
2002             rect->right = rect->left + GetSystemMetrics(SM_CYCAPTION) - 1;
2003             rect->bottom = rect->top + GetSystemMetrics(SM_CYCAPTION) - 1;
2004           }
2005       }
2006       return TRUE;
2007   }
2008   return FALSE;
2009 }
2010
2011 /***********************************************************************
2012  *           NC_StartSizeMove
2013  *
2014  * Initialisation of a move or resize, when initiatied from a menu choice.
2015  * Return hit test code for caption or sizing border.
2016  */
2017 static LONG NC_StartSizeMove( WND* wndPtr, WPARAM16 wParam,
2018                               POINT16 *capturePoint )
2019 {
2020     LONG hittest = 0;
2021     POINT16 pt;
2022     MSG msg;
2023     RECT rectWindow;
2024
2025     GetWindowRect(wndPtr->hwndSelf,&rectWindow);
2026
2027     if ((wParam & 0xfff0) == SC_MOVE)
2028     {
2029           /* Move pointer at the center of the caption */
2030         RECT rect;
2031         if (TWEAK_WineLook == WIN31_LOOK)
2032             NC_GetInsideRect( wndPtr->hwndSelf, &rect );
2033         else
2034             NC_GetInsideRect95( wndPtr->hwndSelf, &rect );
2035         if (wndPtr->dwStyle & WS_SYSMENU)
2036             rect.left += GetSystemMetrics(SM_CXSIZE) + 1;
2037         if (wndPtr->dwStyle & WS_MINIMIZEBOX)
2038             rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
2039         if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
2040             rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
2041         pt.x = rectWindow.left + (rect.right - rect.left) / 2;
2042         pt.y = rectWindow.top + rect.top + GetSystemMetrics(SM_CYSIZE)/2;
2043         hittest = HTCAPTION;
2044         *capturePoint = pt;
2045     }
2046     else  /* SC_SIZE */
2047     {
2048         while(!hittest)
2049         {
2050             MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, MSGF_SIZE, PM_REMOVE, FALSE, NULL );
2051             switch(msg.message)
2052             {
2053             case WM_MOUSEMOVE:
2054                 CONV_POINT32TO16(&msg.pt, &pt);
2055                 hittest = NC_HandleNCHitTest( wndPtr->hwndSelf, pt );
2056                 if ((hittest < HTLEFT) || (hittest > HTBOTTOMRIGHT))
2057                     hittest = 0;
2058                 break;
2059
2060             case WM_LBUTTONUP:
2061                 return 0;
2062
2063             case WM_KEYDOWN:
2064                 switch(msg.wParam)
2065                 {
2066                 case VK_UP:
2067                     hittest = HTTOP;
2068                     pt.x =(rectWindow.left+rectWindow.right)/2;
2069                     pt.y = rectWindow.top + GetSystemMetrics(SM_CYFRAME) / 2;
2070                     break;
2071                 case VK_DOWN:
2072                     hittest = HTBOTTOM;
2073                     pt.x =(rectWindow.left+rectWindow.right)/2;
2074                     pt.y = rectWindow.bottom - GetSystemMetrics(SM_CYFRAME) / 2;
2075                     break;
2076                 case VK_LEFT:
2077                     hittest = HTLEFT;
2078                     pt.x = rectWindow.left + GetSystemMetrics(SM_CXFRAME) / 2;
2079                     pt.y =(rectWindow.top+rectWindow.bottom)/2;
2080                     break;
2081                 case VK_RIGHT:
2082                     hittest = HTRIGHT;
2083                     pt.x = rectWindow.right - GetSystemMetrics(SM_CXFRAME) / 2;
2084                     pt.y =(rectWindow.top+rectWindow.bottom)/2;
2085                     break;
2086                 case VK_RETURN:
2087                 case VK_ESCAPE: return 0;
2088                 }
2089             }
2090         }
2091         *capturePoint = pt;
2092     }
2093     SetCursorPos( pt.x, pt.y );
2094     NC_HandleSetCursor( wndPtr->hwndSelf,
2095                         wndPtr->hwndSelf, MAKELONG( hittest, WM_MOUSEMOVE ));
2096     return hittest;
2097 }
2098
2099
2100 /***********************************************************************
2101  *           NC_DoSizeMove
2102  *
2103  * Perform SC_MOVE and SC_SIZE commands.               `
2104  */
2105 static void NC_DoSizeMove( HWND hwnd, WORD wParam )
2106 {
2107     MSG msg;
2108     RECT sizingRect, mouseRect;
2109     HDC hdc;
2110     LONG hittest = (LONG)(wParam & 0x0f);
2111     HCURSOR16 hDragCursor = 0, hOldCursor = 0;
2112     POINT minTrack, maxTrack;
2113     POINT16 capturePoint, pt;
2114     WND *     wndPtr = WIN_FindWndPtr( hwnd );
2115     BOOL    thickframe = HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle );
2116     BOOL    iconic = wndPtr->dwStyle & WS_MINIMIZE;
2117     BOOL    moved = FALSE;
2118     DWORD     dwPoint = GetMessagePos ();
2119
2120     capturePoint = pt = *(POINT16*)&dwPoint;
2121
2122     if (IsZoomed(hwnd) || !IsWindowVisible(hwnd) ||
2123         (wndPtr->flags & WIN_MANAGED)) goto END;
2124
2125     if ((wParam & 0xfff0) == SC_MOVE)
2126     {
2127         if (!(wndPtr->dwStyle & WS_CAPTION)) goto END;
2128         if (!hittest)
2129              hittest = NC_StartSizeMove( wndPtr, wParam, &capturePoint );
2130         if (!hittest) goto END;
2131     }
2132     else  /* SC_SIZE */
2133     {
2134         if (!thickframe) goto END;
2135         if ( hittest && hittest != HTSYSMENU ) hittest += 2;
2136         else
2137         {
2138             SetCapture(hwnd);
2139             hittest = NC_StartSizeMove( wndPtr, wParam, &capturePoint );
2140             if (!hittest)
2141             {
2142                 ReleaseCapture();
2143                 goto END;
2144             }
2145         }
2146     }
2147
2148       /* Get min/max info */
2149
2150     WINPOS_GetMinMaxInfo( wndPtr, NULL, NULL, &minTrack, &maxTrack );
2151     sizingRect = wndPtr->rectWindow;
2152     if (wndPtr->dwStyle & WS_CHILD)
2153         GetClientRect( wndPtr->parent->hwndSelf, &mouseRect );
2154     else
2155         SetRect(&mouseRect, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
2156     if (ON_LEFT_BORDER(hittest))
2157     {
2158         mouseRect.left  = MAX( mouseRect.left, sizingRect.right-maxTrack.x );
2159         mouseRect.right = MIN( mouseRect.right, sizingRect.right-minTrack.x );
2160     }
2161     else if (ON_RIGHT_BORDER(hittest))
2162     {
2163         mouseRect.left  = MAX( mouseRect.left, sizingRect.left+minTrack.x );
2164         mouseRect.right = MIN( mouseRect.right, sizingRect.left+maxTrack.x );
2165     }
2166     if (ON_TOP_BORDER(hittest))
2167     {
2168         mouseRect.top    = MAX( mouseRect.top, sizingRect.bottom-maxTrack.y );
2169         mouseRect.bottom = MIN( mouseRect.bottom,sizingRect.bottom-minTrack.y);
2170     }
2171     else if (ON_BOTTOM_BORDER(hittest))
2172     {
2173         mouseRect.top    = MAX( mouseRect.top, sizingRect.top+minTrack.y );
2174         mouseRect.bottom = MIN( mouseRect.bottom, sizingRect.top+maxTrack.y );
2175     }
2176     if (wndPtr->dwStyle & WS_CHILD)
2177     {
2178         MapWindowPoints( wndPtr->parent->hwndSelf, 0,
2179                 (LPPOINT)&mouseRect, 2 );
2180     }
2181     SendMessage16( hwnd, WM_ENTERSIZEMOVE, 0, 0 );
2182
2183     if (GetCapture() != hwnd) SetCapture( hwnd );
2184
2185     if (wndPtr->dwStyle & WS_CHILD)
2186     {
2187           /* Retrieve a default cache DC (without using the window style) */
2188         hdc = GetDCEx( wndPtr->parent->hwndSelf, 0, DCX_CACHE );
2189     }
2190     else
2191     {  /* Grab the server only when moving top-level windows without desktop */
2192         hdc = GetDC( 0 );
2193     }
2194
2195     wndPtr->pDriver->pPreSizeMove(wndPtr);
2196
2197     if( iconic ) /* create a cursor for dragging */
2198     {
2199         HICON16 hIcon = GetClassWord(wndPtr->hwndSelf, GCW_HICON);
2200         if(!hIcon) hIcon = (HICON16) SendMessage16( hwnd, WM_QUERYDRAGICON, 0, 0L);
2201         if( hIcon ) hDragCursor =  CURSORICON_IconToCursor( hIcon, TRUE );
2202         if( !hDragCursor ) iconic = FALSE;
2203     }
2204
2205     if( !iconic ) NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2206
2207     while(1)
2208     {
2209         int dx = 0, dy = 0;
2210
2211         MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, MSGF_SIZE, PM_REMOVE, FALSE, NULL );
2212
2213           /* Exit on button-up, Return, or Esc */
2214         if ((msg.message == WM_LBUTTONUP) ||
2215             ((msg.message == WM_KEYDOWN) &&
2216              ((msg.wParam == VK_RETURN) || (msg.wParam == VK_ESCAPE)))) break;
2217
2218         if ((msg.message != WM_KEYDOWN) && (msg.message != WM_MOUSEMOVE))
2219             continue;  /* We are not interested in other messages */
2220
2221         dwPoint = GetMessagePos ();
2222         pt = *(POINT16*)&dwPoint;
2223
2224         if (msg.message == WM_KEYDOWN) switch(msg.wParam)
2225         {
2226             case VK_UP:    pt.y -= 8; break;
2227             case VK_DOWN:  pt.y += 8; break;
2228             case VK_LEFT:  pt.x -= 8; break;
2229             case VK_RIGHT: pt.x += 8; break;
2230         }
2231
2232         pt.x = MAX( pt.x, mouseRect.left );
2233         pt.x = MIN( pt.x, mouseRect.right );
2234         pt.y = MAX( pt.y, mouseRect.top );
2235         pt.y = MIN( pt.y, mouseRect.bottom );
2236
2237         dx = pt.x - capturePoint.x;
2238         dy = pt.y - capturePoint.y;
2239
2240         if (dx || dy)
2241         {
2242             if( !moved )
2243             {
2244                 moved = TRUE;
2245                 if( iconic ) /* ok, no system popup tracking */
2246                 {
2247                     hOldCursor = SetCursor(hDragCursor);
2248                     ShowCursor( TRUE );
2249                     WINPOS_ShowIconTitle( wndPtr, FALSE );
2250                 }
2251             }
2252
2253             if (msg.message == WM_KEYDOWN) SetCursorPos( pt.x, pt.y );
2254             else
2255             {
2256                 RECT newRect = sizingRect;
2257
2258                 if (hittest == HTCAPTION) OffsetRect( &newRect, dx, dy );
2259                 if (ON_LEFT_BORDER(hittest)) newRect.left += dx;
2260                 else if (ON_RIGHT_BORDER(hittest)) newRect.right += dx;
2261                 if (ON_TOP_BORDER(hittest)) newRect.top += dy;
2262                 else if (ON_BOTTOM_BORDER(hittest)) newRect.bottom += dy;
2263                 if( !iconic )
2264                 {
2265                     NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2266                     NC_DrawMovingFrame( hdc, &newRect, thickframe );
2267                 }
2268                 capturePoint = pt;
2269                 sizingRect = newRect;
2270             }
2271         }
2272     }
2273
2274     ReleaseCapture();
2275     if( iconic )
2276     {
2277         if( moved ) /* restore cursors, show icon title later on */
2278         {
2279             ShowCursor( FALSE );
2280             SetCursor( hOldCursor );
2281         }
2282         DestroyCursor( hDragCursor );
2283     }
2284     else
2285         NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2286
2287     if (wndPtr->dwStyle & WS_CHILD)
2288         ReleaseDC( wndPtr->parent->hwndSelf, hdc );
2289     else
2290     {
2291         ReleaseDC( 0, hdc );
2292     }
2293
2294     wndPtr->pDriver->pPostSizeMove(wndPtr);
2295
2296     if (HOOK_IsHooked( WH_CBT ))
2297     {
2298         RECT16* pr = SEGPTR_NEW(RECT16);
2299         if( pr )
2300         {
2301             CONV_RECT32TO16( &sizingRect, pr );
2302             if( HOOK_CallHooks16( WH_CBT, HCBT_MOVESIZE, hwnd,
2303                                 (LPARAM)SEGPTR_GET(pr)) )
2304                 sizingRect = wndPtr->rectWindow;
2305             else
2306                 CONV_RECT16TO32( pr, &sizingRect );
2307             SEGPTR_FREE(pr);
2308         }
2309     }
2310     SendMessage16( hwnd, WM_EXITSIZEMOVE, 0, 0 );
2311     SendMessage16( hwnd, WM_SETVISIBLE, !IsIconic16(hwnd), 0L);
2312
2313     /* window moved or resized */
2314     if (moved)
2315     {
2316         /* if the moving/resizing isn't canceled call SetWindowPos
2317          * with the new position or the new size of the window
2318          */
2319         if (!((msg.message == WM_KEYDOWN) && (msg.wParam == VK_ESCAPE)) )
2320         {
2321         /* NOTE: SWP_NOACTIVATE prevents document window activation in Word 6 */
2322         SetWindowPos( hwnd, 0, sizingRect.left, sizingRect.top,
2323                         sizingRect.right - sizingRect.left,
2324                         sizingRect.bottom - sizingRect.top,
2325                       ( hittest == HTCAPTION ) ? SWP_NOSIZE : 0 );
2326         }
2327     }
2328
2329     if( IsWindow(hwnd) )
2330         if( wndPtr->dwStyle & WS_MINIMIZE )
2331         {
2332             /* Single click brings up the system menu when iconized */
2333
2334             if( !moved )
2335             {
2336                  if( wndPtr->dwStyle & WS_SYSMENU )
2337                      SendMessage16( hwnd, WM_SYSCOMMAND,
2338                                     SC_MOUSEMENU + HTSYSMENU, *((LPARAM*)&pt));
2339             }
2340             else WINPOS_ShowIconTitle( wndPtr, TRUE );
2341         }
2342
2343 END:
2344     WIN_ReleaseWndPtr(wndPtr);
2345 }
2346
2347
2348 /***********************************************************************
2349  *           NC_TrackMinMaxBox95
2350  *
2351  * Track a mouse button press on the minimize or maximize box.
2352  *
2353  * The big difference between 3.1 and 95 is the disabled button state.
2354  * In win95 the system button can be disabled, so it can ignore the mouse
2355  * event.
2356  *
2357  */
2358 static void NC_TrackMinMaxBox95( HWND hwnd, WORD wParam )
2359 {
2360     MSG msg;
2361     POINT16 pt16;
2362     HDC hdc = GetWindowDC( hwnd );
2363     BOOL pressed = TRUE;
2364     UINT state;
2365     DWORD wndStyle = GetWindowLongA( hwnd, GWL_STYLE);
2366     HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
2367
2368     void  (*paintButton)(HWND, HDC16, BOOL, BOOL);
2369
2370     if (wParam == HTMINBUTTON)
2371     {
2372         /* If the style is not present, do nothing */
2373         if (!(wndStyle & WS_MINIMIZEBOX))
2374             return;
2375
2376         /* Check if the sysmenu item for minimize is there  */
2377         state = GetMenuState(hSysMenu, SC_MINIMIZE, MF_BYCOMMAND);
2378
2379         paintButton = &NC_DrawMinButton95;
2380     }
2381     else
2382     {
2383         /* If the style is not present, do nothing */
2384         if (!(wndStyle & WS_MAXIMIZEBOX))
2385             return;
2386
2387         /* Check if the sysmenu item for maximize is there  */
2388         state = GetMenuState(hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND);
2389
2390         paintButton = &NC_DrawMaxButton95;
2391     }
2392
2393     SetCapture( hwnd );
2394
2395     (*paintButton)( hwnd, hdc, TRUE, FALSE);
2396
2397     do
2398     {
2399         BOOL oldstate = pressed;
2400         MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, 0, PM_REMOVE, FALSE, NULL );
2401         CONV_POINT32TO16( &msg.pt, &pt16 );
2402
2403         pressed = (NC_HandleNCHitTest( hwnd, pt16 ) == wParam);
2404         if (pressed != oldstate)
2405            (*paintButton)( hwnd, hdc, pressed, FALSE);
2406     } while (msg.message != WM_LBUTTONUP);
2407
2408     (*paintButton)( hwnd, hdc, FALSE, FALSE);
2409
2410     ReleaseCapture();
2411     ReleaseDC( hwnd, hdc );
2412
2413     /* If the item minimize or maximize of the sysmenu are not there */
2414     /* or if the style is not present, do nothing */
2415     if ((!pressed) || (state == 0xFFFFFFFF))
2416         return;
2417
2418     if (wParam == HTMINBUTTON)
2419         SendMessage16( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, *(LONG*)&pt16 );
2420     else
2421         SendMessage16( hwnd, WM_SYSCOMMAND,
2422                   IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, *(LONG*)&pt16 );
2423 }
2424
2425 /***********************************************************************
2426  *           NC_TrackMinMaxBox
2427  *
2428  * Track a mouse button press on the minimize or maximize box.
2429  */
2430 static void NC_TrackMinMaxBox( HWND hwnd, WORD wParam )
2431 {
2432     MSG msg;
2433     POINT16 pt16;
2434     HDC hdc = GetWindowDC( hwnd );
2435     BOOL pressed = TRUE;
2436     void  (*paintButton)(HWND, HDC16, BOOL);
2437
2438     SetCapture( hwnd );
2439
2440     if (wParam == HTMINBUTTON)
2441         paintButton = &NC_DrawMinButton;
2442     else
2443         paintButton = &NC_DrawMaxButton;
2444
2445     (*paintButton)( hwnd, hdc, TRUE);
2446
2447     do
2448     {
2449         BOOL oldstate = pressed;
2450         MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, 0, PM_REMOVE, FALSE, NULL );
2451         CONV_POINT32TO16( &msg.pt, &pt16 );
2452
2453         pressed = (NC_HandleNCHitTest( hwnd, pt16 ) == wParam);
2454         if (pressed != oldstate)
2455            (*paintButton)( hwnd, hdc, pressed);
2456     } while (msg.message != WM_LBUTTONUP);
2457
2458     (*paintButton)( hwnd, hdc, FALSE);
2459
2460     ReleaseCapture();
2461     ReleaseDC( hwnd, hdc );
2462
2463     if (!pressed) return;
2464
2465     if (wParam == HTMINBUTTON)
2466         SendMessage16( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, *(LONG*)&pt16 );
2467     else
2468         SendMessage16( hwnd, WM_SYSCOMMAND,
2469                   IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, *(LONG*)&pt16 );
2470 }
2471
2472
2473 /***********************************************************************
2474  * NC_TrackCloseButton95
2475  *
2476  * Track a mouse button press on the Win95 close button.
2477  */
2478 static void
2479 NC_TrackCloseButton95 (HWND hwnd, WORD wParam)
2480 {
2481     MSG msg;
2482     POINT16 pt16;
2483     HDC hdc;
2484     BOOL pressed = TRUE;
2485     HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
2486     UINT state;
2487
2488     if(hSysMenu == 0)
2489         return;
2490
2491     state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
2492
2493     /* If the item close of the sysmenu is disabled or not there do nothing */
2494     if((state & MF_DISABLED) || (state & MF_GRAYED) || (state == 0xFFFFFFFF))
2495         return;
2496
2497     hdc = GetWindowDC( hwnd );
2498
2499     SetCapture( hwnd );
2500
2501     NC_DrawCloseButton95 (hwnd, hdc, TRUE, FALSE);
2502
2503     do
2504     {
2505         BOOL oldstate = pressed;
2506         MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, 0, PM_REMOVE, FALSE, NULL );
2507         CONV_POINT32TO16( &msg.pt, &pt16 );
2508
2509         pressed = (NC_HandleNCHitTest( hwnd, pt16 ) == wParam);
2510         if (pressed != oldstate)
2511            NC_DrawCloseButton95 (hwnd, hdc, pressed, FALSE);
2512     } while (msg.message != WM_LBUTTONUP);
2513
2514     NC_DrawCloseButton95 (hwnd, hdc, FALSE, FALSE);
2515
2516     ReleaseCapture();
2517     ReleaseDC( hwnd, hdc );
2518     if (!pressed) return;
2519
2520     SendMessage16( hwnd, WM_SYSCOMMAND, SC_CLOSE, *(LONG*)&pt16 );
2521 }
2522
2523
2524 /***********************************************************************
2525  *           NC_TrackScrollBar
2526  *
2527  * Track a mouse button press on the horizontal or vertical scroll-bar.
2528  */
2529 static void NC_TrackScrollBar( HWND hwnd, WPARAM wParam, POINT pt )
2530 {
2531     MSG16 *msg;
2532     INT scrollbar;
2533     WND *wndPtr = WIN_FindWndPtr( hwnd );
2534
2535     if ((wParam & 0xfff0) == SC_HSCROLL)
2536     {
2537         if ((wParam & 0x0f) != HTHSCROLL) goto END;
2538         scrollbar = SB_HORZ;
2539     }
2540     else  /* SC_VSCROLL */
2541     {
2542         if ((wParam & 0x0f) != HTVSCROLL) goto END;
2543         scrollbar = SB_VERT;
2544     }
2545
2546     if (!(msg = SEGPTR_NEW(MSG16))) goto END;
2547     pt.x -= wndPtr->rectWindow.left;
2548     pt.y -= wndPtr->rectWindow.top;
2549     SetCapture( hwnd );
2550     SCROLL_HandleScrollEvent( hwnd, scrollbar, WM_LBUTTONDOWN, pt );
2551
2552     do
2553     {
2554         GetMessage16( SEGPTR_GET(msg), 0, 0, 0 );
2555         switch(msg->message)
2556         {
2557         case WM_LBUTTONUP:
2558         case WM_MOUSEMOVE:
2559         case WM_SYSTIMER:
2560             pt.x = LOWORD(msg->lParam) + wndPtr->rectClient.left -
2561               wndPtr->rectWindow.left;
2562             pt.y = HIWORD(msg->lParam) + wndPtr->rectClient.top -
2563               wndPtr->rectWindow.top;
2564             SCROLL_HandleScrollEvent( hwnd, scrollbar, msg->message, pt );
2565             break;
2566         default:
2567             TranslateMessage16( msg );
2568             DispatchMessage16( msg );
2569             break;
2570         }
2571         if (!IsWindow( hwnd ))
2572         {
2573             ReleaseCapture();
2574             break;
2575         }
2576     } while (msg->message != WM_LBUTTONUP);
2577     SEGPTR_FREE(msg);
2578 END:
2579     WIN_ReleaseWndPtr(wndPtr);
2580 }
2581
2582 /***********************************************************************
2583  *           NC_HandleNCLButtonDown
2584  *
2585  * Handle a WM_NCLBUTTONDOWN message. Called from DefWindowProc().
2586  */
2587 LONG NC_HandleNCLButtonDown( WND* pWnd, WPARAM16 wParam, LPARAM lParam )
2588 {
2589     HWND hwnd = pWnd->hwndSelf;
2590
2591     switch(wParam)  /* Hit test */
2592     {
2593     case HTCAPTION:
2594          hwnd = WIN_GetTopParent(hwnd);
2595
2596          if( WINPOS_SetActiveWindow(hwnd, TRUE, TRUE) || (GetActiveWindow() == hwnd) )
2597                 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam );
2598          break;
2599
2600     case HTSYSMENU:
2601          if( pWnd->dwStyle & WS_SYSMENU )
2602          {
2603              if( !(pWnd->dwStyle & WS_MINIMIZE) )
2604              {
2605                 HDC hDC = GetWindowDC(hwnd);
2606                 if (TWEAK_WineLook == WIN31_LOOK)
2607                     NC_DrawSysButton( hwnd, hDC, TRUE );
2608                 else
2609                     NC_DrawSysButton95( hwnd, hDC, TRUE );
2610                 ReleaseDC( hwnd, hDC );
2611              }
2612              SendMessage16( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, lParam );
2613          }
2614          break;
2615
2616     case HTMENU:
2617         SendMessage16( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU, lParam );
2618         break;
2619
2620     case HTHSCROLL:
2621         SendMessage16( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
2622         break;
2623
2624     case HTVSCROLL:
2625         SendMessage16( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
2626         break;
2627
2628     case HTMINBUTTON:
2629     case HTMAXBUTTON:
2630         if (TWEAK_WineLook == WIN31_LOOK)
2631             NC_TrackMinMaxBox( hwnd, wParam );
2632         else
2633             NC_TrackMinMaxBox95( hwnd, wParam );
2634         break;
2635
2636     case HTCLOSE:
2637         if (TWEAK_WineLook >= WIN95_LOOK)
2638             NC_TrackCloseButton95 (hwnd, wParam);
2639         break;
2640
2641     case HTLEFT:
2642     case HTRIGHT:
2643     case HTTOP:
2644     case HTTOPLEFT:
2645     case HTTOPRIGHT:
2646     case HTBOTTOM:
2647     case HTBOTTOMLEFT:
2648     case HTBOTTOMRIGHT:
2649         /* make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU */
2650         SendMessage16( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - 2, lParam);
2651         break;
2652
2653     case HTBORDER:
2654         break;
2655     }
2656     return 0;
2657 }
2658
2659
2660 /***********************************************************************
2661  *           NC_HandleNCLButtonDblClk
2662  *
2663  * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
2664  */
2665 LONG NC_HandleNCLButtonDblClk( WND *pWnd, WPARAM16 wParam, LPARAM lParam )
2666 {
2667     /*
2668      * if this is an icon, send a restore since we are handling
2669      * a double click
2670      */
2671     if (pWnd->dwStyle & WS_MINIMIZE)
2672     {
2673         SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_RESTORE, lParam );
2674         return 0;
2675     }
2676
2677     switch(wParam)  /* Hit test */
2678     {
2679     case HTCAPTION:
2680         /* stop processing if WS_MAXIMIZEBOX is missing */
2681         if (pWnd->dwStyle & WS_MAXIMIZEBOX)
2682             SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND,
2683                       (pWnd->dwStyle & WS_MAXIMIZE) ? SC_RESTORE : SC_MAXIMIZE,
2684                       lParam );
2685         break;
2686
2687     case HTSYSMENU:
2688         if (!(GetClassWord(pWnd->hwndSelf, GCW_STYLE) & CS_NOCLOSE))
2689             SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_CLOSE, lParam );
2690         break;
2691
2692     case HTHSCROLL:
2693         SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL,
2694                        lParam );
2695         break;
2696
2697     case HTVSCROLL:
2698         SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL,
2699                        lParam );
2700         break;
2701     }
2702     return 0;
2703 }
2704
2705
2706 /***********************************************************************
2707  *           NC_HandleSysCommand
2708  *
2709  * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
2710  */
2711 LONG NC_HandleSysCommand( HWND hwnd, WPARAM16 wParam, POINT16 pt )
2712 {
2713     WND *wndPtr = WIN_FindWndPtr( hwnd );
2714     POINT pt32;
2715     UINT16 uCommand = wParam & 0xFFF0;
2716
2717     TRACE("Handling WM_SYSCOMMAND %x %d,%d\n", wParam, pt.x, pt.y );
2718
2719     if (wndPtr->dwStyle & WS_CHILD && uCommand != SC_KEYMENU )
2720         ScreenToClient16( wndPtr->parent->hwndSelf, &pt );
2721
2722     switch (uCommand)
2723     {
2724     case SC_SIZE:
2725     case SC_MOVE:
2726         NC_DoSizeMove( hwnd, wParam );
2727         break;
2728
2729     case SC_MINIMIZE:
2730         if (hwnd == GetForegroundWindow())
2731             ShowOwnedPopups(hwnd,FALSE);
2732         ShowWindow( hwnd, SW_MINIMIZE );
2733         break;
2734
2735     case SC_MAXIMIZE:
2736         if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
2737             ShowOwnedPopups(hwnd,TRUE);
2738         ShowWindow( hwnd, SW_MAXIMIZE );
2739         break;
2740
2741     case SC_RESTORE:
2742         if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
2743             ShowOwnedPopups(hwnd,TRUE);
2744         ShowWindow( hwnd, SW_RESTORE );
2745         break;
2746
2747     case SC_CLOSE:
2748         WIN_ReleaseWndPtr(wndPtr);
2749         return SendMessage16( hwnd, WM_CLOSE, 0, 0 );
2750
2751     case SC_VSCROLL:
2752     case SC_HSCROLL:
2753         CONV_POINT16TO32( &pt, &pt32 );
2754         NC_TrackScrollBar( hwnd, wParam, pt32 );
2755         break;
2756
2757     case SC_MOUSEMENU:
2758         CONV_POINT16TO32( &pt, &pt32 );
2759         MENU_TrackMouseMenuBar( wndPtr, wParam & 0x000F, pt32 );
2760         break;
2761
2762     case SC_KEYMENU:
2763         MENU_TrackKbdMenuBar( wndPtr , wParam , pt.x );
2764         break;
2765
2766     case SC_TASKLIST:
2767         WinExec( "taskman.exe", SW_SHOWNORMAL );
2768         break;
2769
2770     case SC_SCREENSAVE:
2771         if (wParam == SC_ABOUTWINE)
2772             ShellAboutA(hwnd,"Wine", WINE_RELEASE_INFO, 0);
2773         else
2774           if (wParam == SC_PUTMARK)
2775             TRACE_(shell)("Mark requested by user\n");
2776         break;
2777
2778     case SC_HOTKEY:
2779     case SC_ARRANGE:
2780     case SC_NEXTWINDOW:
2781     case SC_PREVWINDOW:
2782         FIXME("unimplemented!\n");
2783         break;
2784     }
2785     WIN_ReleaseWndPtr(wndPtr);
2786     return 0;
2787 }
2788
2789 /*************************************************************
2790 *  NC_DrawGrayButton
2791 *
2792 * Stub for the grayed button of the caption
2793 *
2794 *************************************************************/
2795
2796 BOOL NC_DrawGrayButton(HDC hdc, int x, int y)
2797 {
2798     HBITMAP hMaskBmp;
2799     HDC hdcMask = CreateCompatibleDC (0);
2800     HBRUSH hOldBrush;
2801
2802     hMaskBmp = CreateBitmap (12, 10, 1, 1, lpGrayMask);
2803
2804     if(hMaskBmp == 0)
2805         return FALSE;
2806
2807     SelectObject (hdcMask, hMaskBmp);
2808
2809     /* Draw the grayed bitmap using the mask */
2810     hOldBrush = SelectObject (hdc, RGB(128, 128, 128));
2811     BitBlt (hdc, x, y, 12, 10,
2812             hdcMask, 0, 0, 0xB8074A);
2813
2814     /* Clean up */
2815     SelectObject (hdc, hOldBrush);
2816     DeleteObject(hMaskBmp);
2817     DeleteDC (hdcMask);
2818
2819     return TRUE;
2820 }