git.oblomov.eu Git - wine/blob - windows/winpos.c

   1 /*
   2  * Window position related functions.
   3  *
   4  * Copyright 1993, 1994, 1995 Alexandre Julliard
   5  *                       1995, 1996, 1999 Alex Korobka
   6  */
   7
   8 #include <string.h>
   9 #include "wine/winuser16.h"
  10 #include "heap.h"
  11 #include "module.h"
  12 #include "user.h"
  13 #include "region.h"
  14 #include "win.h"
  15 #include "hook.h"
  16 #include "message.h"
  17 #include "queue.h"
  18 #include "options.h"
  19 #include "task.h"
  20 #include "winpos.h"
  21 #include "dce.h"
  22 #include "nonclient.h"
  23 #include "debugtools.h"
  24 #include "local.h"
  25 #include "ldt.h"
  26
  27 DEFAULT_DEBUG_CHANNEL(win)
  28
  29 #define HAS_DLGFRAME(style,exStyle) \
  30     (((exStyle) & WS_EX_DLGMODALFRAME) || \
  31      (((style) & WS_DLGFRAME) && !((style) & WS_BORDER)))
  32
  33 #define HAS_THICKFRAME(style) \
  34     (((style) & WS_THICKFRAME) && \
  35      !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
  36
  37 #define  SWP_AGG_NOGEOMETRYCHANGE \
  38     (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE)
  39 #define  SWP_AGG_NOPOSCHANGE \
  40     (SWP_AGG_NOGEOMETRYCHANGE | SWP_NOZORDER)
  41 #define  SWP_AGG_STATUSFLAGS \
  42     (SWP_AGG_NOPOSCHANGE | SWP_FRAMECHANGED | SWP_HIDEWINDOW | SWP_SHOWWINDOW)
  43
  44 #define EMPTYPOINT(pt)          ((*(LONG*)&(pt)) == -1)
  45
  46 #define PLACE_MIN               0x0001
  47 #define PLACE_MAX               0x0002
  48 #define PLACE_RECT              0x0004
  49
  50 #define SWP_EX_NOCOPY           0x0001
  51 #define SWP_EX_PAINTSELF        0x0002
  52 #define SWP_EX_NONCLIENT        0x0004
  53
  54 #define MINMAX_NOSWP            0x00010000
  55
  56 /* ----- internal variables ----- */
  57
  58 static HWND hwndPrevActive  = 0;  /* Previously active window */
  59 static HWND hGlobalShellWindow=0; /*the shell*/
  60 static HWND hGlobalTaskmanWindow=0;
  61 static HWND hGlobalProgmanWindow=0;
  62
  63 static LPCSTR atomInternalPos;
  64
  65 extern HQUEUE16 hActiveQueue;
  66
  67 /***********************************************************************
  68  *           WINPOS_CreateInternalPosAtom
  69  */
  70 BOOL WINPOS_CreateInternalPosAtom()
  71 {
  72     LPSTR str = "SysIP";
  73     atomInternalPos = (LPCSTR)(DWORD)GlobalAddAtomA(str);
  74     return (atomInternalPos) ? TRUE : FALSE;
  75 }
  76
  77 /***********************************************************************
  78  *           WINPOS_CheckInternalPos
  79  *
  80  * Called when a window is destroyed.
  81  */
  82 void WINPOS_CheckInternalPos( WND* wndPtr )
  83 {
  84     LPINTERNALPOS lpPos;
  85     MESSAGEQUEUE *pMsgQ = 0;
  86     HWND hwnd = wndPtr->hwndSelf;
  87
  88     lpPos = (LPINTERNALPOS) GetPropA( hwnd, atomInternalPos );
  89
  90     /* Retrieve the message queue associated with this window */
  91     pMsgQ = (MESSAGEQUEUE *)QUEUE_Lock( wndPtr->hmemTaskQ );
  92     if ( !pMsgQ )
  93     {
  94         WARN("\tMessage queue not found. Exiting!\n" );
  95         return;
  96     }
  97
  98     if( hwnd == hwndPrevActive ) hwndPrevActive = 0;
  99
 100     if( hwnd == PERQDATA_GetActiveWnd( pMsgQ->pQData ) )
 101     {
 102         PERQDATA_SetActiveWnd( pMsgQ->pQData, 0 );
 103         WARN("\tattempt to activate destroyed window!\n");
 104     }
 105
 106     if( lpPos )
 107     {
 108         if( IsWindow(lpPos->hwndIconTitle) )
 109             DestroyWindow( lpPos->hwndIconTitle );
 110         HeapFree( SystemHeap, 0, lpPos );
 111     }
 112
 113     QUEUE_Unlock( pMsgQ );
 114     return;
 115 }
 116
 117 /***********************************************************************
 118  *           WINPOS_FindIconPos
 119  *
 120  * Find a suitable place for an iconic window.
 121  */
 122 static POINT16 WINPOS_FindIconPos( WND* wndPtr, POINT16 pt )
 123 {
 124     RECT16 rectParent;
 125     short x, y, xspacing, yspacing;
 126
 127     GetClientRect16( wndPtr->parent->hwndSelf, &rectParent );
 128     if ((pt.x >= rectParent.left) && (pt.x + GetSystemMetrics(SM_CXICON) < rectParent.right) &&
 129         (pt.y >= rectParent.top) && (pt.y + GetSystemMetrics(SM_CYICON) < rectParent.bottom))
 130         return pt;  /* The icon already has a suitable position */
 131
 132     xspacing = GetSystemMetrics(SM_CXICONSPACING);
 133     yspacing = GetSystemMetrics(SM_CYICONSPACING);
 134
 135     y = rectParent.bottom;
 136     for (;;)
 137     {
 138         for (x = rectParent.left; x <= rectParent.right-xspacing; x += xspacing)
 139         {
 140               /* Check if another icon already occupies this spot */
 141             WND *childPtr = WIN_LockWndPtr(wndPtr->parent->child);
 142             while (childPtr)
 143             {
 144                 if ((childPtr->dwStyle & WS_MINIMIZE) && (childPtr != wndPtr))
 145                 {
 146                     if ((childPtr->rectWindow.left < x + xspacing) &&
 147                         (childPtr->rectWindow.right >= x) &&
 148                         (childPtr->rectWindow.top <= y) &&
 149                         (childPtr->rectWindow.bottom > y - yspacing))
 150                         break;  /* There's a window in there */
 151                 }
 152                 WIN_UpdateWndPtr(&childPtr,childPtr->next);
 153             }
 154             WIN_ReleaseWndPtr(childPtr);
 155             if (!childPtr) /* No window was found, so it's OK for us */
 156             {
 157                 pt.x = x + (xspacing - GetSystemMetrics(SM_CXICON)) / 2;
 158                 pt.y = y - (yspacing + GetSystemMetrics(SM_CYICON)) / 2;
 159                 return pt;
 160             }
 161         }
 162         y -= yspacing;
 163     }
 164 }
 165
 166
 167 /***********************************************************************
 168  *           ArrangeIconicWindows16   (USER.170)
 169  */
 170 UINT16 WINAPI ArrangeIconicWindows16( HWND16 parent)
 171 {
 172     return ArrangeIconicWindows(parent);
 173 }
 174 /***********************************************************************
 175  *           ArrangeIconicWindows   (USER32.7)
 176  */
 177 UINT WINAPI ArrangeIconicWindows( HWND parent )
 178 {
 179     RECT rectParent;
 180     HWND hwndChild;
 181     INT x, y, xspacing, yspacing;
 182
 183     GetClientRect( parent, &rectParent );
 184     x = rectParent.left;
 185     y = rectParent.bottom;
 186     xspacing = GetSystemMetrics(SM_CXICONSPACING);
 187     yspacing = GetSystemMetrics(SM_CYICONSPACING);
 188
 189     hwndChild = GetWindow( parent, GW_CHILD );
 190     while (hwndChild)
 191     {
 192         if( IsIconic( hwndChild ) )
 193         {
 194             WND *wndPtr = WIN_FindWndPtr(hwndChild);
 195
 196             WINPOS_ShowIconTitle( wndPtr, FALSE );
 197
 198             SetWindowPos( hwndChild, 0, x + (xspacing - GetSystemMetrics(SM_CXICON)) / 2,
 199                             y - yspacing - GetSystemMetrics(SM_CYICON)/2, 0, 0,
 200                             SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
 201             if( IsWindow(hwndChild) )
 202                 WINPOS_ShowIconTitle(wndPtr , TRUE );
 203             WIN_ReleaseWndPtr(wndPtr);
 204
 205             if (x <= rectParent.right - xspacing) x += xspacing;
 206             else
 207             {
 208                 x = rectParent.left;
 209                 y -= yspacing;
 210             }
 211         }
 212         hwndChild = GetWindow( hwndChild, GW_HWNDNEXT );
 213     }
 214     return yspacing;
 215 }
 216
 217
 218 /***********************************************************************
 219  *             SwitchToThisWindow16   (USER.172)
 220  */
 221 void WINAPI SwitchToThisWindow16( HWND16 hwnd, BOOL16 restore )
 222 {
 223     SwitchToThisWindow( hwnd, restore );
 224 }
 225
 226
 227 /***********************************************************************
 228  *             SwitchToThisWindow   (USER32.539)
 229  */
 230 void WINAPI SwitchToThisWindow( HWND hwnd, BOOL restore )
 231 {
 232     ShowWindow( hwnd, restore ? SW_RESTORE : SW_SHOWMINIMIZED );
 233 }
 234
 235
 236 /***********************************************************************
 237  *           GetWindowRect16   (USER.32)
 238  */
 239 void WINAPI GetWindowRect16( HWND16 hwnd, LPRECT16 rect )
 240 {
 241     WND * wndPtr = WIN_FindWndPtr( hwnd );
 242     if (!wndPtr) return;
 243
 244     CONV_RECT32TO16( &wndPtr->rectWindow, rect );
 245     if (wndPtr->dwStyle & WS_CHILD)
 246         MapWindowPoints16( wndPtr->parent->hwndSelf, 0, (POINT16 *)rect, 2 );
 247     WIN_ReleaseWndPtr(wndPtr);
 248 }
 249
 250
 251 /***********************************************************************
 252  *           GetWindowRect   (USER32.308)
 253  */
 254 BOOL WINAPI GetWindowRect( HWND hwnd, LPRECT rect )
 255 {
 256     WND * wndPtr = WIN_FindWndPtr( hwnd );
 257     if (!wndPtr) return FALSE;
 258
 259     *rect = wndPtr->rectWindow;
 260     if (wndPtr->dwStyle & WS_CHILD)
 261         MapWindowPoints( wndPtr->parent->hwndSelf, 0, (POINT *)rect, 2 );
 262     WIN_ReleaseWndPtr(wndPtr);
 263     return TRUE;
 264 }
 265
 266
 267 /***********************************************************************
 268  *           GetWindowRgn
 269  */
 270 BOOL WINAPI GetWindowRgn ( HWND hwnd, HRGN hrgn )
 271
 272 {
 273   RECT    rect;
 274   WND * wndPtr = WIN_FindWndPtr( hwnd );
 275   if (!wndPtr) return (ERROR);
 276
 277   FIXME("GetWindowRgn: doesn't really do regions\n");
 278
 279   memset (&rect, 0, sizeof(rect));
 280
 281   GetWindowRect ( hwnd, &rect );
 282
 283   FIXME("Check whether a valid region here\n");
 284
 285   SetRectRgn ( hrgn, rect.left, rect.top, rect.right, rect.bottom );
 286
 287   WIN_ReleaseWndPtr(wndPtr);
 288   return (SIMPLEREGION);
 289 }
 290
 291 /***********************************************************************
 292  *           SetWindowRgn
 293  */
 294 INT WINAPI SetWindowRgn( HWND hwnd, HRGN hrgn,BOOL bRedraw)
 295
 296 {
 297
 298   FIXME("SetWindowRgn: stub\n");
 299   return TRUE;
 300 }
 301
 302 /***********************************************************************
 303  *           SetWindowRgn16
 304  */
 305 INT16 WINAPI SetWindowRgn16( HWND16 hwnd, HRGN16 hrgn,BOOL16 bRedraw)
 306
 307 {
 308
 309   FIXME("SetWindowRgn16: stub\n");
 310   return TRUE;
 311 }
 312
 313
 314 /***********************************************************************
 315  *           GetClientRect16   (USER.33)
 316  */
 317 void WINAPI GetClientRect16( HWND16 hwnd, LPRECT16 rect )
 318 {
 319     WND * wndPtr = WIN_FindWndPtr( hwnd );
 320
 321     rect->left = rect->top = rect->right = rect->bottom = 0;
 322     if (wndPtr)
 323     {
 324         rect->right  = wndPtr->rectClient.right - wndPtr->rectClient.left;
 325         rect->bottom = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
 326     }
 327     WIN_ReleaseWndPtr(wndPtr);
 328 }
 329
 330
 331 /***********************************************************************
 332  *           GetClientRect   (USER.220)
 333  */
 334 BOOL WINAPI GetClientRect( HWND hwnd, LPRECT rect )
 335 {
 336     WND * wndPtr = WIN_FindWndPtr( hwnd );
 337
 338     rect->left = rect->top = rect->right = rect->bottom = 0;
 339     if (!wndPtr) return FALSE;
 340     rect->right  = wndPtr->rectClient.right - wndPtr->rectClient.left;
 341     rect->bottom = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
 342
 343     WIN_ReleaseWndPtr(wndPtr);
 344     return TRUE;
 345 }
 346
 347
 348 /*******************************************************************
 349  *         ClientToScreen16   (USER.28)
 350  */
 351 void WINAPI ClientToScreen16( HWND16 hwnd, LPPOINT16 lppnt )
 352 {
 353     MapWindowPoints16( hwnd, 0, lppnt, 1 );
 354 }
 355
 356
 357 /*******************************************************************
 358  *         ClientToScreen   (USER32.52)
 359  */
 360 BOOL WINAPI ClientToScreen( HWND hwnd, LPPOINT lppnt )
 361 {
 362     MapWindowPoints( hwnd, 0, lppnt, 1 );
 363     return TRUE;
 364 }
 365
 366
 367 /*******************************************************************
 368  *         ScreenToClient16   (USER.29)
 369  */
 370 void WINAPI ScreenToClient16( HWND16 hwnd, LPPOINT16 lppnt )
 371 {
 372     MapWindowPoints16( 0, hwnd, lppnt, 1 );
 373 }
 374
 375
 376 /*******************************************************************
 377  *         ScreenToClient   (USER32.447)
 378  */
 379 BOOL WINAPI ScreenToClient( HWND hwnd, LPPOINT lppnt )
 380 {
 381     MapWindowPoints( 0, hwnd, lppnt, 1 );
 382     return TRUE;
 383 }
 384
 385
 386 /***********************************************************************
 387  *           WINPOS_WindowFromPoint
 388  *
 389  * Find the window and hittest for a given point.
 390  */
 391 INT16 WINPOS_WindowFromPoint( WND* wndScope, POINT16 pt, WND **ppWnd )
 392 {
 393     WND *wndPtr;
 394     INT16 hittest = HTERROR;
 395     INT16 retvalue;
 396     POINT16 xy = pt;
 397
 398    *ppWnd = NULL;
 399     wndPtr = WIN_LockWndPtr(wndScope->child);
 400
 401     if( wndScope->flags & WIN_MANAGED )
 402     {
 403         /* In managed mode we have to check wndScope first as it is also
 404          * a window which received the mouse event. */
 405
 406         if( wndScope->dwStyle & WS_DISABLED )
 407         {
 408             retvalue = HTERROR;
 409             goto end;
 410         }
 411         if( pt.x < wndScope->rectClient.left || pt.x >= wndScope->rectClient.right ||
 412             pt.y < wndScope->rectClient.top || pt.y >= wndScope->rectClient.bottom )
 413             goto hittest;
 414     }
 415     MapWindowPoints16( GetDesktopWindow16(), wndScope->hwndSelf, &xy, 1 );
 416
 417     for (;;)
 418     {
 419         while (wndPtr)
 420         {
 421             /* If point is in window, and window is visible, and it  */
 422             /* is enabled (or it's a top-level window), then explore */
 423             /* its children. Otherwise, go to the next window.       */
 424
 425             if ((wndPtr->dwStyle & WS_VISIBLE) &&
 426                 (!(wndPtr->dwStyle & WS_DISABLED) ||
 427                  ((wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) != WS_CHILD)) &&
 428                 (xy.x >= wndPtr->rectWindow.left) &&
 429                 (xy.x < wndPtr->rectWindow.right) &&
 430                 (xy.y >= wndPtr->rectWindow.top) &&
 431                 (xy.y < wndPtr->rectWindow.bottom))
 432             {
 433                 *ppWnd = wndPtr;  /* Got a suitable window */
 434
 435                 /* If window is minimized or disabled, return at once */
 436                 if (wndPtr->dwStyle & WS_MINIMIZE)
 437                 {
 438                     retvalue = HTCAPTION;
 439                     goto end;
 440                 }
 441                 if (wndPtr->dwStyle & WS_DISABLED)
 442                 {
 443                     retvalue = HTERROR;
 444                     goto end;
 445                 }
 446
 447                 /* If point is not in client area, ignore the children */
 448                 if ((xy.x < wndPtr->rectClient.left) ||
 449                     (xy.x >= wndPtr->rectClient.right) ||
 450                     (xy.y < wndPtr->rectClient.top) ||
 451                     (xy.y >= wndPtr->rectClient.bottom)) break;
 452
 453                 xy.x -= wndPtr->rectClient.left;
 454                 xy.y -= wndPtr->rectClient.top;
 455                 WIN_UpdateWndPtr(&wndPtr,wndPtr->child);
 456             }
 457             else
 458             {
 459                 WIN_UpdateWndPtr(&wndPtr,wndPtr->next);
 460             }
 461         }
 462
 463 hittest:
 464         /* If nothing found, try the scope window */
 465         if (!*ppWnd) *ppWnd = wndScope;
 466
 467         /* Send the WM_NCHITTEST message (only if to the same task) */
 468         if ((*ppWnd)->hmemTaskQ == GetFastQueue16())
 469         {
 470             hittest = (INT16)SendMessage16( (*ppWnd)->hwndSelf, WM_NCHITTEST,
 471                                                  0, MAKELONG( pt.x, pt.y ) );
 472             if (hittest != HTTRANSPARENT)
 473             {
 474                 retvalue = hittest;  /* Found the window */
 475                 goto end;
 476         }
 477         }
 478         else
 479         {
 480             retvalue = HTCLIENT;
 481             goto end;
 482         }
 483
 484         /* If no children found in last search, make point relative to parent */
 485         if (!wndPtr)
 486         {
 487             xy.x += (*ppWnd)->rectClient.left;
 488             xy.y += (*ppWnd)->rectClient.top;
 489         }
 490
 491         /* Restart the search from the next sibling */
 492         WIN_UpdateWndPtr(&wndPtr,(*ppWnd)->next);
 493         *ppWnd = (*ppWnd)->parent;
 494     }
 495
 496 end:
 497     WIN_ReleaseWndPtr(wndPtr);
 498     return retvalue;
 499 }
 500
 501
 502 /*******************************************************************
 503  *         WindowFromPoint16   (USER.30)
 504  */
 505 HWND16 WINAPI WindowFromPoint16( POINT16 pt )
 506 {
 507     WND *pWnd;
 508     WINPOS_WindowFromPoint( WIN_GetDesktop(), pt, &pWnd );
 509     WIN_ReleaseDesktop();
 510     return pWnd->hwndSelf;
 511 }
 512
 513
 514 /*******************************************************************
 515  *         WindowFromPoint   (USER32.582)
 516  */
 517 HWND WINAPI WindowFromPoint( POINT pt )
 518 {
 519     WND *pWnd;
 520     POINT16 pt16;
 521     CONV_POINT32TO16( &pt, &pt16 );
 522     WINPOS_WindowFromPoint( WIN_GetDesktop(), pt16, &pWnd );
 523     WIN_ReleaseDesktop();
 524     return (HWND)pWnd->hwndSelf;
 525 }
 526
 527
 528 /*******************************************************************
 529  *         ChildWindowFromPoint16   (USER.191)
 530  */
 531 HWND16 WINAPI ChildWindowFromPoint16( HWND16 hwndParent, POINT16 pt )
 532 {
 533     POINT pt32;
 534     CONV_POINT16TO32( &pt, &pt32 );
 535     return (HWND16)ChildWindowFromPoint( hwndParent, pt32 );
 536 }
 537
 538
 539 /*******************************************************************
 540  *         ChildWindowFromPoint   (USER32.49)
 541  */
 542 HWND WINAPI ChildWindowFromPoint( HWND hwndParent, POINT pt )
 543 {
 544     /* pt is in the client coordinates */
 545
 546     WND* wnd = WIN_FindWndPtr(hwndParent);
 547     RECT rect;
 548     HWND retvalue;
 549
 550     if( !wnd ) return 0;
 551
 552     /* get client rect fast */
 553     rect.top = rect.left = 0;
 554     rect.right = wnd->rectClient.right - wnd->rectClient.left;
 555     rect.bottom = wnd->rectClient.bottom - wnd->rectClient.top;
 556
 557     if (!PtInRect( &rect, pt ))
 558     {
 559         retvalue = 0;
 560         goto end;
 561     }
 562     WIN_UpdateWndPtr(&wnd,wnd->child);
 563     while ( wnd )
 564     {
 565         if (PtInRect( &wnd->rectWindow, pt ))
 566         {
 567             retvalue = wnd->hwndSelf;
 568             goto end;
 569         }
 570         WIN_UpdateWndPtr(&wnd,wnd->next);
 571     }
 572     retvalue = hwndParent;
 573 end:
 574     WIN_ReleaseWndPtr(wnd);
 575     return retvalue;
 576 }
 577
 578 /*******************************************************************
 579  *         ChildWindowFromPointEx16   (USER.50)
 580  */
 581 HWND16 WINAPI ChildWindowFromPointEx16( HWND16 hwndParent, POINT16 pt, UINT16 uFlags)
 582 {
 583     POINT pt32;
 584     CONV_POINT16TO32( &pt, &pt32 );
 585     return (HWND16)ChildWindowFromPointEx( hwndParent, pt32, uFlags );
 586 }
 587
 588
 589 /*******************************************************************
 590  *         ChildWindowFromPointEx32   (USER32.50)
 591  */
 592 HWND WINAPI ChildWindowFromPointEx( HWND hwndParent, POINT pt,
 593                 UINT uFlags)
 594 {
 595     /* pt is in the client coordinates */
 596
 597     WND* wnd = WIN_FindWndPtr(hwndParent);
 598     RECT rect;
 599     HWND retvalue;
 600
 601     if( !wnd ) return 0;
 602
 603     /* get client rect fast */
 604     rect.top = rect.left = 0;
 605     rect.right = wnd->rectClient.right - wnd->rectClient.left;
 606     rect.bottom = wnd->rectClient.bottom - wnd->rectClient.top;
 607
 608     if (!PtInRect( &rect, pt ))
 609     {
 610         retvalue = 0;
 611         goto end;
 612     }
 613     WIN_UpdateWndPtr(&wnd,wnd->child);
 614
 615     while ( wnd )
 616     {
 617         if (PtInRect( &wnd->rectWindow, pt )) {
 618                 if ( (uFlags & CWP_SKIPINVISIBLE) &&
 619                                 !(wnd->dwStyle & WS_VISIBLE) );
 620                 else if ( (uFlags & CWP_SKIPDISABLED) &&
 621                                 (wnd->dwStyle & WS_DISABLED) );
 622                 else if ( (uFlags & CWP_SKIPTRANSPARENT) &&
 623                                 (wnd->dwExStyle & WS_EX_TRANSPARENT) );
 624                 else
 625                 {
 626                     retvalue = wnd->hwndSelf;
 627                     goto end;
 628                 }
 629
 630         }
 631         WIN_UpdateWndPtr(&wnd,wnd->next);
 632     }
 633     retvalue = hwndParent;
 634 end:
 635     WIN_ReleaseWndPtr(wnd);
 636     return retvalue;
 637 }
 638
 639
 640 /*******************************************************************
 641  *         WINPOS_GetWinOffset
 642  *
 643  * Calculate the offset between the origin of the two windows. Used
 644  * to implement MapWindowPoints.
 645  */
 646 static void WINPOS_GetWinOffset( HWND hwndFrom, HWND hwndTo,
 647                                  POINT *offset )
 648 {
 649     WND * wndPtr = 0;
 650
 651     offset->x = offset->y = 0;
 652     if (hwndFrom == hwndTo ) return;
 653
 654       /* Translate source window origin to screen coords */
 655     if (hwndFrom)
 656     {
 657         if (!(wndPtr = WIN_FindWndPtr( hwndFrom )))
 658         {
 659             ERR("bad hwndFrom = %04x\n",hwndFrom);
 660             return;
 661         }
 662         while (wndPtr->parent)
 663         {
 664             offset->x += wndPtr->rectClient.left;
 665             offset->y += wndPtr->rectClient.top;
 666             WIN_UpdateWndPtr(&wndPtr,wndPtr->parent);
 667         }
 668         WIN_ReleaseWndPtr(wndPtr);
 669     }
 670
 671       /* Translate origin to destination window coords */
 672     if (hwndTo)
 673     {
 674         if (!(wndPtr = WIN_FindWndPtr( hwndTo )))
 675         {
 676             ERR("bad hwndTo = %04x\n", hwndTo );
 677             return;
 678         }
 679         while (wndPtr->parent)
 680         {
 681             offset->x -= wndPtr->rectClient.left;
 682             offset->y -= wndPtr->rectClient.top;
 683             WIN_UpdateWndPtr(&wndPtr,wndPtr->parent);
 684         }
 685         WIN_ReleaseWndPtr(wndPtr);
 686     }
 687 }
 688
 689
 690 /*******************************************************************
 691  *         MapWindowPoints16   (USER.258)
 692  */
 693 void WINAPI MapWindowPoints16( HWND16 hwndFrom, HWND16 hwndTo,
 694                                LPPOINT16 lppt, UINT16 count )
 695 {
 696     POINT offset;
 697
 698     WINPOS_GetWinOffset( hwndFrom, hwndTo, &offset );
 699     while (count--)
 700     {
 701         lppt->x += offset.x;
 702         lppt->y += offset.y;
 703         lppt++;
 704     }
 705 }
 706
 707
 708 /*******************************************************************
 709  *         MapWindowPoints   (USER32.386)
 710  */
 711 INT WINAPI MapWindowPoints( HWND hwndFrom, HWND hwndTo,
 712                                LPPOINT lppt, UINT count )
 713 {
 714     POINT offset;
 715
 716     WINPOS_GetWinOffset( hwndFrom, hwndTo, &offset );
 717     while (count--)
 718     {
 719         lppt->x += offset.x;
 720         lppt->y += offset.y;
 721         lppt++;
 722     }
 723     return MAKELONG( LOWORD(offset.x), LOWORD(offset.y) );
 724 }
 725
 726
 727 /***********************************************************************
 728  *           IsIconic16   (USER.31)
 729  */
 730 BOOL16 WINAPI IsIconic16(HWND16 hWnd)
 731 {
 732     return IsIconic(hWnd);
 733 }
 734
 735
 736 /***********************************************************************
 737  *           IsIconic   (USER32.345)
 738  */
 739 BOOL WINAPI IsIconic(HWND hWnd)
 740 {
 741     BOOL retvalue;
 742     WND * wndPtr = WIN_FindWndPtr(hWnd);
 743     if (wndPtr == NULL) return FALSE;
 744     retvalue = (wndPtr->dwStyle & WS_MINIMIZE) != 0;
 745     WIN_ReleaseWndPtr(wndPtr);
 746     return retvalue;
 747 }
 748
 749
 750 /***********************************************************************
 751  *           IsZoomed   (USER.272)
 752  */
 753 BOOL16 WINAPI IsZoomed16(HWND16 hWnd)
 754 {
 755     return IsZoomed(hWnd);
 756 }
 757
 758
 759 /***********************************************************************
 760  *           IsZoomed   (USER.352)
 761  */
 762 BOOL WINAPI IsZoomed(HWND hWnd)
 763 {
 764     BOOL retvalue;
 765     WND * wndPtr = WIN_FindWndPtr(hWnd);
 766     if (wndPtr == NULL) return FALSE;
 767     retvalue = (wndPtr->dwStyle & WS_MAXIMIZE) != 0;
 768     WIN_ReleaseWndPtr(wndPtr);
 769     return retvalue;
 770 }
 771
 772
 773 /*******************************************************************
 774  *         GetActiveWindow    (USER.60)
 775  */
 776 HWND16 WINAPI GetActiveWindow16(void)
 777 {
 778     return (HWND16)GetActiveWindow();
 779 }
 780
 781 /*******************************************************************
 782  *         GetActiveWindow    (USER32.205)
 783  */
 784 HWND WINAPI GetActiveWindow(void)
 785 {
 786     MESSAGEQUEUE *pCurMsgQ = 0;
 787     HWND hwndActive = 0;
 788
 789     /* Get the messageQ for the current thread */
 790     if (!(pCurMsgQ = (MESSAGEQUEUE *)QUEUE_Lock( GetFastQueue16() )))
 791 {
 792         WARN("\tCurrent message queue not found. Exiting!\n" );
 793         return 0;
 794     }
 795
 796     /* Return the current active window from the perQ data of the current message Q */
 797     hwndActive = PERQDATA_GetActiveWnd( pCurMsgQ->pQData );
 798
 799     QUEUE_Unlock( pCurMsgQ );
 800     return hwndActive;
 801 }
 802
 803
 804 /*******************************************************************
 805  *         WINPOS_CanActivate
 806  */
 807 static BOOL WINPOS_CanActivate(WND* pWnd)
 808 {
 809     if( pWnd && ((pWnd->dwStyle & (WS_DISABLED | WS_VISIBLE | WS_CHILD))
 810         == WS_VISIBLE) ) return TRUE;
 811     return FALSE;
 812 }
 813
 814
 815 /*******************************************************************
 816  *         SetActiveWindow16    (USER.59)
 817  */
 818 HWND16 WINAPI SetActiveWindow16( HWND16 hwnd )
 819 {
 820     return SetActiveWindow(hwnd);
 821 }
 822
 823
 824 /*******************************************************************
 825  *         SetActiveWindow    (USER32.463)
 826  */
 827 HWND WINAPI SetActiveWindow( HWND hwnd )
 828 {
 829     HWND prev = 0;
 830     WND *wndPtr = WIN_FindWndPtr( hwnd );
 831     MESSAGEQUEUE *pMsgQ = 0, *pCurMsgQ = 0;
 832
 833     if ( !WINPOS_CanActivate(wndPtr) )
 834     {
 835         prev = 0;
 836         goto end;
 837     }
 838
 839     /* Get the messageQ for the current thread */
 840     if (!(pCurMsgQ = (MESSAGEQUEUE *)QUEUE_Lock( GetFastQueue16() )))
 841     {
 842         WARN("\tCurrent message queue not found. Exiting!\n" );
 843         goto CLEANUP;
 844     }
 845
 846     /* Retrieve the message queue associated with this window */
 847     pMsgQ = (MESSAGEQUEUE *)QUEUE_Lock( wndPtr->hmemTaskQ );
 848     if ( !pMsgQ )
 849     {
 850         WARN("\tWindow message queue not found. Exiting!\n" );
 851         goto CLEANUP;
 852     }
 853
 854     /* Make sure that the window is associated with the calling threads
 855      * message queue. It must share the same perQ data.
 856      */
 857
 858     if ( pCurMsgQ->pQData != pMsgQ->pQData )
 859         goto CLEANUP;
 860
 861     /* Save current active window */
 862     prev = PERQDATA_GetActiveWnd( pMsgQ->pQData );
 863
 864     WINPOS_SetActiveWindow( hwnd, 0, 0 );
 865
 866 CLEANUP:
 867     /* Unlock the queues before returning */
 868     if ( pMsgQ )
 869         QUEUE_Unlock( pMsgQ );
 870     if ( pCurMsgQ )
 871         QUEUE_Unlock( pCurMsgQ );
 872
 873 end:
 874     WIN_ReleaseWndPtr(wndPtr);
 875     return prev;
 876 }
 877
 878
 879 /*******************************************************************
 880  *         GetForegroundWindow16    (USER.608)
 881  */
 882 HWND16 WINAPI GetForegroundWindow16(void)
 883 {
 884     return (HWND16)GetForegroundWindow();
 885 }
 886
 887
 888 /*******************************************************************
 889  *         SetForegroundWindow16    (USER.609)
 890  */
 891 BOOL16 WINAPI SetForegroundWindow16( HWND16 hwnd )
 892 {
 893     return SetForegroundWindow( hwnd );
 894 }
 895
 896
 897 /*******************************************************************
 898  *         GetForegroundWindow    (USER32.241)
 899  */
 900 HWND WINAPI GetForegroundWindow(void)
 901 {
 902     HWND hwndActive = 0;
 903
 904     /* Get the foreground window (active window of hActiveQueue) */
 905     if ( hActiveQueue )
 906     {
 907         MESSAGEQUEUE *pActiveQueue = QUEUE_Lock( hActiveQueue );
 908         if ( pActiveQueue )
 909             hwndActive = PERQDATA_GetActiveWnd( pActiveQueue->pQData );
 910
 911         QUEUE_Unlock( pActiveQueue );
 912     }
 913
 914     return hwndActive;
 915 }
 916
 917 /*******************************************************************
 918  *         SetForegroundWindow    (USER32.482)
 919  */
 920 BOOL WINAPI SetForegroundWindow( HWND hwnd )
 921 {
 922     return WINPOS_ChangeActiveWindow( hwnd, FALSE );
 923 }
 924
 925
 926 /*******************************************************************
 927  *         GetShellWindow16    (USER.600)
 928  */
 929 HWND16 WINAPI GetShellWindow16(void)
 930 {
 931     return GetShellWindow();
 932 }
 933
 934 /*******************************************************************
 935  *         SetShellWindow    (USER32.504)
 936  */
 937 HWND WINAPI SetShellWindow(HWND hwndshell)
 938 {   WARN("(hWnd=%08x) semi stub\n",hwndshell );
 939
 940     hGlobalShellWindow = hwndshell;
 941     return hGlobalShellWindow;
 942 }
 943
 944
 945 /*******************************************************************
 946  *         GetShellWindow    (USER32.287)
 947  */
 948 HWND WINAPI GetShellWindow(void)
 949 {   WARN("(hWnd=%x) semi stub\n",hGlobalShellWindow );
 950
 951     return hGlobalShellWindow;
 952 }
 953
 954
 955 /***********************************************************************
 956  *           BringWindowToTop16   (USER.45)
 957  */
 958 BOOL16 WINAPI BringWindowToTop16( HWND16 hwnd )
 959 {
 960     return BringWindowToTop(hwnd);
 961 }
 962
 963
 964 /***********************************************************************
 965  *           BringWindowToTop   (USER32.11)
 966  */
 967 BOOL WINAPI BringWindowToTop( HWND hwnd )
 968 {
 969     return SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE );
 970 }
 971
 972
 973 /***********************************************************************
 974  *           MoveWindow16   (USER.56)
 975  */
 976 BOOL16 WINAPI MoveWindow16( HWND16 hwnd, INT16 x, INT16 y, INT16 cx, INT16 cy,
 977                             BOOL16 repaint )
 978 {
 979     return MoveWindow(hwnd,x,y,cx,cy,repaint);
 980 }
 981
 982
 983 /***********************************************************************
 984  *           MoveWindow   (USER32.399)
 985  */
 986 BOOL WINAPI MoveWindow( HWND hwnd, INT x, INT y, INT cx, INT cy,
 987                             BOOL repaint )
 988 {
 989     int flags = SWP_NOZORDER | SWP_NOACTIVATE;
 990     if (!repaint) flags |= SWP_NOREDRAW;
 991     TRACE("%04x %d,%d %dx%d %d\n",
 992             hwnd, x, y, cx, cy, repaint );
 993     return SetWindowPos( hwnd, 0, x, y, cx, cy, flags );
 994 }
 995
 996 /***********************************************************************
 997  *           WINPOS_InitInternalPos
 998  */
 999 static LPINTERNALPOS WINPOS_InitInternalPos( WND* wnd, POINT pt,
1000                                              LPRECT restoreRect )
1001 {
1002     LPINTERNALPOS lpPos = (LPINTERNALPOS) GetPropA( wnd->hwndSelf,
1003                                                       atomInternalPos );
1004     if( !lpPos )
1005     {
1006         /* this happens when the window is minimized/maximized
1007          * for the first time (rectWindow is not adjusted yet) */
1008
1009         lpPos = HeapAlloc( SystemHeap, 0, sizeof(INTERNALPOS) );
1010         if( !lpPos ) return NULL;
1011
1012         SetPropA( wnd->hwndSelf, atomInternalPos, (HANDLE)lpPos );
1013         lpPos->hwndIconTitle = 0; /* defer until needs to be shown */
1014         CONV_RECT32TO16( &wnd->rectWindow, &lpPos->rectNormal );
1015         *(UINT*)&lpPos->ptIconPos = *(UINT*)&lpPos->ptMaxPos = 0xFFFFFFFF;
1016     }
1017
1018     if( wnd->dwStyle & WS_MINIMIZE )
1019         CONV_POINT32TO16( &pt, &lpPos->ptIconPos );
1020     else if( wnd->dwStyle & WS_MAXIMIZE )
1021         CONV_POINT32TO16( &pt, &lpPos->ptMaxPos );
1022     else if( restoreRect )
1023         CONV_RECT32TO16( restoreRect, &lpPos->rectNormal );
1024
1025     return lpPos;
1026 }
1027
1028 /***********************************************************************
1029  *           WINPOS_RedrawIconTitle
1030  */
1031 BOOL WINPOS_RedrawIconTitle( HWND hWnd )
1032 {
1033     LPINTERNALPOS lpPos = (LPINTERNALPOS)GetPropA( hWnd, atomInternalPos );
1034     if( lpPos )
1035     {
1036         if( lpPos->hwndIconTitle )
1037         {
1038             SendMessageA( lpPos->hwndIconTitle, WM_SHOWWINDOW, TRUE, 0);
1039             InvalidateRect( lpPos->hwndIconTitle, NULL, TRUE );
1040             return TRUE;
1041         }
1042     }
1043     return FALSE;
1044 }
1045
1046 /***********************************************************************
1047  *           WINPOS_ShowIconTitle
1048  */
1049 BOOL WINPOS_ShowIconTitle( WND* pWnd, BOOL bShow )
1050 {
1051     LPINTERNALPOS lpPos = (LPINTERNALPOS)GetPropA( pWnd->hwndSelf, atomInternalPos );
1052
1053     if( lpPos && !(pWnd->flags & WIN_MANAGED))
1054     {
1055         HWND16 hWnd = lpPos->hwndIconTitle;
1056
1057         TRACE("0x%04x %i\n", pWnd->hwndSelf, (bShow != 0) );
1058
1059         if( !hWnd )
1060             lpPos->hwndIconTitle = hWnd = ICONTITLE_Create( pWnd );
1061         if( bShow )
1062         {
1063             if( ( pWnd = WIN_FindWndPtr(hWnd) ) != NULL)
1064             {
1065                 if( !(pWnd->dwStyle & WS_VISIBLE) )
1066                 {
1067                    SendMessageA( hWnd, WM_SHOWWINDOW, TRUE, 0 );
1068                    SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
1069                                  SWP_NOACTIVATE | SWP_NOZORDER | SWP_SHOWWINDOW );
1070                 }
1071                 WIN_ReleaseWndPtr(pWnd);
1072             }
1073         }
1074         else ShowWindow( hWnd, SW_HIDE );
1075     }
1076     return FALSE;
1077 }
1078
1079 /*******************************************************************
1080  *           WINPOS_GetMinMaxInfo
1081  *
1082  * Get the minimized and maximized information for a window.
1083  */
1084 void WINPOS_GetMinMaxInfo( WND *wndPtr, POINT *maxSize, POINT *maxPos,
1085                            POINT *minTrack, POINT *maxTrack )
1086 {
1087     LPINTERNALPOS lpPos;
1088     MINMAXINFO MinMax;
1089     INT xinc, yinc;
1090
1091     /* Compute default values */
1092
1093     MinMax.ptMaxSize.x = GetSystemMetrics(SM_CXSCREEN);
1094     MinMax.ptMaxSize.y = GetSystemMetrics(SM_CYSCREEN);
1095     MinMax.ptMinTrackSize.x = GetSystemMetrics(SM_CXMINTRACK);
1096     MinMax.ptMinTrackSize.y = GetSystemMetrics(SM_CYMINTRACK);
1097     MinMax.ptMaxTrackSize.x = GetSystemMetrics(SM_CXSCREEN);
1098     MinMax.ptMaxTrackSize.y = GetSystemMetrics(SM_CYSCREEN);
1099
1100     if (wndPtr->flags & WIN_MANAGED) xinc = yinc = 0;
1101     else if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1102     {
1103         xinc = GetSystemMetrics(SM_CXDLGFRAME);
1104         yinc = GetSystemMetrics(SM_CYDLGFRAME);
1105     }
1106     else
1107     {
1108         xinc = yinc = 0;
1109         if (HAS_THICKFRAME(wndPtr->dwStyle))
1110         {
1111             xinc += GetSystemMetrics(SM_CXFRAME);
1112             yinc += GetSystemMetrics(SM_CYFRAME);
1113         }
1114         if (wndPtr->dwStyle & WS_BORDER)
1115         {
1116             xinc += GetSystemMetrics(SM_CXBORDER);
1117             yinc += GetSystemMetrics(SM_CYBORDER);
1118         }
1119     }
1120     MinMax.ptMaxSize.x += 2 * xinc;
1121     MinMax.ptMaxSize.y += 2 * yinc;
1122
1123     lpPos = (LPINTERNALPOS)GetPropA( wndPtr->hwndSelf, atomInternalPos );
1124     if( lpPos && !EMPTYPOINT(lpPos->ptMaxPos) )
1125         CONV_POINT16TO32( &lpPos->ptMaxPos, &MinMax.ptMaxPosition );
1126     else
1127     {
1128         MinMax.ptMaxPosition.x = -xinc;
1129         MinMax.ptMaxPosition.y = -yinc;
1130     }
1131
1132     SendMessageA( wndPtr->hwndSelf, WM_GETMINMAXINFO, 0, (LPARAM)&MinMax );
1133
1134       /* Some sanity checks */
1135
1136     TRACE("%ld %ld / %ld %ld / %ld %ld / %ld %ld\n",
1137                       MinMax.ptMaxSize.x, MinMax.ptMaxSize.y,
1138                       MinMax.ptMaxPosition.x, MinMax.ptMaxPosition.y,
1139                       MinMax.ptMaxTrackSize.x, MinMax.ptMaxTrackSize.y,
1140                       MinMax.ptMinTrackSize.x, MinMax.ptMinTrackSize.y);
1141     MinMax.ptMaxTrackSize.x = MAX( MinMax.ptMaxTrackSize.x,
1142                                    MinMax.ptMinTrackSize.x );
1143     MinMax.ptMaxTrackSize.y = MAX( MinMax.ptMaxTrackSize.y,
1144                                    MinMax.ptMinTrackSize.y );
1145
1146     if (maxSize) *maxSize = MinMax.ptMaxSize;
1147     if (maxPos) *maxPos = MinMax.ptMaxPosition;
1148     if (minTrack) *minTrack = MinMax.ptMinTrackSize;
1149     if (maxTrack) *maxTrack = MinMax.ptMaxTrackSize;
1150 }
1151
1152 /***********************************************************************
1153  *           WINPOS_MinMaximize
1154  *
1155  * Fill in lpRect and return additional flags to be used with SetWindowPos().
1156  * This function assumes that 'cmd' is different from the current window
1157  * state.
1158  */
1159 UINT WINPOS_MinMaximize( WND* wndPtr, UINT16 cmd, LPRECT16 lpRect )
1160 {
1161     UINT swpFlags = 0;
1162     POINT pt, size;
1163     LPINTERNALPOS lpPos;
1164
1165     TRACE("0x%04x %u\n", wndPtr->hwndSelf, cmd );
1166
1167     size.x = wndPtr->rectWindow.left; size.y = wndPtr->rectWindow.top;
1168     lpPos = WINPOS_InitInternalPos( wndPtr, size, &wndPtr->rectWindow );
1169
1170     if (lpPos && !HOOK_CallHooks16(WH_CBT, HCBT_MINMAX, wndPtr->hwndSelf, cmd))
1171     {
1172         if( wndPtr->dwStyle & WS_MINIMIZE )
1173         {
1174             if( !SendMessageA( wndPtr->hwndSelf, WM_QUERYOPEN, 0, 0L ) )
1175                 return (SWP_NOSIZE | SWP_NOMOVE);
1176             swpFlags |= SWP_NOCOPYBITS;
1177         }
1178         switch( cmd )
1179         {
1180             case SW_MINIMIZE:
1181                  if( wndPtr->dwStyle & WS_MAXIMIZE)
1182                  {
1183                      wndPtr->flags |= WIN_RESTORE_MAX;
1184                      wndPtr->dwStyle &= ~WS_MAXIMIZE;
1185                  }
1186                  else
1187                      wndPtr->flags &= ~WIN_RESTORE_MAX;
1188                  wndPtr->dwStyle |= WS_MINIMIZE;
1189
1190                  if( wndPtr->flags & WIN_NATIVE )
1191                      if( wndPtr->pDriver->pSetHostAttr( wndPtr, HAK_ICONICSTATE, TRUE ) )
1192                          swpFlags |= MINMAX_NOSWP;
1193
1194                  lpPos->ptIconPos = WINPOS_FindIconPos( wndPtr, lpPos->ptIconPos );
1195
1196                  SetRect16( lpRect, lpPos->ptIconPos.x, lpPos->ptIconPos.y,
1197                                     GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON) );
1198                  swpFlags |= SWP_NOCOPYBITS;
1199                  break;
1200
1201             case SW_MAXIMIZE:
1202                 CONV_POINT16TO32( &lpPos->ptMaxPos, &pt );
1203                 WINPOS_GetMinMaxInfo( wndPtr, &size, &pt, NULL, NULL );
1204                 CONV_POINT32TO16( &pt, &lpPos->ptMaxPos );
1205
1206                  if( wndPtr->dwStyle & WS_MINIMIZE )
1207                  {
1208                      if( wndPtr->flags & WIN_NATIVE )
1209                          if( wndPtr->pDriver->pSetHostAttr( wndPtr, HAK_ICONICSTATE, FALSE ) )
1210                              swpFlags |= MINMAX_NOSWP;
1211
1212                      WINPOS_ShowIconTitle( wndPtr, FALSE );
1213                      wndPtr->dwStyle &= ~WS_MINIMIZE;
1214                  }
1215                  wndPtr->dwStyle |= WS_MAXIMIZE;
1216
1217                  SetRect16( lpRect, lpPos->ptMaxPos.x, lpPos->ptMaxPos.y,
1218                                     size.x, size.y );
1219                  break;
1220
1221             case SW_RESTORE:
1222                  if( wndPtr->dwStyle & WS_MINIMIZE )
1223                  {
1224                      if( wndPtr->flags & WIN_NATIVE )
1225                          if( wndPtr->pDriver->pSetHostAttr( wndPtr, HAK_ICONICSTATE, FALSE ) )
1226                              swpFlags |= MINMAX_NOSWP;
1227
1228                      wndPtr->dwStyle &= ~WS_MINIMIZE;
1229                      WINPOS_ShowIconTitle( wndPtr, FALSE );
1230
1231                      if( wndPtr->flags & WIN_RESTORE_MAX)
1232                      {
1233                          /* Restore to maximized position */
1234                          CONV_POINT16TO32( &lpPos->ptMaxPos, &pt );
1235                          WINPOS_GetMinMaxInfo( wndPtr, &size, &pt, NULL, NULL);
1236                          CONV_POINT32TO16( &pt, &lpPos->ptMaxPos );
1237                          wndPtr->dwStyle |= WS_MAXIMIZE;
1238                          SetRect16( lpRect, lpPos->ptMaxPos.x, lpPos->ptMaxPos.y, size.x, size.y );
1239                          break;
1240                      }
1241                  }
1242                  else
1243                      if( !(wndPtr->dwStyle & WS_MAXIMIZE) ) return (UINT16)(-1);
1244                      else wndPtr->dwStyle &= ~WS_MAXIMIZE;
1245
1246                  /* Restore to normal position */
1247
1248                 *lpRect = lpPos->rectNormal;
1249                  lpRect->right -= lpRect->left;
1250                  lpRect->bottom -= lpRect->top;
1251
1252                  break;
1253         }
1254     } else swpFlags |= SWP_NOSIZE | SWP_NOMOVE;
1255     return swpFlags;
1256 }
1257
1258 /***********************************************************************
1259  *           ShowWindowAsync   (USER32.535)
1260  *
1261  * doesn't wait; returns immediately.
1262  * used by threads to toggle windows in other (possibly hanging) threads
1263  */
1264 BOOL WINAPI ShowWindowAsync( HWND hwnd, INT cmd )
1265 {
1266     /* FIXME: does ShowWindow() return immediately ? */
1267     return ShowWindow(hwnd, cmd);
1268 }
1269
1270
1271 /***********************************************************************
1272  *           ShowWindow16   (USER.42)
1273  */
1274 BOOL16 WINAPI ShowWindow16( HWND16 hwnd, INT16 cmd )
1275 {
1276     return ShowWindow(hwnd,cmd);
1277 }
1278
1279
1280 /***********************************************************************
1281  *           ShowWindow   (USER32.534)
1282  */
1283 BOOL WINAPI ShowWindow( HWND hwnd, INT cmd )
1284 {
1285     WND*        wndPtr = WIN_FindWndPtr( hwnd );
1286     BOOL        wasVisible, showFlag;
1287     RECT16      newPos = {0, 0, 0, 0};
1288     UINT        swp = 0;
1289
1290     if (!wndPtr) return FALSE;
1291
1292     TRACE("hwnd=%04x, cmd=%d\n", hwnd, cmd);
1293
1294     wasVisible = (wndPtr->dwStyle & WS_VISIBLE) != 0;
1295
1296     switch(cmd)
1297     {
1298         case SW_HIDE:
1299             if (!wasVisible) goto END;;
1300             swp |= SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOMOVE |
1301                         SWP_NOACTIVATE | SWP_NOZORDER;
1302             if ((hwnd == GetFocus()) || IsChild( hwnd, GetFocus()))
1303             {
1304                 /* Revert focus to parent */
1305                 SetFocus( GetParent(hwnd) );
1306             }
1307             break;
1308
1309         case SW_SHOWMINNOACTIVE:
1310             swp |= SWP_NOACTIVATE | SWP_NOZORDER;
1311             /* fall through */
1312         case SW_SHOWMINIMIZED:
1313             swp |= SWP_SHOWWINDOW;
1314             /* fall through */
1315         case SW_MINIMIZE:
1316             swp |= SWP_FRAMECHANGED;
1317             if( !(wndPtr->dwStyle & WS_MINIMIZE) )
1318                  swp |= WINPOS_MinMaximize( wndPtr, SW_MINIMIZE, &newPos );
1319             else swp |= SWP_NOSIZE | SWP_NOMOVE;
1320             break;
1321
1322         case SW_SHOWMAXIMIZED: /* same as SW_MAXIMIZE */
1323             swp |= SWP_SHOWWINDOW | SWP_FRAMECHANGED;
1324             if( !(wndPtr->dwStyle & WS_MAXIMIZE) )
1325                  swp |= WINPOS_MinMaximize( wndPtr, SW_MAXIMIZE, &newPos );
1326             else swp |= SWP_NOSIZE | SWP_NOMOVE;
1327             break;
1328
1329         case SW_SHOWNA:
1330             swp |= SWP_NOACTIVATE | SWP_NOZORDER;
1331             /* fall through */
1332         case SW_SHOW:
1333             swp |= SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE;
1334
1335             /*
1336              * ShowWindow has a little peculiar behavior that if the
1337              * window is already the topmost window, it will not
1338              * activate it.
1339              */
1340             if (GetTopWindow((HWND)0)==hwnd)
1341               swp |= SWP_NOACTIVATE;
1342
1343             break;
1344
1345         case SW_SHOWNOACTIVATE:
1346             swp |= SWP_NOZORDER;
1347             if (GetActiveWindow()) swp |= SWP_NOACTIVATE;
1348             /* fall through */
1349         case SW_SHOWNORMAL:  /* same as SW_NORMAL: */
1350         case SW_SHOWDEFAULT: /* FIXME: should have its own handler */
1351         case SW_RESTORE:
1352             swp |= SWP_SHOWWINDOW | SWP_FRAMECHANGED;
1353
1354             if( wndPtr->dwStyle & (WS_MINIMIZE | WS_MAXIMIZE) )
1355                  swp |= WINPOS_MinMaximize( wndPtr, SW_RESTORE, &newPos );
1356             else swp |= SWP_NOSIZE | SWP_NOMOVE;
1357             break;
1358     }
1359
1360     showFlag = (cmd != SW_HIDE);
1361     if (showFlag != wasVisible)
1362     {
1363         SendMessageA( hwnd, WM_SHOWWINDOW, showFlag, 0 );
1364         if (!IsWindow( hwnd )) goto END;
1365     }
1366
1367     if ((wndPtr->dwStyle & WS_CHILD) &&
1368         !IsWindowVisible( wndPtr->parent->hwndSelf ) &&
1369         (swp & (SWP_NOSIZE | SWP_NOMOVE)) == (SWP_NOSIZE | SWP_NOMOVE) )
1370     {
1371         /* Don't call SetWindowPos() on invisible child windows */
1372         if (cmd == SW_HIDE) wndPtr->dwStyle &= ~WS_VISIBLE;
1373         else wndPtr->dwStyle |= WS_VISIBLE;
1374     }
1375     else
1376     {
1377         /* We can't activate a child window */
1378         if (wndPtr->dwStyle & WS_CHILD) swp |= SWP_NOACTIVATE | SWP_NOZORDER;
1379         if (!(swp & MINMAX_NOSWP))
1380             SetWindowPos( hwnd, HWND_TOP, newPos.left, newPos.top,
1381                                           newPos.right, newPos.bottom, LOWORD(swp) );
1382         if (!IsWindow( hwnd )) goto END;
1383         else if( wndPtr->dwStyle & WS_MINIMIZE ) WINPOS_ShowIconTitle( wndPtr, TRUE );
1384     }
1385
1386     if (wndPtr->flags & WIN_NEED_SIZE)
1387     {
1388         /* should happen only in CreateWindowEx() */
1389         int wParam = SIZE_RESTORED;
1390
1391         wndPtr->flags &= ~WIN_NEED_SIZE;
1392         if (wndPtr->dwStyle & WS_MAXIMIZE) wParam = SIZE_MAXIMIZED;
1393         else if (wndPtr->dwStyle & WS_MINIMIZE) wParam = SIZE_MINIMIZED;
1394         SendMessageA( hwnd, WM_SIZE, wParam,
1395                      MAKELONG(wndPtr->rectClient.right-wndPtr->rectClient.left,
1396                             wndPtr->rectClient.bottom-wndPtr->rectClient.top));
1397         SendMessageA( hwnd, WM_MOVE, 0,
1398                    MAKELONG(wndPtr->rectClient.left, wndPtr->rectClient.top) );
1399     }
1400
1401 END:
1402     WIN_ReleaseWndPtr(wndPtr);
1403     return wasVisible;
1404 }
1405
1406
1407 /***********************************************************************
1408  *           GetInternalWindowPos16   (USER.460)
1409  */
1410 UINT16 WINAPI GetInternalWindowPos16( HWND16 hwnd, LPRECT16 rectWnd,
1411                                       LPPOINT16 ptIcon )
1412 {
1413     WINDOWPLACEMENT16 wndpl;
1414     if (GetWindowPlacement16( hwnd, &wndpl ))
1415     {
1416         if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
1417         if (ptIcon)  *ptIcon = wndpl.ptMinPosition;
1418         return wndpl.showCmd;
1419     }
1420     return 0;
1421 }
1422
1423
1424 /***********************************************************************
1425  *           GetInternalWindowPos   (USER32.245)
1426  */
1427 UINT WINAPI GetInternalWindowPos( HWND hwnd, LPRECT rectWnd,
1428                                       LPPOINT ptIcon )
1429 {
1430     WINDOWPLACEMENT wndpl;
1431     if (GetWindowPlacement( hwnd, &wndpl ))
1432     {
1433         if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
1434         if (ptIcon)  *ptIcon = wndpl.ptMinPosition;
1435         return wndpl.showCmd;
1436     }
1437     return 0;
1438 }
1439
1440 /***********************************************************************
1441  *           GetWindowPlacement16   (USER.370)
1442  */
1443 BOOL16 WINAPI GetWindowPlacement16( HWND16 hwnd, WINDOWPLACEMENT16 *wndpl )
1444 {
1445     WND *pWnd = WIN_FindWndPtr( hwnd );
1446     LPINTERNALPOS lpPos;
1447
1448     if(!pWnd ) return FALSE;
1449
1450     lpPos = (LPINTERNALPOS)WINPOS_InitInternalPos( pWnd,
1451                              *(LPPOINT)&pWnd->rectWindow.left, &pWnd->rectWindow );
1452         wndpl->length  = sizeof(*wndpl);
1453         if( pWnd->dwStyle & WS_MINIMIZE )
1454             wndpl->showCmd = SW_SHOWMINIMIZED;
1455         else
1456             wndpl->showCmd = ( pWnd->dwStyle & WS_MAXIMIZE )
1457                              ? SW_SHOWMAXIMIZED : SW_SHOWNORMAL ;
1458         if( pWnd->flags & WIN_RESTORE_MAX )
1459             wndpl->flags = WPF_RESTORETOMAXIMIZED;
1460         else
1461             wndpl->flags = 0;
1462         wndpl->ptMinPosition = lpPos->ptIconPos;
1463         wndpl->ptMaxPosition = lpPos->ptMaxPos;
1464         wndpl->rcNormalPosition = lpPos->rectNormal;
1465
1466     WIN_ReleaseWndPtr(pWnd);
1467         return TRUE;
1468     }
1469
1470
1471 /***********************************************************************
1472  *           GetWindowPlacement   (USER32.307)
1473  *
1474  * Win95:
1475  * Fails if wndpl->length of Win95 (!) apps is invalid.
1476  */
1477 BOOL WINAPI GetWindowPlacement( HWND hwnd, WINDOWPLACEMENT *pwpl32 )
1478 {
1479     if( pwpl32 )
1480     {
1481         WINDOWPLACEMENT16 wpl;
1482         wpl.length = sizeof(wpl);
1483         if( GetWindowPlacement16( hwnd, &wpl ) )
1484         {
1485             pwpl32->length = sizeof(*pwpl32);
1486             pwpl32->flags = wpl.flags;
1487             pwpl32->showCmd = wpl.showCmd;
1488             CONV_POINT16TO32( &wpl.ptMinPosition, &pwpl32->ptMinPosition );
1489             CONV_POINT16TO32( &wpl.ptMaxPosition, &pwpl32->ptMaxPosition );
1490             CONV_RECT16TO32( &wpl.rcNormalPosition, &pwpl32->rcNormalPosition );
1491             return TRUE;
1492         }
1493     }
1494     return FALSE;
1495 }
1496
1497
1498 /***********************************************************************
1499  *           WINPOS_SetPlacement
1500  */
1501 static BOOL WINPOS_SetPlacement( HWND hwnd, const WINDOWPLACEMENT16 *wndpl,
1502                                                 UINT flags )
1503 {
1504     WND *pWnd = WIN_FindWndPtr( hwnd );
1505     if( pWnd )
1506     {
1507         LPINTERNALPOS lpPos = (LPINTERNALPOS)WINPOS_InitInternalPos( pWnd,
1508                              *(LPPOINT)&pWnd->rectWindow.left, &pWnd->rectWindow );
1509
1510         if( flags & PLACE_MIN ) lpPos->ptIconPos = wndpl->ptMinPosition;
1511         if( flags & PLACE_MAX ) lpPos->ptMaxPos = wndpl->ptMaxPosition;
1512         if( flags & PLACE_RECT) lpPos->rectNormal = wndpl->rcNormalPosition;
1513
1514         if( pWnd->dwStyle & WS_MINIMIZE )
1515         {
1516             WINPOS_ShowIconTitle( pWnd, FALSE );
1517             if( wndpl->flags & WPF_SETMINPOSITION && !EMPTYPOINT(lpPos->ptIconPos))
1518                 SetWindowPos( hwnd, 0, lpPos->ptIconPos.x, lpPos->ptIconPos.y,
1519                                 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
1520         }
1521         else if( pWnd->dwStyle & WS_MAXIMIZE )
1522         {
1523             if( !EMPTYPOINT(lpPos->ptMaxPos) )
1524                 SetWindowPos( hwnd, 0, lpPos->ptMaxPos.x, lpPos->ptMaxPos.y,
1525                                 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
1526         }
1527         else if( flags & PLACE_RECT )
1528                 SetWindowPos( hwnd, 0, lpPos->rectNormal.left, lpPos->rectNormal.top,
1529                                 lpPos->rectNormal.right - lpPos->rectNormal.left,
1530                                 lpPos->rectNormal.bottom - lpPos->rectNormal.top,
1531                                 SWP_NOZORDER | SWP_NOACTIVATE );
1532
1533         ShowWindow( hwnd, wndpl->showCmd );
1534         if( IsWindow(hwnd) && pWnd->dwStyle & WS_MINIMIZE )
1535         {
1536             if( pWnd->dwStyle & WS_VISIBLE ) WINPOS_ShowIconTitle( pWnd, TRUE );
1537
1538             /* SDK: ...valid only the next time... */
1539             if( wndpl->flags & WPF_RESTORETOMAXIMIZED ) pWnd->flags |= WIN_RESTORE_MAX;
1540         }
1541         WIN_ReleaseWndPtr(pWnd);
1542         return TRUE;
1543     }
1544     return FALSE;
1545 }
1546
1547
1548 /***********************************************************************
1549  *           SetWindowPlacement16   (USER.371)
1550  */
1551 BOOL16 WINAPI SetWindowPlacement16(HWND16 hwnd, const WINDOWPLACEMENT16 *wndpl)
1552 {
1553     return WINPOS_SetPlacement( hwnd, wndpl,
1554                                 PLACE_MIN | PLACE_MAX | PLACE_RECT );
1555 }
1556
1557 /***********************************************************************
1558  *           SetWindowPlacement   (USER32.519)
1559  *
1560  * Win95:
1561  * Fails if wndpl->length of Win95 (!) apps is invalid.
1562  */
1563 BOOL WINAPI SetWindowPlacement( HWND hwnd, const WINDOWPLACEMENT *pwpl32 )
1564 {
1565     if( pwpl32 )
1566     {
1567         WINDOWPLACEMENT16 wpl;
1568
1569         wpl.length = sizeof(WINDOWPLACEMENT16);
1570         wpl.flags = pwpl32->flags;
1571         wpl.showCmd = pwpl32->showCmd;
1572         wpl.ptMinPosition.x = pwpl32->ptMinPosition.x;
1573         wpl.ptMinPosition.y = pwpl32->ptMinPosition.y;
1574         wpl.ptMaxPosition.x = pwpl32->ptMaxPosition.x;
1575         wpl.ptMaxPosition.y = pwpl32->ptMaxPosition.y;
1576         wpl.rcNormalPosition.left = pwpl32->rcNormalPosition.left;
1577         wpl.rcNormalPosition.top = pwpl32->rcNormalPosition.top;
1578         wpl.rcNormalPosition.right = pwpl32->rcNormalPosition.right;
1579         wpl.rcNormalPosition.bottom = pwpl32->rcNormalPosition.bottom;
1580
1581         return WINPOS_SetPlacement( hwnd, &wpl, PLACE_MIN | PLACE_MAX | PLACE_RECT );
1582     }
1583     return FALSE;
1584 }
1585
1586
1587 /***********************************************************************
1588  *           SetInternalWindowPos16   (USER.461)
1589  */
1590 void WINAPI SetInternalWindowPos16( HWND16 hwnd, UINT16 showCmd,
1591                                     LPRECT16 rect, LPPOINT16 pt )
1592 {
1593     if( IsWindow16(hwnd) )
1594     {
1595         WINDOWPLACEMENT16 wndpl;
1596         UINT flags;
1597
1598         wndpl.length  = sizeof(wndpl);
1599         wndpl.showCmd = showCmd;
1600         wndpl.flags = flags = 0;
1601
1602         if( pt )
1603         {
1604             flags |= PLACE_MIN;
1605             wndpl.flags |= WPF_SETMINPOSITION;
1606             wndpl.ptMinPosition = *pt;
1607         }
1608         if( rect )
1609         {
1610             flags |= PLACE_RECT;
1611             wndpl.rcNormalPosition = *rect;
1612         }
1613         WINPOS_SetPlacement( hwnd, &wndpl, flags );
1614     }
1615 }
1616
1617
1618 /***********************************************************************
1619  *           SetInternalWindowPos   (USER32.483)
1620  */
1621 void WINAPI SetInternalWindowPos( HWND hwnd, UINT showCmd,
1622                                     LPRECT rect, LPPOINT pt )
1623 {
1624     if( IsWindow(hwnd) )
1625     {
1626         WINDOWPLACEMENT16 wndpl;
1627         UINT flags;
1628
1629         wndpl.length  = sizeof(wndpl);
1630         wndpl.showCmd = showCmd;
1631         wndpl.flags = flags = 0;
1632
1633         if( pt )
1634         {
1635             flags |= PLACE_MIN;
1636             wndpl.flags |= WPF_SETMINPOSITION;
1637             CONV_POINT32TO16( pt, &wndpl.ptMinPosition );
1638         }
1639         if( rect )
1640         {
1641             flags |= PLACE_RECT;
1642             CONV_RECT32TO16( rect, &wndpl.rcNormalPosition );
1643         }
1644         WINPOS_SetPlacement( hwnd, &wndpl, flags );
1645     }
1646 }
1647
1648 /*******************************************************************
1649  *         WINPOS_SetActiveWindow
1650  *
1651  * SetActiveWindow() back-end. This is the only function that
1652  * can assign active status to a window. It must be called only
1653  * for the top level windows.
1654  */
1655 BOOL WINPOS_SetActiveWindow( HWND hWnd, BOOL fMouse, BOOL fChangeFocus)
1656 {
1657     CBTACTIVATESTRUCT16* cbtStruct;
1658     WND*     wndPtr=0, *wndTemp;
1659     HQUEUE16 hOldActiveQueue, hNewActiveQueue;
1660     MESSAGEQUEUE *pOldActiveQueue = 0, *pNewActiveQueue = 0;
1661     WORD     wIconized = 0;
1662     HWND     hwndActive = 0;
1663     BOOL     bRet = 0;
1664
1665     TRACE("(%04x, %d, %d)\n", hWnd, fMouse, fChangeFocus );
1666
1667     /* Get current active window from the active queue */
1668     if ( hActiveQueue )
1669     {
1670         pOldActiveQueue = QUEUE_Lock( hActiveQueue );
1671         if ( pOldActiveQueue )
1672             hwndActive = PERQDATA_GetActiveWnd( pOldActiveQueue->pQData );
1673     }
1674
1675     /* paranoid checks */
1676     if( hWnd == GetDesktopWindow() || (bRet = (hWnd == hwndActive)) )
1677         goto CLEANUP_END;
1678
1679 /*  if (wndPtr && (GetFastQueue16() != wndPtr->hmemTaskQ))
1680  *      return 0;
1681  */
1682     wndPtr = WIN_FindWndPtr(hWnd);
1683     hOldActiveQueue = hActiveQueue;
1684
1685     if( (wndTemp = WIN_FindWndPtr(hwndActive)) )
1686     {
1687         wIconized = HIWORD(wndTemp->dwStyle & WS_MINIMIZE);
1688         WIN_ReleaseWndPtr(wndTemp);
1689     }
1690     else
1691         TRACE("no current active window.\n");
1692
1693     /* call CBT hook chain */
1694     if ((cbtStruct = SEGPTR_NEW(CBTACTIVATESTRUCT16)))
1695     {
1696         cbtStruct->fMouse     = fMouse;
1697         cbtStruct->hWndActive = hwndActive;
1698         bRet = (BOOL)HOOK_CallHooks16( WH_CBT, HCBT_ACTIVATE, (WPARAM16)hWnd,
1699                                      (LPARAM)SEGPTR_GET(cbtStruct) );
1700         SEGPTR_FREE(cbtStruct);
1701         if (bRet) goto CLEANUP_END;
1702     }
1703
1704     /* set prev active wnd to current active wnd and send notification */
1705     if ((hwndPrevActive = hwndActive) && IsWindow(hwndPrevActive))
1706     {
1707         MESSAGEQUEUE *pTempActiveQueue = 0;
1708
1709         if (!SendMessageA( hwndPrevActive, WM_NCACTIVATE, FALSE, 0 ))
1710         {
1711             if (GetSysModalWindow16() != hWnd)
1712                 goto CLEANUP_END;
1713             /* disregard refusal if hWnd is sysmodal */
1714         }
1715
1716         SendMessageA( hwndPrevActive, WM_ACTIVATE,
1717                         MAKEWPARAM( WA_INACTIVE, wIconized ),
1718                         (LPARAM)hWnd );
1719
1720         /* check if something happened during message processing
1721          * (global active queue may have changed)
1722          */
1723         pTempActiveQueue = QUEUE_Lock( hActiveQueue );
1724         if(!pTempActiveQueue)
1725             goto CLEANUP_END;
1726
1727         hwndActive = PERQDATA_GetActiveWnd( pTempActiveQueue->pQData );
1728         QUEUE_Unlock( pTempActiveQueue );
1729         if( hwndPrevActive != hwndActive )
1730             goto CLEANUP_END;
1731     }
1732
1733     /* Set new active window in the message queue */
1734     hwndActive = hWnd;
1735     if ( wndPtr )
1736     {
1737         pNewActiveQueue = QUEUE_Lock( wndPtr->hmemTaskQ );
1738         if ( pNewActiveQueue )
1739             PERQDATA_SetActiveWnd( pNewActiveQueue->pQData, hwndActive );
1740     }
1741     else /* have to do this or MDI frame activation goes to hell */
1742         if( pOldActiveQueue )
1743             PERQDATA_SetActiveWnd( pOldActiveQueue->pQData, 0 );
1744
1745     /* send palette messages */
1746     if (hWnd && SendMessage16( hWnd, WM_QUERYNEWPALETTE, 0, 0L))
1747         SendMessage16((HWND16)-1, WM_PALETTEISCHANGING, (WPARAM16)hWnd, 0L );
1748
1749     /* if prev wnd is minimized redraw icon title */
1750     if( IsIconic( hwndPrevActive ) ) WINPOS_RedrawIconTitle(hwndPrevActive);
1751
1752     /* managed windows will get ConfigureNotify event */
1753     if (wndPtr && !(wndPtr->dwStyle & WS_CHILD) && !(wndPtr->flags & WIN_MANAGED))
1754     {
1755         /* check Z-order and bring hWnd to the top */
1756         for (wndTemp = WIN_LockWndPtr(WIN_GetDesktop()->child); wndTemp; WIN_UpdateWndPtr(&wndTemp,wndTemp->next))
1757         {
1758             if (wndTemp->dwStyle & WS_VISIBLE) break;
1759         }
1760         WIN_ReleaseDesktop();
1761         WIN_ReleaseWndPtr(wndTemp);
1762
1763         if( wndTemp != wndPtr )
1764             SetWindowPos(hWnd, HWND_TOP, 0,0,0,0,
1765                            SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
1766         if (!IsWindow(hWnd))
1767             goto CLEANUP;
1768     }
1769
1770     /* Get a handle to the new active queue */
1771     hNewActiveQueue = wndPtr ? wndPtr->hmemTaskQ : 0;
1772
1773     /* send WM_ACTIVATEAPP if necessary */
1774     if (hOldActiveQueue != hNewActiveQueue)
1775     {
1776         WND **list, **ppWnd;
1777         WND *pDesktop = WIN_GetDesktop();
1778
1779         if ((list = WIN_BuildWinArray( pDesktop, 0, NULL )))
1780         {
1781             for (ppWnd = list; *ppWnd; ppWnd++)
1782             {
1783                 if (!IsWindow( (*ppWnd)->hwndSelf )) continue;
1784
1785                 if ((*ppWnd)->hmemTaskQ == hOldActiveQueue)
1786                    SendMessage16( (*ppWnd)->hwndSelf, WM_ACTIVATEAPP,
1787                                    0, QUEUE_GetQueueTask(hNewActiveQueue) );
1788             }
1789             WIN_ReleaseWinArray(list);
1790         }
1791
1792         hActiveQueue = hNewActiveQueue;
1793
1794         if ((list = WIN_BuildWinArray(pDesktop, 0, NULL )))
1795         {
1796             for (ppWnd = list; *ppWnd; ppWnd++)
1797             {
1798                 if (!IsWindow( (*ppWnd)->hwndSelf )) continue;
1799
1800                 if ((*ppWnd)->hmemTaskQ == hNewActiveQueue)
1801                    SendMessage16( (*ppWnd)->hwndSelf, WM_ACTIVATEAPP,
1802                                   1, QUEUE_GetQueueTask( hOldActiveQueue ) );
1803             }
1804             WIN_ReleaseWinArray(list);
1805         }
1806         WIN_ReleaseDesktop();
1807
1808         if (hWnd && !IsWindow(hWnd)) goto CLEANUP;
1809     }
1810
1811     if (hWnd)
1812     {
1813         /* walk up to the first unowned window */
1814         wndTemp = WIN_LockWndPtr(wndPtr);
1815         while (wndTemp->owner)
1816         {
1817             WIN_UpdateWndPtr(&wndTemp,wndTemp->owner);
1818         }
1819         /* and set last active owned popup */
1820         wndTemp->hwndLastActive = hWnd;
1821
1822         wIconized = HIWORD(wndTemp->dwStyle & WS_MINIMIZE);
1823         WIN_ReleaseWndPtr(wndTemp);
1824         SendMessageA( hWnd, WM_NCACTIVATE, TRUE, 0 );
1825         SendMessageA( hWnd, WM_ACTIVATE,
1826                  MAKEWPARAM( (fMouse) ? WA_CLICKACTIVE : WA_ACTIVE, wIconized),
1827                  (LPARAM)hwndPrevActive );
1828         if( !IsWindow(hWnd) ) goto CLEANUP;
1829     }
1830
1831     /* change focus if possible */
1832     if ( fChangeFocus )
1833     {
1834         if ( pNewActiveQueue )
1835         {
1836             HWND hOldFocus = PERQDATA_GetFocusWnd( pNewActiveQueue->pQData );
1837
1838             if ( WIN_GetTopParent( hOldFocus ) != hwndActive )
1839                 FOCUS_SwitchFocus( pNewActiveQueue, hOldFocus,
1840                                    (wndPtr && (wndPtr->dwStyle & WS_MINIMIZE))?
1841                                    0 : hwndActive );
1842         }
1843
1844         if ( pOldActiveQueue &&
1845              ( !pNewActiveQueue ||
1846                 pNewActiveQueue->pQData != pOldActiveQueue->pQData ) )
1847         {
1848             HWND hOldFocus = PERQDATA_GetFocusWnd( pOldActiveQueue->pQData );
1849             if ( hOldFocus )
1850                 FOCUS_SwitchFocus( pOldActiveQueue, hOldFocus, 0 );
1851         }
1852     }
1853
1854     if( !hwndPrevActive && wndPtr )
1855         (*wndPtr->pDriver->pForceWindowRaise)(wndPtr);
1856
1857     /* if active wnd is minimized redraw icon title */
1858     if( IsIconic(hwndActive) ) WINPOS_RedrawIconTitle(hwndActive);
1859
1860     bRet = (hWnd == hwndActive);  /* Success? */
1861
1862 CLEANUP: /* Unlock the message queues before returning */
1863
1864     if ( pNewActiveQueue )
1865         QUEUE_Unlock( pNewActiveQueue );
1866
1867 CLEANUP_END:
1868
1869     if ( pOldActiveQueue )
1870         QUEUE_Unlock( pOldActiveQueue );
1871
1872     WIN_ReleaseWndPtr(wndPtr);
1873     return bRet;
1874 }
1875
1876 /*******************************************************************
1877  *         WINPOS_ActivateOtherWindow
1878  *
1879  *  Activates window other than pWnd.
1880  */
1881 BOOL WINPOS_ActivateOtherWindow(WND* pWnd)
1882 {
1883   BOOL  bRet = 0;
1884   WND*          pWndTo = NULL;
1885     HWND       hwndActive = 0;
1886
1887     /* Get current active window from the active queue */
1888     if ( hActiveQueue )
1889     {
1890         MESSAGEQUEUE *pActiveQueue = QUEUE_Lock( hActiveQueue );
1891         if ( pActiveQueue )
1892         {
1893             hwndActive = PERQDATA_GetActiveWnd( pActiveQueue->pQData );
1894             QUEUE_Unlock( pActiveQueue );
1895         }
1896     }
1897
1898   if( pWnd->hwndSelf == hwndPrevActive )
1899       hwndPrevActive = 0;
1900
1901   if( hwndActive != pWnd->hwndSelf &&
1902     ( hwndActive || QUEUE_IsExitingQueue(pWnd->hmemTaskQ)) )
1903       return 0;
1904
1905   if( !(pWnd->dwStyle & WS_POPUP) || !(pWnd->owner) ||
1906       !WINPOS_CanActivate((pWndTo = WIN_GetTopParentPtr(pWnd->owner))) )
1907   {
1908       WND* pWndPtr = WIN_GetTopParentPtr(pWnd);
1909
1910       WIN_ReleaseWndPtr(pWndTo);
1911       pWndTo = WIN_FindWndPtr(hwndPrevActive);
1912
1913       while( !WINPOS_CanActivate(pWndTo) )
1914       {
1915          /* by now owned windows should've been taken care of */
1916           WIN_UpdateWndPtr(&pWndTo,pWndPtr->next);
1917           WIN_UpdateWndPtr(&pWndPtr,pWndTo);
1918           if( !pWndTo ) break;
1919       }
1920       WIN_ReleaseWndPtr(pWndPtr);
1921   }
1922
1923   bRet = WINPOS_SetActiveWindow( pWndTo ? pWndTo->hwndSelf : 0, FALSE, TRUE );
1924
1925   /* switch desktop queue to current active */
1926   if( pWndTo )
1927   {
1928       WIN_GetDesktop()->hmemTaskQ = pWndTo->hmemTaskQ;
1929       WIN_ReleaseWndPtr(pWndTo);
1930       WIN_ReleaseDesktop();
1931   }
1932
1933   hwndPrevActive = 0;
1934   return bRet;
1935 }
1936
1937 /*******************************************************************
1938  *         WINPOS_ChangeActiveWindow
1939  *
1940  */
1941 BOOL WINPOS_ChangeActiveWindow( HWND hWnd, BOOL mouseMsg )
1942 {
1943     WND *wndPtr, *wndTemp;
1944     BOOL retvalue;
1945     HWND hwndActive = 0;
1946
1947     /* Get current active window from the active queue */
1948     if ( hActiveQueue )
1949     {
1950         MESSAGEQUEUE *pActiveQueue = QUEUE_Lock( hActiveQueue );
1951         if ( pActiveQueue )
1952         {
1953             hwndActive = PERQDATA_GetActiveWnd( pActiveQueue->pQData );
1954             QUEUE_Unlock( pActiveQueue );
1955         }
1956     }
1957
1958     if (!hWnd)
1959         return WINPOS_SetActiveWindow( 0, mouseMsg, TRUE );
1960
1961     wndPtr = WIN_FindWndPtr(hWnd);
1962     if( !wndPtr ) return FALSE;
1963
1964     /* child windows get WM_CHILDACTIVATE message */
1965     if( (wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) == WS_CHILD )
1966     {
1967         retvalue = SendMessageA(hWnd, WM_CHILDACTIVATE, 0, 0L);
1968         goto end;
1969     }
1970
1971     if( hWnd == hwndActive )
1972     {
1973         retvalue = FALSE;
1974         goto end;
1975     }
1976
1977     if( !WINPOS_SetActiveWindow(hWnd ,mouseMsg ,TRUE) )
1978     {
1979         retvalue = FALSE;
1980         goto end;
1981     }
1982
1983     /* switch desktop queue to current active */
1984     wndTemp = WIN_GetDesktop();
1985     if( wndPtr->parent == wndTemp)
1986         wndTemp->hmemTaskQ = wndPtr->hmemTaskQ;
1987     WIN_ReleaseDesktop();
1988
1989     retvalue = TRUE;
1990 end:
1991     WIN_ReleaseWndPtr(wndPtr);
1992     return retvalue;
1993 }
1994
1995
1996 /***********************************************************************
1997  *           WINPOS_SendNCCalcSize
1998  *
1999  * Send a WM_NCCALCSIZE message to a window.
2000  * All parameters are read-only except newClientRect.
2001  * oldWindowRect, oldClientRect and winpos must be non-NULL only
2002  * when calcValidRect is TRUE.
2003  */
2004 LONG WINPOS_SendNCCalcSize( HWND hwnd, BOOL calcValidRect,
2005                             RECT *newWindowRect, RECT *oldWindowRect,
2006                             RECT *oldClientRect, WINDOWPOS *winpos,
2007                             RECT *newClientRect )
2008 {
2009     NCCALCSIZE_PARAMS params;
2010     WINDOWPOS winposCopy;
2011     LONG result;
2012
2013     params.rgrc[0] = *newWindowRect;
2014     if (calcValidRect)
2015     {
2016         winposCopy = *winpos;
2017         params.rgrc[1] = *oldWindowRect;
2018         params.rgrc[2] = *oldClientRect;
2019         params.lppos = &winposCopy;
2020     }
2021     result = SendMessageA( hwnd, WM_NCCALCSIZE, calcValidRect,
2022                              (LPARAM)&params );
2023     TRACE("%d,%d-%d,%d\n",
2024                  params.rgrc[0].left, params.rgrc[0].top,
2025                  params.rgrc[0].right, params.rgrc[0].bottom );
2026
2027     /* If the application send back garbage, ignore it */
2028     if (params.rgrc[0].left <= params.rgrc[0].right && params.rgrc[0].top <= params.rgrc[0].bottom)
2029         *newClientRect = params.rgrc[0];
2030
2031     return result;
2032 }
2033
2034
2035 /***********************************************************************
2036  *           WINPOS_HandleWindowPosChanging16
2037  *
2038  * Default handling for a WM_WINDOWPOSCHANGING. Called from DefWindowProc().
2039  */
2040 LONG WINPOS_HandleWindowPosChanging16( WND *wndPtr, WINDOWPOS16 *winpos )
2041 {
2042     POINT maxSize, minTrack;
2043     if (winpos->flags & SWP_NOSIZE) return 0;
2044     if ((wndPtr->dwStyle & WS_THICKFRAME) ||
2045         ((wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) == 0))
2046     {
2047         WINPOS_GetMinMaxInfo( wndPtr, &maxSize, NULL, &minTrack, NULL );
2048         if (maxSize.x < winpos->cx) winpos->cx = maxSize.x;
2049         if (maxSize.y < winpos->cy) winpos->cy = maxSize.y;
2050         if (!(wndPtr->dwStyle & WS_MINIMIZE))
2051         {
2052             if (winpos->cx < minTrack.x ) winpos->cx = minTrack.x;
2053             if (winpos->cy < minTrack.y ) winpos->cy = minTrack.y;
2054         }
2055     }
2056     return 0;
2057 }
2058
2059
2060 /***********************************************************************
2061  *           WINPOS_HandleWindowPosChanging
2062  *
2063  * Default handling for a WM_WINDOWPOSCHANGING. Called from DefWindowProc().
2064  */
2065 LONG WINPOS_HandleWindowPosChanging( WND *wndPtr, WINDOWPOS *winpos )
2066 {
2067     POINT maxSize;
2068     if (winpos->flags & SWP_NOSIZE) return 0;
2069     if ((wndPtr->dwStyle & WS_THICKFRAME) ||
2070         ((wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) == 0))
2071     {
2072         WINPOS_GetMinMaxInfo( wndPtr, &maxSize, NULL, NULL, NULL );
2073         winpos->cx = MIN( winpos->cx, maxSize.x );
2074         winpos->cy = MIN( winpos->cy, maxSize.y );
2075     }
2076     return 0;
2077 }
2078
2079 /***********************************************************************
2080  *           SWP_DoOwnedPopups
2081  *
2082  * fix Z order taking into account owned popups -
2083  * basically we need to maintain them above the window that owns them
2084  *
2085  * FIXME: hide/show owned popups when owner visibility changes.
2086  */
2087 static HWND SWP_DoOwnedPopups(WND* pDesktop, WND* wndPtr, HWND hwndInsertAfter, WORD flags)
2088 {
2089     WND*        w = WIN_LockWndPtr(pDesktop->child);
2090
2091     WARN("(%04x) hInsertAfter = %04x\n", wndPtr->hwndSelf, hwndInsertAfter );
2092
2093     if( (wndPtr->dwStyle & WS_POPUP) && wndPtr->owner )
2094     {
2095         /* make sure this popup stays above the owner */
2096
2097         HWND hwndLocalPrev = HWND_TOP;
2098
2099         if( hwndInsertAfter != HWND_TOP )
2100         {
2101             while( w != wndPtr->owner )
2102             {
2103                 if (w != wndPtr) hwndLocalPrev = w->hwndSelf;
2104                 if( hwndLocalPrev == hwndInsertAfter ) break;
2105                 WIN_UpdateWndPtr(&w,w->next);
2106             }
2107             hwndInsertAfter = hwndLocalPrev;
2108         }
2109     }
2110     else if( wndPtr->dwStyle & WS_CHILD )
2111         goto END;
2112
2113     WIN_UpdateWndPtr(&w, pDesktop->child);
2114
2115     while( w )
2116     {
2117         if( w == wndPtr ) break;
2118
2119         if( (w->dwStyle & WS_POPUP) && w->owner == wndPtr )
2120         {
2121             SetWindowPos(w->hwndSelf, hwndInsertAfter, 0, 0, 0, 0,
2122                  SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOSENDCHANGING | SWP_DEFERERASE);
2123             hwndInsertAfter = w->hwndSelf;
2124         }
2125         WIN_UpdateWndPtr(&w, w->next);
2126     }
2127
2128 END:
2129     WIN_ReleaseWndPtr(w);
2130     return hwndInsertAfter;
2131 }
2132
2133 /***********************************************************************
2134  *           SWP_CopyValidBits
2135  *
2136  * Make window look nice without excessive repainting
2137  *
2138  * visible and update regions are in window coordinates
2139  * client and window rectangles are in parent client coordinates
2140  *
2141  * FIXME: SWP_EX_PAINTSELF in uFlags works only if both old and new
2142  *        window rects have the same origin.
2143  *
2144  * Returns: uFlags and a dirty region in *pVisRgn.
2145  */
2146 static UINT SWP_CopyValidBits( WND* Wnd, HRGN* pVisRgn,
2147                                LPRECT lpOldWndRect,
2148                                LPRECT lpOldClientRect, UINT uFlags )
2149 {
2150  RECT r;
2151  HRGN newVisRgn, dirtyRgn;
2152  INT  my = COMPLEXREGION;
2153
2154  TRACE("\tnew wnd=(%i %i-%i %i) old wnd=(%i %i-%i %i), %04x\n",
2155               Wnd->rectWindow.left, Wnd->rectWindow.top,
2156               Wnd->rectWindow.right, Wnd->rectWindow.bottom,
2157               lpOldWndRect->left, lpOldWndRect->top,
2158               lpOldWndRect->right, lpOldWndRect->bottom, *pVisRgn);
2159  TRACE("\tnew client=(%i %i-%i %i) old client=(%i %i-%i %i)\n",
2160               Wnd->rectClient.left, Wnd->rectClient.top,
2161               Wnd->rectClient.right, Wnd->rectClient.bottom,
2162               lpOldClientRect->left, lpOldClientRect->top,
2163               lpOldClientRect->right,lpOldClientRect->bottom );
2164
2165  if( Wnd->hrgnUpdate == 1 )
2166      uFlags |= SWP_EX_NOCOPY; /* whole window is invalid, nothing to copy */
2167
2168  newVisRgn = DCE_GetVisRgn( Wnd->hwndSelf, DCX_WINDOW | DCX_CLIPSIBLINGS, 0, 0);
2169  dirtyRgn = CreateRectRgn( 0, 0, 0, 0 );
2170
2171  if( !(uFlags & SWP_EX_NOCOPY) ) /* make sure dst region covers only valid bits */
2172      my = CombineRgn( dirtyRgn, newVisRgn, *pVisRgn, RGN_AND );
2173
2174  if( (my == NULLREGION) || (uFlags & SWP_EX_NOCOPY) )
2175  {
2176 nocopy:
2177
2178      TRACE("\twon't copy anything!\n");
2179
2180      /* set dirtyRgn to the sum of old and new visible regions
2181       * in parent client coordinates */
2182
2183      OffsetRgn( newVisRgn, Wnd->rectWindow.left, Wnd->rectWindow.top );
2184      OffsetRgn( *pVisRgn, lpOldWndRect->left, lpOldWndRect->top );
2185
2186      CombineRgn(*pVisRgn, *pVisRgn, newVisRgn, RGN_OR );
2187  }
2188  else                   /* copy valid bits to a new location */
2189  {
2190      INT  dx, dy, ow, oh, nw, nh, ocw, ncw, och, nch;
2191      HRGN hrgnValid = dirtyRgn; /* non-empty intersection of old and new visible rgns */
2192
2193      /* subtract already invalid region inside Wnd from the dst region */
2194
2195      if( Wnd->hrgnUpdate )
2196          if( CombineRgn( hrgnValid, hrgnValid, Wnd->hrgnUpdate, RGN_DIFF) == NULLREGION )
2197              goto nocopy;
2198
2199      /* check if entire window can be copied */
2200
2201      ow = lpOldWndRect->right - lpOldWndRect->left;
2202      oh = lpOldWndRect->bottom - lpOldWndRect->top;
2203      nw = Wnd->rectWindow.right - Wnd->rectWindow.left;
2204      nh = Wnd->rectWindow.bottom - Wnd->rectWindow.top;
2205
2206      ocw = lpOldClientRect->right - lpOldClientRect->left;
2207      och = lpOldClientRect->bottom - lpOldClientRect->top;
2208      ncw = Wnd->rectClient.right  - Wnd->rectClient.left;
2209      nch = Wnd->rectClient.bottom  - Wnd->rectClient.top;
2210
2211      if(  (ocw != ncw) || (och != nch) ||
2212           ( ow !=  nw) || ( oh !=  nh) ||
2213           ((lpOldClientRect->top - lpOldWndRect->top)   !=
2214            (Wnd->rectClient.top - Wnd->rectWindow.top)) ||
2215           ((lpOldClientRect->left - lpOldWndRect->left) !=
2216            (Wnd->rectClient.left - Wnd->rectWindow.left)) )
2217      {
2218         dx = Wnd->rectClient.left - lpOldClientRect->left;
2219         dy = Wnd->rectClient.top - lpOldClientRect->top;
2220
2221         /* restrict valid bits to the common client rect */
2222
2223         r.left = Wnd->rectClient.left - Wnd->rectWindow.left;
2224         r.top = Wnd->rectClient.top  - Wnd->rectWindow.top;
2225         r.right = r.left + MIN( ocw, ncw );
2226         r.bottom = r.top + MIN( och, nch );
2227
2228         REGION_CropRgn( hrgnValid, hrgnValid, &r,
2229                         (uFlags & SWP_EX_PAINTSELF) ? NULL : (POINT*)&(Wnd->rectWindow));
2230         GetRgnBox( hrgnValid, &r );
2231         if( IsRectEmpty( &r ) )
2232             goto nocopy;
2233         r = *lpOldClientRect;
2234      }
2235      else
2236      {
2237         dx = Wnd->rectWindow.left - lpOldWndRect->left;
2238         dy = Wnd->rectWindow.top -  lpOldWndRect->top;
2239         if( !(uFlags & SWP_EX_PAINTSELF) )
2240             OffsetRgn( hrgnValid, Wnd->rectWindow.left, Wnd->rectWindow.top );
2241         r = *lpOldWndRect;
2242      }
2243
2244      if( !(uFlags & SWP_EX_PAINTSELF) )
2245      {
2246         /* Move remaining regions to parent coordinates */
2247         OffsetRgn( newVisRgn, Wnd->rectWindow.left, Wnd->rectWindow.top );
2248         OffsetRgn( *pVisRgn,  lpOldWndRect->left, lpOldWndRect->top );
2249      }
2250      else
2251         OffsetRect( &r, -lpOldWndRect->left, -lpOldWndRect->top );
2252
2253      TRACE("\tcomputing dirty region!\n");
2254
2255      /* Compute combined dirty region (old + new - valid) */
2256      CombineRgn( *pVisRgn, *pVisRgn, newVisRgn, RGN_OR);
2257      CombineRgn( *pVisRgn, *pVisRgn, hrgnValid, RGN_DIFF);
2258
2259      /* Blt valid bits, r is the rect to copy  */
2260
2261      if( dx || dy )
2262      {
2263          RECT rClip;
2264          HDC hDC;
2265          DC* dc;
2266
2267          /* get DC and clip rect with drawable rect to avoid superfluous expose events
2268             from copying clipped areas */
2269
2270          if( uFlags & SWP_EX_PAINTSELF )
2271          {
2272              hDC = GetDCEx( Wnd->hwndSelf, hrgnValid, DCX_WINDOW | DCX_CACHE |
2273                             DCX_KEEPCLIPRGN | DCX_INTERSECTRGN | DCX_CLIPSIBLINGS );
2274              rClip.right = nw; rClip.bottom = nh;
2275          }
2276          else
2277          {
2278              hDC = GetDCEx( Wnd->parent->hwndSelf, hrgnValid, DCX_CACHE |
2279                             DCX_KEEPCLIPRGN | DCX_INTERSECTRGN | DCX_CLIPSIBLINGS );
2280              rClip.right = Wnd->parent->rectClient.right - Wnd->parent->rectClient.left;
2281              rClip.bottom = Wnd->parent->rectClient.bottom - Wnd->parent->rectClient.top;
2282          }
2283          rClip.left = rClip.top = 0;
2284
2285          if( (dc = (DC *)GDI_GetObjPtr(hDC, DC_MAGIC)) )
2286          {
2287             if( oh > nh ) r.bottom = r.top  + nh;
2288             if( ow < nw ) r.right = r.left  + nw;
2289
2290             if( IntersectRect( &r, &r, &rClip ) )
2291             {
2292                 Wnd->pDriver->pSurfaceCopy( Wnd->parent, dc, dx, dy, &r, TRUE );
2293
2294                  /* When you copy the bits without repainting, parent doesn't
2295                     get validated appropriately. Therefore, we have to validate
2296                     the parent with the windows' updated region when the
2297                     parent's update region is not empty. */
2298
2299                 if (Wnd->parent->hrgnUpdate != 0 && !(Wnd->parent->dwStyle & WS_CLIPCHILDREN))
2300                 {
2301                   OffsetRect(&r, dx, dy);
2302                   ValidateRect(Wnd->parent->hwndSelf, &r);
2303                 }
2304             }
2305
2306             GDI_HEAP_UNLOCK( hDC );
2307          }
2308          ReleaseDC( (uFlags & SWP_EX_PAINTSELF) ?
2309                      Wnd->hwndSelf :  Wnd->parent->hwndSelf, hDC);
2310      }
2311  }
2312
2313  /* *pVisRgn now points to the invalidated region */
2314
2315  DeleteObject(newVisRgn);
2316  DeleteObject(dirtyRgn);
2317  return uFlags;
2318 }
2319
2320 /***********************************************************************
2321  *           SWP_DoSimpleFrameChanged
2322  *
2323  * NOTE: old and new client rect origins are identical, only
2324  *       extents may have changed. Window extents are the same.
2325  */
2326 static void SWP_DoSimpleFrameChanged( WND* wndPtr, RECT* pOldClientRect, WORD swpFlags, UINT uFlags )
2327 {
2328     INT  i = 0;
2329     RECT rect;
2330     HRGN hrgn = 0;
2331
2332     if( !(swpFlags & SWP_NOCLIENTSIZE) )
2333     {
2334         /* Client rect changed its position/size, most likely a scrollar
2335          * was added/removed.
2336          *
2337          * FIXME: WVR alignment flags
2338          */
2339
2340         if( wndPtr->rectClient.right >  pOldClientRect->right ) /* right edge */
2341         {
2342             i++;
2343             rect.top = 0;
2344             rect.bottom = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
2345             rect.right = wndPtr->rectClient.right - wndPtr->rectClient.left;
2346             if(!(uFlags & SWP_EX_NOCOPY))
2347                 rect.left = pOldClientRect->right - wndPtr->rectClient.left;
2348             else
2349             {
2350                 rect.left = 0;
2351                 goto redraw;
2352             }
2353         }
2354
2355         if( wndPtr->rectClient.bottom > pOldClientRect->bottom ) /* bottom edge */
2356         {
2357             if( i )
2358                 hrgn = CreateRectRgnIndirect( &rect );
2359             rect.left = 0;
2360             rect.right = wndPtr->rectClient.right - wndPtr->rectClient.left;
2361             rect.bottom = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
2362             if(!(uFlags & SWP_EX_NOCOPY))
2363                 rect.top = pOldClientRect->bottom - wndPtr->rectClient.top;
2364             else
2365                 rect.top = 0;
2366             if( i++ )
2367                 REGION_UnionRectWithRgn( hrgn, &rect );
2368         }
2369
2370         if( i == 0 && (uFlags & SWP_EX_NOCOPY) ) /* force redraw anyway */
2371         {
2372             rect = wndPtr->rectWindow;
2373             OffsetRect( &rect, wndPtr->rectWindow.left - wndPtr->rectClient.left,
2374                                wndPtr->rectWindow.top - wndPtr->rectClient.top );
2375             i++;
2376         }
2377     }
2378
2379     if( i )
2380     {
2381 redraw:
2382         PAINT_RedrawWindow( wndPtr->hwndSelf, &rect, hrgn, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE |
2383                             RDW_ERASENOW | RDW_ALLCHILDREN, RDW_EX_TOPFRAME | RDW_EX_USEHRGN );
2384     }
2385     else
2386     {
2387         WIN_UpdateNCRgn(wndPtr, 0, UNC_UPDATE | UNC_ENTIRE);
2388     }
2389
2390     if( hrgn > 1 )
2391         DeleteObject( hrgn );
2392 }
2393
2394 /***********************************************************************
2395  *           SWP_DoWinPosChanging
2396  */
2397 static BOOL SWP_DoWinPosChanging( WND* wndPtr, WINDOWPOS* pWinpos,
2398                                   RECT* pNewWindowRect, RECT* pNewClientRect )
2399 {
2400       /* Send WM_WINDOWPOSCHANGING message */
2401
2402     if (!(pWinpos->flags & SWP_NOSENDCHANGING))
2403         SendMessageA( wndPtr->hwndSelf, WM_WINDOWPOSCHANGING, 0, (LPARAM)pWinpos );
2404
2405       /* Calculate new position and size */
2406
2407     *pNewWindowRect = wndPtr->rectWindow;
2408     *pNewClientRect = (wndPtr->dwStyle & WS_MINIMIZE) ? wndPtr->rectWindow
2409                                                     : wndPtr->rectClient;
2410
2411     if (!(pWinpos->flags & SWP_NOSIZE))
2412     {
2413         pNewWindowRect->right  = pNewWindowRect->left + pWinpos->cx;
2414         pNewWindowRect->bottom = pNewWindowRect->top + pWinpos->cy;
2415     }
2416     if (!(pWinpos->flags & SWP_NOMOVE))
2417     {
2418         pNewWindowRect->left    = pWinpos->x;
2419         pNewWindowRect->top     = pWinpos->y;
2420         pNewWindowRect->right  += pWinpos->x - wndPtr->rectWindow.left;
2421         pNewWindowRect->bottom += pWinpos->y - wndPtr->rectWindow.top;
2422
2423         OffsetRect( pNewClientRect, pWinpos->x - wndPtr->rectWindow.left,
2424                                     pWinpos->y - wndPtr->rectWindow.top );
2425     }
2426
2427     pWinpos->flags |= SWP_NOCLIENTMOVE | SWP_NOCLIENTSIZE;
2428     return TRUE;
2429 }
2430
2431 /***********************************************************************
2432  *           SWP_DoNCCalcSize
2433  */
2434 static UINT SWP_DoNCCalcSize( WND* wndPtr, WINDOWPOS* pWinpos,
2435                               RECT* pNewWindowRect, RECT* pNewClientRect, WORD f)
2436 {
2437     UINT wvrFlags = 0;
2438
2439       /* Send WM_NCCALCSIZE message to get new client area */
2440     if( (pWinpos->flags & (SWP_FRAMECHANGED | SWP_NOSIZE)) != SWP_NOSIZE )
2441     {
2442          wvrFlags = WINPOS_SendNCCalcSize( pWinpos->hwnd, TRUE, pNewWindowRect,
2443                                     &wndPtr->rectWindow, &wndPtr->rectClient,
2444                                     pWinpos, pNewClientRect );
2445
2446          /* FIXME: WVR_ALIGNxxx */
2447
2448          if( pNewClientRect->left != wndPtr->rectClient.left ||
2449              pNewClientRect->top != wndPtr->rectClient.top )
2450              pWinpos->flags &= ~SWP_NOCLIENTMOVE;
2451
2452          if( (pNewClientRect->right - pNewClientRect->left !=
2453               wndPtr->rectClient.right - wndPtr->rectClient.left) ||
2454              (pNewClientRect->bottom - pNewClientRect->top !=
2455               wndPtr->rectClient.bottom - wndPtr->rectClient.top) )
2456              pWinpos->flags &= ~SWP_NOCLIENTSIZE;
2457     }
2458     else
2459       if( !(f & SWP_NOMOVE) && (pNewClientRect->left != wndPtr->rectClient.left ||
2460                                 pNewClientRect->top != wndPtr->rectClient.top) )
2461             pWinpos->flags &= ~SWP_NOCLIENTMOVE;
2462     return wvrFlags;
2463 }
2464
2465 /***********************************************************************
2466  *           SetWindowPos   (USER.2)
2467  */
2468 BOOL16 WINAPI SetWindowPos16( HWND16 hwnd, HWND16 hwndInsertAfter,
2469                               INT16 x, INT16 y, INT16 cx, INT16 cy, WORD flags)
2470 {
2471     return SetWindowPos(hwnd,(INT)(INT16)hwndInsertAfter,x,y,cx,cy,flags);
2472 }
2473
2474 /***********************************************************************
2475  *           SetWindowPos   (USER32.520)
2476  */
2477 BOOL WINAPI SetWindowPos( HWND hwnd, HWND hwndInsertAfter,
2478                           INT x, INT y, INT cx, INT cy, UINT flags )
2479 {
2480     WINDOWPOS   winpos;
2481     WND *       wndPtr,*wndTemp;
2482     RECT        newWindowRect, newClientRect;
2483     RECT        oldWindowRect, oldClientRect;
2484     HRGN        visRgn = 0;
2485     UINT        wvrFlags = 0, uFlags = 0;
2486     BOOL        retvalue, resync = FALSE, bChangePos;
2487     HWND        hwndActive = 0;
2488
2489     /* Get current active window from the active queue */
2490     if ( hActiveQueue )
2491     {
2492         MESSAGEQUEUE *pActiveQueue = QUEUE_Lock( hActiveQueue );
2493         if ( pActiveQueue )
2494         {
2495             hwndActive = PERQDATA_GetActiveWnd( pActiveQueue->pQData );
2496             QUEUE_Unlock( pActiveQueue );
2497         }
2498     }
2499
2500     TRACE("hwnd %04x, swp (%i,%i)-(%i,%i) flags %08x\n",
2501                                                  hwnd, x, y, x+cx, y+cy, flags);
2502
2503     bChangePos = !(flags & SWP_WINE_NOHOSTMOVE);
2504     flags &= ~SWP_WINE_NOHOSTMOVE;
2505
2506
2507       /* ------------------------------------------------------------------------ CHECKS */
2508
2509       /* Check window handle */
2510
2511     if (hwnd == GetDesktopWindow()) return FALSE;
2512     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
2513
2514     TRACE("\tcurrent (%i,%i)-(%i,%i), style %08x\n", wndPtr->rectWindow.left, wndPtr->rectWindow.top,
2515                           wndPtr->rectWindow.right, wndPtr->rectWindow.bottom, (unsigned)wndPtr->dwStyle );
2516
2517       /* Fix redundant flags */
2518
2519     if(wndPtr->dwStyle & WS_VISIBLE)
2520         flags &= ~SWP_SHOWWINDOW;
2521     else
2522     {
2523         if (!(flags & SWP_SHOWWINDOW))
2524               flags |= SWP_NOREDRAW;
2525         flags &= ~SWP_HIDEWINDOW;
2526     }
2527
2528     if ( cx < 0 ) cx = 0; if( cy < 0 ) cy = 0;
2529
2530     if ((wndPtr->rectWindow.right - wndPtr->rectWindow.left == cx) &&
2531         (wndPtr->rectWindow.bottom - wndPtr->rectWindow.top == cy))
2532         flags |= SWP_NOSIZE;    /* Already the right size */
2533
2534     if ((wndPtr->rectWindow.left == x) && (wndPtr->rectWindow.top == y))
2535         flags |= SWP_NOMOVE;    /* Already the right position */
2536
2537     if (hwnd == hwndActive)
2538         flags |= SWP_NOACTIVATE;   /* Already active */
2539     else if ( (wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) != WS_CHILD )
2540     {
2541         if(!(flags & SWP_NOACTIVATE)) /* Bring to the top when activating */
2542         {
2543             flags &= ~SWP_NOZORDER;
2544             hwndInsertAfter = HWND_TOP;
2545             goto Pos;
2546         }
2547     }
2548
2549       /* Check hwndInsertAfter */
2550
2551       /* FIXME: TOPMOST not supported yet */
2552     if ((hwndInsertAfter == HWND_TOPMOST) ||
2553         (hwndInsertAfter == HWND_NOTOPMOST)) hwndInsertAfter = HWND_TOP;
2554
2555       /* hwndInsertAfter must be a sibling of the window */
2556     if ((hwndInsertAfter != HWND_TOP) && (hwndInsertAfter != HWND_BOTTOM))
2557     {
2558          WND* wnd = WIN_FindWndPtr(hwndInsertAfter);
2559
2560          if( wnd ) {
2561              if( wnd->parent != wndPtr->parent )
2562              {
2563                  retvalue = FALSE;
2564                  WIN_ReleaseWndPtr(wnd);
2565                  goto END;
2566              }
2567            if( wnd->next == wndPtr ) flags |= SWP_NOZORDER;
2568          }
2569          WIN_ReleaseWndPtr(wnd);
2570     }
2571
2572 Pos:  /* ------------------------------------------------------------------------ MAIN part */
2573
2574       /* Fill the WINDOWPOS structure */
2575
2576     winpos.hwnd = hwnd;
2577     winpos.hwndInsertAfter = hwndInsertAfter;
2578     winpos.x = x;
2579     winpos.y = y;
2580     winpos.cx = cx;
2581     winpos.cy = cy;
2582     winpos.flags = flags;
2583
2584     SWP_DoWinPosChanging( wndPtr, &winpos, &newWindowRect, &newClientRect );
2585
2586     if((winpos.flags & (SWP_NOZORDER | SWP_HIDEWINDOW | SWP_SHOWWINDOW)) != SWP_NOZORDER)
2587     {
2588         if( wndPtr->parent == WIN_GetDesktop() )
2589             hwndInsertAfter = SWP_DoOwnedPopups( wndPtr->parent, wndPtr,
2590                                         hwndInsertAfter, winpos.flags );
2591         WIN_ReleaseDesktop();
2592     }
2593
2594     if(!(wndPtr->flags & WIN_NATIVE) )
2595     {
2596         if( hwndInsertAfter == HWND_TOP )
2597            winpos.flags |= ( wndPtr->parent->child == wndPtr)? SWP_NOZORDER: 0;
2598         else
2599         if( hwndInsertAfter == HWND_BOTTOM )
2600            winpos.flags |= ( wndPtr->next )? 0: SWP_NOZORDER;
2601         else
2602         if( !(winpos.flags & SWP_NOZORDER) )
2603            if( GetWindow(hwndInsertAfter, GW_HWNDNEXT) == wndPtr->hwndSelf )
2604                winpos.flags |= SWP_NOZORDER;
2605
2606         if( !(winpos.flags & (SWP_NOREDRAW | SWP_SHOWWINDOW)) &&
2607             ((winpos.flags & (SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_HIDEWINDOW | SWP_FRAMECHANGED))
2608                           != (SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER)) )
2609         {
2610             /* get a previous visible region for SWP_CopyValidBits() */
2611             DWORD flags = DCX_WINDOW;
2612
2613             if (wndPtr->dwStyle & WS_CLIPSIBLINGS)
2614                flags |= DCX_CLIPSIBLINGS;
2615
2616             visRgn = DCE_GetVisRgn(hwnd, flags, 0, 0);
2617         }
2618     }
2619
2620     /* Common operations */
2621
2622     wvrFlags = SWP_DoNCCalcSize( wndPtr, &winpos, &newWindowRect, &newClientRect, flags );
2623
2624     if(!(winpos.flags & SWP_NOZORDER))
2625     {
2626         if ( WIN_UnlinkWindow( winpos.hwnd ) )
2627            WIN_LinkWindow( winpos.hwnd, hwndInsertAfter );
2628     }
2629
2630     /* Reset active DCEs */
2631
2632     if( (((winpos.flags & SWP_AGG_NOPOSCHANGE) != SWP_AGG_NOPOSCHANGE) &&
2633                                          wndPtr->dwStyle & WS_VISIBLE) ||
2634         (flags & (SWP_HIDEWINDOW | SWP_SHOWWINDOW)) )
2635     {
2636         RECT rect;
2637
2638         UnionRect(&rect, &newWindowRect, &wndPtr->rectWindow);
2639         DCE_InvalidateDCE(wndPtr, &rect);
2640     }
2641
2642     oldWindowRect = wndPtr->rectWindow;
2643     oldClientRect = wndPtr->rectClient;
2644
2645     /* Find out if we have to redraw the whole client rect */
2646
2647     if( oldClientRect.bottom - oldClientRect.top ==
2648         newClientRect.bottom - newClientRect.top ) wvrFlags &= ~WVR_VREDRAW;
2649
2650     if( oldClientRect.right - oldClientRect.left ==
2651         newClientRect.right - newClientRect.left ) wvrFlags &= ~WVR_HREDRAW;
2652
2653     if( (winpos.flags & SWP_NOCOPYBITS) || (!(winpos.flags & SWP_NOCLIENTSIZE) &&
2654            (wvrFlags >= WVR_HREDRAW) && (wvrFlags < WVR_VALIDRECTS)) )
2655     {
2656         uFlags |= SWP_EX_NOCOPY;
2657     }
2658 /*
2659  *  Use this later in CopyValidBits()
2660  *
2661     else if( 0  )
2662         uFlags |= SWP_EX_NONCLIENT;
2663  */
2664
2665     /* FIXME: actually do something with WVR_VALIDRECTS */
2666
2667     wndPtr->rectWindow = newWindowRect;
2668     wndPtr->rectClient = newClientRect;
2669
2670     if (wndPtr->flags & WIN_NATIVE)     /* -------------------------------------------- hosted window */
2671     {
2672         BOOL bCallDriver = TRUE;
2673         HWND tempInsertAfter = winpos.hwndInsertAfter;
2674
2675         winpos.hwndInsertAfter = hwndInsertAfter;
2676
2677         if( !(winpos.flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW | SWP_NOREDRAW)) )
2678         {
2679           /* This is the only place where we need to force repainting of the contents
2680              of windows created by the host window system, all other cases go through the
2681              expose event handling */
2682
2683             if( (winpos.flags & (SWP_NOSIZE | SWP_FRAMECHANGED)) == (SWP_NOSIZE | SWP_FRAMECHANGED) )
2684             {
2685                 cx = newWindowRect.right - newWindowRect.left;
2686                 cy = newWindowRect.bottom - newWindowRect.top;
2687
2688                 wndPtr->pDriver->pSetWindowPos(wndPtr, &winpos, bChangePos);
2689                 winpos.hwndInsertAfter = tempInsertAfter;
2690                 bCallDriver = FALSE;
2691
2692                 if( winpos.flags & SWP_NOCLIENTMOVE )
2693                     SWP_DoSimpleFrameChanged(wndPtr, &oldClientRect, winpos.flags, uFlags );
2694                 else
2695                 {
2696                     /* client area moved but window extents remained the same, copy valid bits */
2697
2698                     visRgn = CreateRectRgn( 0, 0, cx, cy );
2699                     uFlags = SWP_CopyValidBits( wndPtr, &visRgn, &oldWindowRect, &oldClientRect,
2700                                                 uFlags | SWP_EX_PAINTSELF );
2701                 }
2702             }
2703         }
2704
2705         if( bCallDriver )
2706         {
2707             if( !(winpos.flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW | SWP_NOREDRAW)) )
2708             {
2709                 if( (oldClientRect.left - oldWindowRect.left == newClientRect.left - newWindowRect.left) &&
2710                     (oldClientRect.top - oldWindowRect.top == newClientRect.top - newWindowRect.top) &&
2711                    !(uFlags & SWP_EX_NOCOPY) )
2712                 {
2713                   /* The origin of the client rect didn't move so we can try to repaint
2714                    * only the nonclient area by setting bit gravity hint for the host window system.
2715                    */
2716
2717                     if( !(wndPtr->flags & WIN_MANAGED) )
2718                     {
2719                         HRGN hrgn = CreateRectRgn( 0, 0, newWindowRect.right - newWindowRect.left,
2720                                                      newWindowRect.bottom - newWindowRect.top);
2721                         RECT rcn = newClientRect;
2722                         RECT rco = oldClientRect;
2723
2724                         OffsetRect( &rcn, -newWindowRect.left, -newWindowRect.top );
2725                         OffsetRect( &rco, -oldWindowRect.left, -oldWindowRect.top );
2726                         IntersectRect( &rcn, &rcn, &rco );
2727                         visRgn = CreateRectRgnIndirect( &rcn );
2728                         CombineRgn( visRgn, hrgn, visRgn, RGN_DIFF );
2729                         DeleteObject( hrgn );
2730                         uFlags = SWP_EX_PAINTSELF;
2731                     }
2732                     wndPtr->pDriver->pSetHostAttr(wndPtr, HAK_BITGRAVITY, BGNorthWest );
2733                 }
2734                 else
2735                     wndPtr->pDriver->pSetHostAttr(wndPtr, HAK_BITGRAVITY, BGForget );
2736             }
2737
2738             wndPtr->pDriver->pSetWindowPos(wndPtr, &winpos, bChangePos);
2739             winpos.hwndInsertAfter = tempInsertAfter;
2740         }
2741
2742         if( winpos.flags & SWP_SHOWWINDOW )
2743         {
2744                 HWND focus, curr;
2745
2746                 wndPtr->dwStyle |= WS_VISIBLE;
2747
2748                 if (wndPtr->flags & WIN_MANAGED) resync = TRUE;
2749
2750                 /* focus was set to unmapped window, reset host focus
2751                  * since the window is now visible */
2752
2753                 focus = curr = GetFocus();
2754                 while (curr)
2755                 {
2756                     if (curr == hwnd)
2757                     {
2758                         WND *pFocus = WIN_FindWndPtr( focus );
2759                         if (pFocus)
2760                             pFocus->pDriver->pSetFocus(pFocus);
2761                         WIN_ReleaseWndPtr(pFocus);
2762                         break;
2763                     }
2764                     curr = GetParent(curr);
2765                 }
2766         }
2767     }
2768     else                                /* -------------------------------------------- emulated window */
2769     {
2770             if( winpos.flags & SWP_SHOWWINDOW )
2771             {
2772                 wndPtr->dwStyle |= WS_VISIBLE;
2773                 uFlags |= SWP_EX_PAINTSELF;
2774                 visRgn = 1; /* redraw the whole window */
2775             }
2776             else if( !(winpos.flags & SWP_NOREDRAW) )
2777             {
2778                 if( winpos.flags & SWP_HIDEWINDOW )
2779                 {
2780                     if( visRgn > 1 ) /* map to parent */
2781                         OffsetRgn( visRgn, oldWindowRect.left, oldWindowRect.top );
2782                     else
2783                         visRgn = 0;
2784                 }
2785                 else
2786                 {
2787                     if( (winpos.flags & SWP_AGG_NOPOSCHANGE) != SWP_AGG_NOPOSCHANGE )
2788                          uFlags = SWP_CopyValidBits(wndPtr, &visRgn, &oldWindowRect,
2789                                                             &oldClientRect, uFlags);
2790                     else
2791                     {
2792                         /* nothing moved, redraw frame if needed */
2793
2794                         if( winpos.flags & SWP_FRAMECHANGED )
2795                             SWP_DoSimpleFrameChanged( wndPtr, &oldClientRect, winpos.flags, uFlags );
2796                         if( visRgn )
2797                         {
2798                             DeleteObject( visRgn );
2799                             visRgn = 0;
2800                         }
2801                     }
2802                 }
2803             }
2804     }
2805
2806     if( winpos.flags & SWP_HIDEWINDOW )
2807     {
2808         wndPtr->dwStyle &= ~WS_VISIBLE;
2809
2810         if (hwnd == CARET_GetHwnd()) DestroyCaret();
2811
2812         /* FIXME: This will cause the window to be activated irrespective
2813          * of whether it is owned by the same thread. Has to be done
2814          * asynchronously.
2815          */
2816
2817         if (winpos.hwnd == hwndActive)
2818             WINPOS_ActivateOtherWindow( wndPtr );
2819     }
2820
2821     /* ------------------------------------------------------------------------ FINAL */
2822
2823     if (wndPtr->flags & WIN_NATIVE)
2824         EVENT_Synchronize();  /* Synchronize with the host window system */
2825
2826     if (!GetCapture() && ((wndPtr->dwStyle & WS_VISIBLE) || (flags & SWP_HIDEWINDOW)))
2827     {
2828         /* Simulate a mouse event to set the cursor */
2829         DWORD posX, posY, keyState;
2830
2831         if ( EVENT_QueryPointer( &posX, &posY, &keyState ) )
2832         {
2833             int iWndsLocks = WIN_SuspendWndsLock();
2834
2835             hardware_event( WM_MOUSEMOVE, keyState, 0,
2836                             posX, posY, GetTickCount(), 0 );
2837
2838             WIN_RestoreWndsLock(iWndsLocks);
2839         }
2840     }
2841
2842     wndTemp = WIN_GetDesktop();
2843
2844     /* repaint invalidated region (if any)
2845      *
2846      * FIXME: if SWP_NOACTIVATE is not set then set invalid regions here without any painting
2847      *        and force update after ChangeActiveWindow() to avoid painting frames twice.
2848      */
2849
2850     if( visRgn )
2851     {
2852         if( !(winpos.flags & SWP_NOREDRAW) )
2853         {
2854
2855             /*  Use PAINT_RedrawWindow to explicitly force an invalidation of the window,
2856                 its parent and sibling and so on, and then erase the parent window
2857                 back ground if the parent is either a top-level window or its parent's parent
2858                 is top-level window. Rely on the system to repaint other affected
2859                 windows later on.  */
2860             if( uFlags & SWP_EX_PAINTSELF )
2861             {
2862                 PAINT_RedrawWindow( wndPtr->hwndSelf, NULL, (visRgn == 1) ? 0 : visRgn,
2863                                 RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN,
2864                                 RDW_EX_XYWINDOW | RDW_EX_USEHRGN );
2865             }
2866             else
2867             {
2868                     PAINT_RedrawWindow( wndPtr->parent->hwndSelf, NULL, (visRgn == 1) ? 0 : visRgn,
2869                                 RDW_ERASE | RDW_INVALIDATE | RDW_ALLCHILDREN,
2870                                 RDW_EX_USEHRGN );
2871             }
2872
2873             if(wndPtr -> parent == wndTemp || wndPtr->parent->parent == wndTemp )
2874                 {
2875                 PAINT_RedrawWindow( wndPtr->parent->hwndSelf, NULL, 0,
2876                                 RDW_ERASENOW | RDW_NOCHILDREN, 0 );
2877             }
2878         }
2879         if( visRgn != 1 )
2880             DeleteObject( visRgn );
2881     }
2882
2883     WIN_ReleaseDesktop();
2884
2885     if (!(flags & SWP_NOACTIVATE))
2886             WINPOS_ChangeActiveWindow( winpos.hwnd, FALSE );
2887
2888       /* And last, send the WM_WINDOWPOSCHANGED message */
2889
2890     TRACE("\tstatus flags = %04x\n", winpos.flags & SWP_AGG_STATUSFLAGS);
2891
2892     if ( resync ||
2893         (((winpos.flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE) &&
2894          !(winpos.flags & SWP_NOSENDCHANGING)) )
2895     {
2896         SendMessageA( winpos.hwnd, WM_WINDOWPOSCHANGED, 0, (LPARAM)&winpos );
2897         if (resync) EVENT_Synchronize();
2898     }
2899
2900     retvalue = TRUE;
2901 END:
2902     WIN_ReleaseWndPtr(wndPtr);
2903     return retvalue;
2904 }
2905
2906
2907 /***********************************************************************
2908  *           BeginDeferWindowPos16   (USER.259)
2909  */
2910 HDWP16 WINAPI BeginDeferWindowPos16( INT16 count )
2911 {
2912     return BeginDeferWindowPos( count );
2913 }
2914
2915
2916 /***********************************************************************
2917  *           BeginDeferWindowPos   (USER32.9)
2918  */
2919 HDWP WINAPI BeginDeferWindowPos( INT count )
2920 {
2921     HDWP handle;
2922     DWP *pDWP;
2923
2924     if (count <= 0) return 0;
2925     handle = USER_HEAP_ALLOC( sizeof(DWP) + (count-1)*sizeof(WINDOWPOS) );
2926     if (!handle) return 0;
2927     pDWP = (DWP *) USER_HEAP_LIN_ADDR( handle );
2928     pDWP->actualCount    = 0;
2929     pDWP->suggestedCount = count;
2930     pDWP->valid          = TRUE;
2931     pDWP->wMagic         = DWP_MAGIC;
2932     pDWP->hwndParent     = 0;
2933     return handle;
2934 }
2935
2936
2937 /***********************************************************************
2938  *           DeferWindowPos16   (USER.260)
2939  */
2940 HDWP16 WINAPI DeferWindowPos16( HDWP16 hdwp, HWND16 hwnd, HWND16 hwndAfter,
2941                                 INT16 x, INT16 y, INT16 cx, INT16 cy,
2942                                 UINT16 flags )
2943 {
2944     return DeferWindowPos( hdwp, hwnd, (INT)(INT16)hwndAfter,
2945                              x, y, cx, cy, flags );
2946 }
2947
2948
2949 /***********************************************************************
2950  *           DeferWindowPos   (USER32.128)
2951  */
2952 HDWP WINAPI DeferWindowPos( HDWP hdwp, HWND hwnd, HWND hwndAfter,
2953                                 INT x, INT y, INT cx, INT cy,
2954                                 UINT flags )
2955 {
2956     DWP *pDWP;
2957     int i;
2958     HDWP newhdwp = hdwp,retvalue;
2959     /* HWND parent; */
2960     WND *pWnd;
2961
2962     pDWP = (DWP *) USER_HEAP_LIN_ADDR( hdwp );
2963     if (!pDWP) return 0;
2964     if (hwnd == GetDesktopWindow()) return 0;
2965
2966     if (!(pWnd=WIN_FindWndPtr( hwnd ))) {
2967         USER_HEAP_FREE( hdwp );
2968         return 0;
2969     }
2970
2971 /* Numega Bounds Checker Demo dislikes the following code.
2972    In fact, I've not been able to find any "same parent" requirement in any docu
2973    [AM 980509]
2974  */
2975 #if 0
2976     /* All the windows of a DeferWindowPos() must have the same parent */
2977     parent = pWnd->parent->hwndSelf;
2978     if (pDWP->actualCount == 0) pDWP->hwndParent = parent;
2979     else if (parent != pDWP->hwndParent)
2980     {
2981         USER_HEAP_FREE( hdwp );
2982         retvalue = 0;
2983         goto END;
2984     }
2985 #endif
2986
2987     for (i = 0; i < pDWP->actualCount; i++)
2988     {
2989         if (pDWP->winPos[i].hwnd == hwnd)
2990         {
2991               /* Merge with the other changes */
2992             if (!(flags & SWP_NOZORDER))
2993             {
2994                 pDWP->winPos[i].hwndInsertAfter = hwndAfter;
2995             }
2996             if (!(flags & SWP_NOMOVE))
2997             {
2998                 pDWP->winPos[i].x = x;
2999                 pDWP->winPos[i].y = y;
3000             }
3001             if (!(flags & SWP_NOSIZE))
3002             {
3003                 pDWP->winPos[i].cx = cx;
3004                 pDWP->winPos[i].cy = cy;
3005             }
3006             pDWP->winPos[i].flags &= flags | ~(SWP_NOSIZE | SWP_NOMOVE |
3007                                                SWP_NOZORDER | SWP_NOREDRAW |
3008                                                SWP_NOACTIVATE | SWP_NOCOPYBITS|
3009                                                SWP_NOOWNERZORDER);
3010             pDWP->winPos[i].flags |= flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW |
3011                                               SWP_FRAMECHANGED);
3012             retvalue = hdwp;
3013             goto END;
3014         }
3015     }
3016     if (pDWP->actualCount >= pDWP->suggestedCount)
3017     {
3018         newhdwp = USER_HEAP_REALLOC( hdwp,
3019                       sizeof(DWP) + pDWP->suggestedCount*sizeof(WINDOWPOS) );
3020         if (!newhdwp)
3021         {
3022             retvalue = 0;
3023             goto END;
3024         }
3025         pDWP = (DWP *) USER_HEAP_LIN_ADDR( newhdwp );
3026         pDWP->suggestedCount++;
3027     }
3028     pDWP->winPos[pDWP->actualCount].hwnd = hwnd;
3029     pDWP->winPos[pDWP->actualCount].hwndInsertAfter = hwndAfter;
3030     pDWP->winPos[pDWP->actualCount].x = x;
3031     pDWP->winPos[pDWP->actualCount].y = y;
3032     pDWP->winPos[pDWP->actualCount].cx = cx;
3033     pDWP->winPos[pDWP->actualCount].cy = cy;
3034     pDWP->winPos[pDWP->actualCount].flags = flags;
3035     pDWP->actualCount++;
3036     retvalue = newhdwp;
3037 END:
3038     WIN_ReleaseWndPtr(pWnd);
3039     return retvalue;
3040 }
3041
3042
3043 /***********************************************************************
3044  *           EndDeferWindowPos16   (USER.261)
3045  */
3046 BOOL16 WINAPI EndDeferWindowPos16( HDWP16 hdwp )
3047 {
3048     return EndDeferWindowPos( hdwp );
3049 }
3050
3051
3052 /***********************************************************************
3053  *           EndDeferWindowPos   (USER32.173)
3054  */
3055 BOOL WINAPI EndDeferWindowPos( HDWP hdwp )
3056 {
3057     DWP *pDWP;
3058     WINDOWPOS *winpos;
3059     BOOL res = TRUE;
3060     int i;
3061
3062     pDWP = (DWP *) USER_HEAP_LIN_ADDR( hdwp );
3063     if (!pDWP) return FALSE;
3064     for (i = 0, winpos = pDWP->winPos; i < pDWP->actualCount; i++, winpos++)
3065     {
3066         if (!(res = SetWindowPos( winpos->hwnd, winpos->hwndInsertAfter,
3067                                     winpos->x, winpos->y, winpos->cx,
3068                                     winpos->cy, winpos->flags ))) break;
3069     }
3070     USER_HEAP_FREE( hdwp );
3071     return res;
3072 }
3073
3074
3075 /***********************************************************************
3076  *           TileChildWindows   (USER.199)
3077  */
3078 void WINAPI TileChildWindows16( HWND16 parent, WORD action )
3079 {
3080     FIXME("(%04x, %d): stub\n", parent, action);
3081 }
3082
3083 /***********************************************************************
3084  *           CascageChildWindows   (USER.198)
3085  */
3086 void WINAPI CascadeChildWindows16( HWND16 parent, WORD action )
3087 {
3088     FIXME("(%04x, %d): stub\n", parent, action);
3089 }
3090
3091 /***********************************************************************
3092  *           SetProgmanWindow                   [USER32.522]
3093  */
3094 HRESULT WINAPI SetProgmanWindow ( HWND hwnd )
3095 {
3096         hGlobalProgmanWindow = hwnd;
3097         return hGlobalProgmanWindow;
3098 }
3099
3100 /***********************************************************************
3101  *           GetProgmanWindow                   [USER32.289]
3102  */
3103 HRESULT WINAPI GetProgmanWindow ( )
3104 {
3105         return hGlobalProgmanWindow;
3106 }
3107
3108 /***********************************************************************
3109  *           SetShellWindowEx                   [USER32.531]
3110  * hwndProgman =  Progman[Program Manager]
3111  *                |-> SHELLDLL_DefView
3112  * hwndListView = |   |-> SysListView32
3113  *                |   |   |-> tooltips_class32
3114  *                |   |
3115  *                |   |-> SysHeader32
3116  *                |
3117  *                |-> ProxyTarget
3118  */
3119 HRESULT WINAPI SetShellWindowEx ( HWND hwndProgman, HWND hwndListView )
3120 {
3121         FIXME("0x%08x 0x%08x stub\n",hwndProgman ,hwndListView );
3122         hGlobalShellWindow = hwndProgman;
3123         return hGlobalShellWindow;
3124
3125 }
3126
3127 /***********************************************************************
3128  *           SetTaskmanWindow                   [USER32.537]
3129  * NOTES
3130  *   hwnd = MSTaskSwWClass
3131  *          |-> SysTabControl32
3132  */
3133 HRESULT WINAPI SetTaskmanWindow ( HWND hwnd )
3134 {
3135         hGlobalTaskmanWindow = hwnd;
3136         return hGlobalTaskmanWindow;
3137 }
3138
3139 /***********************************************************************
3140  *           GetTaskmanWindow                   [USER32.304]
3141  */
3142 HRESULT WINAPI GetTaskmanWindow ( )
3143 {
3144         return hGlobalTaskmanWindow;
3145 }