windows/winpos.c

   1 /*
   2  * Window position related functions.
   3  *
   4  * Copyright 1993, 1994 Alexandre Julliard
   5  */
   6
   7 static char Copyright[] = "Copyright  Alexandre Julliard, 1993, 1994";
   8
   9 #include "sysmetrics.h"
  10 #include "user.h"
  11 #include "win.h"
  12 #include "message.h"
  13 #include "winpos.h"
  14 #include "stddebug.h"
  15 /* #define DEBUG_WIN */
  16 /* #undef  DEBUG_WIN */
  17 #include "debug.h"
  18
  19 static HWND hwndActive = 0;  /* Currently active window */
  20
  21
  22 /***********************************************************************
  23  *           GetWindowRect   (USER.32)
  24  */
  25 void GetWindowRect( HWND hwnd, LPRECT rect )
  26 {
  27     WND * wndPtr = WIN_FindWndPtr( hwnd );
  28     if (!wndPtr) return;
  29
  30     *rect = wndPtr->rectWindow;
  31     if (wndPtr->dwStyle & WS_CHILD)
  32         MapWindowPoints( wndPtr->hwndParent, 0, (POINT *)rect, 2 );
  33 }
  34
  35
  36 /***********************************************************************
  37  *           GetClientRect   (USER.33)
  38  */
  39 void GetClientRect( HWND hwnd, LPRECT rect )
  40 {
  41     WND * wndPtr = WIN_FindWndPtr( hwnd );
  42
  43     rect->left = rect->top = rect->right = rect->bottom = 0;
  44     if (wndPtr)
  45     {
  46         rect->right  = wndPtr->rectClient.right - wndPtr->rectClient.left;
  47         rect->bottom = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
  48     }
  49 }
  50
  51
  52 /*******************************************************************
  53  *         ClientToScreen   (USER.28)
  54  */
  55 void ClientToScreen( HWND hwnd, LPPOINT lppnt )
  56 {
  57     MapWindowPoints( hwnd, 0, lppnt, 1 );
  58 }
  59
  60
  61 /*******************************************************************
  62  *         ScreenToClient   (USER.29)
  63  */
  64 void ScreenToClient( HWND hwnd, LPPOINT lppnt )
  65 {
  66     MapWindowPoints( 0, hwnd, lppnt, 1 );
  67 }
  68
  69
  70 /*******************************************************************
  71  *         WindowFromPoint   (USER.30)
  72  */
  73 HWND WindowFromPoint( POINT pt )
  74 {
  75     HWND hwndRet = 0;
  76     HWND hwnd = GetDesktopWindow();
  77
  78     while(hwnd)
  79     {
  80           /* If point is in window, and window is visible,   */
  81           /* not disabled and not transparent, then explore  */
  82           /* its children. Otherwise, go to the next window. */
  83
  84         WND *wndPtr = WIN_FindWndPtr( hwnd );
  85         if ((pt.x >= wndPtr->rectWindow.left) &&
  86             (pt.x < wndPtr->rectWindow.right) &&
  87             (pt.y >= wndPtr->rectWindow.top) &&
  88             (pt.y < wndPtr->rectWindow.bottom) &&
  89             !(wndPtr->dwStyle & WS_DISABLED) &&
  90             (wndPtr->dwStyle & WS_VISIBLE) &&
  91             !(wndPtr->dwExStyle & WS_EX_TRANSPARENT))
  92         {
  93             hwndRet = hwnd;
  94               /* If window is minimized, ignore its children */
  95             if (wndPtr->dwStyle & WS_MINIMIZE) break;
  96             pt.x -= wndPtr->rectClient.left;
  97             pt.y -= wndPtr->rectClient.top;
  98             hwnd = wndPtr->hwndChild;
  99         }
 100         else hwnd = wndPtr->hwndNext;
 101     }
 102     return hwndRet;
 103 }
 104
 105 /*******************************************************************
 106  *         ChildWindowFromPoint   (USER.191)
 107  */
 108 HWND ChildWindowFromPoint( HWND hwndParent, POINT pt )
 109 {
 110     RECT rect;
 111     HWND hwnd;
 112
 113     GetWindowRect( hwndParent, &rect );
 114     if (!PtInRect( &rect, pt )) return 0;
 115     hwnd = GetTopWindow( hwndParent );
 116     while (hwnd)
 117     {
 118         GetWindowRect( hwnd, &rect );
 119         if (PtInRect( &rect, pt )) return hwnd;
 120         hwnd = GetWindow( hwnd, GW_HWNDNEXT );
 121     }
 122     return hwndParent;
 123 }
 124
 125
 126 /*******************************************************************
 127  *         MapWindowPoints   (USER.258)
 128  */
 129 void MapWindowPoints( HWND hwndFrom, HWND hwndTo, LPPOINT lppt, WORD count )
 130 {
 131     WND * wndPtr;
 132     POINT * curpt;
 133     POINT origin = { 0, 0 };
 134     WORD i;
 135
 136       /* Translate source window origin to screen coords */
 137     while(hwndFrom)
 138     {
 139         wndPtr = WIN_FindWndPtr( hwndFrom );
 140         origin.x += wndPtr->rectClient.left;
 141         origin.y += wndPtr->rectClient.top;
 142         hwndFrom = (wndPtr->dwStyle & WS_CHILD) ? wndPtr->hwndParent : 0;
 143     }
 144
 145       /* Translate origin to destination window coords */
 146     while(hwndTo)
 147     {
 148         wndPtr = WIN_FindWndPtr( hwndTo );
 149         origin.x -= wndPtr->rectClient.left;
 150         origin.y -= wndPtr->rectClient.top;
 151         hwndTo = (wndPtr->dwStyle & WS_CHILD) ? wndPtr->hwndParent : 0;
 152     }
 153
 154       /* Translate points */
 155     for (i = 0, curpt = lppt; i < count; i++, curpt++)
 156     {
 157         curpt->x += origin.x;
 158         curpt->y += origin.y;
 159     }
 160 }
 161
 162
 163 /***********************************************************************
 164  *           IsIconic   (USER.31)
 165  */
 166 BOOL IsIconic(HWND hWnd)
 167 {
 168     WND * wndPtr = WIN_FindWndPtr(hWnd);
 169     if (wndPtr == NULL) return FALSE;
 170     return (wndPtr->dwStyle & WS_MINIMIZE) != 0;
 171 }
 172
 173
 174 /***********************************************************************
 175  *           IsZoomed   (USER.272)
 176  */
 177 BOOL IsZoomed(HWND hWnd)
 178 {
 179     WND * wndPtr = WIN_FindWndPtr(hWnd);
 180     if (wndPtr == NULL) return FALSE;
 181     return (wndPtr->dwStyle & WS_MAXIMIZE) != 0;
 182 }
 183
 184
 185 /*******************************************************************
 186  *         GetActiveWindow    (USER.60)
 187  */
 188 HWND GetActiveWindow()
 189 {
 190     return hwndActive;
 191 }
 192
 193 /*******************************************************************
 194  *         SetActiveWindow    (USER.59)
 195  */
 196 HWND SetActiveWindow( HWND hwnd )
 197 {
 198     HWND prev = hwndActive;
 199     WND *wndPtr = WIN_FindWndPtr( hwnd );
 200     if (!wndPtr || (wndPtr->dwStyle & WS_CHILD)) return 0;
 201     SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE );
 202     return prev;
 203 }
 204
 205
 206 /***********************************************************************
 207  *           BringWindowToTop   (USER.45)
 208  */
 209 BOOL BringWindowToTop( HWND hwnd )
 210 {
 211     return SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE );
 212 }
 213
 214
 215 /***********************************************************************
 216  *           MoveWindow   (USER.56)
 217  */
 218 BOOL MoveWindow( HWND hwnd, short x, short y, short cx, short cy, BOOL repaint)
 219 {
 220     int flags = SWP_NOZORDER | SWP_NOACTIVATE;
 221     if (!repaint) flags |= SWP_NOREDRAW;
 222     dprintf_win(stddeb, "MoveWindow: %d %d,%d %dx%d %d\n",
 223             hwnd, x, y, cx, cy, repaint );
 224     return SetWindowPos( hwnd, 0, x, y, cx, cy, flags );
 225 }
 226
 227
 228 /***********************************************************************
 229  *           ShowWindow   (USER.42)
 230  */
 231 BOOL ShowWindow( HWND hwnd, int cmd )
 232 {
 233     WND * wndPtr = WIN_FindWndPtr( hwnd );
 234     BOOL wasVisible;
 235     BOOL wasIconic;
 236     int swpflags = 0;
 237
 238     if (!wndPtr) return FALSE;
 239
 240     dprintf_win(stddeb,"ShowWindow: hwnd=%04X, cmd=%d\n", hwnd, cmd);
 241
 242     /*
 243      *  wasVisible is true if user has not made window invisible
 244      *  wasIconic is true if the window is not iconified
 245      */
 246     wasVisible = (wndPtr->dwStyle & WS_VISIBLE) != 0;
 247
 248     switch(cmd)
 249     {
 250         case SW_HIDE:
 251             /*
 252              *  if the window wasn't visible to begin with -- just return
 253              */
 254             if (!wasVisible)
 255                 return FALSE;  /* Nothing to do */
 256             swpflags |= SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOMOVE |
 257                         SWP_NOACTIVATE | SWP_NOZORDER;
 258             break;
 259
 260
 261         case SW_SHOWMINNOACTIVE:
 262         case SW_SHOWMINIMIZED:
 263         case SW_MINIMIZE:
 264             wndPtr->dwStyle |= WS_MINIMIZE;
 265             swpflags |= SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE |
 266                         SWP_NOACTIVATE | SWP_NOZORDER;
 267
 268             /* store the size and position of the window, so we can
 269              *  deiconify it to the same size and position
 270              */
 271             wndPtr->rectNormal = wndPtr->rectWindow;
 272             wndPtr->ptIconPos.x = wndPtr->rectWindow.left;
 273             wndPtr->ptIconPos.y = wndPtr->rectWindow.top;
 274             /* move the window to icon size and position and
 275              * tell it that it is going to have to be painted
 276              */
 277             MoveWindow(hwnd, wndPtr->ptIconPos.x, wndPtr->ptIconPos.y,
 278                        SYSMETRICS_CXICON, SYSMETRICS_CYICON, FALSE);
 279             RedrawWindow( hwnd, NULL, 0, RDW_FRAME | RDW_ERASENOW );
 280             break;
 281
 282         case SW_SHOWNA:
 283         case SW_SHOWMAXIMIZED: /* same as SW_MAXIMIZE: */
 284         case SW_SHOW:
 285             swpflags |= SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE;
 286             break;
 287
 288
 289         case SW_SHOWNORMAL:  /* same as SW_NORMAL: */
 290         case SW_SHOWNOACTIVATE:
 291         case SW_RESTORE:
 292             wasIconic = IsIconic(hwnd);
 293             wndPtr->dwStyle &= ~WS_MINIMIZE;
 294             wndPtr->dwStyle &= ~WS_MAXIMIZE;
 295             swpflags |= SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE;
 296             if (cmd == SW_SHOWNOACTIVATE)
 297             {
 298                 swpflags |= SWP_NOZORDER;
 299                 if (GetActiveWindow()) swpflags |= SWP_NOACTIVATE;
 300             }
 301             if (wasIconic) {
 302                 MoveWindow(hwnd, wndPtr->rectNormal.left,
 303                            wndPtr->rectNormal.top,
 304                            wndPtr->rectNormal.right - wndPtr->rectNormal.left,
 305                            wndPtr->rectNormal.bottom - wndPtr->rectNormal.top,
 306                            FALSE);
 307             }
 308             break;
 309     }
 310
 311     SendMessage( hwnd, WM_SHOWWINDOW, (cmd != SW_HIDE), 0 );
 312     SetWindowPos( hwnd, 0, 0, 0, 0, 0, swpflags );
 313
 314       /* Send WM_SIZE and WM_MOVE messages if not already done */
 315     if (!(wndPtr->flags & WIN_GOT_SIZEMSG))
 316     {
 317         int wParam = SIZE_RESTORED;
 318         if (wndPtr->dwStyle & WS_MAXIMIZE) wParam = SIZE_MAXIMIZED;
 319         else if (wndPtr->dwStyle & WS_MINIMIZE) wParam = SIZE_MINIMIZED;
 320         wndPtr->flags |= WIN_GOT_SIZEMSG;
 321         SendMessage( hwnd, WM_SIZE, wParam,
 322                      MAKELONG(wndPtr->rectClient.right-wndPtr->rectClient.left,
 323                             wndPtr->rectClient.bottom-wndPtr->rectClient.top));
 324         SendMessage( hwnd, WM_MOVE, 0,
 325                    MAKELONG(wndPtr->rectClient.left, wndPtr->rectClient.top) );
 326     }
 327
 328     return wasVisible;
 329 }
 330
 331
 332 /***********************************************************************
 333  *           GetInternalWindowPos   (USER.460)
 334  */
 335 WORD GetInternalWindowPos( HWND hwnd, LPRECT rectWnd, LPPOINT ptIcon )
 336 {
 337     WINDOWPLACEMENT wndpl;
 338     if (!GetWindowPlacement( hwnd, &wndpl )) return 0;
 339     if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
 340     if (ptIcon)  *ptIcon = wndpl.ptMinPosition;
 341     return wndpl.showCmd;
 342 }
 343
 344
 345 /***********************************************************************
 346  *           SetInternalWindowPos   (USER.461)
 347  */
 348 void SetInternalWindowPos( HWND hwnd, WORD showCmd, LPRECT rect, LPPOINT pt )
 349 {
 350     WINDOWPLACEMENT wndpl;
 351     WND *wndPtr = WIN_FindWndPtr( hwnd );
 352
 353     wndpl.length  = sizeof(wndpl);
 354     wndpl.flags   = (pt != NULL) ? WPF_SETMINPOSITION : 0;
 355     wndpl.showCmd = showCmd;
 356     if (pt) wndpl.ptMinPosition = *pt;
 357     wndpl.rcNormalPosition = (rect != NULL) ? *rect : wndPtr->rectNormal;
 358     wndpl.ptMaxPosition = wndPtr->ptMaxPos;
 359     SetWindowPlacement( hwnd, &wndpl );
 360 }
 361
 362
 363 /***********************************************************************
 364  *           GetWindowPlacement   (USER.370)
 365  */
 366 BOOL GetWindowPlacement( HWND hwnd, WINDOWPLACEMENT *wndpl )
 367 {
 368     WND *wndPtr = WIN_FindWndPtr( hwnd );
 369     if (!wndPtr) return FALSE;
 370
 371     wndpl->length  = sizeof(*wndpl);
 372     wndpl->flags   = 0;
 373     wndpl->showCmd = IsZoomed(hwnd) ? SW_SHOWMAXIMIZED :
 374                      (IsIconic(hwnd) ? SW_SHOWMINIMIZED : SW_SHOWNORMAL);
 375     wndpl->ptMinPosition = wndPtr->ptIconPos;
 376     wndpl->ptMaxPosition = wndPtr->ptMaxPos;
 377     wndpl->rcNormalPosition = wndPtr->rectNormal;
 378     return TRUE;
 379 }
 380
 381
 382 /***********************************************************************
 383  *           SetWindowPlacement   (USER.371)
 384  */
 385 BOOL SetWindowPlacement( HWND hwnd, WINDOWPLACEMENT *wndpl )
 386 {
 387     WND *wndPtr = WIN_FindWndPtr( hwnd );
 388     if (!wndPtr) return FALSE;
 389
 390     if (wndpl->flags & WPF_SETMINPOSITION)
 391         wndPtr->ptIconPos = wndpl->ptMinPosition;
 392     if ((wndpl->flags & WPF_RESTORETOMAXIMIZED) &&
 393         (wndpl->showCmd == SW_SHOWMINIMIZED)) wndPtr->flags |= WIN_RESTORE_MAX;
 394     wndPtr->ptMaxPos   = wndpl->ptMaxPosition;
 395     wndPtr->rectNormal = wndpl->rcNormalPosition;
 396     ShowWindow( hwnd, wndpl->showCmd );
 397     return TRUE;
 398 }
 399
 400
 401 /*******************************************************************
 402  *         WINPOS_NextWindowFromPoint
 403  *
 404  *  Looks for next enabled window that is
 405  *  a) sibling of hwnd, later in Z-order and encloses pt, or
 406  *  b) parent of hwnd
 407  */
 408 HWND WINPOS_NextWindowFromPoint( HWND hwnd, POINT pt )
 409 {
 410     WND *wndPtr = WIN_FindWndPtr( hwnd );
 411
 412     if (!wndPtr->hwndParent) return hwnd;  /* desktop window */
 413     ScreenToClient( wndPtr->hwndParent, &pt ); /* make pt relative to parent */
 414     for (;;)
 415     {
 416         if (!wndPtr->hwndNext) break;  /* No more children */
 417         hwnd = wndPtr->hwndNext;
 418         wndPtr = WIN_FindWndPtr( hwnd );
 419         if ((wndPtr->dwStyle & WS_VISIBLE) &&
 420             !(wndPtr->dwStyle & WS_DISABLED) &&
 421             PtInRect( &wndPtr->rectWindow, pt )) return hwnd;
 422     }
 423     return wndPtr->hwndParent;
 424 }
 425
 426
 427 /*******************************************************************
 428  *         WINPOS_GetMinMaxInfo
 429  *
 430  * Send a WM_GETMINMAXINFO to the window.
 431  */
 432 void WINPOS_GetMinMaxInfo( HWND hwnd, POINT *maxSize, POINT *maxPos,
 433                            POINT *minTrack, POINT *maxTrack )
 434 {
 435     HANDLE minmaxHandle;
 436     MINMAXINFO MinMax, *pMinMax;
 437     WND *wndPtr = WIN_FindWndPtr( hwnd );
 438
 439     MinMax.ptMaxSize.x = SYSMETRICS_CXSCREEN;
 440     MinMax.ptMaxSize.y = SYSMETRICS_CYSCREEN;
 441     MinMax.ptMaxPosition = wndPtr->ptMaxPos;
 442     MinMax.ptMinTrackSize.x = SYSMETRICS_CXMINTRACK;
 443     MinMax.ptMinTrackSize.y = SYSMETRICS_CYMINTRACK;
 444     MinMax.ptMaxTrackSize.x = SYSMETRICS_CXSCREEN;
 445     MinMax.ptMaxTrackSize.y = SYSMETRICS_CYSCREEN;
 446
 447     minmaxHandle = USER_HEAP_ALLOC( LMEM_MOVEABLE, sizeof(MINMAXINFO) );
 448     if (minmaxHandle)
 449     {
 450         pMinMax = (MINMAXINFO *) USER_HEAP_ADDR( minmaxHandle );
 451         memcpy( pMinMax, &MinMax, sizeof(MinMax) );
 452         SendMessage( hwnd, WM_GETMINMAXINFO, 0, (LONG)pMinMax );
 453     }
 454     else pMinMax = &MinMax;
 455
 456       /* Some sanity checks */
 457
 458     pMinMax->ptMaxTrackSize.x = max( pMinMax->ptMaxTrackSize.x,
 459                                      pMinMax->ptMinTrackSize.x );
 460     pMinMax->ptMaxTrackSize.y = max( pMinMax->ptMaxTrackSize.y,
 461                                      pMinMax->ptMinTrackSize.y );
 462
 463     if (maxSize) *maxSize = pMinMax->ptMaxSize;
 464     if (maxPos) *maxPos = pMinMax->ptMaxPosition;
 465     if (minTrack) *minTrack = pMinMax->ptMinTrackSize;
 466     if (maxTrack) *maxTrack = pMinMax->ptMaxTrackSize;
 467     if (minmaxHandle) USER_HEAP_FREE( minmaxHandle );
 468 }
 469
 470
 471 /*******************************************************************
 472  *         WINPOS_ChangeActiveWindow
 473  *
 474  * Change the active window and send the corresponding messages.
 475  */
 476 HWND WINPOS_ChangeActiveWindow( HWND hwnd, BOOL mouseMsg )
 477 {
 478     HWND prevActive = hwndActive;
 479     if (hwnd == hwndActive) return 0;
 480     if (hwndActive)
 481     {
 482         if (!SendMessage( hwndActive, WM_NCACTIVATE, FALSE, 0 )) return 0;
 483         SendMessage( hwndActive, WM_ACTIVATE, WA_INACTIVE,
 484                      MAKELONG( IsIconic(hwndActive), hwnd ) );
 485         /* Send WM_ACTIVATEAPP here */
 486     }
 487
 488     hwndActive = hwnd;
 489     if (hwndActive)
 490     {
 491         WND *wndPtr = WIN_FindWndPtr( hwndActive );
 492         wndPtr->hwndPrevActive = prevActive;
 493
 494         /* Send WM_ACTIVATEAPP here */
 495         SendMessage( hwnd, WM_NCACTIVATE, TRUE, 0 );
 496         SendMessage( hwnd, WM_ACTIVATE, mouseMsg ? WA_CLICKACTIVE : WA_ACTIVE,
 497                      MAKELONG( IsIconic(hwnd), prevActive ) );
 498     }
 499     return prevActive;
 500 }
 501
 502
 503 /***********************************************************************
 504  *           WINPOS_SendNCCalcSize
 505  *
 506  * Send a WM_NCCALCSIZE message to a window.
 507  * All parameters are read-only except newClientRect.
 508  * oldWindowRect, oldClientRect and winpos must be non-NULL only
 509  * when calcValidRect is TRUE.
 510  */
 511 LONG WINPOS_SendNCCalcSize( HWND hwnd, BOOL calcValidRect, RECT *newWindowRect,
 512                             RECT *oldWindowRect, RECT *oldClientRect,
 513                             WINDOWPOS *winpos, RECT *newClientRect )
 514 {
 515     NCCALCSIZE_PARAMS *params;
 516     HANDLE hparams;
 517     LONG result;
 518
 519     if (!(hparams = USER_HEAP_ALLOC( GMEM_MOVEABLE, sizeof(*params) )))
 520         return 0;
 521     params = (NCCALCSIZE_PARAMS *) USER_HEAP_ADDR( hparams );
 522     params->rgrc[0] = *newWindowRect;
 523     if (calcValidRect)
 524     {
 525         params->rgrc[1] = *oldWindowRect;
 526         params->rgrc[2] = *oldClientRect;
 527         params->lppos = winpos;
 528     }
 529     result = SendMessage( hwnd, WM_NCCALCSIZE, calcValidRect, (LONG)params);
 530     *newClientRect = params->rgrc[0];
 531     USER_HEAP_FREE( hparams );
 532     return result;
 533 }
 534
 535
 536 /***********************************************************************
 537  *           WINPOS_HandleWindowPosChanging
 538  *
 539  * Default handling for a WM_WINDOWPOSCHANGING. Called from DefWindowProc().
 540  */
 541 LONG WINPOS_HandleWindowPosChanging( WINDOWPOS *winpos )
 542 {
 543     POINT maxSize;
 544     WND *wndPtr = WIN_FindWndPtr( winpos->hwnd );
 545     if (!wndPtr || (winpos->flags & SWP_NOSIZE)) return 0;
 546     if ((wndPtr->dwStyle & WS_THICKFRAME) ||
 547         (wndPtr->dwStyle & (WS_POPUP | WS_CHILD) == 0))
 548     {
 549         WINPOS_GetMinMaxInfo( winpos->hwnd, &maxSize, NULL, NULL, NULL );
 550         winpos->cx = min( winpos->cx, maxSize.x );
 551         winpos->cy = min( winpos->cy, maxSize.y );
 552     }
 553     return 0;
 554 }
 555
 556
 557 /***********************************************************************
 558  *           WINPOS_MoveWindowZOrder
 559  *
 560  * Move a window in Z order, invalidating everything that needs it.
 561  * Only necessary for windows without associated X window.
 562  */
 563 static void WINPOS_MoveWindowZOrder( HWND hwnd, HWND hwndAfter, BOOL erase )
 564 {
 565     BOOL movingUp;
 566     HWND hwndCur;
 567     WND *wndPtr = WIN_FindWndPtr( hwnd );
 568
 569     /* We have two possible cases:
 570      * - The window is moving up: we have to invalidate all areas
 571      *   of the window that were covered by other windows
 572      * - The window is moving down: we have to invalidate areas
 573      *   of other windows covered by this one.
 574      */
 575
 576     if (hwndAfter == HWND_TOP)
 577     {
 578         movingUp = TRUE;
 579     }
 580     else if (hwndAfter == HWND_BOTTOM)
 581     {
 582         if (!wndPtr->hwndNext) return;  /* Already at the bottom */
 583         movingUp = FALSE;
 584     }
 585     else
 586     {
 587         if (wndPtr->hwndNext == hwndAfter) return;  /* Already placed right */
 588
 589           /* Determine which window we encounter first in Z-order */
 590         hwndCur = GetWindow( wndPtr->hwndParent, GW_CHILD );
 591         while ((hwndCur != hwnd) && (hwndCur != hwndAfter))
 592             hwndCur = GetWindow( hwndCur, GW_HWNDNEXT );
 593         movingUp = (hwndCur == hwndAfter);
 594     }
 595
 596     if (movingUp)
 597     {
 598         HWND hwndPrevAfter = wndPtr->hwndNext;
 599         WIN_UnlinkWindow( hwnd );
 600         WIN_LinkWindow( hwnd, hwndAfter );
 601         hwndCur = wndPtr->hwndNext;
 602         while (hwndCur != hwndPrevAfter)
 603         {
 604             WND *curPtr = WIN_FindWndPtr( hwndCur );
 605             RECT rect = curPtr->rectWindow;
 606             OffsetRect( &rect, -wndPtr->rectClient.left,
 607                         -wndPtr->rectClient.top );
 608             RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE | RDW_ALLCHILDREN |
 609                           RDW_FRAME | (erase ? RDW_ERASENOW : RDW_ERASE) );
 610             hwndCur = curPtr->hwndNext;
 611         }
 612     }
 613     else  /* Moving down */
 614     {
 615         hwndCur = wndPtr->hwndNext;
 616         WIN_UnlinkWindow( hwnd );
 617         WIN_LinkWindow( hwnd, hwndAfter );
 618         while (hwndCur != hwnd)
 619         {
 620             WND *curPtr = WIN_FindWndPtr( hwndCur );
 621             RECT rect = wndPtr->rectWindow;
 622             OffsetRect( &rect, -curPtr->rectClient.left,
 623                         -curPtr->rectClient.top );
 624             RedrawWindow( hwndCur, &rect, 0, RDW_INVALIDATE | RDW_ALLCHILDREN |
 625                           RDW_FRAME | (erase ? RDW_ERASENOW : RDW_ERASE) );
 626             hwndCur = curPtr->hwndNext;
 627         }
 628     }
 629 }
 630
 631
 632 /***********************************************************************
 633  *           WINPOS_InternalSetWindowPos
 634  *
 635  * Helper function for SetWindowPos.
 636  */
 637 static BOOL WINPOS_InternalSetWindowPos( WINDOWPOS *winpos )
 638 {
 639     HWND hwndAfter;
 640     WND *wndPtr;
 641     RECT newWindowRect, newClientRect;
 642     int flags, result;
 643     int changeMask = 0;
 644     XWindowChanges winChanges;
 645
 646       /* Send WM_WINDOWPOSCHANGING message */
 647
 648     if (!(winpos->flags & SWP_NOSENDCHANGING))
 649         SendMessage( winpos->hwnd, WM_WINDOWPOSCHANGING, 0, (LONG)winpos );
 650
 651       /* Check window handle */
 652
 653     if (winpos->hwnd == GetDesktopWindow()) return FALSE;
 654     if (!(wndPtr = WIN_FindWndPtr( winpos->hwnd ))) return FALSE;
 655
 656       /* Check dimensions */
 657
 658     if (winpos->cx <= 0) winpos->cx = 1;
 659     if (winpos->cy <= 0) winpos->cy = 1;
 660
 661       /* Check flags */
 662
 663     flags = winpos->flags;
 664     if (winpos->hwnd == hwndActive) flags |= SWP_NOACTIVATE; /*Already active*/
 665
 666       /* Check hwndAfter */
 667
 668     hwndAfter = winpos->hwndInsertAfter;
 669     if (!(flags & (SWP_NOZORDER | SWP_NOACTIVATE)))
 670     {
 671           /* Ignore TOPMOST flags when activating a window */
 672           /* _and_ moving it in Z order. */
 673         if ((hwndAfter == HWND_TOPMOST) || (hwndAfter == HWND_NOTOPMOST))
 674             hwndAfter = HWND_TOP;
 675     }
 676       /* TOPMOST not supported yet */
 677     if ((hwndAfter == HWND_TOPMOST) || (hwndAfter == HWND_NOTOPMOST))
 678         hwndAfter = HWND_TOP;
 679       /* hwndAfter must be a sibling of the window */
 680     if ((hwndAfter != HWND_TOP) && (hwndAfter != HWND_BOTTOM) &&
 681         (GetParent(winpos->hwnd) != GetParent(hwndAfter))) return FALSE;
 682
 683       /* Calculate new position and size */
 684
 685     newWindowRect = wndPtr->rectWindow;
 686     newClientRect = wndPtr->rectClient;
 687
 688     if (!(flags & SWP_NOSIZE))
 689     {
 690         newWindowRect.right  = newWindowRect.left + winpos->cx;
 691         newWindowRect.bottom = newWindowRect.top + winpos->cy;
 692         winChanges.width     = winpos->cx;
 693         winChanges.height    = winpos->cy;
 694         changeMask |= CWWidth | CWHeight;
 695     }
 696     if (!(flags & SWP_NOMOVE))
 697     {
 698         newWindowRect.left    = winpos->x;
 699         newWindowRect.top     = winpos->y;
 700         newWindowRect.right  += winpos->x - wndPtr->rectWindow.left;
 701         newWindowRect.bottom += winpos->y - wndPtr->rectWindow.top;
 702         if (wndPtr->dwStyle & WS_CHILD)
 703         {
 704             WND *parentPtr = WIN_FindWndPtr(wndPtr->hwndParent);
 705             winChanges.x = winpos->x + parentPtr->rectClient.left
 706                            - parentPtr->rectWindow.left;
 707             winChanges.y = winpos->y + parentPtr->rectClient.top
 708                            - parentPtr->rectWindow.top;
 709         }
 710         else
 711         {
 712             winChanges.x = winpos->x;
 713             winChanges.y = winpos->y;
 714         }
 715         changeMask |= CWX | CWY;
 716     }
 717
 718       /* Reposition window in Z order */
 719
 720     if (!(flags & SWP_NOZORDER))
 721     {
 722         if (wndPtr->window)
 723         {
 724             WIN_UnlinkWindow( winpos->hwnd );
 725             WIN_LinkWindow( winpos->hwnd, hwndAfter );
 726             if (hwndAfter == HWND_TOP) winChanges.stack_mode = Above;
 727             else winChanges.stack_mode = Below;
 728             if ((hwndAfter != HWND_TOP) && (hwndAfter != HWND_BOTTOM))
 729             {
 730                 WND * insertPtr = WIN_FindWndPtr( hwndAfter );
 731                 winChanges.sibling = insertPtr->window;
 732                 changeMask |= CWSibling;
 733             }
 734             changeMask |= CWStackMode;
 735         }
 736         else WINPOS_MoveWindowZOrder( winpos->hwnd, hwndAfter,
 737                                       !(flags & SWP_DEFERERASE) );
 738     }
 739
 740       /* Send WM_NCCALCSIZE message to get new client area */
 741
 742     result = WINPOS_SendNCCalcSize( winpos->hwnd, TRUE, &newWindowRect,
 743                                     &wndPtr->rectWindow, &wndPtr->rectClient,
 744                                     winpos, &newClientRect );
 745     /* ....  Should handle result here */
 746
 747       /* Perform the moving and resizing */
 748
 749     if (wndPtr->window)
 750     {
 751         if (changeMask) XConfigureWindow( display, wndPtr->window,
 752                                           changeMask, &winChanges );
 753         wndPtr->rectWindow = newWindowRect;
 754         wndPtr->rectClient = newClientRect;
 755     }
 756     else
 757     {
 758         RECT oldWindowRect = wndPtr->rectWindow;
 759
 760         wndPtr->rectWindow = newWindowRect;
 761         wndPtr->rectClient = newClientRect;
 762
 763         if (changeMask)
 764         {
 765             HRGN hrgn1 = CreateRectRgnIndirect( &oldWindowRect );
 766             HRGN hrgn2 = CreateRectRgnIndirect( &wndPtr->rectWindow );
 767             HRGN hrgn3 = CreateRectRgn( 0, 0, 0, 0 );
 768             CombineRgn( hrgn3, hrgn1, hrgn2, RGN_DIFF );
 769             RedrawWindow( wndPtr->hwndParent, NULL, hrgn3,
 770                           RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_ERASENOW );
 771             if ((oldWindowRect.left != wndPtr->rectWindow.left) ||
 772                 (oldWindowRect.top != wndPtr->rectWindow.top))
 773             {
 774                 RedrawWindow( winpos->hwnd, NULL, 0, RDW_INVALIDATE |
 775                               RDW_FRAME | RDW_ALLCHILDREN | RDW_ERASENOW );
 776             }
 777             DeleteObject( hrgn1 );
 778             DeleteObject( hrgn2 );
 779             DeleteObject( hrgn3 );
 780         }
 781     }
 782
 783     if (flags & SWP_SHOWWINDOW)
 784     {
 785         wndPtr->dwStyle |= WS_VISIBLE;
 786         if (wndPtr->window)
 787         {
 788             XMapWindow( display, wndPtr->window );
 789             MSG_Synchronize();
 790             if (flags & SWP_NOREDRAW)  /* Validate the whole window */
 791                 RedrawWindow( winpos->hwnd, NULL, 0, RDW_VALIDATE );
 792         }
 793     }
 794     else if (flags & SWP_HIDEWINDOW)
 795     {
 796         wndPtr->dwStyle &= ~WS_VISIBLE;
 797         if (wndPtr->window)
 798         {
 799             XUnmapWindow( display, wndPtr->window );
 800         }
 801         else
 802         {
 803             RedrawWindow( wndPtr->hwndParent, &wndPtr->rectWindow, 0,
 804                           RDW_INVALIDATE | RDW_FRAME |
 805                           RDW_ALLCHILDREN | RDW_ERASENOW );
 806         }
 807         if ((winpos->hwnd == GetFocus()) || IsChild(winpos->hwnd, GetFocus()))
 808             SetFocus( GetParent(winpos->hwnd) );  /* Revert focus to parent */
 809         if (winpos->hwnd == hwndActive)
 810         {
 811               /* Activate previously active window if possible */
 812             HWND newActive = wndPtr->hwndPrevActive;
 813             if (!IsWindow(newActive) || (newActive == winpos->hwnd))
 814             {
 815                 newActive = GetTopWindow(GetDesktopWindow());
 816                 if (newActive == winpos->hwnd) newActive = wndPtr->hwndNext;
 817             }
 818             WINPOS_ChangeActiveWindow( newActive, FALSE );
 819         }
 820     }
 821
 822       /* Activate the window */
 823
 824     if (!(flags & SWP_NOACTIVATE))
 825     {
 826         if (!(wndPtr->dwStyle & WS_CHILD))
 827             WINPOS_ChangeActiveWindow( winpos->hwnd, FALSE );
 828     }
 829
 830       /* Send WM_NCPAINT message if needed */
 831
 832     if (flags & SWP_SHOWWINDOW)
 833     {
 834           /* Repaint the window frame and background */
 835         RedrawWindow( winpos->hwnd, NULL, 0,
 836                       RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
 837     }
 838     else
 839     {
 840         if ((flags & SWP_FRAMECHANGED) ||
 841             (!(flags & SWP_NOSIZE)) ||
 842             (!(flags & SWP_NOMOVE)) ||
 843             (!(flags & SWP_NOACTIVATE)) ||
 844             (!(flags & SWP_NOZORDER)))
 845                 SendMessage( winpos->hwnd, WM_NCPAINT, 1, 0L );
 846     }
 847
 848       /* And last, send the WM_WINDOWPOSCHANGED message */
 849
 850     SendMessage( winpos->hwnd, WM_WINDOWPOSCHANGED, 0, (LONG)winpos );
 851     return TRUE;
 852 }
 853
 854
 855 /***********************************************************************
 856  *           BeginDeferWindowPos   (USER.259)
 857  */
 858 HDWP BeginDeferWindowPos( INT count )
 859 {
 860     HDWP handle;
 861     DWP *pDWP;
 862
 863     if (count <= 0) return 0;
 864     handle = USER_HEAP_ALLOC( GMEM_MOVEABLE,
 865                               sizeof(DWP) + (count-1)*sizeof(WINDOWPOS) );
 866     if (!handle) return 0;
 867     pDWP = (DWP *) USER_HEAP_ADDR( handle );
 868     pDWP->actualCount    = 0;
 869     pDWP->suggestedCount = count;
 870     pDWP->valid          = TRUE;
 871     pDWP->wMagic         = DWP_MAGIC;
 872     pDWP->hwndParent     = 0;
 873     return handle;
 874 }
 875
 876
 877 /***********************************************************************
 878  *           DeferWindowPos   (USER.260)
 879  */
 880 HDWP DeferWindowPos( HDWP hdwp, HWND hwnd, HWND hwndAfter, INT x, INT y,
 881                      INT cx, INT cy, WORD flags )
 882 {
 883     DWP *pDWP;
 884     int i;
 885     HDWP newhdwp = hdwp;
 886
 887     pDWP = (DWP *) USER_HEAP_ADDR( hdwp );
 888     if (!pDWP) return 0;
 889
 890       /* All the windows of a DeferWindowPos() must have the same parent */
 891
 892     if (pDWP->actualCount == 0) pDWP->hwndParent = GetParent( hwnd );
 893     else if (GetParent( hwnd ) != pDWP->hwndParent)
 894     {
 895         USER_HEAP_FREE( hdwp );
 896         return 0;
 897     }
 898
 899     for (i = 0; i < pDWP->actualCount; i++)
 900     {
 901         if (pDWP->winPos[i].hwnd == hwnd)
 902         {
 903               /* Merge with the other changes */
 904             if (!(flags & SWP_NOZORDER))
 905             {
 906                 pDWP->winPos[i].hwndInsertAfter = hwndAfter;
 907             }
 908             if (!(flags & SWP_NOMOVE))
 909             {
 910                 pDWP->winPos[i].x = x;
 911                 pDWP->winPos[i].y = y;
 912             }
 913             if (!(flags & SWP_NOSIZE))
 914             {
 915                 pDWP->winPos[i].cx = cx;
 916                 pDWP->winPos[i].cy = cy;
 917             }
 918             pDWP->winPos[i].flags &= flags & (SWP_NOSIZE | SWP_NOMOVE |
 919                                               SWP_NOZORDER | SWP_NOREDRAW |
 920                                               SWP_NOACTIVATE | SWP_NOCOPYBITS |
 921                                               SWP_NOOWNERZORDER);
 922             pDWP->winPos[i].flags |= flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW |
 923                                               SWP_FRAMECHANGED);
 924             return hdwp;
 925         }
 926     }
 927     if (pDWP->actualCount >= pDWP->suggestedCount)
 928     {
 929         newhdwp = USER_HEAP_REALLOC( hdwp,
 930                       sizeof(DWP) + pDWP->suggestedCount*sizeof(WINDOWPOS), 0);
 931         if (!newhdwp) return 0;
 932         pDWP = (DWP *) USER_HEAP_ADDR( newhdwp );
 933         pDWP->suggestedCount++;
 934     }
 935     pDWP->winPos[pDWP->actualCount].hwnd = hwnd;
 936     pDWP->winPos[pDWP->actualCount].hwndInsertAfter = hwndAfter;
 937     pDWP->winPos[pDWP->actualCount].x = x;
 938     pDWP->winPos[pDWP->actualCount].y = y;
 939     pDWP->winPos[pDWP->actualCount].cx = cx;
 940     pDWP->winPos[pDWP->actualCount].cy = cy;
 941     pDWP->winPos[pDWP->actualCount].flags = flags;
 942     pDWP->actualCount++;
 943     return newhdwp;
 944 }
 945
 946
 947 /***********************************************************************
 948  *           EndDeferWindowPos   (USER.261)
 949  */
 950 BOOL EndDeferWindowPos( HDWP hdwp )
 951 {
 952     DWP *pDWP;
 953     BOOL res = TRUE;
 954     int i;
 955
 956     pDWP = (DWP *) USER_HEAP_ADDR( hdwp );
 957     if (!pDWP) return FALSE;
 958     for (i = 0; i < pDWP->actualCount; i++)
 959     {
 960         if (!(res = WINPOS_InternalSetWindowPos( &pDWP->winPos[i] ))) break;
 961     }
 962     USER_HEAP_FREE( hdwp );
 963     return res;
 964 }
 965
 966
 967 /***********************************************************************
 968  *           SetWindowPos   (USER.232)
 969  */
 970 BOOL SetWindowPos( HWND hwnd, HWND hwndInsertAfter, INT x, INT y,
 971                    INT cx, INT cy, WORD flags )
 972 {
 973     HDWP hdwp;
 974
 975     dprintf_win(stddeb, "SetWindowPos: %04X %d %d,%d %dx%d 0x%x\n",
 976             hwnd, hwndInsertAfter, x, y, cx, cy, flags );
 977     if (!(hdwp = BeginDeferWindowPos( 1 ))) return FALSE;
 978     if (!(hdwp = DeferWindowPos( hdwp, hwnd, hwndInsertAfter,
 979                                  x, y, cx, cy, flags ))) return FALSE;
 980     return EndDeferWindowPos( hdwp );
 981 }
 982
 983 /***********************************************************************
 984  *           TileChildWindows   (USER.199)
 985  */
 986 void TileChildWindows( HWND parent, WORD action )
 987 {
 988     printf("STUB TileChildWindows(%04X, %d)\n", parent, action);
 989 }
 990
 991 /***********************************************************************
 992  *           CascageChildWindows   (USER.198)
 993  */
 994 void CascadeChildWindows( HWND parent, WORD action )
 995 {
 996     printf("STUB CascadeChildWindows(%04X, %d)\n", parent, action);
 997 }
 998
 999 /***********************************************************************
1000  *           ArrangeIconicWindows   (USER.170)
1001  */
1002 WORD ArrangeIconicWindows( HWND parent )
1003 {
1004     printf("STUB ArrangeIconicWindows(%04X)\n", parent);
1005     return 0;
1006 }