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 "version.h"
   9 #include "win.h"
  10 #include "message.h"
  11 #include "sysmetrics.h"
  12 #include "user.h"
  13 #include "heap.h"
  14 #include "cursoricon.h"
  15 #include "dialog.h"
  16 #include "menu.h"
  17 #include "winpos.h"
  18 #include "hook.h"
  19 #include "scroll.h"
  20 #include "nonclient.h"
  21 #include "graphics.h"
  22 #include "queue.h"
  23 #include "selectors.h"
  24 #include "tweak.h"
  25 #include "debug.h"
  26 #include "options.h"
  27
  28
  29 int  NC_CaptionLeftNudge;
  30 int  NC_CaptionTopNudge;
  31 int  NC_SysControlNudge;
  32 int  NC_MaxControlNudge;
  33 int  NC_MinControlNudge;
  34 UINT32  NC_CaptionTextFlags;
  35 HBRUSH32  NC_WinHighlight95;
  36 HBRUSH32  NC_WinShadow95;
  37
  38 static HBITMAP16 hbitmapClose = 0;
  39 static HBITMAP16 hbitmapCloseD = 0;
  40 static HBITMAP16 hbitmapMinimize = 0;
  41 static HBITMAP16 hbitmapMinimizeD = 0;
  42 static HBITMAP16 hbitmapMaximize = 0;
  43 static HBITMAP16 hbitmapMaximizeD = 0;
  44 static HBITMAP16 hbitmapRestore = 0;
  45 static HBITMAP16 hbitmapRestoreD = 0;
  46
  47 #define SC_ABOUTWINE            (SC_SCREENSAVE+1)
  48
  49   /* Some useful macros */
  50 #define HAS_DLGFRAME(style,exStyle) \
  51     (((exStyle) & WS_EX_DLGMODALFRAME) || \
  52      (((style) & WS_DLGFRAME) && !((style) & WS_BORDER)))
  53
  54 #define HAS_THICKFRAME(style) \
  55     (((style) & WS_THICKFRAME) && \
  56      !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
  57
  58 #define HAS_FIXEDFRAME(style,exStyle) \
  59    (((((exStyle) & WS_EX_DLGMODALFRAME) || \
  60       ((style) & WS_DLGFRAME)) && ((style) & WS_BORDER)) && \
  61      !((style) & WS_THICKFRAME))
  62
  63 #define HAS_SIZEFRAME(style) \
  64     (((style) & WS_THICKFRAME) && \
  65      !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
  66
  67 #define HAS_MENU(w)  (!((w)->dwStyle & WS_CHILD) && ((w)->wIDmenu != 0))
  68
  69 #define ON_LEFT_BORDER(hit) \
  70  (((hit) == HTLEFT) || ((hit) == HTTOPLEFT) || ((hit) == HTBOTTOMLEFT))
  71 #define ON_RIGHT_BORDER(hit) \
  72  (((hit) == HTRIGHT) || ((hit) == HTTOPRIGHT) || ((hit) == HTBOTTOMRIGHT))
  73 #define ON_TOP_BORDER(hit) \
  74  (((hit) == HTTOP) || ((hit) == HTTOPLEFT) || ((hit) == HTTOPRIGHT))
  75 #define ON_BOTTOM_BORDER(hit) \
  76  (((hit) == HTBOTTOM) || ((hit) == HTBOTTOMLEFT) || ((hit) == HTBOTTOMRIGHT))
  77
  78 /***********************************************************************
  79  *           NC_AdjustRect
  80  *
  81  * Compute the size of the window rectangle from the size of the
  82  * client rectangle.
  83  */
  84 static void NC_AdjustRect( LPRECT16 rect, DWORD style, BOOL32 menu,
  85                            DWORD exStyle )
  86 {
  87     if(TWEAK_Win95Look)
  88         ERR(nonclient, "Called in Win95 mode. Aiee! Please report this.\n" );
  89
  90     if(style & WS_ICONIC) return;
  91     /* Decide if the window will be managed (see CreateWindowEx) */
  92     if (!(Options.managed && !(style & WS_CHILD) &&
  93           ((style & (WS_DLGFRAME | WS_THICKFRAME)) ||
  94            (exStyle & WS_EX_DLGMODALFRAME))))
  95     {
  96         if (HAS_DLGFRAME( style, exStyle ))
  97             InflateRect16(rect, SYSMETRICS_CXDLGFRAME, SYSMETRICS_CYDLGFRAME );
  98         else
  99         {
 100             if (HAS_THICKFRAME(style))
 101                 InflateRect16( rect, SYSMETRICS_CXFRAME, SYSMETRICS_CYFRAME );
 102             if (style & WS_BORDER)
 103                 InflateRect16( rect, SYSMETRICS_CXBORDER, SYSMETRICS_CYBORDER);
 104         }
 105
 106         if ((style & WS_CAPTION) == WS_CAPTION)
 107             rect->top -= SYSMETRICS_CYCAPTION - SYSMETRICS_CYBORDER;
 108     }
 109     if (menu) rect->top -= SYSMETRICS_CYMENU + SYSMETRICS_CYBORDER;
 110
 111     if (style & WS_VSCROLL) {
 112       rect->right  += SYSMETRICS_CXVSCROLL - 1;
 113       if(!(style & WS_BORDER))
 114          rect->right++;
 115     }
 116
 117     if (style & WS_HSCROLL) {
 118       rect->bottom += SYSMETRICS_CYHSCROLL - 1;
 119       if(!(style & WS_BORDER))
 120          rect->bottom++;
 121     }
 122 }
 123
 124
 125 /******************************************************************************
 126  * NC_AdjustRectOuter95
 127  *
 128  * Computes the size of the "outside" parts of the window based on the
 129  * parameters of the client area.
 130  *
 131  + PARAMS
 132  *     LPRECT16  rect
 133  *     DWORD  style
 134  *     BOOL32  menu
 135  *     DWORD  exStyle
 136  *
 137  * NOTES
 138  *     "Outer" parts of a window means the whole window frame, caption and
 139  *     menu bar. It does not include "inner" parts of the frame like client
 140  *     edge, static edge or scroll bars.
 141  *
 142  * Revision history
 143  *     05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
 144  *        Original (NC_AdjustRect95) cut & paste from NC_AdjustRect
 145  *
 146  *     20-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
 147  *        Split NC_AdjustRect95 into NC_AdjustRectOuter95 and
 148  *        NC_AdjustRectInner95 and added handling of Win95 styles.
 149  *
 150  *****************************************************************************/
 151
 152 static void
 153 NC_AdjustRectOuter95 (LPRECT16 rect, DWORD style, BOOL32 menu, DWORD exStyle)
 154 {
 155     if(style & WS_ICONIC) return;
 156
 157     /* Decide if the window will be managed (see CreateWindowEx) */
 158     if (!(Options.managed && !(style & WS_CHILD) &&
 159           ((style & (WS_DLGFRAME | WS_THICKFRAME)) ||
 160            (exStyle & WS_EX_DLGMODALFRAME))))
 161     {
 162         if (HAS_FIXEDFRAME( style, exStyle ))
 163             InflateRect16(rect, SYSMETRICS_CXDLGFRAME, SYSMETRICS_CYDLGFRAME );
 164         else
 165         {
 166             if (HAS_SIZEFRAME(style))
 167                 InflateRect16( rect, SYSMETRICS_CXFRAME, SYSMETRICS_CYFRAME );
 168 #if 0
 169             if (style & WS_BORDER)
 170                 InflateRect16( rect, SYSMETRICS_CXBORDER, SYSMETRICS_CYBORDER);
 171 #endif
 172         }
 173
 174         if ((style & WS_CAPTION) == WS_CAPTION)
 175             if (exStyle & WS_EX_TOOLWINDOW)
 176                 rect->top -= SYSMETRICS_CYSMCAPTION;
 177             else
 178                 rect->top -= SYSMETRICS_CYCAPTION;
 179 //            rect->top -= sysMetrics[SM_CYCAPTION];
 180     }
 181
 182     if (menu)
 183         rect->top -= sysMetrics[SM_CYMENU];
 184 }
 185
 186
 187 /******************************************************************************
 188  * NC_AdjustRectInner95
 189  *
 190  * Computes the size of the "inside" part of the window based on the
 191  * parameters of the client area.
 192  *
 193  + PARAMS
 194  *     LPRECT16 rect
 195  *     DWORD    style
 196  *     DWORD    exStyle
 197  *
 198  * NOTES
 199  *     "Inner" part of a window means the window frame inside of the flat
 200  *     window frame. It includes the client edge, the static edge and the
 201  *     scroll bars.
 202  *
 203  * Revision history
 204  *     05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
 205  *        Original (NC_AdjustRect95) cut & paste from NC_AdjustRect
 206  *
 207  *     20-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
 208  *        Split NC_AdjustRect95 into NC_AdjustRectOuter95 and
 209  *        NC_AdjustRectInner95 and added handling of Win95 styles.
 210  *
 211  *****************************************************************************/
 212
 213 static void
 214 NC_AdjustRectInner95 (LPRECT16 rect, DWORD style, DWORD exStyle)
 215 {
 216     if(style & WS_ICONIC) return;
 217
 218     if (exStyle & WS_EX_CLIENTEDGE)
 219         InflateRect16 (rect, sysMetrics[SM_CXEDGE], sysMetrics[SM_CYEDGE]);
 220
 221     if (exStyle & WS_EX_STATICEDGE)
 222         InflateRect16 (rect, sysMetrics[SM_CXBORDER], sysMetrics[SM_CYBORDER]);
 223
 224     if (style & WS_VSCROLL) rect->right  += SYSMETRICS_CXVSCROLL;
 225     if (style & WS_HSCROLL) rect->bottom += SYSMETRICS_CYHSCROLL;
 226 }
 227
 228
 229 /***********************************************************************
 230  *           DrawCaptionTempA    (USER32.599)
 231  */
 232 DWORD WINAPI DrawCaptionTemp32A(HWND32 hwnd,HDC32 hdc,LPRECT32 rect,
 233     HFONT32 hfont,DWORD x1,LPCSTR str,DWORD x2)
 234 {
 235     FIXME(nonclient,"(%08x,%08x,%p,%08x,%08lx,\"%s\",%08lx): stub\n",
 236         hwnd,hdc,rect,hfont,x1,str,x2);
 237     return 0;
 238 }
 239
 240
 241 /***********************************************************************
 242  *           AdjustWindowRect16    (USER.102)
 243  */
 244 BOOL16 WINAPI AdjustWindowRect16( LPRECT16 rect, DWORD style, BOOL16 menu )
 245 {
 246     return AdjustWindowRectEx16( rect, style, menu, 0 );
 247 }
 248
 249
 250 /***********************************************************************
 251  *           AdjustWindowRect32    (USER32.2)
 252  */
 253 BOOL32 WINAPI AdjustWindowRect32( LPRECT32 rect, DWORD style, BOOL32 menu )
 254 {
 255     return AdjustWindowRectEx32( rect, style, menu, 0 );
 256 }
 257
 258
 259 /***********************************************************************
 260  *           AdjustWindowRectEx16    (USER.454)
 261  */
 262 BOOL16 WINAPI AdjustWindowRectEx16( LPRECT16 rect, DWORD style,
 263                                     BOOL16 menu, DWORD exStyle )
 264 {
 265       /* Correct the window style */
 266
 267     if (!(style & (WS_POPUP | WS_CHILD)))  /* Overlapped window */
 268         style |= WS_CAPTION;
 269     style &= (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME | WS_CHILD);
 270     exStyle &= (WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE |
 271                 WS_EX_STATICEDGE | WS_EX_TOOLWINDOW);
 272     if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
 273
 274     TRACE(nonclient, "(%d,%d)-(%d,%d) %08lx %d %08lx\n",
 275                       rect->left, rect->top, rect->right, rect->bottom,
 276                       style, menu, exStyle );
 277
 278     if(TWEAK_Win95Look) {
 279         NC_AdjustRectOuter95( rect, style, menu, exStyle );
 280         NC_AdjustRectInner95( rect, style, exStyle );
 281     }
 282     else
 283         NC_AdjustRect( rect, style, menu, exStyle );
 284
 285     return TRUE;
 286 }
 287
 288
 289 /***********************************************************************
 290  *           AdjustWindowRectEx32    (USER32.3)
 291  */
 292 BOOL32 WINAPI AdjustWindowRectEx32( LPRECT32 rect, DWORD style,
 293                                     BOOL32 menu, DWORD exStyle )
 294 {
 295     RECT16 rect16;
 296     BOOL32 ret;
 297
 298     CONV_RECT32TO16( rect, &rect16 );
 299     ret = AdjustWindowRectEx16( &rect16, style, (BOOL16)menu, exStyle );
 300     CONV_RECT16TO32( &rect16, rect );
 301     return ret;
 302 }
 303
 304
 305 /***********************************************************************
 306  *           NC_HandleNCCalcSize
 307  *
 308  * Handle a WM_NCCALCSIZE message. Called from DefWindowProc().
 309  */
 310 LONG NC_HandleNCCalcSize( WND *pWnd, RECT32 *winRect )
 311 {
 312     RECT16 tmpRect = { 0, 0, 0, 0 };
 313     LONG result = 0;
 314
 315     if (pWnd->class->style & CS_VREDRAW) result |= WVR_VREDRAW;
 316     if (pWnd->class->style & CS_HREDRAW) result |= WVR_HREDRAW;
 317
 318     if( !( pWnd->dwStyle & WS_MINIMIZE ) ) {
 319         if(TWEAK_Win95Look)
 320             NC_AdjustRectOuter95( &tmpRect, pWnd->dwStyle, FALSE, pWnd->dwExStyle );
 321         else
 322             NC_AdjustRect( &tmpRect, pWnd->dwStyle, FALSE, pWnd->dwExStyle );
 323
 324         winRect->left   -= tmpRect.left;
 325         winRect->top    -= tmpRect.top;
 326         winRect->right  -= tmpRect.right;
 327         winRect->bottom -= tmpRect.bottom;
 328
 329         if (HAS_MENU(pWnd)) {
 330             TRACE(nonclient, "Calling "
 331                                "GetMenuBarHeight with HWND 0x%x, width %d, "
 332                                "at (%d, %d).\n", pWnd->hwndSelf,
 333                                winRect->right - winRect->left,
 334                                -tmpRect.left, -tmpRect.top );
 335
 336             winRect->top +=
 337                 MENU_GetMenuBarHeight( pWnd->hwndSelf,
 338                                        winRect->right - winRect->left,
 339                                        -tmpRect.left, -tmpRect.top ) + 1;
 340         }
 341
 342         if (TWEAK_Win95Look) {
 343             SetRect16 (&tmpRect, 0, 0, 0, 0);
 344             NC_AdjustRectInner95 (&tmpRect, pWnd->dwStyle, pWnd->dwExStyle);
 345             winRect->left   -= tmpRect.left;
 346             winRect->top    -= tmpRect.top;
 347             winRect->right  -= tmpRect.right;
 348             winRect->bottom -= tmpRect.bottom;
 349         }
 350     }
 351     return result;
 352 }
 353
 354
 355 /***********************************************************************
 356  *           NC_GetInsideRect
 357  *
 358  * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
 359  * but without the borders (if any).
 360  * The rectangle is in window coordinates (for drawing with GetWindowDC()).
 361  */
 362 static void NC_GetInsideRect( HWND32 hwnd, RECT32 *rect )
 363 {
 364     WND * wndPtr = WIN_FindWndPtr( hwnd );
 365
 366     rect->top    = rect->left = 0;
 367     rect->right  = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
 368     rect->bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
 369
 370     if ((wndPtr->dwStyle & WS_ICONIC) || (wndPtr->flags & WIN_MANAGED)) return;
 371
 372       /* Remove frame from rectangle */
 373     if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
 374     {
 375         InflateRect32( rect, -SYSMETRICS_CXDLGFRAME, -SYSMETRICS_CYDLGFRAME);
 376         if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME)
 377             InflateRect32( rect, -1, 0 );
 378     }
 379     else
 380     {
 381         if (HAS_THICKFRAME( wndPtr->dwStyle ))
 382             InflateRect32( rect, -SYSMETRICS_CXFRAME, -SYSMETRICS_CYFRAME );
 383         if (wndPtr->dwStyle & WS_BORDER)
 384             InflateRect32( rect, -SYSMETRICS_CXBORDER, -SYSMETRICS_CYBORDER );
 385     }
 386
 387     return;
 388 }
 389
 390
 391 /***********************************************************************
 392  *           NC_GetInsideRect95
 393  *
 394  * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
 395  * but without the borders (if any).
 396  * The rectangle is in window coordinates (for drawing with GetWindowDC()).
 397  */
 398
 399 static void
 400 NC_GetInsideRect95 (HWND32 hwnd, RECT32 *rect)
 401 {
 402     WND * wndPtr = WIN_FindWndPtr( hwnd );
 403
 404     rect->top    = rect->left = 0;
 405     rect->right  = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
 406     rect->bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
 407
 408     if ((wndPtr->dwStyle & WS_ICONIC) || (wndPtr->flags & WIN_MANAGED)) return;
 409
 410       /* Remove frame from rectangle */
 411     if (HAS_FIXEDFRAME (wndPtr->dwStyle, wndPtr->dwExStyle ))
 412     {
 413         InflateRect32( rect, -SYSMETRICS_CXFIXEDFRAME, -SYSMETRICS_CYFIXEDFRAME);
 414     }
 415     else if (HAS_SIZEFRAME (wndPtr->dwStyle))
 416     {
 417         InflateRect32( rect, -SYSMETRICS_CXSIZEFRAME, -SYSMETRICS_CYSIZEFRAME );
 418
 419 /*      if (wndPtr->dwStyle & WS_BORDER)
 420           InflateRect32( rect, -SYSMETRICS_CXBORDER, -SYSMETRICS_CYBORDER );*/
 421     }
 422
 423     if (wndPtr->dwStyle & WS_CHILD) {
 424         if (wndPtr->dwExStyle & WS_EX_CLIENTEDGE)
 425             InflateRect32 (rect, -SYSMETRICS_CXEDGE, -SYSMETRICS_CYEDGE);
 426
 427         if (wndPtr->dwExStyle & WS_EX_STATICEDGE)
 428             InflateRect32 (rect, -SYSMETRICS_CXBORDER, -SYSMETRICS_CYBORDER);
 429     }
 430
 431     return;
 432 }
 433
 434
 435 /***********************************************************************
 436  * NC_DoNCHitTest
 437  *
 438  * Handle a WM_NCHITTEST message. Called from NC_HandleNcHitTest().
 439  */
 440
 441 LONG NC_DoNCHitTest (WND *wndPtr, POINT16 pt )
 442 {
 443     RECT16 rect;
 444
 445     TRACE(nonclient, "hwnd=%04x pt=%d,%d\n",
 446                       wndPtr->hwndSelf, pt.x, pt.y );
 447
 448     GetWindowRect16 (wndPtr->hwndSelf, &rect );
 449     if (!PtInRect16( &rect, pt )) return HTNOWHERE;
 450
 451     if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
 452
 453     if (!(wndPtr->flags & WIN_MANAGED))
 454     {
 455         /* Check borders */
 456         if (HAS_THICKFRAME( wndPtr->dwStyle ))
 457         {
 458             InflateRect16( &rect, -SYSMETRICS_CXFRAME, -SYSMETRICS_CYFRAME );
 459             if (wndPtr->dwStyle & WS_BORDER)
 460                 InflateRect16(&rect,-SYSMETRICS_CXBORDER,-SYSMETRICS_CYBORDER);
 461             if (!PtInRect16( &rect, pt ))
 462             {
 463                 /* Check top sizing border */
 464                 if (pt.y < rect.top)
 465                 {
 466                     if (pt.x < rect.left+SYSMETRICS_CXSIZE) return HTTOPLEFT;
 467                     if (pt.x >= rect.right-SYSMETRICS_CXSIZE) return HTTOPRIGHT;
 468                     return HTTOP;
 469                 }
 470                 /* Check bottom sizing border */
 471                 if (pt.y >= rect.bottom)
 472                 {
 473                     if (pt.x < rect.left+SYSMETRICS_CXSIZE) return HTBOTTOMLEFT;
 474                     if (pt.x >= rect.right-SYSMETRICS_CXSIZE) return HTBOTTOMRIGHT;
 475                     return HTBOTTOM;
 476                 }
 477                 /* Check left sizing border */
 478                 if (pt.x < rect.left)
 479                 {
 480                     if (pt.y < rect.top+SYSMETRICS_CYSIZE) return HTTOPLEFT;
 481                     if (pt.y >= rect.bottom-SYSMETRICS_CYSIZE) return HTBOTTOMLEFT;
 482                     return HTLEFT;
 483                 }
 484                 /* Check right sizing border */
 485                 if (pt.x >= rect.right)
 486                 {
 487                     if (pt.y < rect.top+SYSMETRICS_CYSIZE) return HTTOPRIGHT;
 488                     if (pt.y >= rect.bottom-SYSMETRICS_CYSIZE) return HTBOTTOMRIGHT;
 489                     return HTRIGHT;
 490                 }
 491             }
 492         }
 493         else  /* No thick frame */
 494         {
 495             if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
 496                 InflateRect16(&rect, -SYSMETRICS_CXDLGFRAME, -SYSMETRICS_CYDLGFRAME);
 497             else if (wndPtr->dwStyle & WS_BORDER)
 498                 InflateRect16(&rect, -SYSMETRICS_CXBORDER, -SYSMETRICS_CYBORDER);
 499             if (!PtInRect16( &rect, pt )) return HTBORDER;
 500         }
 501
 502         /* Check caption */
 503
 504         if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
 505         {
 506             rect.top += sysMetrics[SM_CYCAPTION] - 1;
 507             if (!PtInRect16( &rect, pt ))
 508             {
 509                 /* Check system menu */
 510                 if (wndPtr->dwStyle & WS_SYSMENU)
 511                     rect.left += SYSMETRICS_CXSIZE;
 512                 if (pt.x <= rect.left) return HTSYSMENU;
 513                 /* Check maximize box */
 514                 if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
 515                     rect.right -= SYSMETRICS_CXSIZE + 1;
 516                 if (pt.x >= rect.right) return HTMAXBUTTON;
 517                 /* Check minimize box */
 518                 if (wndPtr->dwStyle & WS_MINIMIZEBOX)
 519                     rect.right -= SYSMETRICS_CXSIZE + 1;
 520                 if (pt.x >= rect.right) return HTMINBUTTON;
 521                 return HTCAPTION;
 522             }
 523         }
 524     }
 525
 526       /* Check client area */
 527
 528     ScreenToClient16( wndPtr->hwndSelf, &pt );
 529     GetClientRect16( wndPtr->hwndSelf, &rect );
 530     if (PtInRect16( &rect, pt )) return HTCLIENT;
 531
 532       /* Check vertical scroll bar */
 533
 534     if (wndPtr->dwStyle & WS_VSCROLL)
 535     {
 536         rect.right += SYSMETRICS_CXVSCROLL;
 537         if (PtInRect16( &rect, pt )) return HTVSCROLL;
 538     }
 539
 540       /* Check horizontal scroll bar */
 541
 542     if (wndPtr->dwStyle & WS_HSCROLL)
 543     {
 544         rect.bottom += SYSMETRICS_CYHSCROLL;
 545         if (PtInRect16( &rect, pt ))
 546         {
 547               /* Check size box */
 548             if ((wndPtr->dwStyle & WS_VSCROLL) &&
 549                 (pt.x >= rect.right - SYSMETRICS_CXVSCROLL))
 550                 return HTSIZE;
 551             return HTHSCROLL;
 552         }
 553     }
 554
 555       /* Check menu bar */
 556
 557     if (HAS_MENU(wndPtr))
 558     {
 559         if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
 560             return HTMENU;
 561     }
 562
 563       /* Should never get here */
 564     return HTERROR;
 565 }
 566
 567
 568 /***********************************************************************
 569  * NC_DoNCHitTest95
 570  *
 571  * Handle a WM_NCHITTEST message. Called from NC_HandleNCHitTest().
 572  *
 573  * FIXME:  Just a copy of the Win 3.1 version.
 574  */
 575
 576 LONG
 577 NC_DoNCHitTest95 (WND *wndPtr, POINT16 pt )
 578 {
 579     RECT16 rect;
 580
 581     TRACE(nonclient, "hwnd=%04x pt=%d,%d\n",
 582                       wndPtr->hwndSelf, pt.x, pt.y );
 583
 584     GetWindowRect16 (wndPtr->hwndSelf, &rect );
 585     if (!PtInRect16( &rect, pt )) return HTNOWHERE;
 586
 587     if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
 588
 589     if (!(wndPtr->flags & WIN_MANAGED))
 590     {
 591         /* Check borders */
 592         if (HAS_SIZEFRAME( wndPtr->dwStyle ))
 593         {
 594             InflateRect16( &rect, -SYSMETRICS_CXFRAME, -SYSMETRICS_CYFRAME );
 595 //            if (wndPtr->dwStyle & WS_BORDER)
 596 //                InflateRect16(&rect,-SYSMETRICS_CXBORDER,-SYSMETRICS_CYBORDER);
 597             if (!PtInRect16( &rect, pt ))
 598             {
 599                 /* Check top sizing border */
 600                 if (pt.y < rect.top)
 601                 {
 602                     if (pt.x < rect.left+SYSMETRICS_CXSIZE) return HTTOPLEFT;
 603                     if (pt.x >= rect.right-SYSMETRICS_CXSIZE) return HTTOPRIGHT;
 604                     return HTTOP;
 605                 }
 606                 /* Check bottom sizing border */
 607                 if (pt.y >= rect.bottom)
 608                 {
 609                     if (pt.x < rect.left+SYSMETRICS_CXSIZE) return HTBOTTOMLEFT;
 610                     if (pt.x >= rect.right-SYSMETRICS_CXSIZE) return HTBOTTOMRIGHT;
 611                     return HTBOTTOM;
 612                 }
 613                 /* Check left sizing border */
 614                 if (pt.x < rect.left)
 615                 {
 616                     if (pt.y < rect.top+SYSMETRICS_CYSIZE) return HTTOPLEFT;
 617                     if (pt.y >= rect.bottom-SYSMETRICS_CYSIZE) return HTBOTTOMLEFT;
 618                     return HTLEFT;
 619                 }
 620                 /* Check right sizing border */
 621                 if (pt.x >= rect.right)
 622                 {
 623                     if (pt.y < rect.top+SYSMETRICS_CYSIZE) return HTTOPRIGHT;
 624                     if (pt.y >= rect.bottom-SYSMETRICS_CYSIZE) return HTBOTTOMRIGHT;
 625                     return HTRIGHT;
 626                 }
 627             }
 628         }
 629         else  /* No thick frame */
 630         {
 631             if (HAS_FIXEDFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
 632                 InflateRect16(&rect, -SYSMETRICS_CXDLGFRAME, -SYSMETRICS_CYDLGFRAME);
 633 //            else if (wndPtr->dwStyle & WS_BORDER)
 634 //                InflateRect16(&rect, -SYSMETRICS_CXBORDER, -SYSMETRICS_CYBORDER);
 635             if (!PtInRect16( &rect, pt )) return HTBORDER;
 636         }
 637
 638         /* Check caption */
 639
 640         if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
 641         {
 642             if (wndPtr->dwExStyle & WS_EX_TOOLWINDOW)
 643                 rect.top += sysMetrics[SM_CYSMCAPTION] - 1;
 644             else
 645                 rect.top += sysMetrics[SM_CYCAPTION] - 1;
 646             if (!PtInRect16( &rect, pt ))
 647             {
 648                 /* Check system menu */
 649                 if ((wndPtr->dwStyle & WS_SYSMENU) &&
 650                     ((wndPtr->class->hIconSm) || (wndPtr->class->hIcon)))
 651                     rect.left += sysMetrics[SM_CYCAPTION] - 1;
 652                 if (pt.x < rect.left) return HTSYSMENU;
 653
 654                 /* Check close button */
 655                 if (wndPtr->dwStyle & WS_SYSMENU)
 656                     rect.right -= sysMetrics[SM_CYCAPTION] - 1;
 657                 if (pt.x > rect.right) return HTCLOSE;
 658
 659                 /* Check maximize box */
 660                 if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
 661                     rect.right -= SYSMETRICS_CXSIZE + 1;
 662                 if (pt.x > rect.right) return HTMAXBUTTON;
 663
 664                 /* Check minimize box */
 665                 if (wndPtr->dwStyle & WS_MINIMIZEBOX)
 666                     rect.right -= SYSMETRICS_CXSIZE + 1;
 667                 if (pt.x > rect.right) return HTMINBUTTON;
 668                 return HTCAPTION;
 669             }
 670         }
 671     }
 672
 673       /* Check client area */
 674
 675     ScreenToClient16( wndPtr->hwndSelf, &pt );
 676     GetClientRect16( wndPtr->hwndSelf, &rect );
 677     if (PtInRect16( &rect, pt )) return HTCLIENT;
 678
 679       /* Check vertical scroll bar */
 680
 681     if (wndPtr->dwStyle & WS_VSCROLL)
 682     {
 683         rect.right += SYSMETRICS_CXVSCROLL;
 684         if (PtInRect16( &rect, pt )) return HTVSCROLL;
 685     }
 686
 687       /* Check horizontal scroll bar */
 688
 689     if (wndPtr->dwStyle & WS_HSCROLL)
 690     {
 691         rect.bottom += SYSMETRICS_CYHSCROLL;
 692         if (PtInRect16( &rect, pt ))
 693         {
 694               /* Check size box */
 695             if ((wndPtr->dwStyle & WS_VSCROLL) &&
 696                 (pt.x >= rect.right - SYSMETRICS_CXVSCROLL))
 697                 return HTSIZE;
 698             return HTHSCROLL;
 699         }
 700     }
 701
 702       /* Check menu bar */
 703
 704     if (HAS_MENU(wndPtr))
 705     {
 706         if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
 707             return HTMENU;
 708     }
 709
 710       /* Should never get here */
 711     return HTERROR;
 712 }
 713
 714
 715 /***********************************************************************
 716  * NC_HandleNCHitTest
 717  *
 718  * Handle a WM_NCHITTEST message. Called from DefWindowProc().
 719  */
 720 LONG
 721 NC_HandleNCHitTest( HWND32 hwnd , POINT16 pt)
 722 {
 723     WND* wndPtr = WIN_FindWndPtr( hwnd );
 724
 725     if (!wndPtr)
 726         return HTERROR;
 727
 728     if(TWEAK_Win95Look)
 729         return NC_DoNCHitTest95 (wndPtr, pt);
 730     else
 731         return NC_DoNCHitTest (wndPtr, pt);
 732 }
 733
 734
 735 /***********************************************************************
 736  *           NC_DrawSysButton
 737  */
 738 void NC_DrawSysButton( HWND32 hwnd, HDC32 hdc, BOOL32 down )
 739 {
 740     RECT32 rect;
 741     HDC32 hdcMem;
 742     HBITMAP32 hbitmap;
 743     WND *wndPtr = WIN_FindWndPtr( hwnd );
 744
 745     if( !(wndPtr->flags & WIN_MANAGED) )
 746     {
 747       NC_GetInsideRect( hwnd, &rect );
 748       hdcMem = CreateCompatibleDC32( hdc );
 749       hbitmap = SelectObject32( hdcMem, hbitmapClose );
 750       BitBlt32(hdc, rect.left, rect.top, SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE,
 751                hdcMem, (wndPtr->dwStyle & WS_CHILD) ? SYSMETRICS_CXSIZE : 0, 0,
 752                down ? NOTSRCCOPY : SRCCOPY );
 753       SelectObject32( hdcMem, hbitmap );
 754       DeleteDC32( hdcMem );
 755     }
 756 }
 757
 758
 759 /***********************************************************************
 760  *           NC_DrawMaxButton
 761  */
 762 static void NC_DrawMaxButton( HWND32 hwnd, HDC16 hdc, BOOL32 down )
 763 {
 764     RECT32 rect;
 765     WND *wndPtr = WIN_FindWndPtr( hwnd );
 766
 767     if( !(wndPtr->flags & WIN_MANAGED) )
 768     {
 769       NC_GetInsideRect( hwnd, &rect );
 770       GRAPH_DrawBitmap( hdc, (IsZoomed32(hwnd)
 771                              ? (down ? hbitmapRestoreD : hbitmapRestore)
 772                              : (down ? hbitmapMaximizeD : hbitmapMaximize)),
 773                         rect.right - SYSMETRICS_CXSIZE - 1, rect.top,
 774                         0, 0, SYSMETRICS_CXSIZE+1, SYSMETRICS_CYSIZE, FALSE );
 775     }
 776 }
 777
 778
 779 /***********************************************************************
 780  *           NC_DrawMinButton
 781  */
 782 static void NC_DrawMinButton( HWND32 hwnd, HDC16 hdc, BOOL32 down )
 783 {
 784     RECT32 rect;
 785     WND *wndPtr = WIN_FindWndPtr( hwnd );
 786
 787     if( !(wndPtr->flags & WIN_MANAGED) )
 788     {
 789       NC_GetInsideRect( hwnd, &rect );
 790       if (wndPtr->dwStyle & WS_MAXIMIZEBOX) rect.right -= SYSMETRICS_CXSIZE+1;
 791       GRAPH_DrawBitmap( hdc, (down ? hbitmapMinimizeD : hbitmapMinimize),
 792                         rect.right - SYSMETRICS_CXSIZE - 1, rect.top,
 793                         0, 0, SYSMETRICS_CXSIZE+1, SYSMETRICS_CYSIZE, FALSE );
 794     }
 795 }
 796
 797
 798 /******************************************************************************
 799  *
 800  *   void  NC_DrawSysButton95(
 801  *      HWND32  hwnd,
 802  *      HDC32  hdc,
 803  *      BOOL32  down )
 804  *
 805  *   Draws the Win95 system icon.
 806  *
 807  *   Revision history
 808  *        05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
 809  *             Original implementation from NC_DrawSysButton source.
 810  *        11-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
 811  *             Fixed most bugs.
 812  *
 813  *****************************************************************************/
 814
 815 BOOL32
 816 NC_DrawSysButton95 (HWND32 hwnd, HDC32 hdc, BOOL32 down)
 817 {
 818     WND *wndPtr = WIN_FindWndPtr( hwnd );
 819
 820     if( !(wndPtr->flags & WIN_MANAGED) )
 821     {
 822         HICON32  hIcon = 0;
 823         RECT32 rect;
 824
 825         NC_GetInsideRect95( hwnd, &rect );
 826
 827         if (wndPtr->class->hIconSm)
 828             hIcon = wndPtr->class->hIconSm;
 829         else if (wndPtr->class->hIcon)
 830             hIcon = wndPtr->class->hIcon;
 831
 832         if (hIcon)
 833             DrawIconEx32 (hdc, rect.left + 2, rect.top + 1, hIcon,
 834                           sysMetrics[SM_CYCAPTION] - 3,
 835                           sysMetrics[SM_CYCAPTION] - 3, 0, 0, DI_NORMAL);
 836         return (hIcon != 0);
 837     }
 838     return FALSE;
 839 }
 840
 841
 842 /******************************************************************************
 843  *
 844  *   void  NC_DrawCloseButton95(
 845  *      HWND32  hwnd,
 846  *      HDC32  hdc,
 847  *      BOOL32  down )
 848  *
 849  *   Draws the Win95 close button.
 850  *
 851  *   Revision history
 852  *        11-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
 853  *             Original implementation from NC_DrawSysButton95 source.
 854  *
 855  *****************************************************************************/
 856
 857 void
 858 NC_DrawCloseButton95 (HWND32 hwnd, HDC32 hdc, BOOL32 down)
 859 {
 860     RECT32 rect;
 861     HDC32 hdcMem;
 862     WND *wndPtr = WIN_FindWndPtr( hwnd );
 863
 864     if( !(wndPtr->flags & WIN_MANAGED) )
 865     {
 866         BITMAP32 bmp;
 867         HBITMAP32 hBmp, hOldBmp;
 868
 869         NC_GetInsideRect95( hwnd, &rect );
 870
 871         hdcMem = CreateCompatibleDC32( hdc );
 872         hBmp = /*down ? hbitmapCloseD :*/ hbitmapClose;
 873         hOldBmp = SelectObject32 (hdcMem, hBmp);
 874         GetObject32A (hBmp, sizeof(BITMAP32), &bmp);
 875         BitBlt32 (hdc, rect.right - (sysMetrics[SM_CYCAPTION] + 1 + bmp.bmWidth) / 2,
 876                   rect.top + (sysMetrics[SM_CYCAPTION] - 1 - bmp.bmHeight) / 2,
 877                   bmp.bmWidth, bmp.bmHeight, hdcMem, 0, 0, down ? NOTSRCCOPY : SRCCOPY);
 878
 879         SelectObject32 (hdcMem, hOldBmp);
 880         DeleteDC32 (hdcMem);
 881     }
 882 }
 883
 884
 885 /******************************************************************************
 886  *
 887  *   NC_DrawMaxButton95(
 888  *      HWND32  hwnd,
 889  *      HDC16  hdc,
 890  *      BOOL32  down )
 891  *
 892  *   Draws the maximize button for Win95 style windows.
 893  *
 894  *   Bugs
 895  *        Many.  Spacing might still be incorrect.  Need to fit a close
 896  *        button between the max button and the edge.
 897  *        Should scale the image with the title bar.  And more...
 898  *
 899  *   Revision history
 900  *        05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
 901  *             Original implementation.
 902  *
 903  *****************************************************************************/
 904
 905 static void  NC_DrawMaxButton95(
 906     HWND32 hwnd,
 907     HDC16 hdc,
 908     BOOL32 down )
 909 {
 910     RECT32 rect;
 911     WND *wndPtr = WIN_FindWndPtr( hwnd );
 912     SIZE32  bmsz;
 913     HBITMAP32  bm;
 914
 915     if( !(wndPtr->flags & WIN_MANAGED) &&
 916         GetBitmapDimensionEx32((bm = IsZoomed32(hwnd) ?
 917                                 (down ? hbitmapRestoreD : hbitmapRestore ) :
 918                                 (down ? hbitmapMaximizeD : hbitmapMaximize)),
 919                                &bmsz)) {
 920
 921         NC_GetInsideRect95( hwnd, &rect );
 922
 923         if (wndPtr->dwStyle & WS_SYSMENU)
 924             rect.right -= sysMetrics[SM_CYCAPTION] + 1;
 925
 926         GRAPH_DrawBitmap( hdc, bm, rect.right + NC_MinControlNudge -
 927                           (sysMetrics[SM_CXSIZE] + bmsz.cx) / 2,
 928                           rect.top + (sysMetrics[SM_CYCAPTION] - 1 - bmsz.cy) / 2,
 929                           0, 0, bmsz.cx, bmsz.cy, FALSE );
 930     }
 931
 932     return;
 933 }
 934
 935
 936 /******************************************************************************
 937  *
 938  *   NC_DrawMinButton95(
 939  *      HWND32  hwnd,
 940  *      HDC16  hdc,
 941  *      BOOL32  down )
 942  *
 943  *   Draws the minimize button for Win95 style windows.
 944  *
 945  *   Bugs
 946  *        Many.  Spacing is still incorrect.  Should scale the image with the
 947  *        title bar.  And more...
 948  *
 949  *   Revision history
 950  *        05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
 951  *             Original implementation.
 952  *
 953  *****************************************************************************/
 954
 955 static void  NC_DrawMinButton95(
 956     HWND32 hwnd,
 957     HDC16 hdc,
 958     BOOL32 down )
 959 {
 960     RECT32 rect;
 961     WND *wndPtr = WIN_FindWndPtr( hwnd );
 962     SIZE32  bmsz;
 963     HBITMAP32  bm;
 964
 965     if( !(wndPtr->flags & WIN_MANAGED) &&
 966         GetBitmapDimensionEx32((bm = down ? hbitmapMinimizeD :
 967                                 hbitmapMinimize), &bmsz)) {
 968
 969         NC_GetInsideRect95( hwnd, &rect );
 970
 971         if (wndPtr->dwStyle & WS_SYSMENU)
 972             rect.right -= sysMetrics[SM_CYCAPTION] + 1;
 973
 974         if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
 975             rect.right += -1 + NC_MaxControlNudge -
 976                 (sysMetrics[SM_CXSIZE] + bmsz.cx) / 2;
 977
 978         GRAPH_DrawBitmap( hdc, bm, rect.right + NC_MinControlNudge -
 979                           (sysMetrics[SM_CXSIZE] + bmsz.cx) / 2,
 980                           rect.top + (sysMetrics[SM_CYCAPTION] - 1 - bmsz.cy) / 2,
 981                           0, 0, bmsz.cx, bmsz.cy, FALSE );
 982     }
 983
 984     return;
 985 }
 986
 987
 988 /***********************************************************************
 989  *           NC_DrawFrame
 990  *
 991  * Draw a window frame inside the given rectangle, and update the rectangle.
 992  * The correct pen for the frame must be selected in the DC.
 993  */
 994 static void NC_DrawFrame( HDC32 hdc, RECT32 *rect, BOOL32 dlgFrame,
 995                           BOOL32 active )
 996 {
 997     INT32 width, height;
 998
 999     if(TWEAK_Win95Look)
1000         ERR(nonclient, "Called in Win95 mode. Aiee! Please report this.\n" );
1001
1002     if (dlgFrame)
1003     {
1004         width = SYSMETRICS_CXDLGFRAME - 1;
1005         height = SYSMETRICS_CYDLGFRAME - 1;
1006         SelectObject32( hdc, GetSysColorBrush32(active ? COLOR_ACTIVECAPTION :
1007                                                 COLOR_INACTIVECAPTION) );
1008     }
1009     else
1010     {
1011         width = SYSMETRICS_CXFRAME - 1;
1012         height = SYSMETRICS_CYFRAME - 1;
1013         SelectObject32( hdc, GetSysColorBrush32(active ? COLOR_ACTIVEBORDER :
1014                                                 COLOR_INACTIVEBORDER) );
1015     }
1016
1017       /* Draw frame */
1018     PatBlt32( hdc, rect->left, rect->top,
1019               rect->right - rect->left, height, PATCOPY );
1020     PatBlt32( hdc, rect->left, rect->top,
1021               width, rect->bottom - rect->top, PATCOPY );
1022     PatBlt32( hdc, rect->left, rect->bottom,
1023               rect->right - rect->left, -height, PATCOPY );
1024     PatBlt32( hdc, rect->right, rect->top,
1025               -width, rect->bottom - rect->top, PATCOPY );
1026
1027     if (dlgFrame)
1028     {
1029         InflateRect32( rect, -width, -height );
1030     }
1031     else
1032     {
1033         POINT32 lpt[16];
1034
1035       /* Draw inner rectangle */
1036
1037         GRAPH_DrawRectangle( hdc, rect->left + width,
1038                                   rect->top + height,
1039                                   rect->right - rect->left - 2*width ,
1040                                   rect->bottom - rect->top - 2*height,
1041                                   (HPEN32)0 );
1042
1043       /* Draw the decorations */
1044
1045         lpt[4].x = lpt[0].x = rect->left;
1046         lpt[5].x = lpt[1].x = rect->left + width;
1047         lpt[6].x = lpt[2].x = rect->right - 1;
1048         lpt[7].x = lpt[3].x = rect->right - width - 1;
1049
1050         lpt[0].y = lpt[1].y = lpt[2].y = lpt[3].y =
1051                   rect->top + SYSMETRICS_CYFRAME + SYSMETRICS_CYSIZE;
1052         lpt[4].y = lpt[5].y = lpt[6].y = lpt[7].y =
1053                   rect->bottom - SYSMETRICS_CYFRAME - SYSMETRICS_CYSIZE;
1054
1055         lpt[8].x = lpt[9].x = lpt[10].x = lpt[11].x =
1056                   rect->left + SYSMETRICS_CXFRAME + SYSMETRICS_CXSIZE;
1057         lpt[12].x = lpt[13].x = lpt[14].x = lpt[15].x =
1058                   rect->right - SYSMETRICS_CXFRAME - SYSMETRICS_CYSIZE;
1059
1060         lpt[12].y = lpt[8].y = rect->top;
1061         lpt[13].y = lpt[9].y = rect->top + height;
1062         lpt[14].y = lpt[10].y = rect->bottom - 1;
1063         lpt[15].y = lpt[11].y = rect->bottom - height - 1;
1064
1065         GRAPH_DrawLines( hdc, lpt, 8, (HPEN32)0 );      /* 8 is the maximum */
1066         InflateRect32( rect, -width - 1, -height - 1 );
1067     }
1068 }
1069
1070
1071 /******************************************************************************
1072  *
1073  *   void  NC_DrawFrame95(
1074  *      HDC32  hdc,
1075  *      RECT32  *rect,
1076  *      BOOL32  dlgFrame,
1077  *      BOOL32  active )
1078  *
1079  *   Draw a window frame inside the given rectangle, and update the rectangle.
1080  *   The correct pen for the frame must be selected in the DC.
1081  *
1082  *   Bugs
1083  *        Many.  First, just what IS a frame in Win95?  Note that the 3D look
1084  *        on the outer edge is handled by NC_DoNCPaint95.  As is the inner
1085  *        edge.  The inner rectangle just inside the frame is handled by the
1086  *        Caption code.
1087  *
1088  *        In short, for most people, this function should be a nop (unless
1089  *        you LIKE thick borders in Win95/NT4.0 -- I've been working with
1090  *        them lately, but just to get this code right).  Even so, it doesn't
1091  *        appear to be so.  It's being worked on...
1092  *
1093  *   Revision history
1094  *        06-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1095  *             Original implementation (based on NC_DrawFrame)
1096  *        02-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1097  *             Some minor fixes.
1098  *
1099  *****************************************************************************/
1100
1101 static void  NC_DrawFrame95(
1102     HDC32  hdc,
1103     RECT32  *rect,
1104     BOOL32  dlgFrame,
1105     BOOL32  active )
1106 {
1107     INT32 width, height;
1108
1109     if (dlgFrame)
1110     {
1111         width = sysMetrics[SM_CXDLGFRAME] - sysMetrics[SM_CXEDGE];
1112         height = sysMetrics[SM_CYDLGFRAME] - sysMetrics[SM_CYEDGE];
1113     }
1114     else
1115     {
1116         width = sysMetrics[SM_CXFRAME] - sysMetrics[SM_CXEDGE];
1117         height = sysMetrics[SM_CYFRAME] - sysMetrics[SM_CYEDGE];
1118     }
1119
1120     SelectObject32( hdc, GetSysColorBrush32(active ? COLOR_ACTIVEBORDER :
1121                 COLOR_INACTIVEBORDER) );
1122
1123     /* Draw frame */
1124     PatBlt32( hdc, rect->left, rect->top,
1125               rect->right - rect->left, height, PATCOPY );
1126     PatBlt32( hdc, rect->left, rect->top,
1127               width, rect->bottom - rect->top, PATCOPY );
1128     PatBlt32( hdc, rect->left, rect->bottom,
1129               rect->right - rect->left, -height, PATCOPY );
1130     PatBlt32( hdc, rect->right, rect->top,
1131               -width, rect->bottom - rect->top, PATCOPY );
1132
1133     InflateRect32( rect, -width, -height );
1134 }
1135
1136
1137
1138 /***********************************************************************
1139  *           NC_DrawMovingFrame
1140  *
1141  * Draw the frame used when moving or resizing window.
1142  *
1143  * FIXME:  This causes problems in Win95 mode.  (why?)
1144  */
1145 static void NC_DrawMovingFrame( HDC32 hdc, RECT32 *rect, BOOL32 thickframe )
1146 {
1147     if (thickframe)
1148     {
1149         RECT16 r16;
1150         CONV_RECT32TO16( rect, &r16 );
1151         FastWindowFrame( hdc, &r16, SYSMETRICS_CXFRAME,
1152                          SYSMETRICS_CYFRAME, PATINVERT );
1153     }
1154     else DrawFocusRect32( hdc, rect );
1155 }
1156
1157
1158 /***********************************************************************
1159  *           NC_DrawCaption
1160  *
1161  * Draw the window caption.
1162  * The correct pen for the window frame must be selected in the DC.
1163  */
1164 static void NC_DrawCaption( HDC32 hdc, RECT32 *rect, HWND32 hwnd,
1165                             DWORD style, BOOL32 active )
1166 {
1167     RECT32 r = *rect;
1168     WND * wndPtr = WIN_FindWndPtr( hwnd );
1169     char buffer[256];
1170
1171     if (wndPtr->flags & WIN_MANAGED) return;
1172
1173     if (!hbitmapClose)
1174     {
1175         if (!(hbitmapClose = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSE) )))
1176             return;
1177         hbitmapCloseD    = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSE) );
1178         hbitmapMinimize  = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCE) );
1179         hbitmapMinimizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCED) );
1180         hbitmapMaximize  = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOM) );
1181         hbitmapMaximizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOMD) );
1182         hbitmapRestore   = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORE) );
1183         hbitmapRestoreD  = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORED) );
1184     }
1185
1186     if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME)
1187     {
1188         HBRUSH32 hbrushOld = SelectObject32(hdc, GetSysColorBrush32(COLOR_WINDOW) );
1189         PatBlt32( hdc, r.left, r.top, 1, r.bottom-r.top+1,PATCOPY );
1190         PatBlt32( hdc, r.right-1, r.top, 1, r.bottom-r.top+1, PATCOPY );
1191         PatBlt32( hdc, r.left, r.top-1, r.right-r.left, 1, PATCOPY );
1192         r.left++;
1193         r.right--;
1194         SelectObject32( hdc, hbrushOld );
1195     }
1196
1197     MoveTo( hdc, r.left, r.bottom );
1198     LineTo32( hdc, r.right, r.bottom );
1199
1200     if (style & WS_SYSMENU)
1201     {
1202         NC_DrawSysButton( hwnd, hdc, FALSE );
1203         r.left += SYSMETRICS_CXSIZE + 1;
1204         MoveTo( hdc, r.left - 1, r.top );
1205         LineTo32( hdc, r.left - 1, r.bottom );
1206     }
1207     if (style & WS_MAXIMIZEBOX)
1208     {
1209         NC_DrawMaxButton( hwnd, hdc, FALSE );
1210         r.right -= SYSMETRICS_CXSIZE + 1;
1211     }
1212     if (style & WS_MINIMIZEBOX)
1213     {
1214         NC_DrawMinButton( hwnd, hdc, FALSE );
1215         r.right -= SYSMETRICS_CXSIZE + 1;
1216     }
1217
1218     FillRect32( hdc, &r, GetSysColorBrush32(active ? COLOR_ACTIVECAPTION :
1219                                             COLOR_INACTIVECAPTION) );
1220
1221     if (GetWindowText32A( hwnd, buffer, sizeof(buffer) ))
1222     {
1223         if (active) SetTextColor32( hdc, GetSysColor32( COLOR_CAPTIONTEXT ) );
1224         else SetTextColor32( hdc, GetSysColor32( COLOR_INACTIVECAPTIONTEXT ) );
1225         SetBkMode32( hdc, TRANSPARENT );
1226         DrawText32A( hdc, buffer, -1, &r,
1227                      DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_NOPREFIX );
1228     }
1229 }
1230
1231
1232 /******************************************************************************
1233  *
1234  *   NC_DrawCaption95(
1235  *      HDC32  hdc,
1236  *      RECT32  *rect,
1237  *      HWND32  hwnd,
1238  *      DWORD  style,
1239  *      BOOL32  active )
1240  *
1241  *   Draw the window caption for Win95 style windows.
1242  *   The correct pen for the window frame must be selected in the DC.
1243  *
1244  *   Bugs
1245  *        Hey, a function that finally works!  Well, almost.
1246  *        It's being worked on.
1247  *
1248  *   Revision history
1249  *        05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1250  *             Original implementation.
1251  *        02-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1252  *             Some minor fixes.
1253  *
1254  *****************************************************************************/
1255
1256 static void  NC_DrawCaption95(
1257     HDC32  hdc,
1258     RECT32  *rect,
1259     HWND32 hwnd,
1260     DWORD  style,
1261     BOOL32  active )
1262 {
1263     RECT32  r = *rect;
1264     WND     *wndPtr = WIN_FindWndPtr( hwnd );
1265     char    buffer[256];
1266     POINT32 sep[2] = { { r.left,  r.bottom - 1 },
1267                        { r.right, r.bottom - 1 } };
1268
1269     if (wndPtr->flags & WIN_MANAGED) return;
1270
1271     GRAPH_DrawLines( hdc, sep, 1, TWEAK_PenC095 );
1272     r.bottom--;
1273
1274     FillRect32( hdc, &r, GetSysColorBrush32(active ? COLOR_ACTIVECAPTION :
1275                                             COLOR_INACTIVECAPTION) );
1276
1277     if (!hbitmapClose) {
1278         if (!(hbitmapClose = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSE) )))
1279             return;
1280         hbitmapMinimize  = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCE) );
1281         hbitmapMinimizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCED) );
1282         hbitmapMaximize  = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOM) );
1283         hbitmapMaximizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOMD) );
1284         hbitmapRestore   = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORE) );
1285         hbitmapRestoreD  = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORED) );
1286     }
1287
1288     if (style & WS_SYSMENU) {
1289         if (NC_DrawSysButton95 (hwnd, hdc, FALSE))
1290             r.left += sysMetrics[SM_CYCAPTION] - 1;
1291         NC_DrawCloseButton95 (hwnd, hdc, FALSE);
1292         r.right -= sysMetrics[SM_CYCAPTION] - 1;
1293     }
1294     if (style & WS_MAXIMIZEBOX) {
1295         NC_DrawMaxButton95( hwnd, hdc, FALSE );
1296         r.right -= SYSMETRICS_CXSIZE + 1;
1297     }
1298     if (style & WS_MINIMIZEBOX) {
1299         NC_DrawMinButton95( hwnd, hdc, FALSE );
1300         r.right -= SYSMETRICS_CXSIZE + 1;
1301     }
1302
1303     if (GetWindowText32A( hwnd, buffer, sizeof(buffer) )) {
1304         NONCLIENTMETRICS32A nclm;
1305         HFONT32 hFont, hOldFont;
1306         nclm.cbSize = sizeof(NONCLIENTMETRICS32A);
1307         SystemParametersInfo32A (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
1308         hFont = CreateFontIndirect32A (&nclm.lfCaptionFont);
1309         hOldFont = SelectObject32 (hdc, hFont);
1310         if (active) SetTextColor32( hdc, GetSysColor32( COLOR_CAPTIONTEXT ) );
1311         else SetTextColor32( hdc, GetSysColor32( COLOR_INACTIVECAPTIONTEXT ) );
1312         SetBkMode32( hdc, TRANSPARENT );
1313         r.left += 2;
1314         DrawText32A( hdc, buffer, -1, &r, NC_CaptionTextFlags );
1315         DeleteObject32 (SelectObject32 (hdc, hOldFont));
1316     }
1317 }
1318
1319
1320
1321 /***********************************************************************
1322  *           NC_DoNCPaint
1323  *
1324  * Paint the non-client area. clip is currently unused.
1325  */
1326 void NC_DoNCPaint( WND* wndPtr, HRGN32 clip, BOOL32 suppress_menupaint )
1327 {
1328     HDC32 hdc;
1329     RECT32 rect;
1330     BOOL32 active;
1331     HWND32 hwnd = wndPtr->hwndSelf;
1332
1333     if ( wndPtr->dwStyle & WS_MINIMIZE ||
1334         !WIN_IsWindowDrawable( wndPtr, 0 )) return; /* Nothing to do */
1335
1336     active  = wndPtr->flags & WIN_NCACTIVATED;
1337
1338     TRACE(nonclient, "%04x %d\n", hwnd, active );
1339
1340     if (!(hdc = GetDCEx32( hwnd, 0, DCX_USESTYLE | DCX_WINDOW ))) return;
1341
1342     if (ExcludeVisRect( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left,
1343                         wndPtr->rectClient.top-wndPtr->rectWindow.top,
1344                         wndPtr->rectClient.right-wndPtr->rectWindow.left,
1345                         wndPtr->rectClient.bottom-wndPtr->rectWindow.top )
1346         == NULLREGION)
1347     {
1348         ReleaseDC32( hwnd, hdc );
1349         return;
1350     }
1351
1352     rect.top = rect.left = 0;
1353     rect.right  = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
1354     rect.bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
1355
1356     SelectObject32( hdc, GetSysColorPen32(COLOR_WINDOWFRAME) );
1357
1358     if (!(wndPtr->flags & WIN_MANAGED))
1359     {
1360         if ((wndPtr->dwStyle & WS_BORDER) || (wndPtr->dwStyle & WS_DLGFRAME) ||
1361             (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME))
1362         {
1363             GRAPH_DrawRectangle( hdc, 0, 0,
1364                                  rect.right, rect.bottom, (HPEN32)0 );
1365             InflateRect32( &rect, -1, -1 );
1366         }
1367
1368         if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1369             NC_DrawFrame( hdc, &rect, TRUE, active );
1370         else if (wndPtr->dwStyle & WS_THICKFRAME)
1371             NC_DrawFrame(hdc, &rect, FALSE, active );
1372
1373         if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
1374         {
1375             RECT32 r = rect;
1376             r.bottom = rect.top + SYSMETRICS_CYSIZE;
1377             rect.top += SYSMETRICS_CYSIZE + SYSMETRICS_CYBORDER;
1378             NC_DrawCaption( hdc, &r, hwnd, wndPtr->dwStyle, active );
1379         }
1380     }
1381
1382     if (HAS_MENU(wndPtr))
1383     {
1384         RECT32 r = rect;
1385         r.bottom = rect.top + SYSMETRICS_CYMENU;  /* default height */
1386         rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint );
1387     }
1388
1389       /* Draw the scroll-bars */
1390
1391     if (wndPtr->dwStyle & WS_VSCROLL)
1392         SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE );
1393     if (wndPtr->dwStyle & WS_HSCROLL)
1394         SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE );
1395
1396       /* Draw the "size-box" */
1397
1398     if ((wndPtr->dwStyle & WS_VSCROLL) && (wndPtr->dwStyle & WS_HSCROLL))
1399     {
1400         RECT32 r = rect;
1401         r.left = r.right - SYSMETRICS_CXVSCROLL + 1;
1402         r.top  = r.bottom - SYSMETRICS_CYHSCROLL + 1;
1403         if(wndPtr->dwStyle & WS_BORDER) {
1404           r.left++;
1405           r.top++;
1406         }
1407         FillRect32( hdc, &r, GetSysColorBrush32(COLOR_SCROLLBAR) );
1408     }
1409
1410     ReleaseDC32( hwnd, hdc );
1411 }
1412
1413
1414 /******************************************************************************
1415  *
1416  *   void  NC_DoNCPaint95(
1417  *      WND  *wndPtr,
1418  *      HRGN32  clip,
1419  *      BOOL32  suppress_menupaint )
1420  *
1421  *   Paint the non-client area for Win95 windows.  The clip region is
1422  *   currently ignored.
1423  *
1424  *   Bugs
1425  *        grep -E -A10 -B5 \(95\)\|\(Bugs\)\|\(FIXME\) windows/nonclient.c \
1426  *           misc/tweak.c controls/menu.c  # :-)
1427  *
1428  *   Revision history
1429  *        03-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1430  *             Original implementation
1431  *        10-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1432  *             Fixed some bugs.
1433  *
1434  *****************************************************************************/
1435
1436 void  NC_DoNCPaint95(
1437     WND  *wndPtr,
1438     HRGN32  clip,
1439     BOOL32  suppress_menupaint )
1440 {
1441     HDC32 hdc;
1442     RECT32 rect;
1443     BOOL32 active;
1444     HWND32 hwnd = wndPtr->hwndSelf;
1445
1446     if ( wndPtr->dwStyle & WS_MINIMIZE ||
1447         !WIN_IsWindowDrawable( wndPtr, 0 )) return; /* Nothing to do */
1448
1449     active  = wndPtr->flags & WIN_NCACTIVATED;
1450
1451     TRACE(nonclient, "%04x %d\n", hwnd, active );
1452
1453     if (!(hdc = GetDCEx32( hwnd, 0, DCX_USESTYLE | DCX_WINDOW ))) return;
1454
1455     if (ExcludeVisRect( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left,
1456                         wndPtr->rectClient.top-wndPtr->rectWindow.top,
1457                         wndPtr->rectClient.right-wndPtr->rectWindow.left,
1458                         wndPtr->rectClient.bottom-wndPtr->rectWindow.top )
1459         == NULLREGION)
1460     {
1461         ReleaseDC32( hwnd, hdc );
1462         return;
1463     }
1464
1465     rect.top = rect.left = 0;
1466     rect.right  = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
1467     rect.bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
1468
1469     SelectObject32( hdc, GetSysColorPen32(COLOR_WINDOWFRAME) );
1470
1471     if(!(wndPtr->flags & WIN_MANAGED)) {
1472         if ((wndPtr->dwStyle & WS_BORDER) && ((wndPtr->dwStyle & WS_DLGFRAME) ||
1473             (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME) || (wndPtr->dwStyle & WS_THICKFRAME))) {
1474             DrawEdge32 (hdc, &rect, EDGE_RAISED, BF_RECT | BF_ADJUST);
1475         }
1476
1477         if (HAS_FIXEDFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1478             NC_DrawFrame95( hdc, &rect, TRUE, active );
1479         else if (wndPtr->dwStyle & WS_THICKFRAME)
1480             NC_DrawFrame95(hdc, &rect, FALSE, active );
1481
1482         if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
1483         {
1484             RECT32  r = rect;
1485             if (wndPtr->dwExStyle & WS_EX_TOOLWINDOW) {
1486                 r.bottom = rect.top + sysMetrics[SM_CYSMCAPTION];
1487                 rect.top += sysMetrics[SM_CYSMCAPTION];
1488             }
1489             else {
1490                 r.bottom = rect.top + sysMetrics[SM_CYCAPTION];
1491                 rect.top += sysMetrics[SM_CYCAPTION];
1492             }
1493             NC_DrawCaption95( hdc, &r, hwnd, wndPtr->dwStyle, active );
1494         }
1495     }
1496
1497     if (HAS_MENU(wndPtr))
1498     {
1499         RECT32 r = rect;
1500         r.bottom = rect.top + sysMetrics[SM_CYMENU];
1501
1502         TRACE(nonclient, "Calling DrawMenuBar with "
1503                           "rect (%d, %d)-(%d, %d)\n", r.left, r.top,
1504                           r.right, r.bottom);
1505
1506         rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint ) + 1;
1507     }
1508
1509     TRACE(nonclient, "After MenuBar, rect is (%d, %d)-(%d, %d).\n",
1510                        rect.left, rect.top, rect.right, rect.bottom );
1511
1512     if (wndPtr->dwExStyle & WS_EX_CLIENTEDGE)
1513         DrawEdge32 (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1514
1515     if (wndPtr->dwExStyle & WS_EX_STATICEDGE)
1516         DrawEdge32 (hdc, &rect, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
1517
1518     /* Draw the scroll-bars */
1519
1520     if (wndPtr->dwStyle & WS_VSCROLL)
1521         SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE );
1522     if (wndPtr->dwStyle & WS_HSCROLL)
1523         SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE );
1524
1525     /* Draw the "size-box" */
1526     if ((wndPtr->dwStyle & WS_VSCROLL) && (wndPtr->dwStyle & WS_HSCROLL))
1527     {
1528         RECT32 r = rect;
1529         r.left = r.right - SYSMETRICS_CXVSCROLL + 1;
1530         r.top  = r.bottom - SYSMETRICS_CYHSCROLL + 1;
1531         FillRect32( hdc, &r,  GetSysColorBrush32(COLOR_SCROLLBAR) );
1532     }
1533
1534     ReleaseDC32( hwnd, hdc );
1535 }
1536
1537
1538
1539
1540 /***********************************************************************
1541  *           NC_HandleNCPaint
1542  *
1543  * Handle a WM_NCPAINT message. Called from DefWindowProc().
1544  */
1545 LONG NC_HandleNCPaint( HWND32 hwnd , HRGN32 clip)
1546 {
1547     WND* wndPtr = WIN_FindWndPtr( hwnd );
1548
1549     if( wndPtr && wndPtr->dwStyle & WS_VISIBLE )
1550     {
1551         if( wndPtr->dwStyle & WS_MINIMIZE )
1552             WINPOS_RedrawIconTitle( hwnd );
1553         else if(TWEAK_Win95Look)
1554             NC_DoNCPaint95( wndPtr, clip, FALSE );
1555         else
1556             NC_DoNCPaint( wndPtr, clip, FALSE );
1557     }
1558     return 0;
1559 }
1560
1561
1562 /***********************************************************************
1563  *           NC_HandleNCActivate
1564  *
1565  * Handle a WM_NCACTIVATE message. Called from DefWindowProc().
1566  */
1567 LONG NC_HandleNCActivate( WND *wndPtr, WPARAM16 wParam )
1568 {
1569     WORD wStateChange;
1570
1571     if( wParam ) wStateChange = !(wndPtr->flags & WIN_NCACTIVATED);
1572     else wStateChange = wndPtr->flags & WIN_NCACTIVATED;
1573
1574     if( wStateChange )
1575     {
1576         if (wParam) wndPtr->flags |= WIN_NCACTIVATED;
1577         else wndPtr->flags &= ~WIN_NCACTIVATED;
1578
1579         if( wndPtr->dwStyle & WS_MINIMIZE )
1580             WINPOS_RedrawIconTitle( wndPtr->hwndSelf );
1581         else if( TWEAK_Win95Look )
1582             NC_DoNCPaint95( wndPtr, (HRGN32)1, FALSE );
1583         else
1584             NC_DoNCPaint( wndPtr, (HRGN32)1, FALSE );
1585     }
1586     return TRUE;
1587 }
1588
1589
1590 /***********************************************************************
1591  *           NC_HandleSetCursor
1592  *
1593  * Handle a WM_SETCURSOR message. Called from DefWindowProc().
1594  */
1595 LONG NC_HandleSetCursor( HWND32 hwnd, WPARAM16 wParam, LPARAM lParam )
1596 {
1597     if (hwnd != (HWND32)wParam) return 0;  /* Don't set the cursor for child windows */
1598
1599     switch(LOWORD(lParam))
1600     {
1601     case HTERROR:
1602         {
1603             WORD msg = HIWORD( lParam );
1604             if ((msg == WM_LBUTTONDOWN) || (msg == WM_MBUTTONDOWN) ||
1605                 (msg == WM_RBUTTONDOWN))
1606                 MessageBeep32(0);
1607         }
1608         break;
1609
1610     case HTCLIENT:
1611         {
1612             WND *wndPtr;
1613             if (!(wndPtr = WIN_FindWndPtr( hwnd ))) break;
1614             if (wndPtr->class->hCursor)
1615             {
1616                 SetCursor16( wndPtr->class->hCursor );
1617                 return TRUE;
1618             }
1619             else return FALSE;
1620         }
1621
1622     case HTLEFT:
1623     case HTRIGHT:
1624         return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZEWE16 ) );
1625
1626     case HTTOP:
1627     case HTBOTTOM:
1628         return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENS16 ) );
1629
1630     case HTTOPLEFT:
1631     case HTBOTTOMRIGHT:
1632         return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENWSE16 ) );
1633
1634     case HTTOPRIGHT:
1635     case HTBOTTOMLEFT:
1636         return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENESW16 ) );
1637     }
1638
1639     /* Default cursor: arrow */
1640     return (LONG)SetCursor16( LoadCursor16( 0, IDC_ARROW16 ) );
1641 }
1642
1643 /***********************************************************************
1644  *           NC_GetSysPopupPos
1645  */
1646 BOOL32 NC_GetSysPopupPos( WND* wndPtr, RECT32* rect )
1647 {
1648   if( wndPtr->hSysMenu )
1649   {
1650       if( wndPtr->dwStyle & WS_MINIMIZE )
1651           GetWindowRect32( wndPtr->hwndSelf, rect );
1652       else
1653       {
1654           if(TWEAK_Win95Look)
1655               NC_GetInsideRect95( wndPtr->hwndSelf, rect );
1656           else
1657               NC_GetInsideRect( wndPtr->hwndSelf, rect );
1658           OffsetRect32( rect, wndPtr->rectWindow.left, wndPtr->rectWindow.top);
1659           if (wndPtr->dwStyle & WS_CHILD)
1660               ClientToScreen32( wndPtr->parent->hwndSelf, (POINT32 *)rect );
1661           if(TWEAK_Win95Look) {
1662             rect->right = rect->left + sysMetrics[SM_CYCAPTION] - 1;
1663             rect->bottom = rect->top + sysMetrics[SM_CYCAPTION] - 1;
1664           }
1665           else {
1666             rect->right = rect->left + SYSMETRICS_CXSIZE;
1667             rect->bottom = rect->top + SYSMETRICS_CYSIZE;
1668           }
1669       }
1670       return TRUE;
1671   }
1672   return FALSE;
1673 }
1674
1675 /***********************************************************************
1676  *           NC_StartSizeMove
1677  *
1678  * Initialisation of a move or resize, when initiatied from a menu choice.
1679  * Return hit test code for caption or sizing border.
1680  */
1681 static LONG NC_StartSizeMove( WND* wndPtr, WPARAM16 wParam,
1682                               POINT16 *capturePoint )
1683 {
1684     LONG hittest = 0;
1685     POINT16 pt;
1686     MSG16 msg;
1687
1688     if ((wParam & 0xfff0) == SC_MOVE)
1689     {
1690           /* Move pointer at the center of the caption */
1691         RECT32 rect;
1692         if(TWEAK_Win95Look)
1693             NC_GetInsideRect95( wndPtr->hwndSelf, &rect );
1694         else
1695             NC_GetInsideRect( wndPtr->hwndSelf, &rect );
1696         if (wndPtr->dwStyle & WS_SYSMENU)
1697             rect.left += SYSMETRICS_CXSIZE + 1;
1698         if (wndPtr->dwStyle & WS_MINIMIZEBOX)
1699             rect.right -= SYSMETRICS_CXSIZE + 1;
1700         if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
1701             rect.right -= SYSMETRICS_CXSIZE + 1;
1702         pt.x = wndPtr->rectWindow.left + (rect.right - rect.left) / 2;
1703         pt.y = wndPtr->rectWindow.top + rect.top + SYSMETRICS_CYSIZE/2;
1704         hittest = HTCAPTION;
1705         *capturePoint = pt;
1706
1707         if (wndPtr->dwStyle & WS_CHILD)
1708             ClientToScreen16( wndPtr->parent->hwndSelf, &pt );
1709     }
1710     else  /* SC_SIZE */
1711     {
1712         while(!hittest)
1713         {
1714             MSG_InternalGetMessage( &msg, 0, 0, MSGF_SIZE, PM_REMOVE, FALSE );
1715             switch(msg.message)
1716             {
1717             case WM_MOUSEMOVE:
1718                 hittest = NC_HandleNCHitTest( wndPtr->hwndSelf, msg.pt );
1719                 pt = msg.pt;
1720                 if ((hittest < HTLEFT) || (hittest > HTBOTTOMRIGHT))
1721                     hittest = 0;
1722                 break;
1723
1724             case WM_LBUTTONUP:
1725                 return 0;
1726
1727             case WM_KEYDOWN:
1728                 switch(msg.wParam)
1729                 {
1730                 case VK_UP:
1731                     hittest = HTTOP;
1732                     pt.x =(wndPtr->rectWindow.left+wndPtr->rectWindow.right)/2;
1733                     pt.y = wndPtr->rectWindow.top + SYSMETRICS_CYFRAME / 2;
1734                     break;
1735                 case VK_DOWN:
1736                     hittest = HTBOTTOM;
1737                     pt.x =(wndPtr->rectWindow.left+wndPtr->rectWindow.right)/2;
1738                     pt.y = wndPtr->rectWindow.bottom - SYSMETRICS_CYFRAME / 2;
1739                     break;
1740                 case VK_LEFT:
1741                     hittest = HTLEFT;
1742                     pt.x = wndPtr->rectWindow.left + SYSMETRICS_CXFRAME / 2;
1743                     pt.y =(wndPtr->rectWindow.top+wndPtr->rectWindow.bottom)/2;
1744                     break;
1745                 case VK_RIGHT:
1746                     hittest = HTRIGHT;
1747                     pt.x = wndPtr->rectWindow.right - SYSMETRICS_CXFRAME / 2;
1748                     pt.y =(wndPtr->rectWindow.top+wndPtr->rectWindow.bottom)/2;
1749                     break;
1750                 case VK_RETURN:
1751                 case VK_ESCAPE: return 0;
1752                 }
1753             }
1754         }
1755         *capturePoint = pt;
1756     }
1757     SetCursorPos32( pt.x, pt.y );
1758     NC_HandleSetCursor( wndPtr->hwndSelf,
1759                         wndPtr->hwndSelf, MAKELONG( hittest, WM_MOUSEMOVE ));
1760     return hittest;
1761 }
1762
1763
1764 /***********************************************************************
1765  *           NC_DoSizeMove
1766  *
1767  * Perform SC_MOVE and SC_SIZE commands.
1768  */
1769 static void NC_DoSizeMove( HWND32 hwnd, WORD wParam, POINT16 pt )
1770 {
1771     MSG16 msg;
1772     RECT32 sizingRect, mouseRect;
1773     HDC32 hdc;
1774     LONG hittest = (LONG)(wParam & 0x0f);
1775     HCURSOR16 hDragCursor = 0, hOldCursor = 0;
1776     POINT32 minTrack, maxTrack;
1777     POINT16 capturePoint = pt;
1778     WND *     wndPtr = WIN_FindWndPtr( hwnd );
1779     BOOL32    thickframe = HAS_THICKFRAME( wndPtr->dwStyle );
1780     BOOL32    iconic = wndPtr->dwStyle & WS_MINIMIZE;
1781     BOOL32    moved = FALSE;
1782
1783     if (IsZoomed32(hwnd) || !IsWindowVisible32(hwnd) ||
1784         (wndPtr->flags & WIN_MANAGED)) return;
1785
1786     if ((wParam & 0xfff0) == SC_MOVE)
1787     {
1788         if (!(wndPtr->dwStyle & WS_CAPTION)) return;
1789         if (!hittest)
1790              hittest = NC_StartSizeMove( wndPtr, wParam, &capturePoint );
1791         if (!hittest) return;
1792     }
1793     else  /* SC_SIZE */
1794     {
1795         if (!thickframe) return;
1796         if ( hittest && hittest != HTSYSMENU ) hittest += 2;
1797         else
1798         {
1799             SetCapture32(hwnd);
1800             hittest = NC_StartSizeMove( wndPtr, wParam, &capturePoint );
1801             if (!hittest)
1802             {
1803                 ReleaseCapture();
1804                 return;
1805             }
1806         }
1807     }
1808
1809       /* Get min/max info */
1810
1811     WINPOS_GetMinMaxInfo( wndPtr, NULL, NULL, &minTrack, &maxTrack );
1812     sizingRect = wndPtr->rectWindow;
1813     if (wndPtr->dwStyle & WS_CHILD)
1814         GetClientRect32( wndPtr->parent->hwndSelf, &mouseRect );
1815     else
1816         SetRect32(&mouseRect, 0, 0, SYSMETRICS_CXSCREEN, SYSMETRICS_CYSCREEN);
1817     if (ON_LEFT_BORDER(hittest))
1818     {
1819         mouseRect.left  = MAX( mouseRect.left, sizingRect.right-maxTrack.x );
1820         mouseRect.right = MIN( mouseRect.right, sizingRect.right-minTrack.x );
1821     }
1822     else if (ON_RIGHT_BORDER(hittest))
1823     {
1824         mouseRect.left  = MAX( mouseRect.left, sizingRect.left+minTrack.x );
1825         mouseRect.right = MIN( mouseRect.right, sizingRect.left+maxTrack.x );
1826     }
1827     if (ON_TOP_BORDER(hittest))
1828     {
1829         mouseRect.top    = MAX( mouseRect.top, sizingRect.bottom-maxTrack.y );
1830         mouseRect.bottom = MIN( mouseRect.bottom,sizingRect.bottom-minTrack.y);
1831     }
1832     else if (ON_BOTTOM_BORDER(hittest))
1833     {
1834         mouseRect.top    = MAX( mouseRect.top, sizingRect.top+minTrack.y );
1835         mouseRect.bottom = MIN( mouseRect.bottom, sizingRect.top+maxTrack.y );
1836     }
1837     SendMessage16( hwnd, WM_ENTERSIZEMOVE, 0, 0 );
1838
1839     if (GetCapture32() != hwnd) SetCapture32( hwnd );
1840
1841     if (wndPtr->dwStyle & WS_CHILD)
1842     {
1843           /* Retrieve a default cache DC (without using the window style) */
1844         hdc = GetDCEx32( wndPtr->parent->hwndSelf, 0, DCX_CACHE );
1845     }
1846     else
1847     {  /* Grab the server only when moving top-level windows without desktop */
1848         hdc = GetDC32( 0 );
1849         if (rootWindow == DefaultRootWindow(display)) TSXGrabServer( display );
1850     }
1851
1852     if( iconic ) /* create a cursor for dragging */
1853     {
1854         HICON16 hIcon = (wndPtr->class->hIcon) ? wndPtr->class->hIcon
1855                       : (HICON16)SendMessage16( hwnd, WM_QUERYDRAGICON, 0, 0L);
1856         if( hIcon ) hDragCursor =  CURSORICON_IconToCursor( hIcon, TRUE );
1857         if( !hDragCursor ) iconic = FALSE;
1858     }
1859
1860     if( !iconic ) NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
1861
1862     while(1)
1863     {
1864         int dx = 0, dy = 0;
1865
1866         MSG_InternalGetMessage( &msg, 0, 0, MSGF_SIZE, PM_REMOVE, FALSE );
1867
1868           /* Exit on button-up, Return, or Esc */
1869         if ((msg.message == WM_LBUTTONUP) ||
1870             ((msg.message == WM_KEYDOWN) &&
1871              ((msg.wParam == VK_RETURN) || (msg.wParam == VK_ESCAPE)))) break;
1872
1873         if ((msg.message != WM_KEYDOWN) && (msg.message != WM_MOUSEMOVE))
1874             continue;  /* We are not interested in other messages */
1875
1876         pt = msg.pt;
1877         if (wndPtr->dwStyle & WS_CHILD)
1878             ScreenToClient16( wndPtr->parent->hwndSelf, &pt );
1879
1880         if (msg.message == WM_KEYDOWN) switch(msg.wParam)
1881         {
1882             case VK_UP:    pt.y -= 8; break;
1883             case VK_DOWN:  pt.y += 8; break;
1884             case VK_LEFT:  pt.x -= 8; break;
1885             case VK_RIGHT: pt.x += 8; break;
1886         }
1887
1888         pt.x = MAX( pt.x, mouseRect.left );
1889         pt.x = MIN( pt.x, mouseRect.right );
1890         pt.y = MAX( pt.y, mouseRect.top );
1891         pt.y = MIN( pt.y, mouseRect.bottom );
1892
1893         dx = pt.x - capturePoint.x;
1894         dy = pt.y - capturePoint.y;
1895
1896         if (dx || dy)
1897         {
1898             if( !moved )
1899             {
1900                 moved = TRUE;
1901                 if( iconic ) /* ok, no system popup tracking */
1902                 {
1903                     hOldCursor = SetCursor32(hDragCursor);
1904                     ShowCursor32( TRUE );
1905                     WINPOS_ShowIconTitle( wndPtr, FALSE );
1906                 }
1907             }
1908
1909             if (msg.message == WM_KEYDOWN) SetCursorPos32( pt.x, pt.y );
1910             else
1911             {
1912                 RECT32 newRect = sizingRect;
1913
1914                 if (hittest == HTCAPTION) OffsetRect32( &newRect, dx, dy );
1915                 if (ON_LEFT_BORDER(hittest)) newRect.left += dx;
1916                 else if (ON_RIGHT_BORDER(hittest)) newRect.right += dx;
1917                 if (ON_TOP_BORDER(hittest)) newRect.top += dy;
1918                 else if (ON_BOTTOM_BORDER(hittest)) newRect.bottom += dy;
1919                 if( !iconic )
1920                 {
1921                     NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
1922                     NC_DrawMovingFrame( hdc, &newRect, thickframe );
1923                 }
1924                 capturePoint = pt;
1925                 sizingRect = newRect;
1926             }
1927         }
1928     }
1929
1930     ReleaseCapture();
1931     if( iconic )
1932     {
1933         if( moved ) /* restore cursors, show icon title later on */
1934         {
1935             ShowCursor32( FALSE );
1936             SetCursor32( hOldCursor );
1937         }
1938         DestroyCursor32( hDragCursor );
1939     }
1940     else
1941         NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
1942
1943     if (wndPtr->dwStyle & WS_CHILD)
1944         ReleaseDC32( wndPtr->parent->hwndSelf, hdc );
1945     else
1946     {
1947         ReleaseDC32( 0, hdc );
1948         if (rootWindow == DefaultRootWindow(display)) TSXUngrabServer( display );
1949     }
1950
1951     if (HOOK_IsHooked( WH_CBT ))
1952     {
1953         RECT16* pr = SEGPTR_NEW(RECT16);
1954         if( pr )
1955         {
1956             CONV_RECT32TO16( &sizingRect, pr );
1957             if( HOOK_CallHooks16( WH_CBT, HCBT_MOVESIZE, hwnd,
1958                                 (LPARAM)SEGPTR_GET(pr)) )
1959                 sizingRect = wndPtr->rectWindow;
1960             else
1961                 CONV_RECT16TO32( pr, &sizingRect );
1962             SEGPTR_FREE(pr);
1963         }
1964     }
1965     SendMessage16( hwnd, WM_EXITSIZEMOVE, 0, 0 );
1966     SendMessage16( hwnd, WM_SETVISIBLE, !IsIconic16(hwnd), 0L);
1967
1968     if( moved && !((msg.message == WM_KEYDOWN) && (msg.wParam == VK_ESCAPE)) )
1969     {
1970         /* NOTE: SWP_NOACTIVATE prevents document window activation in Word 6 */
1971         SetWindowPos32( hwnd, 0, sizingRect.left, sizingRect.top,
1972                         sizingRect.right - sizingRect.left,
1973                         sizingRect.bottom - sizingRect.top,
1974                       ( hittest == HTCAPTION ) ? SWP_NOSIZE : 0 );
1975     }
1976
1977     if( IsWindow32(hwnd) )
1978         if( wndPtr->dwStyle & WS_MINIMIZE )
1979         {
1980             /* Single click brings up the system menu when iconized */
1981
1982             if( !moved )
1983             {
1984                  if( wndPtr->dwStyle & WS_SYSMENU )
1985                      SendMessage16( hwnd, WM_SYSCOMMAND,
1986                                     SC_MOUSEMENU + HTSYSMENU, *((LPARAM*)&pt));
1987             }
1988             else WINPOS_ShowIconTitle( wndPtr, TRUE );
1989         }
1990 }
1991
1992
1993 /***********************************************************************
1994  *           NC_TrackMinMaxBox
1995  *
1996  * Track a mouse button press on the minimize or maximize box.
1997  */
1998 static void NC_TrackMinMaxBox( HWND32 hwnd, WORD wParam )
1999 {
2000     MSG16 msg;
2001     HDC32 hdc = GetWindowDC32( hwnd );
2002     BOOL32 pressed = TRUE;
2003     void  (*paintButton)(HWND32, HDC16, BOOL32);
2004
2005     SetCapture32( hwnd );
2006     if (wParam == HTMINBUTTON)
2007         paintButton = (TWEAK_Win95Look) ? &NC_DrawMinButton95 : &NC_DrawMinButton;
2008     else
2009         paintButton = (TWEAK_Win95Look) ? &NC_DrawMaxButton95 : &NC_DrawMaxButton;
2010
2011     (*paintButton)( hwnd, hdc, TRUE );
2012
2013     do
2014     {
2015         BOOL32 oldstate = pressed;
2016         MSG_InternalGetMessage( &msg, 0, 0, 0, PM_REMOVE, FALSE );
2017
2018         pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
2019         if (pressed != oldstate)
2020            (*paintButton)( hwnd, hdc, pressed );
2021     } while (msg.message != WM_LBUTTONUP);
2022
2023     (*paintButton)( hwnd, hdc, FALSE );
2024
2025     ReleaseCapture();
2026     ReleaseDC32( hwnd, hdc );
2027     if (!pressed) return;
2028
2029     if (wParam == HTMINBUTTON)
2030         SendMessage16( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, *(LONG*)&msg.pt );
2031     else
2032         SendMessage16( hwnd, WM_SYSCOMMAND,
2033                   IsZoomed32(hwnd) ? SC_RESTORE:SC_MAXIMIZE, *(LONG*)&msg.pt );
2034 }
2035
2036
2037 /***********************************************************************
2038  * NC_TrackCloseButton95
2039  *
2040  * Track a mouse button press on the Win95 close button.
2041  */
2042 static void
2043 NC_TrackCloseButton95 (HWND32 hwnd, WORD wParam)
2044 {
2045     MSG16 msg;
2046     HDC32 hdc = GetWindowDC32( hwnd );
2047     BOOL32 pressed = TRUE;
2048
2049     SetCapture32( hwnd );
2050
2051     NC_DrawCloseButton95 (hwnd, hdc, TRUE);
2052
2053     do
2054     {
2055         BOOL32 oldstate = pressed;
2056         MSG_InternalGetMessage( &msg, 0, 0, 0, PM_REMOVE, FALSE );
2057
2058         pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
2059         if (pressed != oldstate)
2060            NC_DrawCloseButton95 (hwnd, hdc, pressed);
2061     } while (msg.message != WM_LBUTTONUP);
2062
2063     NC_DrawCloseButton95 (hwnd, hdc, FALSE);
2064
2065     ReleaseCapture();
2066     ReleaseDC32( hwnd, hdc );
2067     if (!pressed) return;
2068
2069     SendMessage16( hwnd, WM_SYSCOMMAND, SC_CLOSE, *(LONG*)&msg.pt );
2070 }
2071
2072
2073 /***********************************************************************
2074  *           NC_TrackScrollBar
2075  *
2076  * Track a mouse button press on the horizontal or vertical scroll-bar.
2077  */
2078 static void NC_TrackScrollBar( HWND32 hwnd, WPARAM32 wParam, POINT32 pt )
2079 {
2080     MSG16 *msg;
2081     INT32 scrollbar;
2082     WND *wndPtr = WIN_FindWndPtr( hwnd );
2083
2084     if ((wParam & 0xfff0) == SC_HSCROLL)
2085     {
2086         if ((wParam & 0x0f) != HTHSCROLL) return;
2087         scrollbar = SB_HORZ;
2088     }
2089     else  /* SC_VSCROLL */
2090     {
2091         if ((wParam & 0x0f) != HTVSCROLL) return;
2092         scrollbar = SB_VERT;
2093     }
2094
2095     if (!(msg = SEGPTR_NEW(MSG16))) return;
2096     pt.x -= wndPtr->rectWindow.left;
2097     pt.y -= wndPtr->rectWindow.top;
2098     SetCapture32( hwnd );
2099     SCROLL_HandleScrollEvent( hwnd, scrollbar, WM_LBUTTONDOWN, pt );
2100
2101     do
2102     {
2103         GetMessage16( SEGPTR_GET(msg), 0, 0, 0 );
2104         switch(msg->message)
2105         {
2106         case WM_LBUTTONUP:
2107         case WM_MOUSEMOVE:
2108         case WM_SYSTIMER:
2109             pt.x = LOWORD(msg->lParam) + wndPtr->rectClient.left -
2110               wndPtr->rectWindow.left;
2111             pt.y = HIWORD(msg->lParam) + wndPtr->rectClient.top -
2112               wndPtr->rectWindow.top;
2113             SCROLL_HandleScrollEvent( hwnd, scrollbar, msg->message, pt );
2114             break;
2115         default:
2116             TranslateMessage16( msg );
2117             DispatchMessage16( msg );
2118             break;
2119         }
2120         if (!IsWindow32( hwnd ))
2121         {
2122             ReleaseCapture();
2123             break;
2124         }
2125     } while (msg->message != WM_LBUTTONUP);
2126     SEGPTR_FREE(msg);
2127 }
2128
2129 /***********************************************************************
2130  *           NC_HandleNCLButtonDown
2131  *
2132  * Handle a WM_NCLBUTTONDOWN message. Called from DefWindowProc().
2133  */
2134 LONG NC_HandleNCLButtonDown( WND* pWnd, WPARAM16 wParam, LPARAM lParam )
2135 {
2136     HWND32 hwnd = pWnd->hwndSelf;
2137
2138     switch(wParam)  /* Hit test */
2139     {
2140     case HTCAPTION:
2141          hwnd = WIN_GetTopParent(hwnd);
2142
2143          if( WINPOS_SetActiveWindow(hwnd, TRUE, TRUE) || (GetActiveWindow32() == hwnd) )
2144                 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam );
2145          break;
2146
2147     case HTSYSMENU:
2148          if( pWnd->dwStyle & WS_SYSMENU )
2149          {
2150              if( !(pWnd->dwStyle & WS_MINIMIZE) )
2151              {
2152                 HDC32 hDC = GetWindowDC32(hwnd);
2153                 if( TWEAK_Win95Look)
2154                     NC_DrawSysButton95( hwnd, hDC, TRUE );
2155                 else
2156                     NC_DrawSysButton( hwnd, hDC, TRUE );
2157                 ReleaseDC32( hwnd, hDC );
2158              }
2159              SendMessage16( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, lParam );
2160          }
2161          break;
2162
2163     case HTMENU:
2164         SendMessage16( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU, lParam );
2165         break;
2166
2167     case HTHSCROLL:
2168         SendMessage16( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
2169         break;
2170
2171     case HTVSCROLL:
2172         SendMessage16( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
2173         break;
2174
2175     case HTMINBUTTON:
2176     case HTMAXBUTTON:
2177         NC_TrackMinMaxBox( hwnd, wParam );
2178         break;
2179
2180     case HTCLOSE:
2181         if (TWEAK_Win95Look)
2182             NC_TrackCloseButton95 (hwnd, wParam);
2183         break;
2184
2185     case HTLEFT:
2186     case HTRIGHT:
2187     case HTTOP:
2188     case HTTOPLEFT:
2189     case HTTOPRIGHT:
2190     case HTBOTTOM:
2191     case HTBOTTOMLEFT:
2192     case HTBOTTOMRIGHT:
2193         /* make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU */
2194         SendMessage16( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - 2, lParam);
2195         break;
2196
2197     case HTBORDER:
2198         break;
2199     }
2200     return 0;
2201 }
2202
2203
2204 /***********************************************************************
2205  *           NC_HandleNCLButtonDblClk
2206  *
2207  * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
2208  */
2209 LONG NC_HandleNCLButtonDblClk( WND *pWnd, WPARAM16 wParam, LPARAM lParam )
2210 {
2211     /*
2212      * if this is an icon, send a restore since we are handling
2213      * a double click
2214      */
2215     if (pWnd->dwStyle & WS_MINIMIZE)
2216     {
2217         SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_RESTORE, lParam );
2218         return 0;
2219     }
2220
2221     switch(wParam)  /* Hit test */
2222     {
2223     case HTCAPTION:
2224         /* stop processing if WS_MAXIMIZEBOX is missing */
2225         if (pWnd->dwStyle & WS_MAXIMIZEBOX)
2226             SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND,
2227                       (pWnd->dwStyle & WS_MAXIMIZE) ? SC_RESTORE : SC_MAXIMIZE,
2228                       lParam );
2229         break;
2230
2231     case HTSYSMENU:
2232         if (!(pWnd->class->style & CS_NOCLOSE))
2233             SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_CLOSE, lParam );
2234         break;
2235
2236     case HTHSCROLL:
2237         SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL,
2238                        lParam );
2239         break;
2240
2241     case HTVSCROLL:
2242         SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL,
2243                        lParam );
2244         break;
2245     }
2246     return 0;
2247 }
2248
2249
2250 /***********************************************************************
2251  *           NC_HandleSysCommand
2252  *
2253  * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
2254  */
2255 LONG NC_HandleSysCommand( HWND32 hwnd, WPARAM16 wParam, POINT16 pt )
2256 {
2257     WND *wndPtr = WIN_FindWndPtr( hwnd );
2258     POINT32 pt32;
2259     UINT16 uCommand = wParam & 0xFFF0;
2260
2261     TRACE(nonclient, "Handling WM_SYSCOMMAND %x %d,%d\n",
2262                       wParam, pt.x, pt.y );
2263
2264     if (wndPtr->dwStyle & WS_CHILD && uCommand != SC_KEYMENU )
2265         ScreenToClient16( wndPtr->parent->hwndSelf, &pt );
2266
2267     switch (uCommand)
2268     {
2269     case SC_SIZE:
2270     case SC_MOVE:
2271         NC_DoSizeMove( hwnd, wParam, pt );
2272         break;
2273
2274     case SC_MINIMIZE:
2275         ShowWindow32( hwnd, SW_MINIMIZE );
2276         break;
2277
2278     case SC_MAXIMIZE:
2279         ShowWindow32( hwnd, SW_MAXIMIZE );
2280         break;
2281
2282     case SC_RESTORE:
2283         ShowWindow32( hwnd, SW_RESTORE );
2284         break;
2285
2286     case SC_CLOSE:
2287         return SendMessage16( hwnd, WM_CLOSE, 0, 0 );
2288
2289     case SC_VSCROLL:
2290     case SC_HSCROLL:
2291         CONV_POINT16TO32( &pt, &pt32 );
2292         NC_TrackScrollBar( hwnd, wParam, pt32 );
2293         break;
2294
2295     case SC_MOUSEMENU:
2296         CONV_POINT16TO32( &pt, &pt32 );
2297         MENU_TrackMouseMenuBar( wndPtr, wParam & 0x000F, pt32 );
2298         break;
2299
2300     case SC_KEYMENU:
2301         MENU_TrackKbdMenuBar( wndPtr , wParam , pt.x );
2302         break;
2303
2304     case SC_TASKLIST:
2305         WinExec32( "taskman.exe", SW_SHOWNORMAL );
2306         break;
2307
2308     case SC_SCREENSAVE:
2309         if (wParam == SC_ABOUTWINE)
2310             ShellAbout32A(hwnd,"Wine", WINE_RELEASE_INFO, 0);
2311         break;
2312
2313     case SC_HOTKEY:
2314     case SC_ARRANGE:
2315     case SC_NEXTWINDOW:
2316     case SC_PREVWINDOW:
2317         /* FIXME: unimplemented */
2318         break;
2319     }
2320     return 0;
2321 }