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