windows/winpos.c

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