windows/nonclient.c

   1 /*
   2  * Non-client area window functions
   3  *
   4  * Copyright 1994 Alexandre Julliard
   5  *
   6  */
   7
   8 #include "win.h"
   9 #include "message.h"
  10 #include "sysmetrics.h"
  11 #include "user.h"
  12 #include "heap.h"
  13 #include "shell.h"
  14 #include "dialog.h"
  15 #include "syscolor.h"
  16 #include "menu.h"
  17 #include "winpos.h"
  18 #include "hook.h"
  19 #include "scroll.h"
  20 #include "nonclient.h"
  21 #include "graphics.h"
  22 #include "queue.h"
  23 #include "selectors.h"
  24 #include "stddebug.h"
  25 #include "debug.h"
  26 #include "options.h"
  27
  28
  29 static HBITMAP16 hbitmapClose = 0;
  30 static HBITMAP16 hbitmapMinimize = 0;
  31 static HBITMAP16 hbitmapMinimizeD = 0;
  32 static HBITMAP16 hbitmapMaximize = 0;
  33 static HBITMAP16 hbitmapMaximizeD = 0;
  34 static HBITMAP16 hbitmapRestore = 0;
  35 static HBITMAP16 hbitmapRestoreD = 0;
  36
  37 #define SC_ABOUTWINE            (SC_SCREENSAVE+1)
  38
  39   /* Some useful macros */
  40 #define HAS_DLGFRAME(style,exStyle) \
  41     (((exStyle) & WS_EX_DLGMODALFRAME) || \
  42      (((style) & WS_DLGFRAME) && !((style) & WS_BORDER)))
  43
  44 #define HAS_THICKFRAME(style) \
  45     (((style) & WS_THICKFRAME) && \
  46      !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
  47
  48 #define HAS_MENU(w)  (!((w)->dwStyle & WS_CHILD) && ((w)->wIDmenu != 0))
  49
  50 #define ON_LEFT_BORDER(hit) \
  51  (((hit) == HTLEFT) || ((hit) == HTTOPLEFT) || ((hit) == HTBOTTOMLEFT))
  52 #define ON_RIGHT_BORDER(hit) \
  53  (((hit) == HTRIGHT) || ((hit) == HTTOPRIGHT) || ((hit) == HTBOTTOMRIGHT))
  54 #define ON_TOP_BORDER(hit) \
  55  (((hit) == HTTOP) || ((hit) == HTTOPLEFT) || ((hit) == HTTOPRIGHT))
  56 #define ON_BOTTOM_BORDER(hit) \
  57  (((hit) == HTBOTTOM) || ((hit) == HTBOTTOMLEFT) || ((hit) == HTBOTTOMRIGHT))
  58
  59 extern HCURSOR16 CURSORICON_IconToCursor( HICON16, BOOL32 );
  60
  61 /***********************************************************************
  62  *           NC_AdjustRect
  63  *
  64  * Compute the size of the window rectangle from the size of the
  65  * client rectangle.
  66  */
  67 static void NC_AdjustRect( LPRECT16 rect, DWORD style, BOOL32 menu,
  68                            DWORD exStyle )
  69 {
  70     if(style & WS_ICONIC) return;
  71     /* Decide if the window will be managed (see CreateWindowEx) */
  72     if (!(Options.managed && !(style & WS_CHILD) &&
  73           ((style & (WS_DLGFRAME | WS_THICKFRAME)) ||
  74            (exStyle & WS_EX_DLGMODALFRAME))))
  75     {
  76         if (HAS_DLGFRAME( style, exStyle ))
  77             InflateRect16(rect, SYSMETRICS_CXDLGFRAME, SYSMETRICS_CYDLGFRAME );
  78         else
  79         {
  80             if (HAS_THICKFRAME(style))
  81                 InflateRect16( rect, SYSMETRICS_CXFRAME, SYSMETRICS_CYFRAME );
  82             if (style & WS_BORDER)
  83                 InflateRect16( rect, SYSMETRICS_CXBORDER, SYSMETRICS_CYBORDER);
  84         }
  85
  86         if ((style & WS_CAPTION) == WS_CAPTION)
  87             rect->top -= SYSMETRICS_CYCAPTION - SYSMETRICS_CYBORDER;
  88     }
  89     if (menu) rect->top -= SYSMETRICS_CYMENU + SYSMETRICS_CYBORDER;
  90
  91     if (style & WS_VSCROLL) rect->right  += SYSMETRICS_CXVSCROLL;
  92     if (style & WS_HSCROLL) rect->bottom += SYSMETRICS_CYHSCROLL;
  93 }
  94
  95
  96 /***********************************************************************
  97  *           AdjustWindowRect16    (USER.102)
  98  */
  99 BOOL16 AdjustWindowRect16( LPRECT16 rect, DWORD style, BOOL16 menu )
 100 {
 101     return AdjustWindowRectEx16( rect, style, menu, 0 );
 102 }
 103
 104
 105 /***********************************************************************
 106  *           AdjustWindowRect32    (USER32.)
 107  */
 108 BOOL32 AdjustWindowRect32( LPRECT32 rect, DWORD style, BOOL32 menu )
 109 {
 110     return AdjustWindowRectEx32( rect, style, menu, 0 );
 111 }
 112
 113
 114 /***********************************************************************
 115  *           AdjustWindowRectEx16    (USER.454)
 116  */
 117 BOOL16 AdjustWindowRectEx16( LPRECT16 rect, DWORD style,
 118                              BOOL16 menu, DWORD exStyle )
 119 {
 120       /* Correct the window style */
 121
 122     if (!(style & (WS_POPUP | WS_CHILD)))  /* Overlapped window */
 123         style |= WS_CAPTION;
 124     style &= (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME | WS_CHILD);
 125     exStyle &= WS_EX_DLGMODALFRAME;
 126     if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
 127
 128     dprintf_nonclient(stddeb, "AdjustWindowRectEx: (%d,%d)-(%d,%d) %08lx %d %08lx\n",
 129                       rect->left, rect->top, rect->right, rect->bottom,
 130                       style, menu, exStyle );
 131
 132     NC_AdjustRect( rect, style, menu, exStyle );
 133     return TRUE;
 134 }
 135
 136
 137 /***********************************************************************
 138  *           AdjustWindowRectEx32    (USER32.)
 139  */
 140 BOOL32 AdjustWindowRectEx32( LPRECT32 rect, DWORD style,
 141                              BOOL32 menu, DWORD exStyle )
 142 {
 143     RECT16 rect16;
 144     BOOL32 ret;
 145
 146     CONV_RECT32TO16( rect, &rect16 );
 147     ret = AdjustWindowRectEx16( &rect16, style, (BOOL16)menu, exStyle );
 148     CONV_RECT16TO32( &rect16, rect );
 149     return ret;
 150 }
 151
 152
 153 /*******************************************************************
 154  *         NC_GetMinMaxInfo
 155  *
 156  * Get the minimized and maximized information for a window.
 157  */
 158 void NC_GetMinMaxInfo( WND *wndPtr, POINT16 *maxSize, POINT16 *maxPos,
 159                        POINT16 *minTrack, POINT16 *maxTrack )
 160 {
 161     MINMAXINFO16 *MinMax;
 162     short xinc, yinc;
 163
 164     if (!(MinMax = SEGPTR_NEW(MINMAXINFO16))) return;
 165
 166       /* Compute default values */
 167
 168     MinMax->ptMaxSize.x = SYSMETRICS_CXSCREEN;
 169     MinMax->ptMaxSize.y = SYSMETRICS_CYSCREEN;
 170     MinMax->ptMinTrackSize.x = SYSMETRICS_CXMINTRACK;
 171     MinMax->ptMinTrackSize.y = SYSMETRICS_CYMINTRACK;
 172     MinMax->ptMaxTrackSize.x = SYSMETRICS_CXSCREEN;
 173     MinMax->ptMaxTrackSize.y = SYSMETRICS_CYSCREEN;
 174
 175     if (wndPtr->flags & WIN_MANAGED) xinc = yinc = 0;
 176     else if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
 177     {
 178         xinc = SYSMETRICS_CXDLGFRAME;
 179         yinc = SYSMETRICS_CYDLGFRAME;
 180     }
 181     else
 182     {
 183         xinc = yinc = 0;
 184         if (HAS_THICKFRAME(wndPtr->dwStyle))
 185         {
 186             xinc += SYSMETRICS_CXFRAME;
 187             yinc += SYSMETRICS_CYFRAME;
 188         }
 189         if (wndPtr->dwStyle & WS_BORDER)
 190         {
 191             xinc += SYSMETRICS_CXBORDER;
 192             yinc += SYSMETRICS_CYBORDER;
 193         }
 194     }
 195     MinMax->ptMaxSize.x += 2 * xinc;
 196     MinMax->ptMaxSize.y += 2 * yinc;
 197
 198     /* Note: The '+' in the following test should really be a ||, but
 199      * that would cause gcc-2.7.0 to generate incorrect code.
 200      */
 201     if ((wndPtr->ptMaxPos.x != -1) + (wndPtr->ptMaxPos.y != -1))
 202         MinMax->ptMaxPosition = wndPtr->ptMaxPos;
 203     else
 204     {
 205         MinMax->ptMaxPosition.x = -xinc;
 206         MinMax->ptMaxPosition.y = -yinc;
 207     }
 208
 209     SendMessage16( wndPtr->hwndSelf, WM_GETMINMAXINFO, 0,
 210                    (LPARAM)SEGPTR_GET(MinMax) );
 211
 212       /* Some sanity checks */
 213
 214     dprintf_nonclient(stddeb,
 215                       "NC_GetMinMaxInfo: %d %d / %d %d / %d %d / %d %d\n",
 216                       MinMax->ptMaxSize.x, MinMax->ptMaxSize.y,
 217                       MinMax->ptMaxPosition.x, MinMax->ptMaxPosition.y,
 218                       MinMax->ptMaxTrackSize.x, MinMax->ptMaxTrackSize.y,
 219                       MinMax->ptMinTrackSize.x, MinMax->ptMinTrackSize.y);
 220     MinMax->ptMaxTrackSize.x = MAX( MinMax->ptMaxTrackSize.x,
 221                                    MinMax->ptMinTrackSize.x );
 222     MinMax->ptMaxTrackSize.y = MAX( MinMax->ptMaxTrackSize.y,
 223                                    MinMax->ptMinTrackSize.y );
 224
 225     if (maxSize) *maxSize = MinMax->ptMaxSize;
 226     if (maxPos) *maxPos = MinMax->ptMaxPosition;
 227     if (minTrack) *minTrack = MinMax->ptMinTrackSize;
 228     if (maxTrack) *maxTrack = MinMax->ptMaxTrackSize;
 229     SEGPTR_FREE(MinMax);
 230 }
 231
 232
 233 /***********************************************************************
 234  *           NC_HandleNCCalcSize
 235  *
 236  * Handle a WM_NCCALCSIZE message. Called from DefWindowProc().
 237  */
 238 LONG NC_HandleNCCalcSize( WND *pWnd, RECT16 *winRect )
 239 {
 240     RECT16 tmpRect = { 0, 0, 0, 0 };
 241     LONG result = 0;
 242
 243     if (pWnd->class->style & CS_VREDRAW) result |= WVR_VREDRAW;
 244     if (pWnd->class->style & CS_HREDRAW) result |= WVR_HREDRAW;
 245
 246     if( !( pWnd->dwStyle & WS_MINIMIZE ) )
 247     {
 248       NC_AdjustRect( &tmpRect, pWnd->dwStyle, FALSE, pWnd->dwExStyle );
 249       winRect->left   -= tmpRect.left;
 250       winRect->top    -= tmpRect.top;
 251       winRect->right  -= tmpRect.right;
 252       winRect->bottom -= tmpRect.bottom;
 253
 254       if (HAS_MENU(pWnd))
 255       {
 256         winRect->top += MENU_GetMenuBarHeight( pWnd->hwndSelf,
 257                                                winRect->right - winRect->left,
 258                                               -tmpRect.left, -tmpRect.top ) + 1;
 259       }
 260     }
 261     return result;
 262 }
 263
 264
 265 /***********************************************************************
 266  *           NC_GetInsideRect
 267  *
 268  * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
 269  * but without the borders (if any).
 270  * The rectangle is in window coordinates (for drawing with GetWindowDC()).
 271  */
 272 static void NC_GetInsideRect( HWND32 hwnd, RECT32 *rect )
 273 {
 274     WND * wndPtr = WIN_FindWndPtr( hwnd );
 275
 276     rect->top    = rect->left = 0;
 277     rect->right  = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
 278     rect->bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
 279
 280     if ((wndPtr->dwStyle & WS_ICONIC) || (wndPtr->flags & WIN_MANAGED)) return;
 281
 282       /* Remove frame from rectangle */
 283     if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
 284     {
 285         InflateRect32( rect, -SYSMETRICS_CXDLGFRAME, -SYSMETRICS_CYDLGFRAME);
 286         if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME)
 287             InflateRect32( rect, -1, 0 );
 288     }
 289     else
 290     {
 291         if (HAS_THICKFRAME( wndPtr->dwStyle ))
 292             InflateRect32( rect, -SYSMETRICS_CXFRAME, -SYSMETRICS_CYFRAME );
 293         if (wndPtr->dwStyle & WS_BORDER)
 294             InflateRect32( rect, -SYSMETRICS_CXBORDER, -SYSMETRICS_CYBORDER );
 295     }
 296 }
 297
 298
 299 /***********************************************************************
 300  *           NC_HandleNCHitTest
 301  *
 302  * Handle a WM_NCHITTEST message. Called from DefWindowProc().
 303  */
 304 LONG NC_HandleNCHitTest( HWND32 hwnd, POINT16 pt )
 305 {
 306     RECT16 rect;
 307     WND *wndPtr = WIN_FindWndPtr( hwnd );
 308     if (!wndPtr) return HTERROR;
 309
 310     dprintf_nonclient(stddeb, "NC_HandleNCHitTest: hwnd=%04x pt=%d,%d\n",
 311                       hwnd, pt.x, pt.y );
 312
 313     GetWindowRect16( hwnd, &rect );
 314     if (!PtInRect16( &rect, pt )) return HTNOWHERE;
 315
 316     if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
 317
 318     if (!(wndPtr->flags & WIN_MANAGED))
 319     {
 320         /* Check borders */
 321         if (HAS_THICKFRAME( wndPtr->dwStyle ))
 322         {
 323             InflateRect16( &rect, -SYSMETRICS_CXFRAME, -SYSMETRICS_CYFRAME );
 324             if (wndPtr->dwStyle & WS_BORDER)
 325                 InflateRect16(&rect,-SYSMETRICS_CXBORDER,-SYSMETRICS_CYBORDER);
 326             if (!PtInRect16( &rect, pt ))
 327             {
 328                 /* Check top sizing border */
 329                 if (pt.y < rect.top)
 330                 {
 331                     if (pt.x < rect.left+SYSMETRICS_CXSIZE) return HTTOPLEFT;
 332                     if (pt.x >= rect.right-SYSMETRICS_CXSIZE) return HTTOPRIGHT;
 333                     return HTTOP;
 334                 }
 335                 /* Check bottom sizing border */
 336                 if (pt.y >= rect.bottom)
 337                 {
 338                     if (pt.x < rect.left+SYSMETRICS_CXSIZE) return HTBOTTOMLEFT;
 339                     if (pt.x >= rect.right-SYSMETRICS_CXSIZE) return HTBOTTOMRIGHT;
 340                     return HTBOTTOM;
 341                 }
 342                 /* Check left sizing border */
 343                 if (pt.x < rect.left)
 344                 {
 345                     if (pt.y < rect.top+SYSMETRICS_CYSIZE) return HTTOPLEFT;
 346                     if (pt.y >= rect.bottom-SYSMETRICS_CYSIZE) return HTBOTTOMLEFT;
 347                     return HTLEFT;
 348                 }
 349                 /* Check right sizing border */
 350                 if (pt.x >= rect.right)
 351                 {
 352                     if (pt.y < rect.top+SYSMETRICS_CYSIZE) return HTTOPRIGHT;
 353                     if (pt.y >= rect.bottom-SYSMETRICS_CYSIZE) return HTBOTTOMRIGHT;
 354                     return HTRIGHT;
 355                 }
 356             }
 357         }
 358         else  /* No thick frame */
 359         {
 360             if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
 361                 InflateRect16(&rect, -SYSMETRICS_CXDLGFRAME, -SYSMETRICS_CYDLGFRAME);
 362             else if (wndPtr->dwStyle & WS_BORDER)
 363                 InflateRect16(&rect, -SYSMETRICS_CXBORDER, -SYSMETRICS_CYBORDER);
 364             if (!PtInRect16( &rect, pt )) return HTBORDER;
 365         }
 366
 367         /* Check caption */
 368
 369         if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
 370         {
 371             rect.top += SYSMETRICS_CYCAPTION - 1;
 372             if (!PtInRect16( &rect, pt ))
 373             {
 374                 /* Check system menu */
 375                 if (wndPtr->dwStyle & WS_SYSMENU)
 376                     rect.left += SYSMETRICS_CXSIZE;
 377                 if (pt.x <= rect.left) return HTSYSMENU;
 378                 /* Check maximize box */
 379                 if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
 380                     rect.right -= SYSMETRICS_CXSIZE + 1;
 381                 if (pt.x >= rect.right) return HTMAXBUTTON;
 382                 /* Check minimize box */
 383                 if (wndPtr->dwStyle & WS_MINIMIZEBOX)
 384                     rect.right -= SYSMETRICS_CXSIZE + 1;
 385                 if (pt.x >= rect.right) return HTMINBUTTON;
 386                 return HTCAPTION;
 387             }
 388         }
 389     }
 390
 391       /* Check client area */
 392
 393     ScreenToClient16( hwnd, &pt );
 394     GetClientRect16( hwnd, &rect );
 395     if (PtInRect16( &rect, pt )) return HTCLIENT;
 396
 397       /* Check vertical scroll bar */
 398
 399     if (wndPtr->dwStyle & WS_VSCROLL)
 400     {
 401         rect.right += SYSMETRICS_CXVSCROLL;
 402         if (PtInRect16( &rect, pt )) return HTVSCROLL;
 403     }
 404
 405       /* Check horizontal scroll bar */
 406
 407     if (wndPtr->dwStyle & WS_HSCROLL)
 408     {
 409         rect.bottom += SYSMETRICS_CYHSCROLL;
 410         if (PtInRect16( &rect, pt ))
 411         {
 412               /* Check size box */
 413             if ((wndPtr->dwStyle & WS_VSCROLL) &&
 414                 (pt.x >= rect.right - SYSMETRICS_CXVSCROLL))
 415                 return HTSIZE;
 416             return HTHSCROLL;
 417         }
 418     }
 419
 420       /* Check menu bar */
 421
 422     if (HAS_MENU(wndPtr))
 423     {
 424         if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
 425             return HTMENU;
 426     }
 427
 428       /* Should never get here */
 429     return HTERROR;
 430 }
 431
 432
 433 /***********************************************************************
 434  *           NC_DrawSysButton
 435  */
 436 void NC_DrawSysButton( HWND32 hwnd, HDC32 hdc, BOOL32 down )
 437 {
 438     RECT32 rect;
 439     HDC32 hdcMem;
 440     HBITMAP32 hbitmap;
 441     WND *wndPtr = WIN_FindWndPtr( hwnd );
 442
 443     if( !(wndPtr->flags & WIN_MANAGED) )
 444     {
 445       NC_GetInsideRect( hwnd, &rect );
 446       hdcMem = CreateCompatibleDC32( hdc );
 447       hbitmap = SelectObject32( hdcMem, hbitmapClose );
 448       BitBlt32(hdc, rect.left, rect.top, SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE,
 449                hdcMem, (wndPtr->dwStyle & WS_CHILD) ? SYSMETRICS_CXSIZE : 0, 0,
 450                down ? NOTSRCCOPY : SRCCOPY );
 451       SelectObject32( hdcMem, hbitmap );
 452       DeleteDC32( hdcMem );
 453     }
 454 }
 455
 456
 457 /***********************************************************************
 458  *           NC_DrawMaxButton
 459  */
 460 static void NC_DrawMaxButton( HWND32 hwnd, HDC16 hdc, BOOL32 down )
 461 {
 462     RECT32 rect;
 463     WND *wndPtr = WIN_FindWndPtr( hwnd );
 464
 465     if( !(wndPtr->flags & WIN_MANAGED) )
 466     {
 467       NC_GetInsideRect( hwnd, &rect );
 468       GRAPH_DrawBitmap( hdc, (IsZoomed32(hwnd) ?
 469                              (down ? hbitmapRestoreD : hbitmapRestore) :
 470                              (down ? hbitmapMaximizeD : hbitmapMaximize)),
 471                         rect.right - SYSMETRICS_CXSIZE - 1, rect.top,
 472                         0, 0, SYSMETRICS_CXSIZE+1, SYSMETRICS_CYSIZE );
 473     }
 474 }
 475
 476
 477 /***********************************************************************
 478  *           NC_DrawMinButton
 479  */
 480 static void NC_DrawMinButton( HWND32 hwnd, HDC16 hdc, BOOL32 down )
 481 {
 482     RECT32 rect;
 483     WND *wndPtr = WIN_FindWndPtr( hwnd );
 484
 485     if( !(wndPtr->flags & WIN_MANAGED) )
 486     {
 487       NC_GetInsideRect( hwnd, &rect );
 488       if (wndPtr->dwStyle & WS_MAXIMIZEBOX) rect.right -= SYSMETRICS_CXSIZE+1;
 489       GRAPH_DrawBitmap( hdc, (down ? hbitmapMinimizeD : hbitmapMinimize),
 490                         rect.right - SYSMETRICS_CXSIZE - 1, rect.top,
 491                         0, 0, SYSMETRICS_CXSIZE+1, SYSMETRICS_CYSIZE );
 492     }
 493 }
 494
 495
 496 /***********************************************************************
 497  *           NC_DrawFrame
 498  *
 499  * Draw a window frame inside the given rectangle, and update the rectangle.
 500  * The correct pen for the frame must be selected in the DC.
 501  */
 502 static void NC_DrawFrame( HDC32 hdc, RECT32 *rect, BOOL32 dlgFrame,
 503                           BOOL32 active )
 504 {
 505     INT32 width, height;
 506
 507     if (dlgFrame)
 508     {
 509         width = SYSMETRICS_CXDLGFRAME - 1;
 510         height = SYSMETRICS_CYDLGFRAME - 1;
 511         SelectObject32( hdc, active ? sysColorObjects.hbrushActiveCaption :
 512                                       sysColorObjects.hbrushInactiveCaption );
 513     }
 514     else
 515     {
 516         width = SYSMETRICS_CXFRAME - 1;
 517         height = SYSMETRICS_CYFRAME - 1;
 518         SelectObject32( hdc, active ? sysColorObjects.hbrushActiveBorder :
 519                                       sysColorObjects.hbrushInactiveBorder );
 520     }
 521
 522       /* Draw frame */
 523     PatBlt32( hdc, rect->left, rect->top,
 524               rect->right - rect->left, height, PATCOPY );
 525     PatBlt32( hdc, rect->left, rect->top,
 526               width, rect->bottom - rect->top, PATCOPY );
 527     PatBlt32( hdc, rect->left, rect->bottom,
 528               rect->right - rect->left, -height, PATCOPY );
 529     PatBlt32( hdc, rect->right, rect->top,
 530               -width, rect->bottom - rect->top, PATCOPY );
 531
 532     if (dlgFrame)
 533     {
 534         InflateRect32( rect, -width, -height );
 535     }
 536     else
 537     {
 538         POINT32 lpt[16];
 539
 540       /* Draw inner rectangle */
 541
 542         GRAPH_DrawRectangle( hdc, rect->left + width,
 543                                   rect->top + height,
 544                                   rect->right - rect->left - 2*width ,
 545                                   rect->bottom - rect->top - 2*height,
 546                                   (HPEN32)0 );
 547
 548       /* Draw the decorations */
 549
 550         lpt[4].x = lpt[0].x = rect->left;
 551         lpt[5].x = lpt[1].x = rect->left + width;
 552         lpt[6].x = lpt[2].x = rect->right - width - 1;
 553         lpt[7].x = lpt[3].x = rect->right - 1;
 554
 555         lpt[0].y = lpt[1].y = lpt[2].y = lpt[3].y =
 556                   rect->top + SYSMETRICS_CYFRAME + SYSMETRICS_CYSIZE;
 557         lpt[4].y = lpt[5].y = lpt[6].y = lpt[7].y =
 558                   rect->bottom - 1 - SYSMETRICS_CYFRAME - SYSMETRICS_CYSIZE;
 559
 560         lpt[8].x = lpt[9].x = lpt[10].x = lpt[11].x =
 561                   rect->left + SYSMETRICS_CXFRAME + SYSMETRICS_CXSIZE;
 562         lpt[12].x = lpt[13].x = lpt[14].x = lpt[15].x =
 563                   rect->right - 1 - SYSMETRICS_CXFRAME - SYSMETRICS_CYSIZE;
 564
 565         lpt[12].y = lpt[8].y = rect->top;
 566         lpt[13].y = lpt[9].y = rect->top + height;
 567         lpt[14].y = lpt[10].y = rect->bottom - height - 1;
 568         lpt[15].y = lpt[11].y = rect->bottom - 1;
 569
 570         GRAPH_DrawLines( hdc, lpt, 8, (HPEN32)0 );      /* 8 is the maximum */
 571         InflateRect32( rect, -width - 1, -height - 1 );
 572     }
 573 }
 574
 575
 576 /***********************************************************************
 577  *           NC_DrawMovingFrame
 578  *
 579  * Draw the frame used when moving or resizing window.
 580  */
 581 static void NC_DrawMovingFrame( HDC16 hdc, RECT16 *rect, BOOL32 thickframe )
 582 {
 583     if (thickframe) FastWindowFrame( hdc, rect, SYSMETRICS_CXFRAME,
 584                                      SYSMETRICS_CYFRAME, PATINVERT );
 585     else DrawFocusRect16( hdc, rect );
 586 }
 587
 588
 589 /***********************************************************************
 590  *           NC_DrawCaption
 591  *
 592  * Draw the window caption.
 593  * The correct pen for the window frame must be selected in the DC.
 594  */
 595 static void NC_DrawCaption( HDC32 hdc, RECT32 *rect, HWND32 hwnd,
 596                             DWORD style, BOOL32 active )
 597 {
 598     RECT32 r = *rect;
 599     WND * wndPtr = WIN_FindWndPtr( hwnd );
 600     char buffer[256];
 601
 602     if (wndPtr->flags & WIN_MANAGED) return;
 603
 604     if (!hbitmapClose)
 605     {
 606         if (!(hbitmapClose = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_CLOSE) )))
 607             return;
 608         hbitmapMinimize  = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_REDUCE) );
 609         hbitmapMinimizeD = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_REDUCED) );
 610         hbitmapMaximize  = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_ZOOM) );
 611         hbitmapMaximizeD = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_ZOOMD) );
 612         hbitmapRestore   = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_RESTORE) );
 613         hbitmapRestoreD  = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_RESTORED) );
 614     }
 615
 616     if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME)
 617     {
 618         HBRUSH32 hbrushOld = SelectObject32(hdc, sysColorObjects.hbrushWindow);
 619         PatBlt32( hdc, r.left, r.top, 1, r.bottom-r.top+1,PATCOPY );
 620         PatBlt32( hdc, r.right-1, r.top, 1, r.bottom-r.top+1, PATCOPY );
 621         PatBlt32( hdc, r.left, r.top-1, r.right-r.left, 1, PATCOPY );
 622         r.left++;
 623         r.right--;
 624         SelectObject32( hdc, hbrushOld );
 625     }
 626
 627     MoveTo( hdc, r.left, r.bottom );
 628     LineTo32( hdc, r.right-1, r.bottom );
 629
 630     if (style & WS_SYSMENU)
 631     {
 632         NC_DrawSysButton( hwnd, hdc, FALSE );
 633         r.left += SYSMETRICS_CXSIZE + 1;
 634         MoveTo( hdc, r.left - 1, r.top );
 635         LineTo32( hdc, r.left - 1, r.bottom );
 636     }
 637     if (style & WS_MAXIMIZEBOX)
 638     {
 639         NC_DrawMaxButton( hwnd, hdc, FALSE );
 640         r.right -= SYSMETRICS_CXSIZE + 1;
 641     }
 642     if (style & WS_MINIMIZEBOX)
 643     {
 644         NC_DrawMinButton( hwnd, hdc, FALSE );
 645         r.right -= SYSMETRICS_CXSIZE + 1;
 646     }
 647
 648     FillRect32( hdc, &r, active ? sysColorObjects.hbrushActiveCaption :
 649                                   sysColorObjects.hbrushInactiveCaption );
 650
 651     if (GetWindowText32A( hwnd, buffer, sizeof(buffer) ))
 652     {
 653         if (active) SetTextColor32( hdc, GetSysColor32( COLOR_CAPTIONTEXT ) );
 654         else SetTextColor32( hdc, GetSysColor32( COLOR_INACTIVECAPTIONTEXT ) );
 655         SetBkMode32( hdc, TRANSPARENT );
 656         DrawText32A( hdc, buffer, -1, &r,
 657                      DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_NOPREFIX );
 658     }
 659 }
 660
 661
 662 /***********************************************************************
 663  *           NC_DoNCPaint
 664  *
 665  * Paint the non-client area. clip is currently unused.
 666  */
 667 void NC_DoNCPaint( HWND32 hwnd, HRGN32 clip, BOOL32 suppress_menupaint )
 668 {
 669     HDC32 hdc;
 670     RECT32 rect;
 671     BOOL32 active;
 672
 673     WND *wndPtr = WIN_FindWndPtr( hwnd );
 674
 675     if (!wndPtr || wndPtr->dwStyle & WS_MINIMIZE ||
 676         !WIN_IsWindowDrawable( wndPtr, 0 )) return; /* Nothing to do */
 677
 678     active  = wndPtr->flags & WIN_NCACTIVATED;
 679
 680     dprintf_nonclient(stddeb, "NC_DoNCPaint: %04x %d\n", hwnd, active );
 681
 682     if (!(hdc = GetDCEx32( hwnd, 0, DCX_USESTYLE | DCX_WINDOW ))) return;
 683
 684     if (ExcludeVisRect( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left,
 685                         wndPtr->rectClient.top-wndPtr->rectWindow.top,
 686                         wndPtr->rectClient.right-wndPtr->rectWindow.left,
 687                         wndPtr->rectClient.bottom-wndPtr->rectWindow.top )
 688         == NULLREGION)
 689     {
 690         ReleaseDC32( hwnd, hdc );
 691         return;
 692     }
 693
 694     rect.top = rect.left = 0;
 695     rect.right  = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
 696     rect.bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
 697
 698     SelectObject32( hdc, sysColorObjects.hpenWindowFrame );
 699
 700     if (!(wndPtr->flags & WIN_MANAGED))
 701     {
 702         if ((wndPtr->dwStyle & WS_BORDER) || (wndPtr->dwStyle & WS_DLGFRAME) ||
 703             (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME))
 704         {
 705             GRAPH_DrawRectangle( hdc, 0, 0,
 706                                  rect.right, rect.bottom, (HPEN32)0 );
 707             InflateRect32( &rect, -1, -1 );
 708         }
 709
 710         if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
 711             NC_DrawFrame( hdc, &rect, TRUE, active );
 712         else if (wndPtr->dwStyle & WS_THICKFRAME)
 713             NC_DrawFrame(hdc, &rect, FALSE, active );
 714
 715         if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
 716         {
 717             RECT32 r = rect;
 718             r.bottom = rect.top + SYSMETRICS_CYSIZE;
 719             rect.top += SYSMETRICS_CYSIZE + SYSMETRICS_CYBORDER;
 720             NC_DrawCaption( hdc, &r, hwnd, wndPtr->dwStyle, active );
 721         }
 722     }
 723
 724     if (HAS_MENU(wndPtr))
 725     {
 726         RECT32 r = rect;
 727         r.bottom = rect.top + SYSMETRICS_CYMENU;  /* default height */
 728         rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint );
 729     }
 730
 731       /* Draw the scroll-bars */
 732
 733     if (wndPtr->dwStyle & WS_VSCROLL)
 734         SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE );
 735     if (wndPtr->dwStyle & WS_HSCROLL)
 736         SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE );
 737
 738       /* Draw the "size-box" */
 739
 740     if ((wndPtr->dwStyle & WS_VSCROLL) && (wndPtr->dwStyle & WS_HSCROLL))
 741     {
 742         RECT32 r = rect;
 743         r.left = r.right - SYSMETRICS_CXVSCROLL + 1;
 744         r.top  = r.bottom - SYSMETRICS_CYHSCROLL + 1;
 745         FillRect32( hdc, &r, sysColorObjects.hbrushScrollbar );
 746     }
 747
 748     ReleaseDC32( hwnd, hdc );
 749 }
 750
 751
 752
 753 /***********************************************************************
 754  *           NC_HandleNCPaint
 755  *
 756  * Handle a WM_NCPAINT message. Called from DefWindowProc().
 757  */
 758 LONG NC_HandleNCPaint( HWND32 hwnd , HRGN32 clip)
 759 {
 760     NC_DoNCPaint( hwnd, clip, FALSE );
 761     return 0;
 762 }
 763
 764
 765 /***********************************************************************
 766  *           NC_HandleNCActivate
 767  *
 768  * Handle a WM_NCACTIVATE message. Called from DefWindowProc().
 769  */
 770 LONG NC_HandleNCActivate( WND *wndPtr, WPARAM16 wParam )
 771 {
 772     WORD wStateChange;
 773
 774     if( wParam ) wStateChange = !(wndPtr->flags & WIN_NCACTIVATED);
 775     else wStateChange = wndPtr->flags & WIN_NCACTIVATED;
 776
 777     if( wStateChange )
 778     {
 779       if (wParam) wndPtr->flags |= WIN_NCACTIVATED;
 780       else wndPtr->flags &= ~WIN_NCACTIVATED;
 781
 782       if( wndPtr->dwStyle & WS_MINIMIZE )
 783         PAINT_RedrawWindow( wndPtr->hwndSelf, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_ERASENOW, 0 );
 784       else
 785         NC_DoNCPaint( wndPtr->hwndSelf, (HRGN32)1, FALSE );
 786     }
 787     return TRUE;
 788 }
 789
 790
 791 /***********************************************************************
 792  *           NC_HandleSetCursor
 793  *
 794  * Handle a WM_SETCURSOR message. Called from DefWindowProc().
 795  */
 796 LONG NC_HandleSetCursor( HWND32 hwnd, WPARAM16 wParam, LPARAM lParam )
 797 {
 798     if (hwnd != (HWND32)wParam) return 0;  /* Don't set the cursor for child windows */
 799
 800     switch(LOWORD(lParam))
 801     {
 802     case HTERROR:
 803         {
 804             WORD msg = HIWORD( lParam );
 805             if ((msg == WM_LBUTTONDOWN) || (msg == WM_MBUTTONDOWN) ||
 806                 (msg == WM_RBUTTONDOWN))
 807                 MessageBeep32(0);
 808         }
 809         break;
 810
 811     case HTCLIENT:
 812         {
 813             WND *wndPtr;
 814             if (!(wndPtr = WIN_FindWndPtr( hwnd ))) break;
 815             if (wndPtr->class->hCursor)
 816             {
 817                 SetCursor16( wndPtr->class->hCursor );
 818                 return TRUE;
 819             }
 820             else return FALSE;
 821         }
 822
 823     case HTLEFT:
 824     case HTRIGHT:
 825         return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZEWE ) );
 826
 827     case HTTOP:
 828     case HTBOTTOM:
 829         return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENS ) );
 830
 831     case HTTOPLEFT:
 832     case HTBOTTOMRIGHT:
 833         return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENWSE ) );
 834
 835     case HTTOPRIGHT:
 836     case HTBOTTOMLEFT:
 837         return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENESW ) );
 838     }
 839
 840     /* Default cursor: arrow */
 841     return (LONG)SetCursor16( LoadCursor16( 0, IDC_ARROW ) );
 842 }
 843
 844 /***********************************************************************
 845  *           NC_GetSysPopupPos
 846  */
 847 BOOL32 NC_GetSysPopupPos( WND* wndPtr, RECT32* rect )
 848 {
 849   if( wndPtr->hSysMenu )
 850   {
 851       if( wndPtr->dwStyle & WS_MINIMIZE )
 852           GetWindowRect32( wndPtr->hwndSelf, rect );
 853       else
 854       {
 855           NC_GetInsideRect( wndPtr->hwndSelf, rect );
 856           OffsetRect32( rect, wndPtr->rectWindow.left, wndPtr->rectWindow.top);
 857           if (wndPtr->dwStyle & WS_CHILD)
 858               ClientToScreen32( wndPtr->parent->hwndSelf, (POINT32 *)rect );
 859           rect->right = rect->left + SYSMETRICS_CXSIZE;
 860           rect->bottom = rect->top + SYSMETRICS_CYSIZE;
 861       }
 862       return TRUE;
 863   }
 864   return FALSE;
 865 }
 866
 867 /***********************************************************************
 868  *           NC_TrackSysMenu
 869  *
 870  * Track a mouse button press on the system menu.
 871  */
 872 static void NC_TrackSysMenu( HWND32 hwnd, POINT16 pt )
 873 {
 874     WND*        wndPtr = WIN_FindWndPtr( hwnd );
 875
 876     if (wndPtr->dwStyle & WS_SYSMENU)
 877     {
 878         int     iconic, on = 1;
 879
 880         iconic = wndPtr->dwStyle & WS_MINIMIZE;
 881
 882         if( !iconic )
 883         {
 884              HDC16      hdc = GetWindowDC32(hwnd);
 885              RECT32     rect;
 886              RECT16     rTrack;
 887              BOOL32     bNew, bTrack = TRUE;
 888              MSG16      msg;
 889
 890              NC_GetSysPopupPos( wndPtr, &rect );
 891              CONV_RECT32TO16( &rect, &rTrack );
 892              MapWindowPoints16( 0, hwnd, (LPPOINT16)&rTrack, 2 );
 893
 894              /* track mouse while waiting for WM_LBUTTONUP */
 895
 896              NC_DrawSysButton( hwnd, hdc, bTrack );
 897              SetCapture32(hwnd);
 898              do
 899              {
 900                 msg.message = WM_NULL;
 901                 PeekMessage16( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE);
 902                 if( msg.message == WM_MOUSEMOVE )
 903                 {
 904                     if( (bNew = PtInRect16(&rTrack, MAKEPOINT16(msg.lParam))) )
 905                     {   if( bTrack ) continue; }
 906                     else
 907                     {   if(!bTrack ) continue; }
 908                     NC_DrawSysButton( hwnd, hdc, bTrack = bNew);
 909                 }
 910              } while( msg.message != WM_LBUTTONUP );
 911
 912              ReleaseCapture();
 913              ReleaseDC32(hwnd, hdc);
 914              on = PtInRect16(&rTrack, MAKEPOINT16(msg.lParam));
 915         }
 916
 917         if( on )
 918             SendMessage16( hwnd, WM_SYSCOMMAND,
 919                            SC_MOUSEMENU + HTSYSMENU, *((LPARAM*)&pt));
 920     }
 921 }
 922
 923
 924 /***********************************************************************
 925  *           NC_StartSizeMove
 926  *
 927  * Initialisation of a move or resize, when initiatied from a menu choice.
 928  * Return hit test code for caption or sizing border.
 929  */
 930 static LONG NC_StartSizeMove( HWND32 hwnd, WPARAM16 wParam,
 931                               POINT16 *capturePoint )
 932 {
 933     LONG hittest = 0;
 934     POINT16 pt;
 935     MSG16 msg;
 936     WND * wndPtr = WIN_FindWndPtr( hwnd );
 937
 938     if ((wParam & 0xfff0) == SC_MOVE)
 939     {
 940           /* Move pointer at the center of the caption */
 941         RECT32 rect;
 942         NC_GetInsideRect( hwnd, &rect );
 943         if (wndPtr->dwStyle & WS_SYSMENU)
 944             rect.left += SYSMETRICS_CXSIZE + 1;
 945         if (wndPtr->dwStyle & WS_MINIMIZEBOX)
 946             rect.right -= SYSMETRICS_CXSIZE + 1;
 947         if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
 948             rect.right -= SYSMETRICS_CXSIZE + 1;
 949         pt.x = wndPtr->rectWindow.left + (rect.right - rect.left) / 2;
 950         pt.y = wndPtr->rectWindow.top + rect.top + SYSMETRICS_CYSIZE/2;
 951         if (wndPtr->dwStyle & WS_CHILD)
 952             ClientToScreen16( wndPtr->parent->hwndSelf, &pt );
 953         hittest = HTCAPTION;
 954     }
 955     else  /* SC_SIZE */
 956     {
 957         SetCapture32(hwnd);
 958         while(!hittest)
 959         {
 960             MSG_InternalGetMessage( &msg, 0, 0, MSGF_SIZE, PM_REMOVE, FALSE );
 961             switch(msg.message)
 962             {
 963             case WM_MOUSEMOVE:
 964                 hittest = NC_HandleNCHitTest( hwnd, msg.pt );
 965                 pt = msg.pt;
 966                 if ((hittest < HTLEFT) || (hittest > HTBOTTOMRIGHT))
 967                     hittest = 0;
 968                 break;
 969
 970             case WM_LBUTTONUP:
 971                 return 0;
 972
 973             case WM_KEYDOWN:
 974                 switch(msg.wParam)
 975                 {
 976                 case VK_UP:
 977                     hittest = HTTOP;
 978                     pt.x =(wndPtr->rectWindow.left+wndPtr->rectWindow.right)/2;
 979                     pt.y = wndPtr->rectWindow.top + SYSMETRICS_CYFRAME / 2;
 980                     break;
 981                 case VK_DOWN:
 982                     hittest = HTBOTTOM;
 983                     pt.x =(wndPtr->rectWindow.left+wndPtr->rectWindow.right)/2;
 984                     pt.y = wndPtr->rectWindow.bottom - SYSMETRICS_CYFRAME / 2;
 985                     break;
 986                 case VK_LEFT:
 987                     hittest = HTLEFT;
 988                     pt.x = wndPtr->rectWindow.left + SYSMETRICS_CXFRAME / 2;
 989                     pt.y =(wndPtr->rectWindow.top+wndPtr->rectWindow.bottom)/2;
 990                     break;
 991                 case VK_RIGHT:
 992                     hittest = HTRIGHT;
 993                     pt.x = wndPtr->rectWindow.right - SYSMETRICS_CXFRAME / 2;
 994                     pt.y =(wndPtr->rectWindow.top+wndPtr->rectWindow.bottom)/2;
 995                     break;
 996                 case VK_RETURN:
 997                 case VK_ESCAPE: return 0;
 998                 }
 999             }
1000         }
1001     }
1002     *capturePoint = pt;
1003     SetCursorPos32( capturePoint->x, capturePoint->y );
1004     NC_HandleSetCursor( hwnd, (WPARAM16)hwnd, MAKELONG( hittest, WM_MOUSEMOVE ));
1005     return hittest;
1006 }
1007
1008
1009 /***********************************************************************
1010  *           NC_DoSizeMove
1011  *
1012  * Perform SC_MOVE and SC_SIZE commands.
1013  */
1014 static void NC_DoSizeMove( HWND32 hwnd, WORD wParam, POINT16 pt )
1015 {
1016     MSG16 msg;
1017     RECT16 sizingRect, mouseRect;
1018     HDC32 hdc;
1019     LONG hittest = (LONG)(wParam & 0x0f);
1020     HCURSOR16 hDragCursor = 0, hOldCursor = 0;
1021     POINT16   minTrack, maxTrack, capturePoint = pt;
1022     WND *     wndPtr = WIN_FindWndPtr( hwnd );
1023     BOOL32    thickframe = HAS_THICKFRAME( wndPtr->dwStyle );
1024     BOOL32    iconic = wndPtr->dwStyle & WS_MINIMIZE;
1025     int       moved = 0;
1026
1027     if (IsZoomed32(hwnd) || !IsWindowVisible32(hwnd) ||
1028         (wndPtr->flags & WIN_MANAGED)) return;
1029
1030     if ((wParam & 0xfff0) == SC_MOVE)
1031     {
1032         if (!(wndPtr->dwStyle & WS_CAPTION)) return;
1033         if (!hittest) hittest = NC_StartSizeMove( hwnd, wParam, &capturePoint );
1034         if (!hittest) return;
1035     }
1036     else  /* SC_SIZE */
1037     {
1038         if (!thickframe) return;
1039         if (hittest) hittest += HTLEFT-1;
1040         else
1041         {
1042             SetCapture32(hwnd);
1043             hittest = NC_StartSizeMove( hwnd, wParam, &capturePoint );
1044             if (!hittest)
1045             {
1046                 ReleaseCapture();
1047                 return;
1048             }
1049         }
1050     }
1051
1052       /* Get min/max info */
1053
1054     NC_GetMinMaxInfo( wndPtr, NULL, NULL, &minTrack, &maxTrack );
1055     sizingRect = wndPtr->rectWindow;
1056     if (wndPtr->dwStyle & WS_CHILD)
1057         GetClientRect16( wndPtr->parent->hwndSelf, &mouseRect );
1058     else SetRect16(&mouseRect, 0, 0, SYSMETRICS_CXSCREEN, SYSMETRICS_CYSCREEN);
1059     if (ON_LEFT_BORDER(hittest))
1060     {
1061         mouseRect.left  = MAX( mouseRect.left, sizingRect.right-maxTrack.x );
1062         mouseRect.right = MIN( mouseRect.right, sizingRect.right-minTrack.x );
1063     }
1064     else if (ON_RIGHT_BORDER(hittest))
1065     {
1066         mouseRect.left  = MAX( mouseRect.left, sizingRect.left+minTrack.x );
1067         mouseRect.right = MIN( mouseRect.right, sizingRect.left+maxTrack.x );
1068     }
1069     if (ON_TOP_BORDER(hittest))
1070     {
1071         mouseRect.top    = MAX( mouseRect.top, sizingRect.bottom-maxTrack.y );
1072         mouseRect.bottom = MIN( mouseRect.bottom,sizingRect.bottom-minTrack.y);
1073     }
1074     else if (ON_BOTTOM_BORDER(hittest))
1075     {
1076         mouseRect.top    = MAX( mouseRect.top, sizingRect.top+minTrack.y );
1077         mouseRect.bottom = MIN( mouseRect.bottom, sizingRect.top+maxTrack.y );
1078     }
1079     SendMessage16( hwnd, WM_ENTERSIZEMOVE, 0, 0 );
1080
1081     if (GetCapture32() != hwnd) SetCapture32( hwnd );
1082
1083     if (wndPtr->dwStyle & WS_CHILD)
1084     {
1085           /* Retrieve a default cache DC (without using the window style) */
1086         hdc = GetDCEx32( wndPtr->parent->hwndSelf, 0, DCX_CACHE );
1087     }
1088     else
1089     {  /* Grab the server only when moving top-level windows without desktop */
1090         hdc = GetDC32( 0 );
1091         if (rootWindow == DefaultRootWindow(display)) XGrabServer( display );
1092     }
1093
1094     if( iconic )
1095     {
1096       HICON16 hIcon = (wndPtr->class->hIcon)
1097                       ? wndPtr->class->hIcon
1098                       : (HICON16)SendMessage16( hwnd, WM_QUERYDRAGICON, 0, 0L);
1099       if( hIcon )
1100       {
1101         hDragCursor =  CURSORICON_IconToCursor( hIcon, TRUE );
1102         hOldCursor = SetCursor32(hDragCursor);
1103         ShowCursor32( TRUE );
1104       } else iconic = FALSE;
1105     }
1106
1107     if( !iconic ) NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
1108
1109     while(1)
1110     {
1111         int dx = 0, dy = 0;
1112
1113         MSG_InternalGetMessage( &msg, 0, 0, MSGF_SIZE, PM_REMOVE, FALSE );
1114
1115           /* Exit on button-up, Return, or Esc */
1116         if ((msg.message == WM_LBUTTONUP) ||
1117             ((msg.message == WM_KEYDOWN) &&
1118              ((msg.wParam == VK_RETURN) || (msg.wParam == VK_ESCAPE)))) break;
1119
1120         if ((msg.message != WM_KEYDOWN) && (msg.message != WM_MOUSEMOVE))
1121             continue;  /* We are not interested in other messages */
1122
1123         pt = msg.pt;
1124         if (wndPtr->dwStyle & WS_CHILD)
1125             ScreenToClient16( wndPtr->parent->hwndSelf, &pt );
1126
1127         if (msg.message == WM_KEYDOWN) switch(msg.wParam)
1128         {
1129             case VK_UP:    pt.y -= 8; break;
1130             case VK_DOWN:  pt.y += 8; break;
1131             case VK_LEFT:  pt.x -= 8; break;
1132             case VK_RIGHT: pt.x += 8; break;
1133         }
1134
1135         pt.x = MAX( pt.x, mouseRect.left );
1136         pt.x = MIN( pt.x, mouseRect.right );
1137         pt.y = MAX( pt.y, mouseRect.top );
1138         pt.y = MIN( pt.y, mouseRect.bottom );
1139
1140         dx = pt.x - capturePoint.x;
1141         dy = pt.y - capturePoint.y;
1142
1143         if (dx || dy)
1144         {
1145             moved = 1;
1146             if (msg.message == WM_KEYDOWN) SetCursorPos32( pt.x, pt.y );
1147             else
1148             {
1149                 RECT16 newRect = sizingRect;
1150
1151                 if (hittest == HTCAPTION) OffsetRect16( &newRect, dx, dy );
1152                 if (ON_LEFT_BORDER(hittest)) newRect.left += dx;
1153                 else if (ON_RIGHT_BORDER(hittest)) newRect.right += dx;
1154                 if (ON_TOP_BORDER(hittest)) newRect.top += dy;
1155                 else if (ON_BOTTOM_BORDER(hittest)) newRect.bottom += dy;
1156                 if( !iconic )
1157                 {
1158                   NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
1159                   NC_DrawMovingFrame( hdc, &newRect, thickframe );
1160                 }
1161                 capturePoint = pt;
1162                 sizingRect = newRect;
1163             }
1164         }
1165     }
1166
1167     ReleaseCapture();
1168     if( iconic )
1169     {
1170       ShowCursor32( FALSE );
1171       SetCursor32(hOldCursor);
1172       if( hDragCursor ) DestroyCursor32( hDragCursor );
1173     }
1174     else
1175       NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
1176
1177     if (wndPtr->dwStyle & WS_CHILD)
1178         ReleaseDC32( wndPtr->parent->hwndSelf, hdc );
1179     else
1180     {
1181         ReleaseDC32( 0, hdc );
1182         if (rootWindow == DefaultRootWindow(display)) XUngrabServer( display );
1183     }
1184
1185     if (HOOK_IsHooked( WH_CBT ))
1186     {
1187        RECT16* pr = SEGPTR_NEW(RECT16);
1188        if( pr )
1189        {
1190          *pr = sizingRect;
1191           if( HOOK_CallHooks16( WH_CBT, HCBT_MOVESIZE, hwnd,
1192                                 (LPARAM)SEGPTR_GET(pr)) )
1193               sizingRect = wndPtr->rectWindow;
1194           else
1195               sizingRect = *pr;
1196           SEGPTR_FREE(pr);
1197        }
1198     }
1199     SendMessage16( hwnd, WM_EXITSIZEMOVE, 0, 0 );
1200     SendMessage16( hwnd, WM_SETVISIBLE, !IsIconic16(hwnd), 0L);
1201
1202     /* Single click brings up the system menu when iconized */
1203
1204     if (!moved && (wndPtr->dwStyle & WS_MINIMIZE))
1205     {
1206         NC_TrackSysMenu( hwnd, pt );
1207         return;
1208     }
1209
1210       /* If Esc key, don't move the window */
1211     if ((msg.message == WM_KEYDOWN) && (msg.wParam == VK_ESCAPE)) return;
1212
1213     if (hittest != HTCAPTION)
1214         SetWindowPos32( hwnd, 0, sizingRect.left, sizingRect.top,
1215                         sizingRect.right - sizingRect.left,
1216                         sizingRect.bottom - sizingRect.top,
1217                         SWP_NOACTIVATE | SWP_NOZORDER );
1218     else SetWindowPos32( hwnd, 0, sizingRect.left, sizingRect.top, 0, 0,
1219                          SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER );
1220 }
1221
1222
1223 /***********************************************************************
1224  *           NC_TrackMinMaxBox
1225  *
1226  * Track a mouse button press on the minimize or maximize box.
1227  */
1228 static void NC_TrackMinMaxBox( HWND32 hwnd, WORD wParam )
1229 {
1230     MSG16 msg;
1231     HDC32 hdc = GetWindowDC32( hwnd );
1232     BOOL32 pressed = TRUE;
1233
1234     SetCapture32( hwnd );
1235     if (wParam == HTMINBUTTON) NC_DrawMinButton( hwnd, hdc, TRUE );
1236     else NC_DrawMaxButton( hwnd, hdc, TRUE );
1237
1238     do
1239     {
1240         BOOL32 oldstate = pressed;
1241         MSG_InternalGetMessage( &msg, 0, 0, 0, PM_REMOVE, FALSE );
1242
1243         pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1244         if (pressed != oldstate)
1245         {
1246             if (wParam == HTMINBUTTON) NC_DrawMinButton( hwnd, hdc, pressed );
1247             else NC_DrawMaxButton( hwnd, hdc, pressed );
1248         }
1249     } while (msg.message != WM_LBUTTONUP);
1250
1251     if (wParam == HTMINBUTTON) NC_DrawMinButton( hwnd, hdc, FALSE );
1252     else NC_DrawMaxButton( hwnd, hdc, FALSE );
1253
1254     ReleaseCapture();
1255     ReleaseDC32( hwnd, hdc );
1256     if (!pressed) return;
1257
1258     if (wParam == HTMINBUTTON)
1259         SendMessage16( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, *(LONG*)&msg.pt );
1260     else
1261         SendMessage16( hwnd, WM_SYSCOMMAND,
1262                   IsZoomed32(hwnd) ? SC_RESTORE:SC_MAXIMIZE, *(LONG*)&msg.pt );
1263 }
1264
1265
1266 /***********************************************************************
1267  *           NC_TrackScrollBar
1268  *
1269  * Track a mouse button press on the horizontal or vertical scroll-bar.
1270  */
1271 static void NC_TrackScrollBar( HWND32 hwnd, WPARAM32 wParam, POINT32 pt )
1272 {
1273     MSG16 *msg;
1274     INT32 scrollbar;
1275     WND *wndPtr = WIN_FindWndPtr( hwnd );
1276
1277     if ((wParam & 0xfff0) == SC_HSCROLL)
1278     {
1279         if ((wParam & 0x0f) != HTHSCROLL) return;
1280         scrollbar = SB_HORZ;
1281     }
1282     else  /* SC_VSCROLL */
1283     {
1284         if ((wParam & 0x0f) != HTVSCROLL) return;
1285         scrollbar = SB_VERT;
1286     }
1287
1288     if (!(msg = SEGPTR_NEW(MSG16))) return;
1289     pt.x -= wndPtr->rectWindow.left;
1290     pt.y -= wndPtr->rectWindow.top;
1291     SetCapture32( hwnd );
1292     SCROLL_HandleScrollEvent( hwnd, scrollbar, WM_LBUTTONDOWN, pt );
1293
1294     do
1295     {
1296         GetMessage16( SEGPTR_GET(msg), 0, 0, 0 );
1297         switch(msg->message)
1298         {
1299         case WM_LBUTTONUP:
1300         case WM_MOUSEMOVE:
1301         case WM_SYSTIMER:
1302             pt.x = LOWORD(msg->lParam) + wndPtr->rectClient.left -
1303               wndPtr->rectWindow.left;
1304             pt.y = HIWORD(msg->lParam) + wndPtr->rectClient.top -
1305               wndPtr->rectWindow.top;
1306             SCROLL_HandleScrollEvent( hwnd, scrollbar, msg->message, pt );
1307             break;
1308         default:
1309             TranslateMessage16( msg );
1310             DispatchMessage16( msg );
1311             break;
1312         }
1313         if (!IsWindow32( hwnd ))
1314         {
1315             ReleaseCapture();
1316             break;
1317         }
1318     } while (msg->message != WM_LBUTTONUP);
1319     SEGPTR_FREE(msg);
1320 }
1321
1322 /***********************************************************************
1323  *           NC_HandleNCLButtonDown
1324  *
1325  * Handle a WM_NCLBUTTONDOWN message. Called from DefWindowProc().
1326  */
1327 LONG NC_HandleNCLButtonDown( HWND32 hwnd, WPARAM16 wParam, LPARAM lParam )
1328 {
1329     switch(wParam)  /* Hit test */
1330     {
1331     case HTCAPTION:
1332         SendMessage16( hwnd, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam );
1333         break;
1334
1335     case HTSYSMENU:
1336         NC_TrackSysMenu( hwnd, MAKEPOINT16(lParam) );
1337         break;
1338
1339     case HTMENU:
1340         SendMessage16( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU, lParam );
1341         break;
1342
1343     case HTHSCROLL:
1344         SendMessage16( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
1345         break;
1346
1347     case HTVSCROLL:
1348         SendMessage16( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
1349         break;
1350
1351     case HTMINBUTTON:
1352     case HTMAXBUTTON:
1353         NC_TrackMinMaxBox( hwnd, wParam );
1354         break;
1355
1356     case HTLEFT:
1357     case HTRIGHT:
1358     case HTTOP:
1359     case HTTOPLEFT:
1360     case HTTOPRIGHT:
1361     case HTBOTTOM:
1362     case HTBOTTOMLEFT:
1363     case HTBOTTOMRIGHT:
1364         SendMessage16( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - HTLEFT+1, lParam);
1365         break;
1366
1367     case HTBORDER:
1368         break;
1369     }
1370     return 0;
1371 }
1372
1373
1374 /***********************************************************************
1375  *           NC_HandleNCLButtonDblClk
1376  *
1377  * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
1378  */
1379 LONG NC_HandleNCLButtonDblClk( WND *pWnd, WPARAM16 wParam, LPARAM lParam )
1380 {
1381     /*
1382      * if this is an icon, send a restore since we are handling
1383      * a double click
1384      */
1385     if (pWnd->dwStyle & WS_MINIMIZE)
1386     {
1387         SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_RESTORE, lParam );
1388         return 0;
1389     }
1390
1391     switch(wParam)  /* Hit test */
1392     {
1393     case HTCAPTION:
1394         /* stop processing if WS_MAXIMIZEBOX is missing */
1395         if (pWnd->dwStyle & WS_MAXIMIZEBOX)
1396             SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND,
1397                       (pWnd->dwStyle & WS_MAXIMIZE) ? SC_RESTORE : SC_MAXIMIZE,
1398                       lParam );
1399         break;
1400
1401     case HTSYSMENU:
1402         if (!(pWnd->class->style & CS_NOCLOSE))
1403             SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_CLOSE, lParam );
1404         break;
1405     }
1406     return 0;
1407 }
1408
1409
1410 /***********************************************************************
1411  *           NC_HandleSysCommand
1412  *
1413  * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
1414  */
1415 LONG NC_HandleSysCommand( HWND32 hwnd, WPARAM16 wParam, POINT16 pt )
1416 {
1417     WND *wndPtr = WIN_FindWndPtr( hwnd );
1418     POINT32 pt32;
1419
1420     dprintf_nonclient(stddeb, "Handling WM_SYSCOMMAND %x %d,%d\n",
1421                       wParam, pt.x, pt.y );
1422
1423     if (wndPtr->dwStyle & WS_CHILD && wParam != SC_KEYMENU )
1424         ScreenToClient16( wndPtr->parent->hwndSelf, &pt );
1425
1426     switch (wParam & 0xfff0)
1427     {
1428     case SC_SIZE:
1429     case SC_MOVE:
1430         NC_DoSizeMove( hwnd, wParam, pt );
1431         break;
1432
1433     case SC_MINIMIZE:
1434         ShowWindow32( hwnd, SW_MINIMIZE );
1435         break;
1436
1437     case SC_MAXIMIZE:
1438         ShowWindow32( hwnd, SW_MAXIMIZE );
1439         break;
1440
1441     case SC_RESTORE:
1442         ShowWindow32( hwnd, SW_RESTORE );
1443         break;
1444
1445     case SC_CLOSE:
1446         return SendMessage16( hwnd, WM_CLOSE, 0, 0 );
1447
1448     case SC_VSCROLL:
1449     case SC_HSCROLL:
1450         CONV_POINT16TO32( &pt, &pt32 );
1451         NC_TrackScrollBar( hwnd, wParam, pt32 );
1452         break;
1453
1454     case SC_MOUSEMENU:
1455         CONV_POINT16TO32( &pt, &pt32 );
1456         MENU_TrackMouseMenuBar( wndPtr, wParam & 0x000F, pt32 );
1457         break;
1458
1459     case SC_KEYMENU:
1460         MENU_TrackKbdMenuBar( wndPtr , wParam , pt.x );
1461         break;
1462
1463     case SC_TASKLIST:
1464         WinExec32( "taskman.exe", SW_SHOWNORMAL );
1465         break;
1466
1467     case SC_SCREENSAVE:
1468         if (wParam == SC_ABOUTWINE)
1469         {
1470             extern const char people[];
1471             ShellAbout32A(hwnd,"Wine",people,0);
1472         }
1473         break;
1474
1475     case SC_HOTKEY:
1476     case SC_ARRANGE:
1477     case SC_NEXTWINDOW:
1478     case SC_PREVWINDOW:
1479         /* FIXME: unimplemented */
1480         break;
1481     }
1482     return 0;
1483 }