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