windows/nonclient.c

   1 /*
   2  * Non-client area window functions
   3  *
   4  * Copyright 1994 Alexandre Julliard
   5  */
   6
   7 static char Copyright[] = "Copyright  Alexandre Julliard, 1994";
   8
   9 #include "win.h"
  10 #include "class.h"
  11 #include "message.h"
  12 #include "sysmetrics.h"
  13 #include "user.h"
  14 #include "scroll.h"
  15 #include "syscolor.h"
  16 #include "stddebug.h"
  17 /* #define DEBUG_NONCLIENT /* */
  18 /* #undef  DEBUG_NONCLIENT /* */
  19 #include "debug.h"
  20
  21
  22 static HBITMAP hbitmapClose = 0;
  23 static HBITMAP hbitmapMDIClose = 0;
  24 static HBITMAP hbitmapMinimize = 0;
  25 static HBITMAP hbitmapMinimizeD = 0;
  26 static HBITMAP hbitmapMaximize = 0;
  27 static HBITMAP hbitmapMaximizeD = 0;
  28 static HBITMAP hbitmapRestore = 0;
  29 static HBITMAP hbitmapRestoreD = 0;
  30
  31 #define SC_ABOUTWINE            (SC_SCREENSAVE+1)
  32 extern HINSTANCE hSysRes;
  33 extern BOOL AboutWine_Proc( HWND hDlg, WORD msg, WORD wParam, LONG lParam );
  34
  35 extern void WINPOS_GetMinMaxInfo( HWND hwnd, POINT *maxSize, POINT *maxPos,
  36                             POINT *minTrack, POINT *maxTrack );  /* winpos.c */
  37 extern BOOL GRAPH_DrawBitmap( HDC hdc, HBITMAP hbitmap, int xdest, int ydest,
  38                               int xsrc, int ysrc, int width, int height,
  39                               int rop );                     /* graphics.c */
  40 extern WORD MENU_GetMenuBarHeight( HWND hwnd, WORD menubarWidth,
  41                                    int orgX, int orgY );         /* menu.c */
  42 extern void MENU_TrackMouseMenuBar( HWND hwnd, POINT pt );       /* menu.c */
  43 extern void MENU_TrackKbdMenuBar( HWND hwnd, WORD wParam );      /* menu.c */
  44 extern WORD MENU_DrawMenuBar( HDC hDC, LPRECT lprect,
  45                               HWND hwnd, BOOL suppress_draw ); /* menu.c */
  46
  47
  48   /* Some useful macros */
  49 #define HAS_DLGFRAME(style,exStyle) \
  50     (((style) & WS_DLGFRAME) && \
  51      (((exStyle) & WS_EX_DLGMODALFRAME) || !((style) & WS_BORDER)))
  52
  53 #define HAS_THICKFRAME(style) \
  54     (((style) & WS_THICKFRAME) && \
  55      !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
  56
  57 #define HAS_MENU(w)  (!((w)->dwStyle & WS_CHILD) && ((w)->wIDmenu != 0))
  58
  59 #define ON_LEFT_BORDER(hit) \
  60  (((hit) == HTLEFT) || ((hit) == HTTOPLEFT) || ((hit) == HTBOTTOMLEFT))
  61 #define ON_RIGHT_BORDER(hit) \
  62  (((hit) == HTRIGHT) || ((hit) == HTTOPRIGHT) || ((hit) == HTBOTTOMRIGHT))
  63 #define ON_TOP_BORDER(hit) \
  64  (((hit) == HTTOP) || ((hit) == HTTOPLEFT) || ((hit) == HTTOPRIGHT))
  65 #define ON_BOTTOM_BORDER(hit) \
  66  (((hit) == HTBOTTOM) || ((hit) == HTBOTTOMLEFT) || ((hit) == HTBOTTOMRIGHT))
  67
  68 /***********************************************************************
  69  *           NC_AdjustRect
  70  *
  71  * Compute the size of the window rectangle from the size of the
  72  * client rectangle.
  73  */
  74 static void NC_AdjustRect( LPRECT rect, DWORD style, BOOL menu, DWORD exStyle )
  75 {
  76     if (HAS_DLGFRAME( style, exStyle ))
  77         InflateRect( rect, SYSMETRICS_CXDLGFRAME, SYSMETRICS_CYDLGFRAME );
  78     else
  79     {
  80         if (HAS_THICKFRAME(style))
  81             InflateRect( rect, SYSMETRICS_CXFRAME, SYSMETRICS_CYFRAME );
  82         if (style & WS_BORDER)
  83             InflateRect( rect, SYSMETRICS_CXBORDER, SYSMETRICS_CYBORDER );
  84     }
  85
  86     if ((style & WS_CAPTION) == WS_CAPTION)
  87         rect->top -= SYSMETRICS_CYCAPTION - SYSMETRICS_CYBORDER;
  88     if (menu) rect->top -= SYSMETRICS_CYMENU + SYSMETRICS_CYBORDER;
  89
  90     if (style & WS_VSCROLL) rect->right  += SYSMETRICS_CXVSCROLL;
  91     if (style & WS_HSCROLL) rect->bottom += SYSMETRICS_CYHSCROLL;
  92 }
  93
  94
  95 /***********************************************************************
  96  *           AdjustWindowRect    (USER.102)
  97  */
  98 void AdjustWindowRect( LPRECT rect, DWORD style, BOOL menu )
  99 {
 100     AdjustWindowRectEx( rect, style, menu, 0 );
 101 }
 102
 103
 104 /***********************************************************************
 105  *           AdjustWindowRectEx    (USER.454)
 106  */
 107 void AdjustWindowRectEx( LPRECT rect, DWORD style, BOOL menu, DWORD exStyle )
 108 {
 109       /* Correct the window style */
 110
 111     if (!(style & (WS_POPUP | WS_CHILD)))  /* Overlapped window */
 112         style |= WS_CAPTION;
 113     if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
 114
 115     dprintf_nonclient(stddeb, "AdjustWindowRectEx: (%d,%d)-(%d,%d) %08x %d %08x\n",
 116       rect->left, rect->top, rect->right, rect->bottom, style, menu, exStyle );
 117
 118     NC_AdjustRect( rect, style, menu, exStyle );
 119 }
 120
 121
 122 /***********************************************************************
 123  *           NC_HandleNCCalcSize
 124  *
 125  * Handle a WM_NCCALCSIZE message. Called from DefWindowProc().
 126  */
 127 LONG NC_HandleNCCalcSize( HWND hwnd, NCCALCSIZE_PARAMS *params )
 128 {
 129     RECT tmpRect = { 0, 0, 0, 0 };
 130     WND *wndPtr = WIN_FindWndPtr( hwnd );
 131
 132     if (!wndPtr) return 0;
 133
 134     /*
 135      * we don't want to change the size if hwnd is an icon since
 136      * there are no window manager handles on an icon
 137      */
 138     if(IsIconic(hwnd)) return 0;
 139
 140     NC_AdjustRect( &tmpRect, wndPtr->dwStyle, FALSE, wndPtr->dwExStyle );
 141     params->rgrc[0].left   -= tmpRect.left;
 142     params->rgrc[0].top    -= tmpRect.top;
 143     params->rgrc[0].right  -= tmpRect.right;
 144     params->rgrc[0].bottom -= tmpRect.bottom;
 145
 146     if (HAS_MENU(wndPtr))
 147     {
 148         params->rgrc[0].top += MENU_GetMenuBarHeight( hwnd,
 149                                   params->rgrc[0].right - params->rgrc[0].left,
 150                                   -tmpRect.left, -tmpRect.top ) + 1;
 151     }
 152     return 0;
 153 }
 154
 155
 156 /***********************************************************************
 157  *           NC_GetInsideRect
 158  *
 159  * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
 160  * but without the borders (if any).
 161  * The rectangle is in window coordinates (for drawing with GetWindowDC()).
 162  */
 163 void NC_GetInsideRect( HWND hwnd, RECT *rect )
 164 {
 165     WND * wndPtr = WIN_FindWndPtr( hwnd );
 166
 167     rect->top    = rect->left = 0;
 168     rect->right  = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
 169     rect->bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
 170
 171       /* Remove frame from rectangle */
 172     if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
 173     {
 174         InflateRect( rect, -SYSMETRICS_CXDLGFRAME, -SYSMETRICS_CYDLGFRAME);
 175         if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME) InflateRect( rect, -1, 0);
 176     }
 177     else
 178     {
 179         if (HAS_THICKFRAME( wndPtr->dwStyle ))
 180             InflateRect( rect, -SYSMETRICS_CXFRAME, -SYSMETRICS_CYFRAME );
 181         if (wndPtr->dwStyle & WS_BORDER)
 182             InflateRect( rect, -SYSMETRICS_CXBORDER, -SYSMETRICS_CYBORDER );
 183     }
 184 }
 185
 186
 187 /***********************************************************************
 188  *           NC_HandleNCHitTest
 189  *
 190  * Handle a WM_NCHITTEST message. Called from DefWindowProc().
 191  */
 192 LONG NC_HandleNCHitTest( HWND hwnd, POINT pt )
 193 {
 194     RECT rect;
 195     WND *wndPtr = WIN_FindWndPtr( hwnd );
 196     if (!wndPtr) return HTERROR;
 197
 198     dprintf_nonclient(stddeb, "NC_HandleNCHitTest: hwnd=%x pt=%d,%d\n",
 199                       hwnd, pt.x, pt.y );
 200
 201     GetWindowRect( hwnd, &rect );
 202     if (!PtInRect( &rect, pt )) return HTNOWHERE;
 203
 204     /*
 205      * if this is a iconic window, we don't care were the hit
 206      * occured, only that it did occur, just return HTCAPTION
 207      * so the caller knows the icon did get hit
 208      */
 209     if (IsIconic(hwnd))
 210     {
 211         return HTCAPTION;       /* change this to something meaningful? */
 212     }
 213
 214       /* Check borders */
 215     if (HAS_THICKFRAME( wndPtr->dwStyle ))
 216     {
 217         InflateRect( &rect, -SYSMETRICS_CXFRAME, -SYSMETRICS_CYFRAME );
 218         if (wndPtr->dwStyle & WS_BORDER)
 219             InflateRect( &rect, -SYSMETRICS_CXBORDER, -SYSMETRICS_CYBORDER );
 220         if (!PtInRect( &rect, pt ))
 221         {
 222               /* Check top sizing border */
 223             if (pt.y < rect.top)
 224             {
 225                 if (pt.x < rect.left+SYSMETRICS_CXSIZE) return HTTOPLEFT;
 226                 if (pt.x >= rect.right-SYSMETRICS_CXSIZE) return HTTOPRIGHT;
 227                 return HTTOP;
 228             }
 229               /* Check bottom sizing border */
 230             if (pt.y >= rect.bottom)
 231             {
 232                 if (pt.x < rect.left+SYSMETRICS_CXSIZE) return HTBOTTOMLEFT;
 233                 if (pt.x >= rect.right-SYSMETRICS_CXSIZE) return HTBOTTOMRIGHT;
 234                 return HTBOTTOM;
 235             }
 236               /* Check left sizing border */
 237             if (pt.x < rect.left)
 238             {
 239                 if (pt.y < rect.top+SYSMETRICS_CYSIZE) return HTTOPLEFT;
 240                 if (pt.y >= rect.bottom-SYSMETRICS_CYSIZE) return HTBOTTOMLEFT;
 241                 return HTLEFT;
 242             }
 243               /* Check right sizing border */
 244             if (pt.x >= rect.right)
 245             {
 246                 if (pt.y < rect.top+SYSMETRICS_CYSIZE) return HTTOPRIGHT;
 247                 if (pt.y >= rect.bottom-SYSMETRICS_CYSIZE) return HTBOTTOMRIGHT;
 248                 return HTRIGHT;
 249             }
 250         }
 251     }
 252     else  /* No thick frame */
 253     {
 254         if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
 255             InflateRect(&rect, -SYSMETRICS_CXDLGFRAME, -SYSMETRICS_CYDLGFRAME);
 256         else if (wndPtr->dwStyle & WS_BORDER)
 257             InflateRect(&rect, -SYSMETRICS_CXBORDER, -SYSMETRICS_CYBORDER);
 258         if (!PtInRect( &rect, pt )) return HTBORDER;
 259     }
 260
 261       /* Check caption */
 262
 263     if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
 264     {
 265         rect.top += SYSMETRICS_CYCAPTION - 1;
 266         if (!PtInRect( &rect, pt ))
 267         {
 268               /* Check system menu */
 269             if (wndPtr->dwStyle & WS_SYSMENU)
 270                 rect.left += SYSMETRICS_CXSIZE;
 271             if (pt.x <= rect.left) return HTSYSMENU;
 272               /* Check maximize box */
 273             if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
 274                 rect.right -= SYSMETRICS_CXSIZE + 1;
 275             if (pt.x >= rect.right) return HTMAXBUTTON;
 276               /* Check minimize box */
 277             if (wndPtr->dwStyle & WS_MINIMIZEBOX)
 278                 rect.right -= SYSMETRICS_CXSIZE + 1;
 279             if (pt.x >= rect.right) return HTMINBUTTON;
 280             return HTCAPTION;
 281         }
 282     }
 283
 284       /* Check client area */
 285
 286     ScreenToClient( hwnd, &pt );
 287     GetClientRect( hwnd, &rect );
 288     if (PtInRect( &rect, pt )) return HTCLIENT;
 289
 290       /* Check vertical scroll bar */
 291
 292     if (wndPtr->dwStyle & WS_VSCROLL)
 293     {
 294         rect.right += SYSMETRICS_CXVSCROLL;
 295         if (PtInRect( &rect, pt )) return HTVSCROLL;
 296     }
 297
 298       /* Check horizontal scroll bar */
 299
 300     if (wndPtr->dwStyle & WS_HSCROLL)
 301     {
 302         rect.bottom += SYSMETRICS_CYHSCROLL;
 303         if (PtInRect( &rect, pt ))
 304         {
 305               /* Check size box */
 306             if ((wndPtr->dwStyle & WS_VSCROLL) &&
 307                 (pt.x >= rect.right - SYSMETRICS_CXVSCROLL))
 308                 return HTSIZE;
 309             return HTHSCROLL;
 310         }
 311     }
 312
 313       /* Check menu bar */
 314
 315     if (HAS_MENU(wndPtr))
 316     {
 317         if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
 318             return HTMENU;
 319     }
 320
 321       /* Should never get here */
 322     return HTERROR;
 323 }
 324
 325
 326 /***********************************************************************
 327  *           NC_DrawSysButton
 328  */
 329 void NC_DrawSysButton( HWND hwnd, HDC hdc, BOOL down )
 330 {
 331     RECT rect;
 332     WND *wndPtr = WIN_FindWndPtr( hwnd );
 333     NC_GetInsideRect( hwnd, &rect );
 334     GRAPH_DrawBitmap( hdc, (wndPtr->dwStyle & WS_CHILD) ?
 335                       hbitmapMDIClose : hbitmapClose,
 336                       rect.left, rect.top,
 337                       1, 1, SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE,
 338                       down ? NOTSRCCOPY : SRCCOPY );
 339 }
 340
 341
 342 /***********************************************************************
 343  *           NC_DrawMaxButton
 344  */
 345 static void NC_DrawMaxButton( HWND hwnd, HDC hdc, BOOL down )
 346 {
 347     RECT rect;
 348     NC_GetInsideRect( hwnd, &rect );
 349     GRAPH_DrawBitmap( hdc, (IsZoomed(hwnd) ?
 350                             (down ? hbitmapRestoreD : hbitmapRestore) :
 351                             (down ? hbitmapMaximizeD : hbitmapMaximize)),
 352                      rect.right - SYSMETRICS_CXSIZE - 1, rect.top - 1,
 353                      0, 0, SYSMETRICS_CXSIZE+2, SYSMETRICS_CYSIZE+2, SRCCOPY );
 354 }
 355
 356
 357 /***********************************************************************
 358  *           NC_DrawMinButton
 359  */
 360 static void NC_DrawMinButton( HWND hwnd, HDC hdc, BOOL down )
 361 {
 362     RECT rect;
 363     WND *wndPtr = WIN_FindWndPtr( hwnd );
 364     NC_GetInsideRect( hwnd, &rect );
 365     if (wndPtr->dwStyle & WS_MAXIMIZEBOX) rect.right -= SYSMETRICS_CXSIZE + 1;
 366     GRAPH_DrawBitmap( hdc, (down ? hbitmapMinimizeD : hbitmapMinimize),
 367                      rect.right - SYSMETRICS_CXSIZE - 1, rect.top - 1,
 368                      0, 0, SYSMETRICS_CXSIZE+2, SYSMETRICS_CYSIZE+2, SRCCOPY );
 369 }
 370
 371
 372 /***********************************************************************
 373  *           NC_DrawFrame
 374  *
 375  * Draw a window frame inside the given rectangle, and update the rectangle.
 376  * The correct pen for the frame must be selected in the DC.
 377  */
 378 static void NC_DrawFrame( HDC hdc, RECT *rect, BOOL dlgFrame, BOOL active )
 379 {
 380     short width, height, tmp;
 381
 382     if (dlgFrame)
 383     {
 384         width = SYSMETRICS_CXDLGFRAME - 1;
 385         height = SYSMETRICS_CYDLGFRAME - 1;
 386         SelectObject( hdc, active ? sysColorObjects.hbrushActiveCaption :
 387                                     sysColorObjects.hbrushInactiveCaption );
 388     }
 389     else
 390     {
 391         width = SYSMETRICS_CXFRAME - 1;
 392         height = SYSMETRICS_CYFRAME - 1;
 393         SelectObject( hdc, active ? sysColorObjects.hbrushActiveBorder :
 394                                     sysColorObjects.hbrushInactiveBorder );
 395     }
 396
 397       /* Draw frame */
 398     PatBlt( hdc, rect->left, rect->top,
 399             rect->right - rect->left, height, PATCOPY );
 400     PatBlt( hdc, rect->left, rect->top,
 401             width, rect->bottom - rect->top, PATCOPY );
 402     PatBlt( hdc, rect->left, rect->bottom,
 403             rect->right - rect->left, -height, PATCOPY );
 404     PatBlt( hdc, rect->right, rect->top,
 405             -width, rect->bottom - rect->top, PATCOPY );
 406
 407     if (dlgFrame)
 408     {
 409         InflateRect( rect, -width, -height );
 410         return;
 411     }
 412
 413       /* Draw inner rectangle */
 414     MoveTo( hdc, rect->left+width, rect->top+height );
 415     LineTo( hdc, rect->right-width-1, rect->top+height );
 416     LineTo( hdc, rect->right-width-1, rect->bottom-height-1 );
 417     LineTo( hdc, rect->left+width, rect->bottom-height-1 );
 418     LineTo( hdc, rect->left+width, rect->top+height );
 419
 420       /* Draw the decorations */
 421     tmp = rect->top + SYSMETRICS_CYFRAME + SYSMETRICS_CYSIZE;
 422     MoveTo( hdc, rect->left, tmp);
 423     LineTo( hdc, rect->left+width, tmp );
 424     MoveTo( hdc, rect->right-width-1, tmp );
 425     LineTo( hdc, rect->right-1, tmp );
 426
 427     tmp = rect->bottom - 1 - SYSMETRICS_CYFRAME - SYSMETRICS_CYSIZE;
 428     MoveTo( hdc, rect->left, tmp );
 429     LineTo( hdc, rect->left+width, tmp );
 430     MoveTo( hdc, rect->right-width-1, tmp );
 431     LineTo( hdc, rect->right-1, tmp );
 432
 433     tmp = rect->left + SYSMETRICS_CXFRAME + SYSMETRICS_CXSIZE;
 434     MoveTo( hdc, tmp, rect->top );
 435     LineTo( hdc, tmp, rect->top+height );
 436     MoveTo( hdc, tmp, rect->bottom-height-1 );
 437     LineTo( hdc, tmp, rect->bottom-1 );
 438
 439     tmp = rect->right - 1 - SYSMETRICS_CXFRAME - SYSMETRICS_CYSIZE;
 440     MoveTo( hdc, tmp, rect->top );
 441     LineTo( hdc, tmp, rect->top+height );
 442     MoveTo( hdc, tmp, rect->bottom-height-1 );
 443     LineTo( hdc, tmp, rect->bottom-1 );
 444
 445     InflateRect( rect, -width-1, -height-1 );
 446 }
 447
 448
 449 /***********************************************************************
 450  *           NC_DrawMovingFrame
 451  *
 452  * Draw the frame used when moving or resizing window.
 453  */
 454 static void NC_DrawMovingFrame( HDC hdc, RECT *rect, BOOL thickframe )
 455 {
 456     if (thickframe)
 457     {
 458         SelectObject( hdc, GetStockObject( GRAY_BRUSH ) );
 459         PatBlt( hdc, rect->left, rect->top,
 460                 rect->right - rect->left - SYSMETRICS_CXFRAME,
 461                 SYSMETRICS_CYFRAME, PATINVERT );
 462         PatBlt( hdc, rect->left, rect->top + SYSMETRICS_CYFRAME,
 463                 SYSMETRICS_CXFRAME,
 464                 rect->bottom - rect->top - SYSMETRICS_CYFRAME, PATINVERT );
 465         PatBlt( hdc, rect->left + SYSMETRICS_CXFRAME, rect->bottom,
 466                 rect->right - rect->left - SYSMETRICS_CXFRAME,
 467                 -SYSMETRICS_CYFRAME, PATINVERT );
 468         PatBlt( hdc, rect->right, rect->top, -SYSMETRICS_CXFRAME,
 469                 rect->bottom - rect->top - SYSMETRICS_CYFRAME, PATINVERT );
 470     }
 471     else DrawFocusRect( hdc, rect );
 472 }
 473
 474
 475 /***********************************************************************
 476  *           NC_DrawCaption
 477  *
 478  * Draw the window caption.
 479  * The correct pen for the window frame must be selected in the DC.
 480  */
 481 static void NC_DrawCaption( HDC hdc, RECT *rect, HWND hwnd,
 482                             DWORD style, BOOL active )
 483 {
 484     RECT r = *rect;
 485     WND * wndPtr = WIN_FindWndPtr( hwnd );
 486     char buffer[256];
 487
 488     if (!hbitmapClose)
 489     {
 490         if (!(hbitmapClose = LoadBitmap( 0, MAKEINTRESOURCE(OBM_CLOSE) )))
 491             return;
 492         if (!(hbitmapMDIClose = LoadBitmap( 0, MAKEINTRESOURCE(OBM_OLD_CLOSE) )))
 493             return;
 494         hbitmapMinimize  = LoadBitmap( 0, MAKEINTRESOURCE(OBM_REDUCE) );
 495         hbitmapMinimizeD = LoadBitmap( 0, MAKEINTRESOURCE(OBM_REDUCED) );
 496         hbitmapMaximize  = LoadBitmap( 0, MAKEINTRESOURCE(OBM_ZOOM) );
 497         hbitmapMaximizeD = LoadBitmap( 0, MAKEINTRESOURCE(OBM_ZOOMD) );
 498         hbitmapRestore   = LoadBitmap( 0, MAKEINTRESOURCE(OBM_RESTORE) );
 499         hbitmapRestoreD  = LoadBitmap( 0, MAKEINTRESOURCE(OBM_RESTORED) );
 500     }
 501
 502     if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME)
 503     {
 504         HBRUSH hbrushOld = SelectObject( hdc, sysColorObjects.hbrushWindow );
 505         PatBlt( hdc, r.left, r.top, 1, r.bottom-r.top+1,PATCOPY );
 506         PatBlt( hdc, r.right-1, r.top, 1, r.bottom-r.top+1, PATCOPY );
 507         PatBlt( hdc, r.left, r.top-1, r.right-r.left, 1, PATCOPY );
 508         r.left++;
 509         r.right--;
 510         SelectObject( hdc, hbrushOld );
 511     }
 512
 513     MoveTo( hdc, r.left, r.bottom );
 514     LineTo( hdc, r.right-1, r.bottom );
 515
 516     if (style & WS_SYSMENU)
 517     {
 518         NC_DrawSysButton( hwnd, hdc, FALSE );
 519         r.left += SYSMETRICS_CXSIZE + 1;
 520         MoveTo( hdc, r.left - 1, r.top );
 521         LineTo( hdc, r.left - 1, r.bottom );
 522     }
 523     if (style & WS_MAXIMIZEBOX)
 524     {
 525         NC_DrawMaxButton( hwnd, hdc, FALSE );
 526         r.right -= SYSMETRICS_CXSIZE + 1;
 527     }
 528     if (style & WS_MINIMIZEBOX)
 529     {
 530         NC_DrawMinButton( hwnd, hdc, FALSE );
 531         r.right -= SYSMETRICS_CXSIZE + 1;
 532     }
 533
 534     FillRect( hdc, &r, active ? sysColorObjects.hbrushActiveCaption :
 535                                 sysColorObjects.hbrushInactiveCaption );
 536
 537     if (GetWindowText( hwnd, buffer, 256 ))
 538     {
 539         if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
 540         else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
 541         SetBkMode( hdc, TRANSPARENT );
 542         DrawText( hdc, buffer, -1, &r, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
 543     }
 544 }
 545
 546
 547 /***********************************************************************
 548  *           NC_DoNCPaint
 549  *
 550  * Paint the non-client area.
 551  * 'hrgn' is the update rgn to use (in client coords) or 1 if no update rgn.
 552  */
 553 void NC_DoNCPaint( HWND hwnd, HRGN hrgn, BOOL active, BOOL suppress_menupaint )
 554 {
 555     HDC hdc;
 556     RECT rect, rect2;
 557
 558     WND *wndPtr = WIN_FindWndPtr( hwnd );
 559
 560     dprintf_nonclient(stddeb, "NC_DoNCPaint: %d %d\n", hwnd, hrgn );
 561     if (!wndPtr || !hrgn) return;
 562     if ((!(wndPtr->dwStyle & (WS_BORDER | WS_DLGFRAME | WS_THICKFRAME))) ||
 563         (!(wndPtr->dwStyle & WS_VISIBLE)))
 564         return;  /* Nothing to do! */
 565
 566     if (hrgn == 1) hdc = GetDCEx( hwnd, 0, DCX_USESTYLE | DCX_WINDOW );
 567     else
 568     {
 569           /* Make region relative to window area */
 570         int xoffset = wndPtr->rectWindow.left - wndPtr->rectClient.left;
 571         int yoffset = wndPtr->rectWindow.top - wndPtr->rectClient.top;
 572         OffsetRgn( hrgn, -xoffset, -yoffset );
 573         hdc = GetDCEx( hwnd, hrgn, DCX_USESTYLE|DCX_WINDOW|DCX_INTERSECTRGN );
 574         OffsetRgn( hrgn, xoffset, yoffset );  /* Restore region */
 575     }
 576     if (!hdc) return;
 577
 578
 579     /*
 580      * If this is an icon, we don't want to do any more nonclient painting
 581      * of the window manager.
 582      * If there is a class icon to draw, draw it
 583      */
 584     if (IsIconic(hwnd))
 585     {
 586         HICON hIcon = WIN_CLASS_INFO(wndPtr).hIcon;
 587         if (hIcon)
 588         {
 589             SendMessage(hwnd, WM_ICONERASEBKGND, hdc, 0);
 590             Rectangle(hdc, wndPtr->rectWindow.left, wndPtr->rectWindow.top,
 591                      wndPtr->rectWindow.right, wndPtr->rectWindow.bottom);
 592             DrawIcon(hdc, 0, 0, hIcon);
 593         }
 594         ReleaseDC(hwnd, hdc);
 595         return;
 596     }
 597
 598     if (ExcludeVisRect( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left,
 599                         wndPtr->rectClient.top-wndPtr->rectWindow.top,
 600                         wndPtr->rectClient.right-wndPtr->rectWindow.left,
 601                         wndPtr->rectClient.bottom-wndPtr->rectWindow.top )
 602         == NULLREGION)
 603     {
 604         ReleaseDC( hwnd, hdc );
 605         return;
 606     }
 607
 608     rect.top = rect.left = 0;
 609     rect.right  = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
 610     rect.bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
 611
 612     SelectObject( hdc, sysColorObjects.hpenWindowFrame );
 613
 614     if ((wndPtr->dwStyle & WS_BORDER) || (wndPtr->dwStyle & WS_DLGFRAME))
 615     {
 616         MoveTo( hdc, 0, 0 );
 617         LineTo( hdc, rect.right-1, 0 );
 618         LineTo( hdc, rect.right-1, rect.bottom-1 );
 619         LineTo( hdc, 0, rect.bottom-1 );
 620         LineTo( hdc, 0, 0 );
 621         InflateRect( &rect, -1, -1 );
 622     }
 623
 624     if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
 625         NC_DrawFrame( hdc, &rect, TRUE, active );
 626     else if (wndPtr->dwStyle & WS_THICKFRAME)
 627         NC_DrawFrame(hdc, &rect, FALSE, active );
 628
 629     if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
 630     {
 631         RECT r = rect;
 632         r.bottom = rect.top + SYSMETRICS_CYSIZE;
 633         rect.top += SYSMETRICS_CYSIZE + SYSMETRICS_CYBORDER;
 634         NC_DrawCaption( hdc, &r, hwnd, wndPtr->dwStyle, active );
 635     }
 636
 637     if (HAS_MENU(wndPtr))
 638     {
 639         RECT r = rect;
 640         r.bottom = rect.top + SYSMETRICS_CYMENU;  /* default height */
 641         rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint );
 642     }
 643
 644     if (wndPtr->dwStyle & (WS_VSCROLL | WS_HSCROLL)) {
 645         if ((wndPtr->dwStyle & WS_VSCROLL) && (wndPtr->VScroll != NULL) &&
 646             (wndPtr->scroll_flags & 0x0001)) {
 647             int bottom = rect.bottom;
 648             if ((wndPtr->dwStyle & WS_HSCROLL) && (wndPtr->scroll_flags & 0x0001))
 649                         bottom -= SYSMETRICS_CYHSCROLL;
 650             SetRect(&rect2, rect.right - SYSMETRICS_CXVSCROLL,
 651                 rect.top, rect.right, bottom);
 652             StdDrawScrollBar(hwnd, hdc, SB_VERT, &rect2, (LPHEADSCROLL)wndPtr->VScroll);
 653             }
 654         if ((wndPtr->dwStyle & WS_HSCROLL) && wndPtr->HScroll != NULL &&
 655             (wndPtr->scroll_flags & 0x0002)) {
 656             int right = rect.right;
 657             if ((wndPtr->dwStyle & WS_VSCROLL) && (wndPtr->scroll_flags & 0x0001))
 658                         right -= SYSMETRICS_CYVSCROLL;
 659             SetRect(&rect2, rect.left, rect.bottom - SYSMETRICS_CYHSCROLL,
 660                     right, rect.bottom);
 661             StdDrawScrollBar(hwnd, hdc, SB_HORZ, &rect2, (LPHEADSCROLL)wndPtr->HScroll);
 662             }
 663
 664         if ((wndPtr->dwStyle & WS_VSCROLL) && (wndPtr->dwStyle & WS_HSCROLL) &&
 665             (wndPtr->scroll_flags & 0x0003) == 0x0003) {
 666                 RECT r = rect;
 667                 r.left = r.right - SYSMETRICS_CXVSCROLL;
 668                 r.top  = r.bottom - SYSMETRICS_CYHSCROLL;
 669                 FillRect( hdc, &r, sysColorObjects.hbrushScrollbar );
 670                 }
 671     }
 672
 673     ReleaseDC( hwnd, hdc );
 674 }
 675
 676
 677
 678 /***********************************************************************
 679  *           NC_HandleNCPaint
 680  *
 681  * Handle a WM_NCPAINT message. Called from DefWindowProc().
 682  */
 683 LONG NC_HandleNCPaint( HWND hwnd, HRGN hrgn )
 684 {
 685     NC_DoNCPaint( hwnd, hrgn, hwnd == GetActiveWindow(), FALSE );
 686     return 0;
 687 }
 688
 689
 690 /***********************************************************************
 691  *           NC_HandleNCActivate
 692  *
 693  * Handle a WM_NCACTIVATE message. Called from DefWindowProc().
 694  */
 695 LONG NC_HandleNCActivate( HWND hwnd, WORD wParam )
 696 {
 697     NC_DoNCPaint( hwnd, (HRGN)1, wParam, FALSE );
 698     return TRUE;
 699 }
 700
 701
 702 /***********************************************************************
 703  *           NC_HandleSetCursor
 704  *
 705  * Handle a WM_SETCURSOR message. Called from DefWindowProc().
 706  */
 707 LONG NC_HandleSetCursor( HWND hwnd, WORD wParam, LONG lParam )
 708 {
 709     if (hwnd != wParam) return 0;  /* Don't set the cursor for child windows */
 710
 711     switch(LOWORD(lParam))
 712     {
 713     case HTERROR:
 714         {
 715             WORD msg = HIWORD( lParam );
 716             if ((msg == WM_LBUTTONDOWN) || (msg == WM_MBUTTONDOWN) ||
 717                 (msg == WM_RBUTTONDOWN))
 718                 MessageBeep(0);
 719         }
 720         break;
 721
 722     case HTCLIENT:
 723         {
 724             WND *wndPtr;
 725             CLASS *classPtr;
 726             if (!(wndPtr = WIN_FindWndPtr( hwnd ))) break;
 727             if (!(classPtr = CLASS_FindClassPtr( wndPtr->hClass ))) break;
 728             if (classPtr->wc.hCursor)
 729             {
 730                 SetCursor( classPtr->wc.hCursor );
 731                 return TRUE;
 732             }
 733             else return FALSE;
 734         }
 735
 736     case HTLEFT:
 737     case HTRIGHT:
 738         return SetCursor( LoadCursor( 0, IDC_SIZEWE ) );
 739
 740     case HTTOP:
 741     case HTBOTTOM:
 742         return SetCursor( LoadCursor( 0, IDC_SIZENS ) );
 743
 744     case HTTOPLEFT:
 745     case HTBOTTOMRIGHT:
 746         return SetCursor( LoadCursor( 0, IDC_SIZENWSE ) );
 747
 748     case HTTOPRIGHT:
 749     case HTBOTTOMLEFT:
 750         return SetCursor( LoadCursor( 0, IDC_SIZENESW ) );
 751     }
 752
 753     /* Default cursor: arrow */
 754     return SetCursor( LoadCursor( 0, IDC_ARROW ) );
 755 }
 756
 757
 758 /***********************************************************************
 759  *           NC_StartSizeMove
 760  *
 761  * Initialisation of a move or resize, when initiatied from a menu choice.
 762  * Return hit test code for caption or sizing border.
 763  */
 764 static LONG NC_StartSizeMove( HWND hwnd, WORD wParam, POINT *capturePoint )
 765 {
 766     LONG hittest = 0;
 767     POINT pt;
 768     MSG msg;
 769     WND * wndPtr = WIN_FindWndPtr( hwnd );
 770
 771     if ((wParam & 0xfff0) == SC_MOVE)
 772     {
 773           /* Move pointer at the center of the caption */
 774         RECT rect;
 775         NC_GetInsideRect( hwnd, &rect );
 776         if (wndPtr->dwStyle & WS_SYSMENU)
 777             rect.left += SYSMETRICS_CXSIZE + 1;
 778         if (wndPtr->dwStyle & WS_MINIMIZEBOX)
 779             rect.right -= SYSMETRICS_CXSIZE + 1;
 780         if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
 781             rect.right -= SYSMETRICS_CXSIZE + 1;
 782         pt.x = wndPtr->rectWindow.left + (rect.right - rect.left) / 2;
 783         pt.y = wndPtr->rectWindow.top + rect.top + SYSMETRICS_CYSIZE/2;
 784         if (wndPtr->dwStyle & WS_CHILD)
 785             ClientToScreen( wndPtr->hwndParent, &pt );
 786         hittest = HTCAPTION;
 787     }
 788     else  /* SC_SIZE */
 789     {
 790         SetCapture(hwnd);
 791         while(!hittest)
 792         {
 793             MSG_GetHardwareMessage( &msg );
 794             switch(msg.message)
 795             {
 796             case WM_MOUSEMOVE:
 797                 hittest = NC_HandleNCHitTest( hwnd, msg.pt );
 798                 pt = msg.pt;
 799                 if ((hittest < HTLEFT) || (hittest > HTBOTTOMRIGHT))
 800                     hittest = 0;
 801                 break;
 802
 803             case WM_LBUTTONUP:
 804                 return 0;
 805
 806             case WM_KEYDOWN:
 807                 switch(msg.wParam)
 808                 {
 809                 case VK_UP:
 810                     hittest = HTTOP;
 811                     pt.x =(wndPtr->rectWindow.left+wndPtr->rectWindow.right)/2;
 812                     pt.y = wndPtr->rectWindow.top + SYSMETRICS_CYFRAME / 2;
 813                     break;
 814                 case VK_DOWN:
 815                     hittest = HTBOTTOM;
 816                     pt.x =(wndPtr->rectWindow.left+wndPtr->rectWindow.right)/2;
 817                     pt.y = wndPtr->rectWindow.bottom - SYSMETRICS_CYFRAME / 2;
 818                     break;
 819                 case VK_LEFT:
 820                     hittest = HTLEFT;
 821                     pt.x = wndPtr->rectWindow.left + SYSMETRICS_CXFRAME / 2;
 822                     pt.y =(wndPtr->rectWindow.top+wndPtr->rectWindow.bottom)/2;
 823                     break;
 824                 case VK_RIGHT:
 825                     hittest = HTRIGHT;
 826                     pt.x = wndPtr->rectWindow.right - SYSMETRICS_CXFRAME / 2;
 827                     pt.y =(wndPtr->rectWindow.top+wndPtr->rectWindow.bottom)/2;
 828                     break;
 829                 case VK_RETURN:
 830                 case VK_ESCAPE: return 0;
 831                 }
 832             }
 833         }
 834     }
 835     *capturePoint = pt;
 836     SetCursorPos( capturePoint->x, capturePoint->y );
 837     NC_HandleSetCursor( hwnd, hwnd, MAKELONG( hittest, WM_MOUSEMOVE ));
 838     return hittest;
 839 }
 840
 841
 842 /***********************************************************************
 843  *           NC_DoSizeMove
 844  *
 845  * Perform SC_MOVE and SC_SIZE commands.
 846  */
 847 static void NC_DoSizeMove( HWND hwnd, WORD wParam, POINT pt )
 848 {
 849     MSG msg;
 850     LONG hittest;
 851     RECT sizingRect, mouseRect;
 852     HDC hdc;
 853     BOOL thickframe;
 854     POINT minTrack, maxTrack, capturePoint = pt;
 855     WND * wndPtr = WIN_FindWndPtr( hwnd );
 856
 857     if (IsZoomed(hwnd) || !IsWindowVisible(hwnd)) return;
 858     hittest = wParam & 0x0f;
 859     thickframe = HAS_THICKFRAME( wndPtr->dwStyle );
 860
 861     if ((wParam & 0xfff0) == SC_MOVE)
 862     {
 863         if (!(wndPtr->dwStyle & WS_CAPTION)) return;
 864         if (!hittest) hittest = NC_StartSizeMove( hwnd, wParam, &capturePoint );
 865         if (!hittest) return;
 866     }
 867     else  /* SC_SIZE */
 868     {
 869         if (!thickframe) return;
 870         if (hittest) hittest += HTLEFT-1;
 871         else
 872         {
 873             SetCapture(hwnd);
 874             hittest = NC_StartSizeMove( hwnd, wParam, &capturePoint );
 875             if (!hittest)
 876             {
 877                 ReleaseCapture();
 878                 return;
 879             }
 880         }
 881     }
 882
 883       /* Get min/max info */
 884
 885     WINPOS_GetMinMaxInfo( hwnd, NULL, NULL, &minTrack, &maxTrack );
 886     sizingRect = wndPtr->rectWindow;
 887     if (wndPtr->dwStyle & WS_CHILD)
 888         GetClientRect( wndPtr->hwndParent, &mouseRect );
 889     else SetRect( &mouseRect, 0, 0, SYSMETRICS_CXSCREEN, SYSMETRICS_CYSCREEN );
 890     if (ON_LEFT_BORDER(hittest))
 891     {
 892         mouseRect.left  = max( mouseRect.left, sizingRect.right-maxTrack.x );
 893         mouseRect.right = min( mouseRect.right, sizingRect.right-minTrack.x );
 894     }
 895     else if (ON_RIGHT_BORDER(hittest))
 896     {
 897         mouseRect.left  = max( mouseRect.left, sizingRect.left+minTrack.x );
 898         mouseRect.right = min( mouseRect.right, sizingRect.left+maxTrack.x );
 899     }
 900     if (ON_TOP_BORDER(hittest))
 901     {
 902         mouseRect.top    = max( mouseRect.top, sizingRect.bottom-maxTrack.y );
 903         mouseRect.bottom = min( mouseRect.bottom,sizingRect.bottom-minTrack.y);
 904     }
 905     else if (ON_BOTTOM_BORDER(hittest))
 906     {
 907         mouseRect.top    = max( mouseRect.top, sizingRect.top+minTrack.y );
 908         mouseRect.bottom = min( mouseRect.bottom, sizingRect.top+maxTrack.y );
 909     }
 910     SendMessage( hwnd, WM_ENTERSIZEMOVE, 0, 0 );
 911
 912     if (GetCapture() != hwnd) SetCapture( hwnd );
 913
 914     if (wndPtr->dwStyle & WS_CHILD) hdc = GetDC( wndPtr->hwndParent );
 915     else
 916     {  /* Grab the server only when moving top-level windows without desktop */
 917         hdc = GetDC( 0 );
 918         if (rootWindow == DefaultRootWindow(display)) XGrabServer( display );
 919     }
 920     NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
 921
 922     while(1)
 923     {
 924         int dx = 0, dy = 0;
 925
 926         MSG_GetHardwareMessage( &msg );
 927
 928           /* Exit on button-up, Return, or Esc */
 929         if ((msg.message == WM_LBUTTONUP) ||
 930             ((msg.message == WM_KEYDOWN) &&
 931              ((msg.wParam == VK_RETURN) || (msg.wParam == VK_ESCAPE)))) break;
 932
 933         if ((msg.message != WM_KEYDOWN) && (msg.message != WM_MOUSEMOVE))
 934             continue;  /* We are not interested in other messages */
 935
 936         pt = msg.pt;
 937         if (wndPtr->dwStyle & WS_CHILD)
 938             ScreenToClient( wndPtr->hwndParent, &pt );
 939
 940
 941         if (msg.message == WM_KEYDOWN) switch(msg.wParam)
 942         {
 943             case VK_UP:    pt.y -= 8; break;
 944             case VK_DOWN:  pt.y += 8; break;
 945             case VK_LEFT:  pt.x -= 8; break;
 946             case VK_RIGHT: pt.x += 8; break;
 947         }
 948
 949         pt.x = max( pt.x, mouseRect.left );
 950         pt.x = min( pt.x, mouseRect.right );
 951         pt.y = max( pt.y, mouseRect.top );
 952         pt.y = min( pt.y, mouseRect.bottom );
 953
 954         dx = pt.x - capturePoint.x;
 955         dy = pt.y - capturePoint.y;
 956
 957         if (dx || dy)
 958         {
 959             if (msg.message == WM_KEYDOWN) SetCursorPos( pt.x, pt.y );
 960             else
 961             {
 962                 RECT newRect = sizingRect;
 963
 964                 if (hittest == HTCAPTION) OffsetRect( &newRect, dx, dy );
 965                 if (ON_LEFT_BORDER(hittest)) newRect.left += dx;
 966                 else if (ON_RIGHT_BORDER(hittest)) newRect.right += dx;
 967                 if (ON_TOP_BORDER(hittest)) newRect.top += dy;
 968                 else if (ON_BOTTOM_BORDER(hittest)) newRect.bottom += dy;
 969                 NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
 970                 NC_DrawMovingFrame( hdc, &newRect, thickframe );
 971                 capturePoint = pt;
 972                 sizingRect = newRect;
 973             }
 974         }
 975     }
 976
 977     NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
 978     ReleaseCapture();
 979     if (wndPtr->dwStyle & WS_CHILD) ReleaseDC( wndPtr->hwndParent, hdc );
 980     else
 981     {
 982         ReleaseDC( 0, hdc );
 983         if (rootWindow == DefaultRootWindow(display)) XUngrabServer( display );
 984     }
 985     SendMessage( hwnd, WM_EXITSIZEMOVE, 0, 0 );
 986
 987       /* If Esc key, don't move the window */
 988     if ((msg.message == WM_KEYDOWN) && (msg.wParam == VK_ESCAPE)) return;
 989
 990     if (hittest != HTCAPTION)
 991         SetWindowPos( hwnd, 0, sizingRect.left, sizingRect.top,
 992                      sizingRect.right - sizingRect.left,
 993                      sizingRect.bottom - sizingRect.top,
 994                      SWP_NOACTIVATE | SWP_NOZORDER );
 995     else SetWindowPos( hwnd, 0, sizingRect.left, sizingRect.top, 0, 0,
 996                       SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER );
 997 }
 998
 999
1000 /***********************************************************************
1001  *           NC_TrackMinMaxBox
1002  *
1003  * Track a mouse button press on the minimize or maximize box.
1004  */
1005 static void NC_TrackMinMaxBox( HWND hwnd, WORD wParam )
1006 {
1007     MSG msg;
1008     HDC hdc = GetWindowDC( hwnd );
1009     BOOL pressed = TRUE;
1010
1011     SetCapture( hwnd );
1012     if (wParam == HTMINBUTTON) NC_DrawMinButton( hwnd, hdc, TRUE );
1013     else NC_DrawMaxButton( hwnd, hdc, TRUE );
1014
1015     do
1016     {
1017         BOOL oldstate = pressed;
1018         MSG_GetHardwareMessage( &msg );
1019
1020         pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1021         if (pressed != oldstate)
1022         {
1023             if (wParam == HTMINBUTTON) NC_DrawMinButton( hwnd, hdc, pressed );
1024             else NC_DrawMaxButton( hwnd, hdc, pressed );
1025         }
1026     } while (msg.message != WM_LBUTTONUP);
1027
1028     if (wParam == HTMINBUTTON) NC_DrawMinButton( hwnd, hdc, FALSE );
1029     else NC_DrawMaxButton( hwnd, hdc, FALSE );
1030
1031     ReleaseCapture();
1032     ReleaseDC( hwnd, hdc );
1033     if (!pressed) return;
1034
1035     if (wParam == HTMINBUTTON)
1036         SendMessage( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, *(LONG*)&msg.pt );
1037     else
1038         SendMessage( hwnd, WM_SYSCOMMAND,
1039                   IsZoomed(hwnd) ? SC_RESTORE : SC_MAXIMIZE, *(LONG*)&msg.pt );
1040 }
1041
1042
1043 /***********************************************************************
1044  *           NC_TrackScrollBar
1045  *
1046  * Track a mouse button press on the horizontal or vertical scroll-bar.
1047  */
1048 static void NC_TrackScrollBar( HWND hwnd, WORD wParam, POINT pt )
1049 {
1050     MSG         msg;
1051     WORD        scrollbar;
1052     if ((wParam & 0xfff0) == SC_HSCROLL)
1053     {
1054         if ((wParam & 0x0f) != HTHSCROLL) return;
1055         scrollbar = SB_HORZ;
1056     }
1057     else  /* SC_VSCROLL */
1058     {
1059         if ((wParam & 0x0f) != HTVSCROLL) return;
1060         scrollbar = SB_VERT;
1061     }
1062
1063     ScreenToClient( hwnd, &pt );
1064     ScrollBarButtonDown( hwnd, scrollbar, pt.x, pt.y );
1065     SetCapture( hwnd );
1066
1067     do
1068     {
1069         MSG_GetHardwareMessage( &msg );
1070         ScreenToClient( hwnd, &msg.pt );
1071         switch(msg.message)
1072         {
1073         case WM_LBUTTONUP:
1074             ScrollBarButtonUp( hwnd, scrollbar, msg.pt.x, msg.pt.y );
1075             break;
1076         case WM_MOUSEMOVE:
1077             ScrollBarMouseMove(hwnd, scrollbar, msg.wParam, msg.pt.x,msg.pt.y);
1078             break;
1079         }
1080     } while (msg.message != WM_LBUTTONUP);
1081     ReleaseCapture();
1082 }
1083
1084 /***********************************************************************
1085  *           NC_TrackSysMenu
1086  *
1087  * Track a mouse button press on the system menu.
1088  */
1089 static void NC_TrackSysMenu( HWND hwnd, HDC hdc, POINT pt )
1090 {
1091     RECT rect;
1092     WND *wndPtr = WIN_FindWndPtr( hwnd );
1093
1094     if (!(wndPtr->dwStyle & WS_SYSMENU)) return;
1095       /* If window has a menu, track the menu bar normally */
1096     if (HAS_MENU(wndPtr)) MENU_TrackMouseMenuBar( hwnd, pt );
1097     else
1098     {
1099           /* Otherwise track the system menu like a normal popup menu */
1100         NC_GetInsideRect( hwnd, &rect );
1101         OffsetRect( &rect, wndPtr->rectWindow.left, wndPtr->rectWindow.top );
1102         if (wndPtr->dwStyle & WS_CHILD)
1103             ClientToScreen( wndPtr->hwndParent, (POINT *)&rect );
1104         rect.right = rect.left + SYSMETRICS_CXSIZE;
1105         rect.bottom = rect.top + SYSMETRICS_CYSIZE;
1106         NC_DrawSysButton( hwnd, hdc, TRUE );
1107         TrackPopupMenu( wndPtr->hSysMenu, TPM_LEFTALIGN | TPM_LEFTBUTTON,
1108                         rect.left, rect.bottom, 0, hwnd, &rect );
1109         NC_DrawSysButton( hwnd, hdc, FALSE );
1110     }
1111 }
1112
1113
1114 /***********************************************************************
1115  *           NC_HandleNCLButtonDown
1116  *
1117  * Handle a WM_NCLBUTTONDOWN message. Called from DefWindowProc().
1118  */
1119 LONG NC_HandleNCLButtonDown( HWND hwnd, WORD wParam, LONG lParam )
1120 {
1121     HDC hdc = GetWindowDC( hwnd );
1122
1123     switch(wParam)  /* Hit test */
1124     {
1125     case HTCAPTION:
1126         SendMessage( hwnd, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam );
1127         break;
1128
1129     case HTSYSMENU:
1130         NC_TrackSysMenu( hwnd, hdc, MAKEPOINT(lParam) );
1131         break;
1132
1133     case HTMENU:
1134         SendMessage( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU, lParam );
1135         break;
1136
1137     case HTHSCROLL:
1138         SendMessage( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
1139         break;
1140
1141     case HTVSCROLL:
1142         SendMessage( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
1143         break;
1144
1145     case HTMINBUTTON:
1146     case HTMAXBUTTON:
1147         NC_TrackMinMaxBox( hwnd, wParam );
1148         break;
1149
1150     case HTLEFT:
1151     case HTRIGHT:
1152     case HTTOP:
1153     case HTTOPLEFT:
1154     case HTTOPRIGHT:
1155     case HTBOTTOM:
1156     case HTBOTTOMLEFT:
1157     case HTBOTTOMRIGHT:
1158         SendMessage( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - HTLEFT+1, lParam);
1159         break;
1160
1161     case HTBORDER:
1162         break;
1163     }
1164
1165     ReleaseDC( hwnd, hdc );
1166     return 0;
1167 }
1168
1169
1170 /***********************************************************************
1171  *           NC_HandleNCLButtonDblClk
1172  *
1173  * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
1174  */
1175 LONG NC_HandleNCLButtonDblClk( HWND hwnd, WORD wParam, LONG lParam )
1176 {
1177     /*
1178      * if this is an icon, send a restore since we are handling
1179      * a double click
1180      */
1181     if (IsIconic(hwnd))
1182     {
1183       SendMessage(hwnd, WM_SYSCOMMAND, SC_RESTORE, lParam);
1184       return 0;
1185     }
1186
1187     switch(wParam)  /* Hit test */
1188     {
1189     case HTCAPTION:
1190         SendMessage( hwnd, WM_SYSCOMMAND, SC_MAXIMIZE, lParam );
1191         break;
1192
1193     case HTSYSMENU:
1194         SendMessage( hwnd, WM_SYSCOMMAND, SC_CLOSE, lParam );
1195         break;
1196     }
1197     return 0;
1198 }
1199
1200
1201 /***********************************************************************
1202  *           NC_HandleSysCommand
1203  *
1204  * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
1205  */
1206 LONG NC_HandleSysCommand( HWND hwnd, WORD wParam, POINT pt )
1207 {
1208     WND *wndPtr = WIN_FindWndPtr( hwnd );
1209
1210     dprintf_nonclient(stddeb, "Handling WM_SYSCOMMAND %x %d,%d\n",
1211                       wParam, pt.x, pt.y );
1212
1213     if (wndPtr->dwStyle & WS_CHILD) ScreenToClient( wndPtr->hwndParent, &pt );
1214
1215     switch (wParam & 0xfff0)
1216     {
1217     case SC_SIZE:
1218     case SC_MOVE:
1219         NC_DoSizeMove( hwnd, wParam, pt );
1220         break;
1221
1222     case SC_MINIMIZE:
1223         ShowWindow( hwnd, SW_MINIMIZE );
1224         break;
1225
1226     case SC_MAXIMIZE:
1227         ShowWindow( hwnd, SW_MAXIMIZE );
1228         break;
1229
1230     case SC_RESTORE:
1231         ShowWindow( hwnd, SW_RESTORE );
1232         break;
1233
1234     case SC_NEXTWINDOW:
1235     case SC_PREVWINDOW:
1236         break;
1237
1238     case SC_CLOSE:
1239         return SendMessage( hwnd, WM_CLOSE, 0, 0 );
1240
1241     case SC_VSCROLL:
1242     case SC_HSCROLL:
1243     if (wndPtr->dwStyle & WS_CHILD) ClientToScreen(wndPtr->hwndParent, &pt);
1244         NC_TrackScrollBar( hwnd, wParam, pt );
1245         break;
1246
1247     case SC_MOUSEMENU:
1248         MENU_TrackMouseMenuBar( hwnd, pt );
1249         break;
1250
1251     case SC_KEYMENU:
1252         MENU_TrackKbdMenuBar( hwnd, wParam );
1253         break;
1254
1255     case SC_ARRANGE:
1256         break;
1257
1258     case SC_TASKLIST:
1259         /* WinExec( "taskman.exe", SW_SHOWNORMAL ); */
1260         break;
1261
1262     case SC_HOTKEY:
1263         break;
1264
1265     case SC_SCREENSAVE:
1266         if (wParam == SC_ABOUTWINE)
1267             DialogBox( hSysRes, MAKEINTRESOURCE(2),
1268                        hwnd, (FARPROC)AboutWine_Proc );
1269         break;
1270     }
1271     return 0;
1272 }