windows/winpos.c

   1 /*
   2  * Window position related functions.
   3  *
   4  * Copyright 1993, 1994, 1995 Alexandre Julliard
   5  *                       1995,1996 Alex Korobka
   6  */
   7
   8 #include <X11/Xlib.h>
   9 #include <X11/Xutil.h>
  10 #include <X11/Xatom.h>
  11 #include "sysmetrics.h"
  12 #include "heap.h"
  13 #include "module.h"
  14 #include "user.h"
  15 #include "win.h"
  16 #include "hook.h"
  17 #include "message.h"
  18 #include "queue.h"
  19 #include "options.h"
  20 #include "winpos.h"
  21 #include "dce.h"
  22 #include "nonclient.h"
  23 #include "stddebug.h"
  24 /* #define DEBUG_WIN */
  25 #include "debug.h"
  26
  27 #define  SWP_AGG_NOGEOMETRYCHANGE \
  28     (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE)
  29 #define  SWP_AGG_NOPOSCHANGE \
  30     (SWP_AGG_NOGEOMETRYCHANGE | SWP_NOZORDER)
  31 #define  SWP_AGG_STATUSFLAGS \
  32     (SWP_AGG_NOPOSCHANGE | SWP_FRAMECHANGED | SWP_HIDEWINDOW | SWP_SHOWWINDOW)
  33
  34 #define SMC_NOCOPY              0x0001
  35 #define SMC_NOPARENTERASE       0x0002
  36 #define SMC_DRAWFRAME           0x0004
  37 #define SMC_SETXPOS             0x0008
  38
  39 /* ----- external functions ----- */
  40
  41 extern void     FOCUS_SwitchFocus( HWND32 , HWND32 );
  42 extern HRGN32   DCE_GetVisRgn( HWND32, WORD );
  43 extern HWND32   CARET_GetHwnd();
  44 extern BOOL32   DCE_InvalidateDCE(WND*, RECT16* );
  45
  46 /* ----- internal variables ----- */
  47
  48 static HWND32 hwndActive      = 0;  /* Currently active window */
  49 static HWND32 hwndPrevActive  = 0;  /* Previously active window */
  50
  51 extern MESSAGEQUEUE* pActiveQueue;
  52
  53 /***********************************************************************
  54  *           WINPOS_CheckActive
  55  */
  56 void WINPOS_CheckActive( HWND32 hwnd )
  57 {
  58   if( hwnd == hwndPrevActive ) hwndPrevActive = 0;
  59   if( hwnd == hwndActive )
  60   {
  61       hwndActive = 0;
  62       dprintf_win(stddeb,"\tattempt to activate destroyed window!\n");
  63   }
  64 }
  65
  66 /***********************************************************************
  67  *           WINPOS_FindIconPos
  68  *
  69  * Find a suitable place for an iconic window.
  70  * The new position is stored into wndPtr->ptIconPos.
  71  */
  72 void WINPOS_FindIconPos( HWND32 hwnd )
  73 {
  74     RECT16 rectParent;
  75     short x, y, xspacing, yspacing;
  76     WND * wndPtr = WIN_FindWndPtr( hwnd );
  77
  78     if (!wndPtr || !wndPtr->parent) return;
  79     GetClientRect16( wndPtr->parent->hwndSelf, &rectParent );
  80     if ((wndPtr->ptIconPos.x >= rectParent.left) &&
  81         (wndPtr->ptIconPos.x + SYSMETRICS_CXICON < rectParent.right) &&
  82         (wndPtr->ptIconPos.y >= rectParent.top) &&
  83         (wndPtr->ptIconPos.y + SYSMETRICS_CYICON < rectParent.bottom))
  84         return;  /* The icon already has a suitable position */
  85
  86     xspacing = yspacing = 70;  /* FIXME: This should come from WIN.INI */
  87     y = rectParent.bottom;
  88     for (;;)
  89     {
  90         for (x = rectParent.left; x<=rectParent.right-xspacing; x += xspacing)
  91         {
  92               /* Check if another icon already occupies this spot */
  93             WND *childPtr = wndPtr->parent->child;
  94             while (childPtr)
  95             {
  96                 if ((childPtr->dwStyle & WS_MINIMIZE) && (childPtr != wndPtr))
  97                 {
  98                     if ((childPtr->rectWindow.left < x + xspacing) &&
  99                         (childPtr->rectWindow.right >= x) &&
 100                         (childPtr->rectWindow.top <= y) &&
 101                         (childPtr->rectWindow.bottom > y - yspacing))
 102                         break;  /* There's a window in there */
 103                 }
 104                 childPtr = childPtr->next;
 105             }
 106             if (!childPtr)
 107             {
 108                   /* No window was found, so it's OK for us */
 109                 wndPtr->ptIconPos.x = x + (xspacing - SYSMETRICS_CXICON) / 2;
 110                 wndPtr->ptIconPos.y = y - (yspacing + SYSMETRICS_CYICON) / 2;
 111                 return;
 112             }
 113         }
 114         y -= yspacing;
 115     }
 116 }
 117
 118
 119 /***********************************************************************
 120  *           ArrangeIconicWindows   (USER32.6)
 121  */
 122 UINT16 ArrangeIconicWindows16( HWND16 parent) {
 123     return ArrangeIconicWindows32(parent);
 124 }
 125 /***********************************************************************
 126  *           ArrangeIconicWindows   (USER.170)
 127  */
 128 UINT32 ArrangeIconicWindows32( HWND32 parent )
 129 {
 130     RECT32 rectParent;
 131     HWND32 hwndChild;
 132     INT32 x, y, xspacing, yspacing;
 133
 134     GetClientRect32( parent, &rectParent );
 135     x = rectParent.left;
 136     y = rectParent.bottom;
 137     xspacing = yspacing = 70;  /* FIXME: This should come from WIN.INI */
 138     hwndChild = GetWindow32( parent, GW_CHILD );
 139     while (hwndChild)
 140     {
 141         if (IsIconic32( hwndChild ))
 142         {
 143             SetWindowPos32( hwndChild, 0, x + (xspacing - SYSMETRICS_CXICON) / 2,
 144                             y - (yspacing + SYSMETRICS_CYICON) / 2, 0, 0,
 145                             SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE );
 146             if (x <= rectParent.right - xspacing) x += xspacing;
 147             else
 148             {
 149                 x = rectParent.left;
 150                 y -= yspacing;
 151             }
 152         }
 153         hwndChild = GetWindow32( hwndChild, GW_HWNDNEXT );
 154     }
 155     return yspacing;
 156 }
 157
 158
 159 /***********************************************************************
 160  *             SwitchToThisWindow16   (USER.172)
 161  */
 162 void SwitchToThisWindow16( HWND16 hwnd, BOOL16 restore )
 163 {
 164     SwitchToThisWindow32( hwnd, restore );
 165 }
 166
 167
 168 /***********************************************************************
 169  *             SwitchToThisWindow32   (USER32.538)
 170  */
 171 void SwitchToThisWindow32( HWND32 hwnd, BOOL32 restore )
 172 {
 173     ShowWindow32( hwnd, restore ? SW_RESTORE : SW_SHOWMINIMIZED );
 174 }
 175
 176
 177 /***********************************************************************
 178  *           GetWindowRect16   (USER.32)
 179  */
 180 void GetWindowRect16( HWND16 hwnd, LPRECT16 rect )
 181 {
 182     WND * wndPtr = WIN_FindWndPtr( hwnd );
 183     if (!wndPtr) return;
 184
 185     *rect = wndPtr->rectWindow;
 186     if (wndPtr->dwStyle & WS_CHILD)
 187         MapWindowPoints16( wndPtr->parent->hwndSelf, 0, (POINT16 *)rect, 2 );
 188 }
 189
 190
 191 /***********************************************************************
 192  *           GetWindowRect32   (USER.32)
 193  */
 194 void GetWindowRect32( HWND32 hwnd, LPRECT32 rect )
 195 {
 196     WND * wndPtr = WIN_FindWndPtr( hwnd );
 197     if (!wndPtr) return;
 198
 199     CONV_RECT16TO32( &wndPtr->rectWindow, rect );
 200     if (wndPtr->dwStyle & WS_CHILD)
 201         MapWindowPoints32( wndPtr->parent->hwndSelf, 0, (POINT32 *)rect, 2 );
 202 }
 203
 204
 205 /***********************************************************************
 206  *           GetClientRect16   (USER.33)
 207  */
 208 void GetClientRect16( HWND16 hwnd, LPRECT16 rect )
 209 {
 210     WND * wndPtr = WIN_FindWndPtr( hwnd );
 211
 212     rect->left = rect->top = rect->right = rect->bottom = 0;
 213     if (wndPtr)
 214     {
 215         rect->right  = wndPtr->rectClient.right - wndPtr->rectClient.left;
 216         rect->bottom = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
 217     }
 218 }
 219
 220
 221 /***********************************************************************
 222  *           GetClientRect32   (USER32.219)
 223  */
 224 void GetClientRect32( HWND32 hwnd, LPRECT32 rect )
 225 {
 226     WND * wndPtr = WIN_FindWndPtr( hwnd );
 227
 228     rect->left = rect->top = rect->right = rect->bottom = 0;
 229     if (wndPtr)
 230     {
 231         rect->right  = wndPtr->rectClient.right - wndPtr->rectClient.left;
 232         rect->bottom = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
 233     }
 234 }
 235
 236
 237 /*******************************************************************
 238  *         ClientToScreen16   (USER.28)
 239  */
 240 BOOL16 ClientToScreen16( HWND16 hwnd, LPPOINT16 lppnt )
 241 {
 242     MapWindowPoints16( hwnd, 0, lppnt, 1 );
 243     return TRUE;
 244 }
 245
 246
 247 /*******************************************************************
 248  *         ClientToScreen32   (USER32.51)
 249  */
 250 BOOL32 ClientToScreen32( HWND32 hwnd, LPPOINT32 lppnt )
 251 {
 252     MapWindowPoints32( hwnd, 0, lppnt, 1 );
 253     return TRUE;
 254 }
 255
 256
 257 /*******************************************************************
 258  *         ScreenToClient16   (USER.29)
 259  */
 260 void ScreenToClient16( HWND16 hwnd, LPPOINT16 lppnt )
 261 {
 262     MapWindowPoints16( 0, hwnd, lppnt, 1 );
 263 }
 264
 265
 266 /*******************************************************************
 267  *         ScreenToClient32   (USER32.446)
 268  */
 269 void ScreenToClient32( HWND32 hwnd, LPPOINT32 lppnt )
 270 {
 271     MapWindowPoints32( 0, hwnd, lppnt, 1 );
 272 }
 273
 274
 275 /***********************************************************************
 276  *           WINPOS_WindowFromPoint
 277  *
 278  * Find the window and hittest for a given point.
 279  */
 280 INT16 WINPOS_WindowFromPoint( WND* wndScope, POINT16 pt, WND **ppWnd )
 281 {
 282     WND *wndPtr;
 283     INT16 hittest = HTERROR;
 284     INT16 x, y;
 285
 286     *ppWnd = NULL;
 287     x = pt.x;
 288     y = pt.y;
 289     wndPtr = wndScope->child;
 290     for (;;)
 291     {
 292         while (wndPtr)
 293         {
 294             /* If point is in window, and window is visible, and it  */
 295             /* is enabled (or it's a top-level window), then explore */
 296             /* its children. Otherwise, go to the next window.       */
 297
 298             if ((wndPtr->dwStyle & WS_VISIBLE) &&
 299                 (!(wndPtr->dwStyle & WS_DISABLED) ||
 300                  ((wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) != WS_CHILD)) &&
 301                 (x >= wndPtr->rectWindow.left) &&
 302                 (x < wndPtr->rectWindow.right) &&
 303                 (y >= wndPtr->rectWindow.top) &&
 304                 (y < wndPtr->rectWindow.bottom))
 305             {
 306                 *ppWnd = wndPtr;  /* Got a suitable window */
 307
 308                 /* If window is minimized or disabled, return at once */
 309                 if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
 310                 if (wndPtr->dwStyle & WS_DISABLED) return HTERROR;
 311
 312                 /* If point is not in client area, ignore the children */
 313                 if ((x < wndPtr->rectClient.left) ||
 314                     (x >= wndPtr->rectClient.right) ||
 315                     (y < wndPtr->rectClient.top) ||
 316                     (y >= wndPtr->rectClient.bottom)) break;
 317
 318                 x -= wndPtr->rectClient.left;
 319                 y -= wndPtr->rectClient.top;
 320                 wndPtr = wndPtr->child;
 321             }
 322             else wndPtr = wndPtr->next;
 323         }
 324
 325         /* If nothing found, return the scope window */
 326         if (!*ppWnd)
 327         {
 328             *ppWnd = wndScope;
 329             if( pt.x >= (wndScope->rectClient.left - wndScope->rectWindow.left) &&
 330                 pt.x >= (wndScope->rectClient.top - wndScope->rectWindow.top ) &&
 331                 pt.x <= (wndScope->rectClient.right - wndScope->rectWindow.left) &&
 332                 pt.x <= (wndScope->rectClient.bottom - wndScope->rectWindow.top ) )
 333                 return HTCLIENT;
 334             if( pt.x < 0 || pt.y < 0 ||
 335                 pt.x > (wndScope->rectWindow.right - wndScope->rectWindow.left) ||
 336                 pt.y > (wndScope->rectWindow.bottom - wndScope->rectWindow.top ) )
 337                 return HTNOWHERE;
 338             return HTCAPTION;   /* doesn't matter in this case */
 339         }
 340
 341         /* Send the WM_NCHITTEST message (only if to the same task) */
 342         if ((*ppWnd)->hmemTaskQ != GetTaskQueue(0)) return HTCLIENT;
 343         hittest = (INT16)SendMessage16( (*ppWnd)->hwndSelf, WM_NCHITTEST, 0,
 344                                     MAKELONG( pt.x, pt.y ) );
 345         if (hittest != HTTRANSPARENT) return hittest;  /* Found the window */
 346
 347         /* If no children found in last search, make point relative to parent*/
 348         if (!wndPtr)
 349         {
 350             x += (*ppWnd)->rectClient.left;
 351             y += (*ppWnd)->rectClient.top;
 352         }
 353
 354         /* Restart the search from the next sibling */
 355         wndPtr = (*ppWnd)->next;
 356         *ppWnd = (*ppWnd)->parent;
 357     }
 358 }
 359
 360
 361 /*******************************************************************
 362  *         WindowFromPoint16   (USER.30)
 363  */
 364 HWND16  WindowFromPoint16( POINT16 pt )
 365 {
 366     WND *pWnd;
 367     WINPOS_WindowFromPoint( WIN_GetDesktop(), pt, &pWnd );
 368     return pWnd->hwndSelf;
 369 }
 370
 371
 372 /*******************************************************************
 373  *         WindowFromPoint32   (USER32.581)
 374  */
 375 HWND32 WindowFromPoint32( POINT32 pt )
 376 {
 377     WND *pWnd;
 378     POINT16 pt16;
 379     CONV_POINT32TO16( &pt, &pt16 );
 380     WINPOS_WindowFromPoint( WIN_GetDesktop(), pt16, &pWnd );
 381     return (HWND32)pWnd->hwndSelf;
 382 }
 383
 384
 385 /*******************************************************************
 386  *         ChildWindowFromPoint16   (USER.191)
 387  */
 388 HWND16 ChildWindowFromPoint16( HWND16 hwndParent, POINT16 pt )
 389 {
 390     /* pt is in the client coordinates */
 391
 392     WND* wnd = WIN_FindWndPtr(hwndParent);
 393     RECT16 rect;
 394
 395     if( !wnd ) return 0;
 396
 397     /* get client rect fast */
 398     rect.top = rect.left = 0;
 399     rect.right = wnd->rectClient.right - wnd->rectClient.left;
 400     rect.bottom = wnd->rectClient.bottom - wnd->rectClient.top;
 401
 402     if (!PtInRect16( &rect, pt )) return 0;
 403
 404     wnd = wnd->child;
 405     while ( wnd )
 406     {
 407         if (PtInRect16( &wnd->rectWindow, pt )) return wnd->hwndSelf;
 408         wnd = wnd->next;
 409     }
 410     return hwndParent;
 411 }
 412
 413
 414 /*******************************************************************
 415  *         ChildWindowFromPoint32   (USER32.)
 416  */
 417 HWND32 ChildWindowFromPoint32( HWND32 hwndParent, POINT32 pt )
 418 {
 419     POINT16 pt16;
 420     CONV_POINT32TO16( &pt, &pt16 );
 421     return (HWND32)ChildWindowFromPoint16( hwndParent, pt16 );
 422 }
 423
 424
 425 /*******************************************************************
 426  *         WINPOS_GetWinOffset
 427  *
 428  * Calculate the offset between the origin of the two windows. Used
 429  * to implement MapWindowPoints.
 430  */
 431 static void WINPOS_GetWinOffset( HWND32 hwndFrom, HWND32 hwndTo,
 432                                  POINT32 *offset )
 433 {
 434     WND * wndPtr;
 435
 436     offset->x = offset->y = 0;
 437     if (hwndFrom == hwndTo ) return;
 438
 439       /* Translate source window origin to screen coords */
 440     if (hwndFrom)
 441     {
 442         if (!(wndPtr = WIN_FindWndPtr( hwndFrom )))
 443         {
 444             fprintf(stderr,"MapWindowPoints: bad hwndFrom = %04x\n",hwndFrom);
 445             return;
 446         }
 447         while (wndPtr->parent)
 448         {
 449             offset->x += wndPtr->rectClient.left;
 450             offset->y += wndPtr->rectClient.top;
 451             wndPtr = wndPtr->parent;
 452         }
 453     }
 454
 455       /* Translate origin to destination window coords */
 456     if (hwndTo)
 457     {
 458         if (!(wndPtr = WIN_FindWndPtr( hwndTo )))
 459         {
 460             fprintf(stderr,"MapWindowPoints: bad hwndTo = %04x\n", hwndTo );
 461             return;
 462         }
 463         while (wndPtr->parent)
 464         {
 465             offset->x -= wndPtr->rectClient.left;
 466             offset->y -= wndPtr->rectClient.top;
 467             wndPtr = wndPtr->parent;
 468         }
 469     }
 470 }
 471
 472
 473 /*******************************************************************
 474  *         MapWindowPoints16   (USER.258)
 475  */
 476 void MapWindowPoints16( HWND16 hwndFrom, HWND16 hwndTo,
 477                         LPPOINT16 lppt, UINT16 count )
 478 {
 479     POINT32 offset;
 480
 481     WINPOS_GetWinOffset( hwndFrom, hwndTo, &offset );
 482     while (count--)
 483     {
 484         lppt->x += offset.x;
 485         lppt->y += offset.y;
 486         lppt++;
 487     }
 488 }
 489
 490
 491 /*******************************************************************
 492  *         MapWindowPoints32   (USER32.385)
 493  */
 494 void MapWindowPoints32( HWND32 hwndFrom, HWND32 hwndTo,
 495                         LPPOINT32 lppt, UINT32 count )
 496 {
 497     POINT32 offset;
 498
 499     WINPOS_GetWinOffset( hwndFrom, hwndTo, &offset );
 500     while (count--)
 501     {
 502         lppt->x += offset.x;
 503         lppt->y += offset.y;
 504         lppt++;
 505     }
 506 }
 507
 508
 509 /***********************************************************************
 510  *           IsIconic   (USER.31)
 511  */
 512 BOOL16 IsIconic16(HWND16 hWnd)
 513 {
 514     return IsIconic32(hWnd);
 515 }
 516 /***********************************************************************
 517  *           IsIconic   (USER32.344)
 518  */
 519 BOOL32 IsIconic32(HWND32 hWnd)
 520 {
 521     WND * wndPtr = WIN_FindWndPtr(hWnd);
 522     if (wndPtr == NULL) return FALSE;
 523     return (wndPtr->dwStyle & WS_MINIMIZE) != 0;
 524 }
 525
 526
 527 /***********************************************************************
 528  *           IsZoomed   (USER.272)
 529  */
 530 BOOL16 IsZoomed16(HWND16 hWnd)
 531 {
 532     return IsZoomed32(hWnd);
 533 }
 534 /***********************************************************************
 535  *           IsZoomed   (USER32.351)
 536  */
 537 BOOL32 IsZoomed32(HWND32 hWnd)
 538 {
 539     WND * wndPtr = WIN_FindWndPtr(hWnd);
 540     if (wndPtr == NULL) return FALSE;
 541     return (wndPtr->dwStyle & WS_MAXIMIZE) != 0;
 542 }
 543
 544
 545 /*******************************************************************
 546  *         GetActiveWindow    (USER.60)
 547  */
 548 HWND16 GetActiveWindow16(void)
 549 {
 550     return GetActiveWindow32();
 551 }
 552 /*******************************************************************
 553  *         GetActiveWindow    (USER32.204)
 554  */
 555 HWND32 GetActiveWindow32(void)
 556 {
 557     return hwndActive;
 558 }
 559
 560
 561 /*******************************************************************
 562  *         WINPOS_IsGoodEnough
 563  */
 564 static BOOL32 WINPOS_IsGoodEnough(WND* pWnd)
 565 {
 566  return (pWnd) ? ((!(pWnd->dwStyle & WS_DISABLED) &&
 567                      pWnd->dwStyle & WS_VISIBLE ) ? TRUE : FALSE) : FALSE;
 568 }
 569
 570
 571 /*******************************************************************
 572  *         SetActiveWindow    (USER.59)
 573  */
 574 HWND16 SetActiveWindow16( HWND16 hwnd )
 575 {
 576     return SetActiveWindow32(hwnd);
 577 }
 578 /*******************************************************************
 579  *         SetActiveWindow    (USER.59)
 580  */
 581 HWND32 SetActiveWindow32( HWND32 hwnd )
 582 {
 583     HWND32 prev = hwndActive;
 584     WND *wndPtr = WIN_FindWndPtr( hwnd );
 585
 586     if ( !WINPOS_IsGoodEnough(wndPtr) ) return 0;
 587
 588     WINPOS_SetActiveWindow( hwnd, 0, 0 );
 589     return prev;
 590 }
 591
 592
 593 /***********************************************************************
 594  *           BringWindowToTop   (USER.45)
 595  */
 596 BOOL16 BringWindowToTop16( HWND16 hwnd )
 597 {
 598     return BringWindowToTop32(hwnd);
 599 }
 600 /***********************************************************************
 601  *           BringWindowToTop   (USER32.10)
 602  */
 603 BOOL32 BringWindowToTop32( HWND32 hwnd )
 604 {
 605     return SetWindowPos32( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE );
 606 }
 607
 608
 609 /***********************************************************************
 610  *           MoveWindow   (USER.56)
 611  */
 612 BOOL16 MoveWindow16(
 613         HWND16 hwnd, INT16 x, INT16 y, INT16 cx, INT16 cy, BOOL16 repaint
 614 ) {
 615     return MoveWindow32(hwnd,x,y,cx,cy,repaint);
 616 }
 617 /***********************************************************************
 618  *           MoveWindow   (USER32.398)
 619  */
 620 BOOL32 MoveWindow32(
 621         HWND32 hwnd, INT32 x, INT32 y, INT32 cx, INT32 cy, BOOL32 repaint
 622 ) {
 623     int flags = SWP_NOZORDER | SWP_NOACTIVATE;
 624     if (!repaint) flags |= SWP_NOREDRAW;
 625     dprintf_win(stddeb, "MoveWindow: %04x %d,%d %dx%d %d\n",
 626             hwnd, x, y, cx, cy, repaint );
 627     return SetWindowPos32( hwnd, 0, x, y, cx, cy, flags );
 628 }
 629
 630 /***********************************************************************
 631  *           ShowWindow   (USER.42)
 632  */
 633 BOOL16 ShowWindow16( HWND16 hwnd, INT16 cmd )
 634 {
 635     return ShowWindow32(hwnd,cmd);
 636 }
 637 /***********************************************************************
 638  *           ShowWindow   (USER.42)
 639  */
 640 BOOL32 ShowWindow32( HWND32 hwnd, INT32 cmd )
 641 {
 642     WND * wndPtr = WIN_FindWndPtr( hwnd );
 643     BOOL32 wasVisible, showFlag;
 644     POINT16 maxSize;
 645     int swpflags = 0;
 646     short x = 0, y = 0, cx = 0, cy = 0;
 647
 648     if (!wndPtr) return FALSE;
 649
 650     dprintf_win(stddeb,"ShowWindow: hwnd=%04x, cmd=%d\n", hwnd, cmd);
 651
 652     wasVisible = (wndPtr->dwStyle & WS_VISIBLE) != 0;
 653
 654     switch(cmd)
 655     {
 656         case SW_HIDE:
 657             if (!wasVisible) return FALSE;
 658             swpflags |= SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOMOVE |
 659                         SWP_NOACTIVATE | SWP_NOZORDER;
 660             break;
 661
 662         case SW_SHOWMINNOACTIVE:
 663             swpflags |= SWP_NOACTIVATE | SWP_NOZORDER;
 664             /* fall through */
 665         case SW_SHOWMINIMIZED:
 666             swpflags |= SWP_SHOWWINDOW;
 667             /* fall through */
 668         case SW_MINIMIZE:
 669             swpflags |= SWP_FRAMECHANGED;
 670             if (!(wndPtr->dwStyle & WS_MINIMIZE))
 671             {
 672                 if( HOOK_CallHooks16( WH_CBT, HCBT_MINMAX, hwnd, cmd) )
 673                     return 0;
 674
 675                 if (wndPtr->dwStyle & WS_MAXIMIZE)
 676                 {
 677                     wndPtr->flags |= WIN_RESTORE_MAX;
 678                     wndPtr->dwStyle &= ~WS_MAXIMIZE;
 679                 }
 680                 else
 681                 {
 682                     wndPtr->flags &= ~WIN_RESTORE_MAX;
 683                     wndPtr->rectNormal = wndPtr->rectWindow;
 684                 }
 685                 wndPtr->dwStyle |= WS_MINIMIZE;
 686                 WINPOS_FindIconPos( hwnd );
 687                 x  = wndPtr->ptIconPos.x;
 688                 y  = wndPtr->ptIconPos.y;
 689                 cx = SYSMETRICS_CXICON;
 690                 cy = SYSMETRICS_CYICON;
 691                 swpflags |= SWP_NOCOPYBITS;
 692             }
 693             else swpflags |= SWP_NOSIZE | SWP_NOMOVE;
 694             break;
 695
 696         case SW_SHOWMAXIMIZED: /* same as SW_MAXIMIZE: */
 697             swpflags |= SWP_SHOWWINDOW | SWP_FRAMECHANGED;
 698             if (!(wndPtr->dwStyle & WS_MAXIMIZE))
 699             {
 700                 if( HOOK_CallHooks16( WH_CBT, HCBT_MINMAX, hwnd, cmd) )
 701                     return 0;
 702
 703                   /* Store the current position and find the maximized size */
 704                 if (!(wndPtr->dwStyle & WS_MINIMIZE))
 705                     wndPtr->rectNormal = wndPtr->rectWindow;
 706
 707                 NC_GetMinMaxInfo( wndPtr, &maxSize,
 708                                   &wndPtr->ptMaxPos, NULL, NULL );
 709                 x  = wndPtr->ptMaxPos.x;
 710                 y  = wndPtr->ptMaxPos.y;
 711
 712                 if( wndPtr->dwStyle & WS_MINIMIZE )
 713                     if( !SendMessage32A( hwnd, WM_QUERYOPEN, 0, 0L ) )
 714                         {
 715                          swpflags |= SWP_NOSIZE | SWP_NOMOVE;
 716                          break;
 717                         }
 718                     else swpflags |= SWP_NOCOPYBITS;
 719
 720                 cx = maxSize.x;
 721                 cy = maxSize.y;
 722                 wndPtr->dwStyle &= ~WS_MINIMIZE;
 723                 wndPtr->dwStyle |= WS_MAXIMIZE;
 724             }
 725             else swpflags |= SWP_NOSIZE | SWP_NOMOVE;
 726             break;
 727
 728         case SW_SHOWNA:
 729             swpflags |= SWP_NOACTIVATE | SWP_NOZORDER;
 730             /* fall through */
 731         case SW_SHOW:
 732             swpflags |= SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE;
 733             break;
 734
 735         case SW_SHOWNOACTIVATE:
 736             swpflags |= SWP_NOZORDER;
 737             if (GetActiveWindow32()) swpflags |= SWP_NOACTIVATE;
 738             /* fall through */
 739         case SW_SHOWNORMAL:  /* same as SW_NORMAL: */
 740         case SW_SHOWDEFAULT: /* FIXME: should have its own handler */
 741         case SW_RESTORE:
 742             swpflags |= SWP_SHOWWINDOW | SWP_FRAMECHANGED;
 743
 744             if (wndPtr->dwStyle & WS_MINIMIZE)
 745             {
 746                 if( HOOK_CallHooks16( WH_CBT, HCBT_MINMAX, hwnd, cmd) )
 747                     return 0;
 748
 749                 if( !SendMessage16( hwnd, WM_QUERYOPEN, 0, 0L) )
 750                   {
 751                     swpflags |= SWP_NOSIZE | SWP_NOMOVE;
 752                     break;
 753                   }
 754                 wndPtr->ptIconPos.x = wndPtr->rectWindow.left;
 755                 wndPtr->ptIconPos.y = wndPtr->rectWindow.top;
 756                 wndPtr->dwStyle &= ~WS_MINIMIZE;
 757                 if (wndPtr->flags & WIN_RESTORE_MAX)
 758                 {
 759                     /* Restore to maximized position */
 760                     NC_GetMinMaxInfo( wndPtr, &maxSize, &wndPtr->ptMaxPos,
 761                                       NULL, NULL );
 762                     x  = wndPtr->ptMaxPos.x;
 763                     y  = wndPtr->ptMaxPos.y;
 764                     cx = maxSize.x;
 765                     cy = maxSize.y;
 766                    wndPtr->dwStyle |= WS_MAXIMIZE;
 767                 }
 768                 else  /* Restore to normal position */
 769                 {
 770                     x  = wndPtr->rectNormal.left;
 771                     y  = wndPtr->rectNormal.top;
 772                     cx = wndPtr->rectNormal.right - wndPtr->rectNormal.left;
 773                     cy = wndPtr->rectNormal.bottom - wndPtr->rectNormal.top;
 774                 }
 775                 swpflags |= SWP_NOCOPYBITS;
 776             }
 777             else if (wndPtr->dwStyle & WS_MAXIMIZE)
 778             {
 779                 if( HOOK_CallHooks16( WH_CBT, HCBT_MINMAX, hwnd, cmd) )
 780                     return 0;
 781
 782                 wndPtr->ptMaxPos.x = wndPtr->rectWindow.left;
 783                 wndPtr->ptMaxPos.y = wndPtr->rectWindow.top;
 784                 wndPtr->dwStyle &= ~WS_MAXIMIZE;
 785                 x  = wndPtr->rectNormal.left;
 786                 y  = wndPtr->rectNormal.top;
 787                 cx = wndPtr->rectNormal.right - wndPtr->rectNormal.left;
 788                 cy = wndPtr->rectNormal.bottom - wndPtr->rectNormal.top;
 789             }
 790             else swpflags |= SWP_NOSIZE | SWP_NOMOVE;
 791             break;
 792     }
 793
 794     showFlag = (cmd != SW_HIDE);
 795     if (showFlag != wasVisible)
 796     {
 797         SendMessage16( hwnd, WM_SHOWWINDOW, showFlag, 0 );
 798         if (!IsWindow32( hwnd )) return wasVisible;
 799     }
 800
 801     if ((wndPtr->dwStyle & WS_CHILD) &&
 802         !IsWindowVisible32( wndPtr->parent->hwndSelf ) &&
 803         (swpflags & SWP_NOSIZE) && (swpflags & SWP_NOMOVE))
 804     {
 805         /* Don't call SetWindowPos32() on invisible child windows */
 806         if (cmd == SW_HIDE) wndPtr->dwStyle &= ~WS_VISIBLE;
 807         else wndPtr->dwStyle |= WS_VISIBLE;
 808     }
 809     else
 810     {
 811         /* We can't activate a child window */
 812         if (wndPtr->dwStyle & WS_CHILD)
 813             swpflags |= SWP_NOACTIVATE | SWP_NOZORDER;
 814         SetWindowPos32( hwnd, HWND_TOP, x, y, cx, cy, swpflags );
 815         if (!IsWindow32( hwnd )) return wasVisible;
 816     }
 817
 818     if (wndPtr->flags & WIN_NEED_SIZE)
 819     {
 820         /* should happen only in CreateWindowEx() */
 821         int wParam = SIZE_RESTORED;
 822
 823         wndPtr->flags &= ~WIN_NEED_SIZE;
 824         if (wndPtr->dwStyle & WS_MAXIMIZE) wParam = SIZE_MAXIMIZED;
 825         else if (wndPtr->dwStyle & WS_MINIMIZE) wParam = SIZE_MINIMIZED;
 826         SendMessage16( hwnd, WM_SIZE, wParam,
 827                      MAKELONG(wndPtr->rectClient.right-wndPtr->rectClient.left,
 828                             wndPtr->rectClient.bottom-wndPtr->rectClient.top));
 829         SendMessage16( hwnd, WM_MOVE, 0,
 830                    MAKELONG(wndPtr->rectClient.left, wndPtr->rectClient.top) );
 831     }
 832
 833     return wasVisible;
 834 }
 835
 836
 837 /***********************************************************************
 838  *           GetInternalWindowPos16   (USER.460)
 839  */
 840 UINT16 GetInternalWindowPos16( HWND16 hwnd, LPRECT16 rectWnd, LPPOINT16 ptIcon)
 841 {
 842     WINDOWPLACEMENT16 wndpl;
 843     if (!GetWindowPlacement16( hwnd, &wndpl )) return 0;
 844     if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
 845     if (ptIcon)  *ptIcon = wndpl.ptMinPosition;
 846     return wndpl.showCmd;
 847 }
 848
 849
 850 /***********************************************************************
 851  *           GetInternalWindowPos32   (USER32.244)
 852  */
 853 UINT32 GetInternalWindowPos32( HWND32 hwnd, LPRECT32 rectWnd, LPPOINT32 ptIcon)
 854 {
 855     WINDOWPLACEMENT32 wndpl;
 856     if (!GetWindowPlacement32( hwnd, &wndpl )) return 0;
 857     if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
 858     if (ptIcon)  *ptIcon = wndpl.ptMinPosition;
 859     return wndpl.showCmd;
 860 }
 861
 862
 863 /***********************************************************************
 864  *           SetInternalWindowPos16   (USER.461)
 865  */
 866 void SetInternalWindowPos16( HWND16 hwnd, UINT16 showCmd,
 867                              LPRECT16 rect, LPPOINT16 pt )
 868 {
 869     WINDOWPLACEMENT16 wndpl;
 870     WND *wndPtr = WIN_FindWndPtr( hwnd );
 871
 872     wndpl.length  = sizeof(wndpl);
 873     wndpl.flags   = (pt != NULL) ? WPF_SETMINPOSITION : 0;
 874     wndpl.showCmd = showCmd;
 875     if (pt) wndpl.ptMinPosition = *pt;
 876     wndpl.rcNormalPosition = (rect != NULL) ? *rect : wndPtr->rectNormal;
 877     wndpl.ptMaxPosition = wndPtr->ptMaxPos;
 878     SetWindowPlacement16( hwnd, &wndpl );
 879 }
 880
 881
 882 /***********************************************************************
 883  *           SetInternalWindowPos32   (USER32.482)
 884  */
 885 void SetInternalWindowPos32( HWND32 hwnd, UINT32 showCmd,
 886                              LPRECT32 rect, LPPOINT32 pt )
 887 {
 888     WINDOWPLACEMENT32 wndpl;
 889     WND *wndPtr = WIN_FindWndPtr( hwnd );
 890
 891     wndpl.length  = sizeof(wndpl);
 892     wndpl.flags   = (pt != NULL) ? WPF_SETMINPOSITION : 0;
 893     wndpl.showCmd = showCmd;
 894     if (pt) wndpl.ptMinPosition = *pt;
 895     if (rect) wndpl.rcNormalPosition = *rect;
 896     else CONV_RECT16TO32( &wndPtr->rectNormal, &wndpl.rcNormalPosition );
 897     CONV_POINT16TO32( &wndPtr->ptMaxPos, &wndpl.ptMaxPosition );
 898     SetWindowPlacement32( hwnd, &wndpl );
 899 }
 900
 901
 902 /***********************************************************************
 903  *           GetWindowPlacement16   (USER.370)
 904  */
 905 BOOL16 GetWindowPlacement16( HWND16 hwnd, WINDOWPLACEMENT16 *wndpl )
 906 {
 907     WND *wndPtr = WIN_FindWndPtr( hwnd );
 908     if (!wndPtr) return FALSE;
 909
 910     wndpl->length  = sizeof(*wndpl);
 911     wndpl->flags   = 0;
 912     wndpl->showCmd = IsZoomed16(hwnd) ? SW_SHOWMAXIMIZED :
 913                      (IsIconic16(hwnd) ? SW_SHOWMINIMIZED : SW_SHOWNORMAL);
 914     wndpl->ptMinPosition = wndPtr->ptIconPos;
 915     wndpl->ptMaxPosition = wndPtr->ptMaxPos;
 916     wndpl->rcNormalPosition = wndPtr->rectNormal;
 917     return TRUE;
 918 }
 919
 920
 921 /***********************************************************************
 922  *           GetWindowPlacement32   (USER32.306)
 923  */
 924 BOOL32 GetWindowPlacement32( HWND32 hwnd, WINDOWPLACEMENT32 *wndpl )
 925 {
 926     WND *wndPtr = WIN_FindWndPtr( hwnd );
 927     if (!wndPtr) return FALSE;
 928
 929     wndpl->length  = sizeof(*wndpl);
 930     wndpl->flags   = 0;
 931     wndpl->showCmd = IsZoomed32(hwnd) ? SW_SHOWMAXIMIZED :
 932                      (IsIconic32(hwnd) ? SW_SHOWMINIMIZED : SW_SHOWNORMAL);
 933     CONV_POINT16TO32( &wndPtr->ptIconPos, &wndpl->ptMinPosition );
 934     CONV_POINT16TO32( &wndPtr->ptMaxPos, &wndpl->ptMaxPosition );
 935     CONV_RECT16TO32( &wndPtr->rectNormal, &wndpl->rcNormalPosition );
 936     return TRUE;
 937 }
 938
 939
 940 /***********************************************************************
 941  *           SetWindowPlacement16   (USER.371)
 942  */
 943 BOOL16 SetWindowPlacement16( HWND16 hwnd, const WINDOWPLACEMENT16 *wndpl )
 944 {
 945     WND *wndPtr = WIN_FindWndPtr( hwnd );
 946     if (!wndPtr) return FALSE;
 947
 948     if (wndpl->flags & WPF_SETMINPOSITION)
 949         wndPtr->ptIconPos = wndpl->ptMinPosition;
 950     if ((wndpl->flags & WPF_RESTORETOMAXIMIZED) &&
 951         (wndpl->showCmd == SW_SHOWMINIMIZED)) wndPtr->flags |= WIN_RESTORE_MAX;
 952     wndPtr->ptMaxPos   = wndpl->ptMaxPosition;
 953     wndPtr->rectNormal = wndpl->rcNormalPosition;
 954     ShowWindow16( hwnd, wndpl->showCmd );
 955     return TRUE;
 956 }
 957
 958
 959 /***********************************************************************
 960  *           SetWindowPlacement32   (USER32.518)
 961  */
 962 BOOL32 SetWindowPlacement32( HWND32 hwnd, const WINDOWPLACEMENT32 *wndpl )
 963 {
 964     WND *wndPtr = WIN_FindWndPtr( hwnd );
 965     if (!wndPtr) return FALSE;
 966
 967     if (wndpl->flags & WPF_SETMINPOSITION)
 968         CONV_POINT32TO16( &wndpl->ptMinPosition, &wndPtr->ptIconPos );
 969     if ((wndpl->flags & WPF_RESTORETOMAXIMIZED) &&
 970         (wndpl->showCmd == SW_SHOWMINIMIZED)) wndPtr->flags |= WIN_RESTORE_MAX;
 971     CONV_POINT32TO16( &wndpl->ptMaxPosition, &wndPtr->ptMaxPos );
 972     CONV_RECT32TO16( &wndpl->rcNormalPosition, &wndPtr->rectNormal );
 973     ShowWindow32( hwnd, wndpl->showCmd );
 974     return TRUE;
 975 }
 976
 977
 978 /***********************************************************************
 979  *           WINPOS_ForceXWindowRaise
 980  *
 981  * Raise a window on top of the X stacking order, while preserving
 982  * the correct Windows Z order.
 983  */
 984 static void WINPOS_ForceXWindowRaise( WND* pWnd )
 985 {
 986     XWindowChanges winChanges;
 987     WND *wndPrev;
 988
 989     /* Raise all windows up to pWnd according to their Z order.
 990      * (it would be easier with sibling-related Below but it doesn't
 991      * work very well with SGI mwm for instance)
 992      */
 993     winChanges.stack_mode = Above;
 994     while (pWnd)
 995     {
 996         if (pWnd->window) XReconfigureWMWindow( display, pWnd->window, 0,
 997                                                 CWStackMode, &winChanges );
 998         wndPrev = WIN_GetDesktop()->child;
 999         if (wndPrev == pWnd) break;
1000         while (wndPrev && (wndPrev->next != pWnd)) wndPrev = wndPrev->next;
1001         pWnd = wndPrev;
1002     }
1003 }
1004
1005
1006 /*******************************************************************
1007  *         WINPOS_SetActiveWindow
1008  *
1009  * back-end to SetActiveWindow
1010  */
1011 BOOL32 WINPOS_SetActiveWindow( HWND32 hWnd, BOOL32 fMouse, BOOL32 fChangeFocus)
1012 {
1013     WND                   *wndPtr          = WIN_FindWndPtr(hWnd);
1014     WND                   *wndTemp         = WIN_FindWndPtr(hwndActive);
1015     CBTACTIVATESTRUCT16   *cbtStruct;
1016     WORD                   wIconized=0;
1017     HQUEUE16 hOldActiveQueue = (pActiveQueue)?pActiveQueue->self:0;
1018     HQUEUE16 hNewActiveQueue;
1019
1020     /* paranoid checks */
1021     if( hWnd == GetDesktopWindow32() || hWnd == hwndActive )
1022         return 0;
1023
1024 /* if (wndPtr && (GetTaskQueue(0) != wndPtr->hmemTaskQ))
1025         return 0;
1026         */
1027
1028     if( wndTemp )
1029         wIconized = HIWORD(wndTemp->dwStyle & WS_MINIMIZE);
1030     else
1031         dprintf_win(stddeb,"WINPOS_ActivateWindow: no current active window.\n");
1032
1033     /* call CBT hook chain */
1034     if ((cbtStruct = SEGPTR_NEW(CBTACTIVATESTRUCT16)))
1035     {
1036         LRESULT wRet;
1037         cbtStruct->fMouse     = fMouse;
1038         cbtStruct->hWndActive = hwndActive;
1039         wRet = HOOK_CallHooks16( WH_CBT, HCBT_ACTIVATE, (WPARAM16)hWnd,
1040                                  (LPARAM)SEGPTR_GET(cbtStruct) );
1041         SEGPTR_FREE(cbtStruct);
1042         if (wRet) return wRet;
1043     }
1044
1045     /* set prev active wnd to current active wnd and send notification */
1046     if ((hwndPrevActive = hwndActive) && IsWindow32(hwndPrevActive))
1047     {
1048         if (!SendMessage16( hwndPrevActive, WM_NCACTIVATE, FALSE, 0 ))
1049         {
1050             if (GetSysModalWindow16() != hWnd) return 0;
1051             /* disregard refusal if hWnd is sysmodal */
1052         }
1053
1054 #if 0
1055         SendMessage32A( hwndPrevActive, WM_ACTIVATE,
1056                         MAKEWPARAM( WA_INACTIVE, wIconized ),
1057                         (LPARAM)hWnd );
1058 #else
1059         /* FIXME: must be SendMessage16() because 32A doesn't do
1060          * intertask at this time */
1061         SendMessage16( hwndPrevActive, WM_ACTIVATE, WA_INACTIVE,
1062                                 MAKELPARAM( (HWND16)hWnd, wIconized ) );
1063 #endif
1064
1065         /* check if something happened during message processing */
1066         if( hwndPrevActive != hwndActive ) return 0;
1067     }
1068
1069     /* set active wnd */
1070     hwndActive = hWnd;
1071
1072     /* send palette messages */
1073     if (hWnd && SendMessage16( hWnd, WM_QUERYNEWPALETTE, 0, 0L))
1074         SendMessage16((HWND16)-1, WM_PALETTEISCHANGING, (WPARAM16)hWnd, 0L );
1075
1076     /* if prev wnd is minimized redraw icon title
1077   if( hwndPrevActive )
1078     {
1079         wndTemp = WIN_FindWndPtr( WIN_GetTopParent( hwndPrevActive ) );
1080         if(wndTemp)
1081           if(wndTemp->dwStyle & WS_MINIMIZE)
1082             RedrawIconTitle(hwndPrevActive);
1083       }
1084   */
1085
1086     /* managed windows will get ConfigureNotify event */
1087     if (wndPtr && !(wndPtr->dwStyle & WS_CHILD) && !(wndPtr->flags & WIN_MANAGED))
1088     {
1089         /* check Z-order and bring hWnd to the top */
1090         for (wndTemp = WIN_GetDesktop()->child; wndTemp; wndTemp = wndTemp->next)
1091             if (wndTemp->dwStyle & WS_VISIBLE) break;
1092
1093         if( wndTemp != wndPtr )
1094             SetWindowPos32(hWnd, HWND_TOP, 0,0,0,0,
1095                            SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
1096         if (!IsWindow32(hWnd)) return 0;
1097     }
1098
1099     hNewActiveQueue = wndPtr ? wndPtr->hmemTaskQ : 0;
1100
1101     /* send WM_ACTIVATEAPP if necessary */
1102     if (hOldActiveQueue != hNewActiveQueue)
1103     {
1104         WND **list, **ppWnd;
1105
1106         if ((list = WIN_BuildWinArray( WIN_GetDesktop() )))
1107         {
1108             for (ppWnd = list; *ppWnd; ppWnd++)
1109             {
1110                 if (!IsWindow32( (*ppWnd)->hwndSelf )) continue;
1111
1112                 if ((*ppWnd)->hmemTaskQ == hOldActiveQueue)
1113                    SendMessage16( (*ppWnd)->hwndSelf, WM_ACTIVATEAPP,
1114                                    0, QUEUE_GetQueueTask(hNewActiveQueue) );
1115             }
1116             HeapFree( SystemHeap, 0, list );
1117         }
1118
1119         pActiveQueue = (hNewActiveQueue)
1120                        ? (MESSAGEQUEUE*) GlobalLock16(hNewActiveQueue) : NULL;
1121
1122         if ((list = WIN_BuildWinArray( WIN_GetDesktop() )))
1123         {
1124             for (ppWnd = list; *ppWnd; ppWnd++)
1125             {
1126                 if (!IsWindow32( (*ppWnd)->hwndSelf )) continue;
1127
1128                 if ((*ppWnd)->hmemTaskQ == hNewActiveQueue)
1129                    SendMessage16( (*ppWnd)->hwndSelf, WM_ACTIVATEAPP,
1130                                   1, QUEUE_GetQueueTask( hOldActiveQueue ) );
1131             }
1132             HeapFree( SystemHeap, 0, list );
1133         }
1134         if (!IsWindow32(hWnd)) return 0;
1135     }
1136
1137     if (hWnd)
1138     {
1139         /* walk up to the first unowned window */
1140         wndTemp = wndPtr;
1141         while (wndTemp->owner) wndTemp = wndTemp->owner;
1142         /* and set last active owned popup */
1143         wndTemp->hwndLastActive = hWnd;
1144
1145         wIconized = HIWORD(wndTemp->dwStyle & WS_MINIMIZE);
1146         SendMessage16( hWnd, WM_NCACTIVATE, TRUE, 0 );
1147 #if 0
1148         SendMessage32A( hWnd, WM_ACTIVATE,
1149                  MAKEWPARAM( (fMouse) ? WA_CLICKACTIVE : WA_ACTIVE, wIconized),
1150                  (LPARAM)hwndPrevActive );
1151 #else
1152         SendMessage16(hWnd, WM_ACTIVATE, (fMouse) ? WA_CLICKACTIVE : WA_ACTIVE,
1153                       MAKELPARAM( (HWND16)hwndPrevActive, wIconized) );
1154 #endif
1155
1156         if( !IsWindow32(hWnd) ) return 0;
1157     }
1158
1159     /* change focus if possible */
1160     if( fChangeFocus && GetFocus32() )
1161         if( WIN_GetTopParent(GetFocus32()) != hwndActive )
1162             FOCUS_SwitchFocus( GetFocus32(),
1163                                (wndPtr->dwStyle & WS_MINIMIZE)? 0: hwndActive);
1164
1165     if( !hwndPrevActive && wndPtr &&
1166          wndPtr->window && !(wndPtr->flags & WIN_MANAGED) )
1167         WINPOS_ForceXWindowRaise(wndPtr);
1168
1169     /* if active wnd is minimized redraw icon title
1170   if( hwndActive )
1171       {
1172         wndPtr = WIN_FindWndPtr(hwndActive);
1173         if(wndPtr->dwStyle & WS_MINIMIZE)
1174            RedrawIconTitle(hwndActive);
1175     }
1176   */
1177     return (hWnd == hwndActive);
1178 }
1179
1180 /*******************************************************************
1181  *         WINPOS_ActivateOtherWindow
1182  *
1183  * DestroyWindow() helper. pWnd must be a top-level window.
1184  */
1185 BOOL32 WINPOS_ActivateOtherWindow(WND* pWnd)
1186 {
1187   BOOL32        bRet = 0;
1188   WND*          pWndTo = NULL;
1189
1190   if( pWnd->hwndSelf == hwndPrevActive )
1191       hwndPrevActive = 0;
1192
1193   if( hwndActive != pWnd->hwndSelf &&
1194     ( hwndActive || QUEUE_IsDoomedQueue(pWnd->hmemTaskQ)) )
1195       return 0;
1196
1197   if( pWnd->dwStyle & WS_POPUP &&
1198       WINPOS_IsGoodEnough( pWnd->owner ) ) pWndTo = pWnd->owner;
1199   else
1200   {
1201     WND* pWndPtr = pWnd;
1202
1203     pWndTo = WIN_FindWndPtr(hwndPrevActive);
1204
1205     while( !WINPOS_IsGoodEnough(pWndTo) )
1206     {
1207       /* by now owned windows should've been taken care of */
1208
1209       pWndTo = pWndPtr->next;
1210       pWndPtr = pWndTo;
1211       if( !pWndTo ) return 0;
1212     }
1213   }
1214
1215   bRet = WINPOS_SetActiveWindow( pWndTo->hwndSelf, FALSE, TRUE );
1216
1217   /* switch desktop queue to current active */
1218   if( pWndTo->parent == WIN_GetDesktop())
1219       WIN_GetDesktop()->hmemTaskQ = pWndTo->hmemTaskQ;
1220
1221   hwndPrevActive = 0;
1222   return bRet;
1223 }
1224
1225 /*******************************************************************
1226  *         WINPOS_ChangeActiveWindow
1227  *
1228  */
1229 BOOL32 WINPOS_ChangeActiveWindow( HWND32 hWnd, BOOL32 mouseMsg )
1230 {
1231     WND *wndPtr = WIN_FindWndPtr(hWnd);
1232
1233     if (!hWnd) return WINPOS_SetActiveWindow( 0, mouseMsg, TRUE );
1234
1235     if( !wndPtr ) return FALSE;
1236
1237     /* child windows get WM_CHILDACTIVATE message */
1238     if( (wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) == WS_CHILD )
1239         return SendMessage16(hWnd, WM_CHILDACTIVATE, 0, 0L);
1240
1241         /* owned popups imply owner activation - not sure */
1242     if ((wndPtr->dwStyle & WS_POPUP) && wndPtr->owner &&
1243         !(wndPtr->owner->dwStyle & WS_DISABLED ))
1244     {
1245         if (!(wndPtr = wndPtr->owner)) return FALSE;
1246         hWnd = wndPtr->hwndSelf;
1247     }
1248
1249     if( hWnd == hwndActive ) return FALSE;
1250
1251     if( !WINPOS_SetActiveWindow(hWnd ,mouseMsg ,TRUE) )
1252         return FALSE;
1253
1254     /* switch desktop queue to current active */
1255     if( wndPtr->parent == WIN_GetDesktop())
1256         WIN_GetDesktop()->hmemTaskQ = wndPtr->hmemTaskQ;
1257
1258     return TRUE;
1259 }
1260
1261
1262 /***********************************************************************
1263  *           WINPOS_SendNCCalcSize
1264  *
1265  * Send a WM_NCCALCSIZE message to a window.
1266  * All parameters are read-only except newClientRect.
1267  * oldWindowRect, oldClientRect and winpos must be non-NULL only
1268  * when calcValidRect is TRUE.
1269  */
1270 LONG WINPOS_SendNCCalcSize( HWND32 hwnd, BOOL32 calcValidRect,
1271                             RECT16 *newWindowRect, RECT16 *oldWindowRect,
1272                             RECT16 *oldClientRect, SEGPTR winpos,
1273                             RECT16 *newClientRect )
1274 {
1275     NCCALCSIZE_PARAMS16 *params;
1276     LONG result;
1277
1278     if (!(params = SEGPTR_NEW(NCCALCSIZE_PARAMS16))) return 0;
1279     params->rgrc[0] = *newWindowRect;
1280     if (calcValidRect)
1281     {
1282         params->rgrc[1] = *oldWindowRect;
1283         params->rgrc[2] = *oldClientRect;
1284         params->lppos = winpos;
1285     }
1286     result = SendMessage16( hwnd, WM_NCCALCSIZE, calcValidRect,
1287                           (LPARAM)SEGPTR_GET( params ) );
1288     dprintf_win( stddeb, "WINPOS_SendNCCalcSize: %d,%d-%d,%d\n",
1289                  params->rgrc[0].left, params->rgrc[0].top,
1290                  params->rgrc[0].right, params->rgrc[0].bottom );
1291     *newClientRect = params->rgrc[0];
1292     SEGPTR_FREE(params);
1293     return result;
1294 }
1295
1296
1297 /***********************************************************************
1298  *           WINPOS_HandleWindowPosChanging16
1299  *
1300  * Default handling for a WM_WINDOWPOSCHANGING. Called from DefWindowProc().
1301  */
1302 LONG WINPOS_HandleWindowPosChanging16( WND *wndPtr, WINDOWPOS16 *winpos )
1303 {
1304     POINT16 maxSize;
1305     if (winpos->flags & SWP_NOSIZE) return 0;
1306     if ((wndPtr->dwStyle & WS_THICKFRAME) ||
1307         ((wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) == 0))
1308     {
1309         NC_GetMinMaxInfo( wndPtr, &maxSize, NULL, NULL, NULL );
1310         winpos->cx = MIN( winpos->cx, maxSize.x );
1311         winpos->cy = MIN( winpos->cy, maxSize.y );
1312     }
1313     return 0;
1314 }
1315
1316
1317 /***********************************************************************
1318  *           WINPOS_HandleWindowPosChanging32
1319  *
1320  * Default handling for a WM_WINDOWPOSCHANGING. Called from DefWindowProc().
1321  */
1322 LONG WINPOS_HandleWindowPosChanging32( WND *wndPtr, WINDOWPOS32 *winpos )
1323 {
1324     POINT16 maxSize;
1325     if (winpos->flags & SWP_NOSIZE) return 0;
1326     if ((wndPtr->dwStyle & WS_THICKFRAME) ||
1327         ((wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) == 0))
1328     {
1329         NC_GetMinMaxInfo( wndPtr, &maxSize, NULL, NULL, NULL );
1330         winpos->cx = MIN( winpos->cx, maxSize.x );
1331         winpos->cy = MIN( winpos->cy, maxSize.y );
1332     }
1333     return 0;
1334 }
1335
1336
1337 /***********************************************************************
1338  *           WINPOS_MoveWindowZOrder
1339  *
1340  * Move a window in Z order, invalidating everything that needs it.
1341  * Only necessary for windows without associated X window.
1342  */
1343 static void WINPOS_MoveWindowZOrder( HWND32 hwnd, HWND32 hwndAfter )
1344 {
1345     BOOL32 movingUp;
1346     WND *pWndAfter, *pWndCur, *wndPtr = WIN_FindWndPtr( hwnd );
1347
1348     /* We have two possible cases:
1349      * - The window is moving up: we have to invalidate all areas
1350      *   of the window that were covered by other windows
1351      * - The window is moving down: we have to invalidate areas
1352      *   of other windows covered by this one.
1353      */
1354
1355     if (hwndAfter == HWND_TOP)
1356     {
1357         movingUp = TRUE;
1358     }
1359     else if (hwndAfter == HWND_BOTTOM)
1360     {
1361         if (!wndPtr->next) return;  /* Already at the bottom */
1362         movingUp = FALSE;
1363     }
1364     else
1365     {
1366         if (!(pWndAfter = WIN_FindWndPtr( hwndAfter ))) return;
1367         if (wndPtr->next == pWndAfter) return;  /* Already placed right */
1368
1369           /* Determine which window we encounter first in Z-order */
1370         pWndCur = wndPtr->parent->child;
1371         while ((pWndCur != wndPtr) && (pWndCur != pWndAfter))
1372             pWndCur = pWndCur->next;
1373         movingUp = (pWndCur == pWndAfter);
1374     }
1375
1376     if (movingUp)
1377     {
1378         WND *pWndPrevAfter = wndPtr->next;
1379         WIN_UnlinkWindow( hwnd );
1380         WIN_LinkWindow( hwnd, hwndAfter );
1381         pWndCur = wndPtr->next;
1382         while (pWndCur != pWndPrevAfter)
1383         {
1384             RECT32 rect = { pWndCur->rectWindow.left,
1385                             pWndCur->rectWindow.top,
1386                             pWndCur->rectWindow.right,
1387                             pWndCur->rectWindow.bottom };
1388             OffsetRect32( &rect, -wndPtr->rectClient.left,
1389                           -wndPtr->rectClient.top );
1390             PAINT_RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE | RDW_ALLCHILDREN |
1391                               RDW_FRAME | RDW_ERASE, 0 );
1392             pWndCur = pWndCur->next;
1393         }
1394     }
1395     else  /* Moving down */
1396     {
1397         pWndCur = wndPtr->next;
1398         WIN_UnlinkWindow( hwnd );
1399         WIN_LinkWindow( hwnd, hwndAfter );
1400         while (pWndCur != wndPtr)
1401         {
1402             RECT32 rect = { pWndCur->rectWindow.left,
1403                             pWndCur->rectWindow.top,
1404                             pWndCur->rectWindow.right,
1405                             pWndCur->rectWindow.bottom };
1406             OffsetRect32( &rect, -pWndCur->rectClient.left,
1407                           -pWndCur->rectClient.top );
1408             PAINT_RedrawWindow( pWndCur->hwndSelf, &rect, 0, RDW_INVALIDATE |
1409                               RDW_ALLCHILDREN | RDW_FRAME | RDW_ERASE, 0 );
1410             pWndCur = pWndCur->next;
1411         }
1412     }
1413 }
1414
1415 /***********************************************************************
1416  *           WINPOS_ReorderOwnedPopups
1417  *
1418  * fix Z order taking into account owned popups -
1419  * basically we need to maintain them above owner window
1420  */
1421 HWND32 WINPOS_ReorderOwnedPopups(HWND32 hwndInsertAfter,WND* wndPtr,WORD flags)
1422 {
1423  WND*   w = WIN_GetDesktop()->child;
1424
1425   if( wndPtr->dwStyle & WS_POPUP && wndPtr->owner )
1426   {
1427    /* implement "local z-order" between the top and owner window */
1428
1429      HWND32 hwndLocalPrev = HWND_TOP;
1430
1431      if( hwndInsertAfter != HWND_TOP )
1432      {
1433         while( w != wndPtr->owner )
1434         {
1435           if (w != wndPtr) hwndLocalPrev = w->hwndSelf;
1436           if( hwndLocalPrev == hwndInsertAfter ) break;
1437           w = w->next;
1438         }
1439         hwndInsertAfter = hwndLocalPrev;
1440      }
1441
1442   }
1443   else if( wndPtr->dwStyle & WS_CHILD ) return hwndInsertAfter;
1444
1445   w = WIN_GetDesktop()->child;
1446   while( w )
1447   {
1448     if( w == wndPtr ) break;
1449
1450     if( w->dwStyle & WS_POPUP && w->owner == wndPtr )
1451     {
1452       SetWindowPos32(w->hwndSelf, hwndInsertAfter, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE |
1453                      SWP_NOACTIVATE | SWP_NOSENDCHANGING | SWP_DEFERERASE);
1454       hwndInsertAfter = w->hwndSelf;
1455     }
1456     w = w->next;
1457   }
1458
1459   return hwndInsertAfter;
1460 }
1461
1462 /***********************************************************************
1463  *           WINPOS_SizeMoveClean
1464  *
1465  * Make window look nice without excessive repainting
1466  *
1467  * the pain:
1468  *
1469  * visible regions are in window coordinates
1470  * update regions are in window client coordinates
1471  * client and window rectangles are in parent client coordinates
1472  */
1473 static UINT32 WINPOS_SizeMoveClean(WND* Wnd, HRGN32 oldVisRgn, LPRECT16 lpOldWndRect, LPRECT16 lpOldClientRect, UINT32 uFlags )
1474 {
1475  HRGN32 newVisRgn = DCE_GetVisRgn(Wnd->hwndSelf,DCX_WINDOW | DCX_CLIPSIBLINGS);
1476  HRGN32 dirtyRgn = CreateRectRgn32(0,0,0,0);
1477  int  other, my;
1478
1479  dprintf_win(stddeb,"cleaning up...new wnd=(%i %i-%i %i) old wnd=(%i %i-%i %i)\n\
1480 \t\tnew client=(%i %i-%i %i) old client=(%i %i-%i %i)\n",
1481                    Wnd->rectWindow.left, Wnd->rectWindow.top, Wnd->rectWindow.right, Wnd->rectWindow.bottom,
1482                    lpOldWndRect->left, lpOldWndRect->top, lpOldWndRect->right, lpOldWndRect->bottom,
1483                    Wnd->rectClient.left,Wnd->rectClient.top,Wnd->rectClient.right,Wnd->rectClient.bottom,
1484                    lpOldClientRect->left,lpOldClientRect->top,lpOldClientRect->right,lpOldClientRect->bottom);
1485
1486  if( (lpOldWndRect->right - lpOldWndRect->left) != (Wnd->rectWindow.right - Wnd->rectWindow.left) ||
1487      (lpOldWndRect->bottom - lpOldWndRect->top) != (Wnd->rectWindow.bottom - Wnd->rectWindow.top) )
1488      uFlags |= SMC_DRAWFRAME;
1489
1490  CombineRgn32( dirtyRgn, newVisRgn, 0, RGN_COPY);
1491
1492  if( !(uFlags & SMC_NOCOPY) )
1493    CombineRgn32( newVisRgn, newVisRgn, oldVisRgn, RGN_AND );
1494
1495  /* map regions to the parent client area */
1496
1497  OffsetRgn32( dirtyRgn, Wnd->rectWindow.left, Wnd->rectWindow.top );
1498  OffsetRgn32( oldVisRgn, lpOldWndRect->left, lpOldWndRect->top );
1499
1500  /* compute invalidated region outside Wnd - (in client coordinates of the parent window) */
1501
1502  other = CombineRgn32(dirtyRgn, oldVisRgn, dirtyRgn, RGN_DIFF);
1503
1504  /* map visible region to the Wnd client area */
1505
1506  OffsetRgn32( newVisRgn, Wnd->rectWindow.left - Wnd->rectClient.left,
1507                          Wnd->rectWindow.top - Wnd->rectClient.top );
1508
1509  /* substract previously invalidated region from the Wnd visible region */
1510
1511  my =  (Wnd->hrgnUpdate > 1) ? CombineRgn32( newVisRgn, newVisRgn,
1512                                              Wnd->hrgnUpdate, RGN_DIFF)
1513                              : COMPLEXREGION;
1514
1515  if( uFlags & SMC_NOCOPY )      /* invalidate Wnd visible region */
1516    {
1517      if (my != NULLREGION)
1518          PAINT_RedrawWindow( Wnd->hwndSelf, NULL, newVisRgn, RDW_INVALIDATE |
1519           RDW_FRAME | RDW_ALLCHILDREN | RDW_ERASE, RDW_C_USEHRGN );
1520      else if(uFlags & SMC_DRAWFRAME)
1521          Wnd->flags |= WIN_NEEDS_NCPAINT;
1522    }
1523  else                   /* bitblt old client area */
1524    {
1525      HDC32 hDC;
1526      int   update;
1527      HRGN32 updateRgn;
1528      int   xfrom,yfrom,xto,yto,width,height;
1529
1530      if( uFlags & SMC_DRAWFRAME )
1531        {
1532          /* copy only client area, frame will be redrawn anyway */
1533
1534          xfrom = lpOldClientRect->left; yfrom = lpOldClientRect->top;
1535          xto = Wnd->rectClient.left; yto = Wnd->rectClient.top;
1536          width = lpOldClientRect->right - xfrom; height = lpOldClientRect->bottom - yfrom;
1537          updateRgn = CreateRectRgn32( 0, 0, width, height );
1538          CombineRgn32( newVisRgn, newVisRgn, updateRgn, RGN_AND );
1539          SetRectRgn32( updateRgn, 0, 0, Wnd->rectClient.right - xto,
1540                        Wnd->rectClient.bottom - yto );
1541        }
1542      else
1543        {
1544          xfrom = lpOldWndRect->left; yfrom = lpOldWndRect->top;
1545          xto = Wnd->rectWindow.left; yto = Wnd->rectWindow.top;
1546          width = lpOldWndRect->right - xfrom; height = lpOldWndRect->bottom - yfrom;
1547          updateRgn = CreateRectRgn32( xto - Wnd->rectClient.left,
1548                                       yto - Wnd->rectClient.top,
1549                                 Wnd->rectWindow.right - Wnd->rectClient.left,
1550                                 Wnd->rectWindow.bottom - Wnd->rectClient.top );
1551        }
1552
1553      CombineRgn32( newVisRgn, newVisRgn, updateRgn, RGN_AND );
1554
1555      /* substract new visRgn from target rect to get a region that won't be copied */
1556
1557      update = CombineRgn32( updateRgn, updateRgn, newVisRgn, RGN_DIFF );
1558
1559      /* Blt valid bits using parent window DC */
1560
1561      if( my != NULLREGION && (xfrom != xto || yfrom != yto) )
1562        {
1563
1564          /* compute clipping region in parent client coordinates */
1565
1566          OffsetRgn32( newVisRgn, Wnd->rectClient.left, Wnd->rectClient.top );
1567          CombineRgn32( oldVisRgn, oldVisRgn, newVisRgn, RGN_OR );
1568
1569          hDC = GetDCEx32( Wnd->parent->hwndSelf, oldVisRgn,
1570                           DCX_KEEPCLIPRGN | DCX_INTERSECTRGN |
1571                           DCX_CACHE | DCX_CLIPSIBLINGS);
1572
1573          BitBlt32( hDC, xto, yto, width, height, hDC, xfrom, yfrom, SRCCOPY );
1574          ReleaseDC32( Wnd->parent->hwndSelf, hDC);
1575        }
1576
1577      if( update != NULLREGION )
1578          PAINT_RedrawWindow( Wnd->hwndSelf, NULL, updateRgn, RDW_INVALIDATE |
1579                          RDW_FRAME | RDW_ALLCHILDREN | RDW_ERASE, RDW_C_USEHRGN );
1580      else if( uFlags & SMC_DRAWFRAME ) Wnd->flags |= WIN_NEEDS_NCPAINT;
1581      DeleteObject32( updateRgn );
1582    }
1583
1584  /* erase uncovered areas */
1585
1586  if( !(uFlags & SMC_NOPARENTERASE) && (other != NULLREGION ) )
1587       PAINT_RedrawWindow( Wnd->parent->hwndSelf, NULL, dirtyRgn,
1588                         RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_ERASE, RDW_C_USEHRGN );
1589  DeleteObject32(dirtyRgn);
1590  DeleteObject32(newVisRgn);
1591  return uFlags;
1592 }
1593
1594
1595 /***********************************************************************
1596  *           WINPOS_FindDeskTopXWindow
1597  *
1598  * Find the actual X window which needs be restacked.
1599  * Used by WINPOS_SetXWindowPos().
1600  */
1601 static Window WINPOS_FindDeskTopXWindow( WND *wndPtr )
1602 {
1603     if (!(wndPtr->flags & WIN_MANAGED))
1604         return wndPtr->window;
1605     else
1606     {
1607         Window window, root, parent, *children;
1608         int nchildren;
1609         window = wndPtr->window;
1610         for (;;)
1611         {
1612             XQueryTree( display, window, &root, &parent,
1613                         &children, &nchildren );
1614             XFree( children );
1615             if (parent == root)
1616                 return window;
1617             window = parent;
1618         }
1619     }
1620 }
1621
1622 /***********************************************************************
1623  *           WINPOS_SetXWindowPos
1624  *
1625  * SetWindowPos() for an X window. Used by the real SetWindowPos().
1626  */
1627 static void WINPOS_SetXWindowPos( WINDOWPOS16 *winpos )
1628 {
1629     XWindowChanges winChanges;
1630     int changeMask = 0;
1631     WND *wndPtr = WIN_FindWndPtr( winpos->hwnd );
1632
1633     if (!(winpos->flags & SWP_NOSIZE))
1634     {
1635         winChanges.width     = winpos->cx;
1636         winChanges.height    = winpos->cy;
1637         changeMask |= CWWidth | CWHeight;
1638
1639         /* Tweak dialog window size hints */
1640
1641         if ((wndPtr->flags & WIN_MANAGED) &&
1642             (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME))
1643         {
1644             XSizeHints *size_hints = XAllocSizeHints();
1645
1646             if (size_hints)
1647             {
1648                 long supplied_return;
1649
1650                 XGetWMSizeHints( display, wndPtr->window, size_hints,
1651                                  &supplied_return, XA_WM_NORMAL_HINTS);
1652                 size_hints->min_width = size_hints->max_width = winpos->cx;
1653                 size_hints->min_height = size_hints->max_height = winpos->cy;
1654                 XSetWMSizeHints( display, wndPtr->window, size_hints,
1655                                  XA_WM_NORMAL_HINTS );
1656                 XFree(size_hints);
1657             }
1658         }
1659     }
1660     if (!(winpos->flags & SWP_NOMOVE))
1661     {
1662         winChanges.x = winpos->x;
1663         winChanges.y = winpos->y;
1664         changeMask |= CWX | CWY;
1665     }
1666     if (!(winpos->flags & SWP_NOZORDER))
1667     {
1668         winChanges.stack_mode = Below;
1669         changeMask |= CWStackMode;
1670
1671         if (winpos->hwndInsertAfter == HWND_TOP) winChanges.stack_mode = Above;
1672         else if (winpos->hwndInsertAfter != HWND_BOTTOM)
1673         {
1674             WND*   insertPtr = WIN_FindWndPtr( winpos->hwndInsertAfter );
1675             Window stack[2];
1676
1677             stack[0] = WINPOS_FindDeskTopXWindow( insertPtr );
1678             stack[1] = WINPOS_FindDeskTopXWindow( wndPtr );
1679
1680             /* for stupid window managers (i.e. all of them) */
1681
1682             XRestackWindows(display, stack, 2);
1683             changeMask &= ~CWStackMode;
1684         }
1685     }
1686     if (!changeMask) return;
1687
1688     XReconfigureWMWindow( display, wndPtr->window, 0, changeMask, &winChanges );
1689 }
1690
1691
1692 /***********************************************************************
1693  *           SetWindowPos   (USER.232)
1694  */
1695 BOOL16 SetWindowPos16( HWND16 hwnd, HWND16 hwndInsertAfter, INT16 x, INT16 y,
1696                        INT16 cx, INT16 cy, WORD flags )
1697 {
1698     return SetWindowPos32(hwnd,(INT32)(INT16)hwndInsertAfter,x,y,cx,cy,flags);
1699 }
1700
1701 /***********************************************************************
1702  *           SetWindowPos   (USER32.519)
1703  */
1704 BOOL32 SetWindowPos32( HWND32 hwnd, HWND32 hwndInsertAfter, INT32 x, INT32 y,
1705                        INT32 cx, INT32 cy, WORD flags )
1706 {
1707     WINDOWPOS16 *winpos;
1708     WND *       wndPtr;
1709     RECT16      newWindowRect, newClientRect, oldWindowRect;
1710     HRGN32      visRgn = 0;
1711     HWND32      tempInsertAfter= 0;
1712     int         result = 0;
1713     UINT32      uFlags = 0;
1714
1715     dprintf_win(stddeb,"SetWindowPos: hwnd %04x, (%i,%i)-(%i,%i) flags %08x\n",
1716                                                  hwnd, x, y, x+cx, y+cy, flags);
1717       /* Check window handle */
1718
1719     if (hwnd == GetDesktopWindow32()) return FALSE;
1720     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
1721
1722     if (wndPtr->dwStyle & WS_VISIBLE) flags &= ~SWP_SHOWWINDOW;
1723     else
1724     {
1725         uFlags |= SMC_NOPARENTERASE;
1726         flags &= ~SWP_HIDEWINDOW;
1727         if (!(flags & SWP_SHOWWINDOW)) flags |= SWP_NOREDRAW;
1728     }
1729
1730 /*     Check for windows that may not be resized
1731        FIXME: this should be done only for Windows 3.0 programs
1732        if (flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW ) )
1733            flags |= SWP_NOSIZE | SWP_NOMOVE;
1734 */
1735       /* Check dimensions */
1736
1737     if (cx <= 0) cx = 1;
1738     if (cy <= 0) cy = 1;
1739
1740       /* Check flags */
1741
1742     if (hwnd == hwndActive) flags |= SWP_NOACTIVATE;   /* Already active */
1743     if ((wndPtr->rectWindow.right - wndPtr->rectWindow.left == cx) &&
1744         (wndPtr->rectWindow.bottom - wndPtr->rectWindow.top == cy))
1745         flags |= SWP_NOSIZE;    /* Already the right size */
1746     if ((wndPtr->rectWindow.left == x) && (wndPtr->rectWindow.top == y))
1747         flags |= SWP_NOMOVE;    /* Already the right position */
1748
1749       /* Check hwndInsertAfter */
1750
1751     if (!(flags & (SWP_NOZORDER | SWP_NOACTIVATE)))
1752     {
1753           /* Ignore TOPMOST flags when activating a window */
1754           /* _and_ moving it in Z order. */
1755         if ((hwndInsertAfter == HWND_TOPMOST) ||
1756             (hwndInsertAfter == HWND_NOTOPMOST))
1757             hwndInsertAfter = HWND_TOP;
1758     }
1759       /* TOPMOST not supported yet */
1760     if ((hwndInsertAfter == HWND_TOPMOST) ||
1761         (hwndInsertAfter == HWND_NOTOPMOST)) hwndInsertAfter = HWND_TOP;
1762
1763       /* hwndInsertAfter must be a sibling of the window */
1764     if ((hwndInsertAfter != HWND_TOP) && (hwndInsertAfter != HWND_BOTTOM))
1765        {
1766          WND* wnd = WIN_FindWndPtr(hwndInsertAfter);
1767          if( wnd->parent != wndPtr->parent ) return FALSE;
1768          if( wnd->next == wndPtr ) flags |= SWP_NOZORDER;
1769        }
1770     else if (!(wndPtr->window))
1771          /* FIXME: the following optimization is no good for "X-ed" windows */
1772        if (hwndInsertAfter == HWND_TOP)
1773            flags |= ( wndPtr->parent->child == wndPtr)? SWP_NOZORDER: 0;
1774        else /* HWND_BOTTOM */
1775            flags |= ( wndPtr->next )? 0: SWP_NOZORDER;
1776
1777       /* Fill the WINDOWPOS structure */
1778
1779     if (!(winpos = SEGPTR_NEW(WINDOWPOS16))) return FALSE;
1780     winpos->hwnd = hwnd;
1781     winpos->hwndInsertAfter = hwndInsertAfter;
1782     winpos->x = x;
1783     winpos->y = y;
1784     winpos->cx = cx;
1785     winpos->cy = cy;
1786     winpos->flags = flags;
1787
1788       /* Send WM_WINDOWPOSCHANGING message */
1789
1790     if (!(flags & SWP_NOSENDCHANGING))
1791         SendMessage16( hwnd, WM_WINDOWPOSCHANGING, 0,
1792                        (LPARAM)SEGPTR_GET(winpos) );
1793
1794       /* Calculate new position and size */
1795
1796     newWindowRect = wndPtr->rectWindow;
1797     newClientRect = (wndPtr->dwStyle & WS_MINIMIZE) ? wndPtr->rectWindow
1798                                                     : wndPtr->rectClient;
1799
1800     if (!(winpos->flags & SWP_NOSIZE))
1801     {
1802         newWindowRect.right  = newWindowRect.left + winpos->cx;
1803         newWindowRect.bottom = newWindowRect.top + winpos->cy;
1804     }
1805     if (!(winpos->flags & SWP_NOMOVE))
1806     {
1807         newWindowRect.left    = winpos->x;
1808         newWindowRect.top     = winpos->y;
1809         newWindowRect.right  += winpos->x - wndPtr->rectWindow.left;
1810         newWindowRect.bottom += winpos->y - wndPtr->rectWindow.top;
1811
1812         OffsetRect16( &newClientRect, winpos->x - wndPtr->rectWindow.left,
1813                                       winpos->y - wndPtr->rectWindow.top );
1814     }
1815
1816     winpos->flags |= SWP_NOCLIENTMOVE | SWP_NOCLIENTSIZE;
1817
1818       /* Reposition window in Z order */
1819
1820     if (!(winpos->flags & SWP_NOZORDER))
1821     {
1822         /* reorder owned popups if hwnd is top-level window
1823          */
1824         if( wndPtr->parent == WIN_GetDesktop() )
1825             hwndInsertAfter = WINPOS_ReorderOwnedPopups( hwndInsertAfter,
1826                                                          wndPtr, flags );
1827
1828         if (wndPtr->window)
1829         {
1830             WIN_UnlinkWindow( winpos->hwnd );
1831             WIN_LinkWindow( winpos->hwnd, hwndInsertAfter );
1832         }
1833         else WINPOS_MoveWindowZOrder( winpos->hwnd, hwndInsertAfter );
1834     }
1835
1836     if ( !wndPtr->window && !(flags & SWP_NOREDRAW) &&
1837         (!(flags & SWP_NOMOVE) || !(flags & SWP_NOSIZE) || (flags & SWP_FRAMECHANGED)) )
1838           visRgn = DCE_GetVisRgn(hwnd, DCX_WINDOW | DCX_CLIPSIBLINGS);
1839
1840
1841       /* Send WM_NCCALCSIZE message to get new client area */
1842     if( (flags & (SWP_FRAMECHANGED | SWP_NOSIZE)) != SWP_NOSIZE )
1843       {
1844          result = WINPOS_SendNCCalcSize( winpos->hwnd, TRUE, &newWindowRect,
1845                                     &wndPtr->rectWindow, &wndPtr->rectClient,
1846                                     SEGPTR_GET(winpos), &newClientRect );
1847
1848          /* FIXME: WVR_ALIGNxxx */
1849
1850          if( newClientRect.left != wndPtr->rectClient.left ||
1851              newClientRect.top != wndPtr->rectClient.top )
1852              winpos->flags &= ~SWP_NOCLIENTMOVE;
1853
1854          if( (newClientRect.right - newClientRect.left !=
1855              wndPtr->rectClient.right - wndPtr->rectClient.left) ||
1856             (newClientRect.bottom - newClientRect.top !=
1857              wndPtr->rectClient.bottom - wndPtr->rectClient.top) )
1858              winpos->flags &= ~SWP_NOCLIENTSIZE;
1859       }
1860     else
1861       if( !(flags & SWP_NOMOVE) && (newClientRect.left != wndPtr->rectClient.left ||
1862                                     newClientRect.top != wndPtr->rectClient.top) )
1863             winpos->flags &= ~SWP_NOCLIENTMOVE;
1864
1865     /* Update active DCEs */
1866
1867     if( !(flags & SWP_NOZORDER) || (flags & SWP_HIDEWINDOW) || (flags & SWP_SHOWWINDOW)
1868                                 || (memcmp(&newWindowRect,&wndPtr->rectWindow,sizeof(RECT16))
1869                                     && wndPtr->dwStyle & WS_VISIBLE ) )
1870       {
1871         RECT16 rect;
1872
1873         UnionRect16(&rect,&newWindowRect,&wndPtr->rectWindow);
1874         DCE_InvalidateDCE(wndPtr->parent, &rect);
1875       }
1876
1877     /* change geometry */
1878
1879     oldWindowRect = wndPtr->rectWindow;
1880
1881     if (wndPtr->window)
1882     {
1883         RECT16 oldClientRect = wndPtr->rectClient;
1884
1885         tempInsertAfter = winpos->hwndInsertAfter;
1886
1887         winpos->hwndInsertAfter = hwndInsertAfter;
1888
1889         /* postpone geometry change */
1890
1891         if( !(flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW)) )
1892           {
1893               WINPOS_SetXWindowPos( winpos );
1894               winpos->hwndInsertAfter = tempInsertAfter;
1895           }
1896         else  uFlags |= SMC_SETXPOS;
1897
1898         wndPtr->rectWindow = newWindowRect;
1899         wndPtr->rectClient = newClientRect;
1900
1901         if( !(flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW)) )
1902           if( (oldClientRect.left - oldWindowRect.left !=
1903                newClientRect.left - newWindowRect.left) ||
1904               (oldClientRect.top - oldWindowRect.top !=
1905                newClientRect.top - newWindowRect.top) || winpos->flags & SWP_NOCOPYBITS )
1906
1907               PAINT_RedrawWindow( wndPtr->hwndSelf, NULL, 0, RDW_INVALIDATE |
1908                               RDW_ALLCHILDREN | RDW_FRAME | RDW_ERASE, 0 );
1909           else
1910               if( winpos->flags & SWP_FRAMECHANGED )
1911               {
1912                 WORD wErase = 0;
1913                 RECT32 rect;
1914
1915                 if( oldClientRect.right > newClientRect.right )
1916                 {
1917                     rect.left = newClientRect.right; rect.top = newClientRect.top;
1918                     rect.right = oldClientRect.right; rect.bottom = newClientRect.bottom;
1919                     wErase = 1;
1920                     PAINT_RedrawWindow( wndPtr->hwndSelf, &rect, 0,
1921                                       RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN, 0 );
1922                 }
1923                 if( oldClientRect.bottom > newClientRect.bottom )
1924                 {
1925                     rect.left = newClientRect.left; rect.top = newClientRect.bottom;
1926                     rect.right = (wErase)?oldClientRect.right:newClientRect.right;
1927                     rect.bottom = oldClientRect.bottom;
1928                     wErase = 1;
1929                     PAINT_RedrawWindow( wndPtr->hwndSelf, &rect, 0,
1930                                       RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN, 0 );
1931                 }
1932                 if( !wErase ) wndPtr->flags |= WIN_NEEDS_NCPAINT;
1933               }
1934     }
1935     else
1936     {
1937         RECT16 oldClientRect = wndPtr->rectClient;
1938
1939         wndPtr->rectWindow = newWindowRect;
1940         wndPtr->rectClient = newClientRect;
1941
1942         if( oldClientRect.bottom - oldClientRect.top ==
1943             newClientRect.bottom - newClientRect.top ) result &= ~WVR_VREDRAW;
1944
1945         if( oldClientRect.right - oldClientRect.left ==
1946             newClientRect.right - newClientRect.left ) result &= ~WVR_HREDRAW;
1947
1948         if( !(flags & (SWP_NOREDRAW | SWP_HIDEWINDOW | SWP_SHOWWINDOW)) )
1949           {
1950             uFlags |=  ((winpos->flags & SWP_NOCOPYBITS) ||
1951                         (result >= WVR_HREDRAW && result < WVR_VALIDRECTS)) ? SMC_NOCOPY : 0;
1952             uFlags |=  (winpos->flags & SWP_FRAMECHANGED) ? SMC_DRAWFRAME : 0;
1953
1954             if( (winpos->flags & SWP_AGG_NOGEOMETRYCHANGE) != SWP_AGG_NOGEOMETRYCHANGE )
1955                 uFlags = WINPOS_SizeMoveClean(wndPtr, visRgn, &oldWindowRect,
1956                                                               &oldClientRect, uFlags);
1957             else
1958               {
1959                 /* adjust frame and do not erase parent */
1960
1961                 if( winpos->flags & SWP_FRAMECHANGED ) wndPtr->flags |= WIN_NEEDS_NCPAINT;
1962                 if( winpos->flags & SWP_NOZORDER ) uFlags |= SMC_NOPARENTERASE;
1963               }
1964           }
1965         DeleteObject32(visRgn);
1966     }
1967
1968     if (flags & SWP_SHOWWINDOW)
1969     {
1970         wndPtr->dwStyle |= WS_VISIBLE;
1971         if (wndPtr->window)
1972         {
1973             if( uFlags & SMC_SETXPOS )
1974             {
1975               WINPOS_SetXWindowPos( winpos );
1976               winpos->hwndInsertAfter = tempInsertAfter;
1977             }
1978             XMapWindow( display, wndPtr->window );
1979         }
1980         else
1981         {
1982             if (!(flags & SWP_NOREDRAW))
1983                 PAINT_RedrawWindow( winpos->hwnd, NULL, 0,
1984                                 RDW_INVALIDATE | RDW_ALLCHILDREN |
1985                                 RDW_FRAME | RDW_ERASENOW | RDW_ERASE, 0 );
1986         }
1987     }
1988     else if (flags & SWP_HIDEWINDOW)
1989     {
1990         wndPtr->dwStyle &= ~WS_VISIBLE;
1991         if (wndPtr->window)
1992         {
1993             XUnmapWindow( display, wndPtr->window );
1994             if( uFlags & SMC_SETXPOS )
1995             {
1996               WINPOS_SetXWindowPos( winpos );
1997               winpos->hwndInsertAfter = tempInsertAfter;
1998             }
1999         }
2000         else
2001         {
2002             if (!(flags & SWP_NOREDRAW))
2003             {
2004                 RECT32 rect = { oldWindowRect.left, oldWindowRect.top,
2005                                 oldWindowRect.right, oldWindowRect.bottom };
2006                 PAINT_RedrawWindow( wndPtr->parent->hwndSelf, &rect, 0,
2007                         RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_ERASE | RDW_ERASENOW, 0);
2008             }
2009             uFlags |= SMC_NOPARENTERASE;
2010         }
2011
2012         if ((winpos->hwnd == GetFocus32()) ||
2013             IsChild32( winpos->hwnd, GetFocus32()))
2014         {
2015             /* Revert focus to parent */
2016             SetFocus32( GetParent32(winpos->hwnd) );
2017         }
2018         if (hwnd == CARET_GetHwnd()) DestroyCaret32();
2019
2020         if (winpos->hwnd == hwndActive)
2021         {
2022               /* Activate previously active window if possible */
2023             HWND32 newActive = hwndPrevActive;
2024             if (!IsWindow32(newActive) || (newActive == winpos->hwnd))
2025             {
2026                 newActive = GetTopWindow32( GetDesktopWindow32() );
2027                 if (newActive == winpos->hwnd)
2028                     newActive = wndPtr->next ? wndPtr->next->hwndSelf : 0;
2029             }
2030             WINPOS_ChangeActiveWindow( newActive, FALSE );
2031         }
2032     }
2033
2034       /* Activate the window */
2035
2036     if (!(flags & SWP_NOACTIVATE))
2037             WINPOS_ChangeActiveWindow( winpos->hwnd, FALSE );
2038
2039       /* Repaint the window */
2040
2041     if (wndPtr->window) EVENT_Synchronize();  /* Wait for all expose events */
2042
2043     EVENT_DummyMotionNotify(); /* Simulate a mouse event to set the cursor */
2044
2045     if (!(flags & SWP_DEFERERASE) && !(uFlags & SMC_NOPARENTERASE) )
2046     {
2047         RECT32  rect;
2048         CONV_RECT16TO32( &oldWindowRect, &rect );
2049         PAINT_RedrawWindow( wndPtr->parent->hwndSelf, (wndPtr->flags & WIN_SAVEUNDER_OVERRIDE)
2050                             ? &rect : NULL, 0, RDW_ALLCHILDREN | RDW_ERASENOW |
2051                           ((wndPtr->flags & WIN_SAVEUNDER_OVERRIDE) ? RDW_INVALIDATE : 0), 0 );
2052         wndPtr->flags &= ~WIN_SAVEUNDER_OVERRIDE;
2053     }
2054     else if( wndPtr->parent == WIN_GetDesktop() && wndPtr->parent->flags & WIN_NEEDS_ERASEBKGND )
2055         PAINT_RedrawWindow( wndPtr->parent->hwndSelf, NULL, 0, RDW_NOCHILDREN | RDW_ERASENOW, 0 );
2056
2057       /* And last, send the WM_WINDOWPOSCHANGED message */
2058
2059     dprintf_win(stddeb,"\tstatus flags = %04x\n", winpos->flags & SWP_AGG_STATUSFLAGS);
2060
2061     if ( ((winpos->flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE) &&
2062         !(winpos->flags & SWP_NOSENDCHANGING))
2063         SendMessage16( winpos->hwnd, WM_WINDOWPOSCHANGED,
2064                        0, (LPARAM)SEGPTR_GET(winpos) );
2065
2066     SEGPTR_FREE(winpos);
2067     return TRUE;
2068 }
2069
2070
2071 /***********************************************************************
2072  *           BeginDeferWindowPos16   (USER.259)
2073  */
2074 HDWP16 BeginDeferWindowPos16( INT16 count )
2075 {
2076     return BeginDeferWindowPos32( count );
2077 }
2078
2079
2080 /***********************************************************************
2081  *           BeginDeferWindowPos32   (USER32.8)
2082  */
2083 HDWP32 BeginDeferWindowPos32( INT32 count )
2084 {
2085     HDWP32 handle;
2086     DWP *pDWP;
2087
2088     if (count <= 0) return 0;
2089     handle = USER_HEAP_ALLOC( sizeof(DWP) + (count-1)*sizeof(WINDOWPOS32) );
2090     if (!handle) return 0;
2091     pDWP = (DWP *) USER_HEAP_LIN_ADDR( handle );
2092     pDWP->actualCount    = 0;
2093     pDWP->suggestedCount = count;
2094     pDWP->valid          = TRUE;
2095     pDWP->wMagic         = DWP_MAGIC;
2096     pDWP->hwndParent     = 0;
2097     return handle;
2098 }
2099
2100
2101 /***********************************************************************
2102  *           DeferWindowPos16   (USER.260)
2103  */
2104 HDWP16 DeferWindowPos16( HDWP16 hdwp, HWND16 hwnd, HWND16 hwndAfter,
2105                          INT16 x, INT16 y, INT16 cx, INT16 cy, UINT16 flags )
2106 {
2107     return DeferWindowPos32( hdwp, hwnd, (INT32)(INT16)hwndAfter,
2108                              x, y, cx, cy, flags );
2109 }
2110
2111
2112 /***********************************************************************
2113  *           DeferWindowPos32   (USER32.127)
2114  */
2115 HDWP32 DeferWindowPos32( HDWP32 hdwp, HWND32 hwnd, HWND32 hwndAfter,
2116                          INT32 x, INT32 y, INT32 cx, INT32 cy, UINT32 flags )
2117 {
2118     DWP *pDWP;
2119     int i;
2120     HDWP32 newhdwp = hdwp;
2121     HWND32 parent;
2122
2123     pDWP = (DWP *) USER_HEAP_LIN_ADDR( hdwp );
2124     if (!pDWP) return 0;
2125     if (hwnd == GetDesktopWindow32()) return 0;
2126
2127       /* All the windows of a DeferWindowPos() must have the same parent */
2128
2129     parent = WIN_FindWndPtr( hwnd )->parent->hwndSelf;
2130     if (pDWP->actualCount == 0) pDWP->hwndParent = parent;
2131     else if (parent != pDWP->hwndParent)
2132     {
2133         USER_HEAP_FREE( hdwp );
2134         return 0;
2135     }
2136
2137     for (i = 0; i < pDWP->actualCount; i++)
2138     {
2139         if (pDWP->winPos[i].hwnd == hwnd)
2140         {
2141               /* Merge with the other changes */
2142             if (!(flags & SWP_NOZORDER))
2143             {
2144                 pDWP->winPos[i].hwndInsertAfter = hwndAfter;
2145             }
2146             if (!(flags & SWP_NOMOVE))
2147             {
2148                 pDWP->winPos[i].x = x;
2149                 pDWP->winPos[i].y = y;
2150             }
2151             if (!(flags & SWP_NOSIZE))
2152             {
2153                 pDWP->winPos[i].cx = cx;
2154                 pDWP->winPos[i].cy = cy;
2155             }
2156             pDWP->winPos[i].flags &= flags & (SWP_NOSIZE | SWP_NOMOVE |
2157                                               SWP_NOZORDER | SWP_NOREDRAW |
2158                                               SWP_NOACTIVATE | SWP_NOCOPYBITS |
2159                                               SWP_NOOWNERZORDER);
2160             pDWP->winPos[i].flags |= flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW |
2161                                               SWP_FRAMECHANGED);
2162             return hdwp;
2163         }
2164     }
2165     if (pDWP->actualCount >= pDWP->suggestedCount)
2166     {
2167         newhdwp = USER_HEAP_REALLOC( hdwp,
2168                       sizeof(DWP) + pDWP->suggestedCount*sizeof(WINDOWPOS32) );
2169         if (!newhdwp) return 0;
2170         pDWP = (DWP *) USER_HEAP_LIN_ADDR( newhdwp );
2171         pDWP->suggestedCount++;
2172     }
2173     pDWP->winPos[pDWP->actualCount].hwnd = hwnd;
2174     pDWP->winPos[pDWP->actualCount].hwndInsertAfter = hwndAfter;
2175     pDWP->winPos[pDWP->actualCount].x = x;
2176     pDWP->winPos[pDWP->actualCount].y = y;
2177     pDWP->winPos[pDWP->actualCount].cx = cx;
2178     pDWP->winPos[pDWP->actualCount].cy = cy;
2179     pDWP->winPos[pDWP->actualCount].flags = flags;
2180     pDWP->actualCount++;
2181     return newhdwp;
2182 }
2183
2184
2185 /***********************************************************************
2186  *           EndDeferWindowPos16   (USER.261)
2187  */
2188 BOOL16 EndDeferWindowPos16( HDWP16 hdwp )
2189 {
2190     return EndDeferWindowPos32( hdwp );
2191 }
2192
2193
2194 /***********************************************************************
2195  *           EndDeferWindowPos32   (USER32.172)
2196  */
2197 BOOL32 EndDeferWindowPos32( HDWP32 hdwp )
2198 {
2199     DWP *pDWP;
2200     WINDOWPOS32 *winpos;
2201     BOOL32 res = TRUE;
2202     int i;
2203
2204     pDWP = (DWP *) USER_HEAP_LIN_ADDR( hdwp );
2205     if (!pDWP) return FALSE;
2206     for (i = 0, winpos = pDWP->winPos; i < pDWP->actualCount; i++, winpos++)
2207     {
2208         if (!(res = SetWindowPos32( winpos->hwnd, winpos->hwndInsertAfter,
2209                                     winpos->x, winpos->y, winpos->cx,
2210                                     winpos->cy, winpos->flags ))) break;
2211     }
2212     USER_HEAP_FREE( hdwp );
2213     return res;
2214 }
2215
2216
2217 /***********************************************************************
2218  *           TileChildWindows   (USER.199)
2219  */
2220 void TileChildWindows( HWND16 parent, WORD action )
2221 {
2222     printf("STUB TileChildWindows(%04x, %d)\n", parent, action);
2223 }
2224
2225 /***********************************************************************
2226  *           CascageChildWindows   (USER.198)
2227  */
2228 void CascadeChildWindows( HWND16 parent, WORD action )
2229 {
2230     printf("STUB CascadeChildWindows(%04x, %d)\n", parent, action);
2231 }