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 "winerror.h"
  10 #include "windef.h"
  11 #include "wingdi.h"
  12 #include "winerror.h"
  13 #include "wine/winuser16.h"
  14 #include "controls.h"
  15 #include "user.h"
  16 #include "region.h"
  17 #include "win.h"
  18 #include "hook.h"
  19 #include "message.h"
  20 #include "queue.h"
  21 #include "winpos.h"
  22 #include "dce.h"
  23 #include "nonclient.h"
  24 #include "debugtools.h"
  25 #include "input.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 EMPTYPOINT(pt)          ((*(LONG*)&(pt)) == -1)
  38
  39 #define PLACE_MIN               0x0001
  40 #define PLACE_MAX               0x0002
  41 #define PLACE_RECT              0x0004
  42
  43
  44 #define DWP_MAGIC  ((INT)('W' | ('P' << 8) | ('O' << 16) | ('S' << 24)))
  45
  46 typedef struct
  47 {
  48     INT       actualCount;
  49     INT       suggestedCount;
  50     BOOL      valid;
  51     INT       wMagic;
  52     HWND      hwndParent;
  53     WINDOWPOS winPos[1];
  54 } DWP;
  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( GetProcessHeap(), 0, lpPos );
 111     }
 112
 113     QUEUE_Unlock( pMsgQ );
 114     return;
 115 }
 116
 117 /***********************************************************************
 118  *              ArrangeIconicWindows (USER.170)
 119  */
 120 UINT16 WINAPI ArrangeIconicWindows16( HWND16 parent)
 121 {
 122     return ArrangeIconicWindows(parent);
 123 }
 124 /***********************************************************************
 125  *              ArrangeIconicWindows (USER32.@)
 126  */
 127 UINT WINAPI ArrangeIconicWindows( HWND parent )
 128 {
 129     RECT rectParent;
 130     HWND hwndChild;
 131     INT x, y, xspacing, yspacing;
 132
 133     GetClientRect( parent, &rectParent );
 134     x = rectParent.left;
 135     y = rectParent.bottom;
 136     xspacing = GetSystemMetrics(SM_CXICONSPACING);
 137     yspacing = GetSystemMetrics(SM_CYICONSPACING);
 138
 139     hwndChild = GetWindow( parent, GW_CHILD );
 140     while (hwndChild)
 141     {
 142         if( IsIconic( hwndChild ) )
 143         {
 144             WND *wndPtr = WIN_FindWndPtr(hwndChild);
 145
 146             WINPOS_ShowIconTitle( wndPtr, FALSE );
 147
 148             SetWindowPos( hwndChild, 0, x + (xspacing - GetSystemMetrics(SM_CXICON)) / 2,
 149                             y - yspacing - GetSystemMetrics(SM_CYICON)/2, 0, 0,
 150                             SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
 151             if( IsWindow(hwndChild) )
 152                 WINPOS_ShowIconTitle(wndPtr , TRUE );
 153             WIN_ReleaseWndPtr(wndPtr);
 154
 155             if (x <= rectParent.right - xspacing) x += xspacing;
 156             else
 157             {
 158                 x = rectParent.left;
 159                 y -= yspacing;
 160             }
 161         }
 162         hwndChild = GetWindow( hwndChild, GW_HWNDNEXT );
 163     }
 164     return yspacing;
 165 }
 166
 167
 168 /***********************************************************************
 169  *              SwitchToThisWindow (USER.172)
 170  */
 171 void WINAPI SwitchToThisWindow16( HWND16 hwnd, BOOL16 restore )
 172 {
 173     SwitchToThisWindow( hwnd, restore );
 174 }
 175
 176
 177 /***********************************************************************
 178  *              SwitchToThisWindow (USER32.@)
 179  */
 180 void WINAPI SwitchToThisWindow( HWND hwnd, BOOL restore )
 181 {
 182     ShowWindow( hwnd, restore ? SW_RESTORE : SW_SHOWMINIMIZED );
 183 }
 184
 185
 186 /***********************************************************************
 187  *              GetWindowRect (USER.32)
 188  */
 189 void WINAPI GetWindowRect16( HWND16 hwnd, LPRECT16 rect )
 190 {
 191     WND * wndPtr = WIN_FindWndPtr( hwnd );
 192     if (!wndPtr) return;
 193
 194     CONV_RECT32TO16( &wndPtr->rectWindow, rect );
 195     if (wndPtr->parent)
 196         MapWindowPoints16( wndPtr->parent->hwndSelf, 0, (POINT16 *)rect, 2 );
 197     WIN_ReleaseWndPtr(wndPtr);
 198 }
 199
 200
 201 /***********************************************************************
 202  *              GetWindowRect (USER32.@)
 203  */
 204 BOOL WINAPI GetWindowRect( HWND hwnd, LPRECT rect )
 205 {
 206     WND * wndPtr = WIN_FindWndPtr( hwnd );
 207     if (!wndPtr) return FALSE;
 208
 209     *rect = wndPtr->rectWindow;
 210     if (wndPtr->parent)
 211         MapWindowPoints( wndPtr->parent->hwndSelf, 0, (POINT *)rect, 2 );
 212     WIN_ReleaseWndPtr(wndPtr);
 213     TRACE("hwnd %04x (%d,%d)-(%d,%d)\n",
 214           hwnd, rect->left, rect->top, rect->right, rect->bottom);
 215     return TRUE;
 216 }
 217
 218
 219 /***********************************************************************
 220  *              GetWindowRgn (USER32.@)
 221  */
 222 int WINAPI GetWindowRgn ( HWND hwnd, HRGN hrgn )
 223 {
 224     int nRet = ERROR;
 225     WND *wndPtr = WIN_FindWndPtr( hwnd );
 226     if (wndPtr)
 227     {
 228         if (wndPtr->hrgnWnd) nRet = CombineRgn( hrgn, wndPtr->hrgnWnd, 0, RGN_COPY );
 229         WIN_ReleaseWndPtr(wndPtr);
 230     }
 231     return nRet;
 232 }
 233
 234 /***********************************************************************
 235  *              SetWindowRgn (USER32.@)
 236  */
 237 int WINAPI SetWindowRgn( HWND hwnd, HRGN hrgn, BOOL bRedraw )
 238 {
 239     RECT rect;
 240     WND *wndPtr;
 241     int ret = FALSE;
 242
 243     if (USER_Driver.pSetWindowRgn)
 244         return USER_Driver.pSetWindowRgn( hwnd, hrgn, bRedraw );
 245
 246     if (!(wndPtr = WIN_FindWndPtr(hwnd))) return FALSE;
 247
 248     if (wndPtr->hrgnWnd == hrgn)
 249     {
 250         ret = TRUE;
 251         goto done;
 252     }
 253
 254     if (hrgn) /* verify that region really exists */
 255     {
 256         if (GetRgnBox( hrgn, &rect ) == ERROR) goto done;
 257     }
 258
 259     if (wndPtr->hrgnWnd)
 260     {
 261         /* delete previous region */
 262         DeleteObject(wndPtr->hrgnWnd);
 263         wndPtr->hrgnWnd = 0;
 264     }
 265     wndPtr->hrgnWnd = hrgn;
 266
 267     /* Size the window to the rectangle of the new region (if it isn't NULL) */
 268     if (hrgn) SetWindowPos( hwnd, 0, rect.left, rect.top,
 269                             rect.right  - rect.left, rect.bottom - rect.top,
 270                             SWP_NOSIZE | SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOACTIVATE |
 271                             SWP_NOZORDER | (bRedraw ? 0 : SWP_NOREDRAW) );
 272     ret = TRUE;
 273
 274  done:
 275     WIN_ReleaseWndPtr(wndPtr);
 276     return ret;
 277 }
 278
 279 /***********************************************************************
 280  *              SetWindowRgn (USER.668)
 281  */
 282 INT16 WINAPI SetWindowRgn16( HWND16 hwnd, HRGN16 hrgn,BOOL16 bRedraw)
 283
 284 {
 285
 286   FIXME("SetWindowRgn16: stub\n");
 287   return TRUE;
 288 }
 289
 290
 291 /***********************************************************************
 292  *              GetClientRect (USER.33)
 293  */
 294 void WINAPI GetClientRect16( HWND16 hwnd, LPRECT16 rect )
 295 {
 296     WND * wndPtr = WIN_FindWndPtr( hwnd );
 297
 298     rect->left = rect->top = rect->right = rect->bottom = 0;
 299     if (wndPtr)
 300     {
 301         rect->right  = wndPtr->rectClient.right - wndPtr->rectClient.left;
 302         rect->bottom = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
 303     }
 304     WIN_ReleaseWndPtr(wndPtr);
 305 }
 306
 307
 308 /***********************************************************************
 309  *              GetClientRect (USER32.@)
 310  */
 311 BOOL WINAPI GetClientRect( HWND hwnd, LPRECT rect )
 312 {
 313     WND * wndPtr = WIN_FindWndPtr( hwnd );
 314
 315     rect->left = rect->top = rect->right = rect->bottom = 0;
 316     if (!wndPtr) return FALSE;
 317     rect->right  = wndPtr->rectClient.right - wndPtr->rectClient.left;
 318     rect->bottom = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
 319
 320     WIN_ReleaseWndPtr(wndPtr);
 321     TRACE("hwnd %04x (%d,%d)-(%d,%d)\n",
 322           hwnd, rect->left, rect->top, rect->right, rect->bottom);
 323     return TRUE;
 324 }
 325
 326
 327 /*******************************************************************
 328  *              ClientToScreen (USER.28)
 329  */
 330 void WINAPI ClientToScreen16( HWND16 hwnd, LPPOINT16 lppnt )
 331 {
 332     MapWindowPoints16( hwnd, 0, lppnt, 1 );
 333 }
 334
 335
 336 /*******************************************************************
 337  *              ClientToScreen (USER32.@)
 338  */
 339 BOOL WINAPI ClientToScreen( HWND hwnd, LPPOINT lppnt )
 340 {
 341     MapWindowPoints( hwnd, 0, lppnt, 1 );
 342     return TRUE;
 343 }
 344
 345
 346 /*******************************************************************
 347  *              ScreenToClient (USER.29)
 348  */
 349 void WINAPI ScreenToClient16( HWND16 hwnd, LPPOINT16 lppnt )
 350 {
 351     MapWindowPoints16( 0, hwnd, lppnt, 1 );
 352 }
 353
 354
 355 /*******************************************************************
 356  *              ScreenToClient (USER32.@)
 357  */
 358 BOOL WINAPI ScreenToClient( HWND hwnd, LPPOINT lppnt )
 359 {
 360     MapWindowPoints( 0, hwnd, lppnt, 1 );
 361     return TRUE;
 362 }
 363
 364
 365 /***********************************************************************
 366  *           WINPOS_WindowFromPoint
 367  *
 368  * Find the window and hittest for a given point.
 369  */
 370 HWND WINPOS_WindowFromPoint( HWND hwndScope, POINT pt, INT *hittest )
 371 {
 372     WND *wndScope, *wndPtr, *wndTmp;
 373     HWND hwnd_ret = 0;
 374     POINT xy = pt;
 375
 376     TRACE("scope %04x %ld,%ld\n", hwndScope, pt.x, pt.y);
 377
 378     if (!hwndScope) hwndScope = GetDesktopWindow();
 379     if (!(wndScope = WIN_FindWndPtr( hwndScope ))) return 0;
 380
 381     *hittest = HTERROR;
 382     wndPtr = WIN_LockWndPtr(wndScope->child);
 383
 384     if( wndScope->dwStyle & WS_DISABLED )
 385     {
 386         *hittest = HTERROR;
 387         goto end;
 388     }
 389
 390     if (wndScope->parent)
 391         MapWindowPoints( GetDesktopWindow(), wndScope->parent->hwndSelf, &xy, 1 );
 392
 393     if (xy.x < wndScope->rectClient.left || pt.x >= wndScope->rectClient.right ||
 394         xy.y < wndScope->rectClient.top || pt.y >= wndScope->rectClient.bottom ||
 395         wndScope->dwStyle & WS_MINIMIZE)
 396         goto hittest;
 397
 398     xy.x -= wndScope->rectClient.left;
 399     xy.y -= wndScope->rectClient.top;
 400
 401     for (;;)
 402     {
 403         while (wndPtr)
 404         {
 405             /* If point is in window, and window is visible, and it  */
 406             /* is enabled (or it's a top-level window), then explore */
 407             /* its children. Otherwise, go to the next window.       */
 408
 409              if ((wndPtr->dwStyle & WS_VISIBLE) &&
 410                 ((wndPtr->dwExStyle & (WS_EX_LAYERED | WS_EX_TRANSPARENT)) != (WS_EX_LAYERED | WS_EX_TRANSPARENT)) &&
 411                 (!(wndPtr->dwStyle & WS_DISABLED) ||
 412                  ((wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) != WS_CHILD)) &&
 413                 (wndPtr->hrgnWnd ?
 414                 PtInRegion(wndPtr->hrgnWnd, xy.x - wndPtr->rectWindow.left,
 415                            xy.y - wndPtr->rectWindow.top) :
 416                 ((xy.x >= wndPtr->rectWindow.left) &&
 417                  (xy.x < wndPtr->rectWindow.right) &&
 418                  (xy.y >= wndPtr->rectWindow.top) &&
 419                  (xy.y < wndPtr->rectWindow.bottom))))
 420             {
 421                 TRACE("%ld,%ld is inside %04x\n", xy.x, xy.y, wndPtr->hwndSelf);
 422                 hwnd_ret = wndPtr->hwndSelf;  /* Got a suitable window */
 423
 424                 /* If window is minimized or disabled, return at once */
 425                 if (wndPtr->dwStyle & WS_MINIMIZE)
 426                 {
 427                     *hittest = HTCAPTION;
 428                     goto end;
 429                 }
 430                 if (wndPtr->dwStyle & WS_DISABLED)
 431                 {
 432                     *hittest = HTERROR;
 433                     goto end;
 434                 }
 435
 436                 /* If point is not in client area, ignore the children */
 437                 if ((xy.x < wndPtr->rectClient.left) ||
 438                     (xy.x >= wndPtr->rectClient.right) ||
 439                     (xy.y < wndPtr->rectClient.top) ||
 440                     (xy.y >= wndPtr->rectClient.bottom)) break;
 441
 442                 xy.x -= wndPtr->rectClient.left;
 443                 xy.y -= wndPtr->rectClient.top;
 444                 WIN_UpdateWndPtr(&wndPtr,wndPtr->child);
 445             }
 446             else
 447             {
 448                 WIN_UpdateWndPtr(&wndPtr,wndPtr->next);
 449             }
 450         }
 451
 452 hittest:
 453         /* If nothing found, try the scope window */
 454         if (!hwnd_ret) hwnd_ret = hwndScope;
 455
 456         /* Send the WM_NCHITTEST message (only if to the same task) */
 457         if (GetWindowThreadProcessId( hwnd_ret, NULL ) == GetCurrentThreadId())
 458         {
 459             INT res = SendMessageA( hwnd_ret, WM_NCHITTEST, 0, MAKELONG( pt.x, pt.y ) );
 460             if (res != HTTRANSPARENT)
 461             {
 462                 *hittest = res;  /* Found the window */
 463                 goto end;
 464             }
 465         }
 466         else
 467         {
 468             *hittest = HTCLIENT;
 469             goto end;
 470         }
 471
 472         if (!(wndTmp = WIN_FindWndPtr( hwnd_ret ))) break;
 473
 474         /* If no children found in last search, make point relative to parent */
 475         if (!wndPtr)
 476         {
 477             xy.x += wndTmp->rectClient.left;
 478             xy.y += wndTmp->rectClient.top;
 479         }
 480
 481         /* Restart the search from the next sibling */
 482         WIN_UpdateWndPtr(&wndPtr,wndTmp->next);
 483         hwnd_ret = wndTmp->parent ? wndTmp->parent->hwndSelf : 0;
 484         WIN_ReleaseWndPtr( wndTmp );
 485     }
 486
 487 end:
 488     WIN_ReleaseWndPtr(wndPtr);
 489     WIN_ReleaseWndPtr(wndScope);
 490     return hwnd_ret;
 491 }
 492
 493
 494 /*******************************************************************
 495  *              WindowFromPoint (USER.30)
 496  */
 497 HWND16 WINAPI WindowFromPoint16( POINT16 pt )
 498 {
 499     POINT pt32;
 500
 501     CONV_POINT16TO32( &pt, &pt32 );
 502     return WindowFromPoint( pt32 );
 503 }
 504
 505
 506 /*******************************************************************
 507  *              WindowFromPoint (USER32.@)
 508  */
 509 HWND WINAPI WindowFromPoint( POINT pt )
 510 {
 511     INT hittest;
 512     return WINPOS_WindowFromPoint( 0, pt, &hittest );
 513 }
 514
 515
 516 /*******************************************************************
 517  *              ChildWindowFromPoint (USER.191)
 518  */
 519 HWND16 WINAPI ChildWindowFromPoint16( HWND16 hwndParent, POINT16 pt )
 520 {
 521     POINT pt32;
 522     CONV_POINT16TO32( &pt, &pt32 );
 523     return (HWND16)ChildWindowFromPoint( hwndParent, pt32 );
 524 }
 525
 526
 527 /*******************************************************************
 528  *              ChildWindowFromPoint (USER32.@)
 529  */
 530 HWND WINAPI ChildWindowFromPoint( HWND hwndParent, POINT pt )
 531 {
 532     /* pt is in the client coordinates */
 533
 534     WND* wnd = WIN_FindWndPtr(hwndParent);
 535     RECT rect;
 536     HWND retvalue;
 537
 538     if( !wnd ) return 0;
 539
 540     /* get client rect fast */
 541     rect.top = rect.left = 0;
 542     rect.right = wnd->rectClient.right - wnd->rectClient.left;
 543     rect.bottom = wnd->rectClient.bottom - wnd->rectClient.top;
 544
 545     if (!PtInRect( &rect, pt ))
 546     {
 547         retvalue = 0;
 548         goto end;
 549     }
 550     WIN_UpdateWndPtr(&wnd,wnd->child);
 551     while ( wnd )
 552     {
 553         if (PtInRect( &wnd->rectWindow, pt ))
 554         {
 555             retvalue = wnd->hwndSelf;
 556             goto end;
 557         }
 558         WIN_UpdateWndPtr(&wnd,wnd->next);
 559     }
 560     retvalue = hwndParent;
 561 end:
 562     WIN_ReleaseWndPtr(wnd);
 563     return retvalue;
 564 }
 565
 566 /*******************************************************************
 567  *              ChildWindowFromPointEx (USER.399)
 568  */
 569 HWND16 WINAPI ChildWindowFromPointEx16( HWND16 hwndParent, POINT16 pt, UINT16 uFlags)
 570 {
 571     POINT pt32;
 572     CONV_POINT16TO32( &pt, &pt32 );
 573     return (HWND16)ChildWindowFromPointEx( hwndParent, pt32, uFlags );
 574 }
 575
 576
 577 /*******************************************************************
 578  *              ChildWindowFromPointEx (USER32.@)
 579  */
 580 HWND WINAPI ChildWindowFromPointEx( HWND hwndParent, POINT pt,
 581                 UINT uFlags)
 582 {
 583     /* pt is in the client coordinates */
 584
 585     WND* wnd = WIN_FindWndPtr(hwndParent);
 586     RECT rect;
 587     HWND retvalue;
 588
 589     if( !wnd ) return 0;
 590
 591     /* get client rect fast */
 592     rect.top = rect.left = 0;
 593     rect.right = wnd->rectClient.right - wnd->rectClient.left;
 594     rect.bottom = wnd->rectClient.bottom - wnd->rectClient.top;
 595
 596     if (!PtInRect( &rect, pt ))
 597     {
 598         retvalue = 0;
 599         goto end;
 600     }
 601     WIN_UpdateWndPtr(&wnd,wnd->child);
 602
 603     while ( wnd )
 604     {
 605         if (PtInRect( &wnd->rectWindow, pt )) {
 606                 if ( (uFlags & CWP_SKIPINVISIBLE) &&
 607                                 !(wnd->dwStyle & WS_VISIBLE) );
 608                 else if ( (uFlags & CWP_SKIPDISABLED) &&
 609                                 (wnd->dwStyle & WS_DISABLED) );
 610                 else if ( (uFlags & CWP_SKIPTRANSPARENT) &&
 611                                 (wnd->dwExStyle & WS_EX_TRANSPARENT) );
 612                 else
 613                 {
 614                     retvalue = wnd->hwndSelf;
 615                     goto end;
 616                 }
 617
 618         }
 619         WIN_UpdateWndPtr(&wnd,wnd->next);
 620     }
 621     retvalue = hwndParent;
 622 end:
 623     WIN_ReleaseWndPtr(wnd);
 624     return retvalue;
 625 }
 626
 627
 628 /*******************************************************************
 629  *         WINPOS_GetWinOffset
 630  *
 631  * Calculate the offset between the origin of the two windows. Used
 632  * to implement MapWindowPoints.
 633  */
 634 static void WINPOS_GetWinOffset( HWND hwndFrom, HWND hwndTo,
 635                                  POINT *offset )
 636 {
 637     WND * wndPtr = 0;
 638
 639     offset->x = offset->y = 0;
 640     if (hwndFrom == hwndTo ) return;
 641
 642       /* Translate source window origin to screen coords */
 643     if (hwndFrom)
 644     {
 645         if (!(wndPtr = WIN_FindWndPtr( hwndFrom )))
 646         {
 647             ERR("bad hwndFrom = %04x\n",hwndFrom);
 648             return;
 649         }
 650         while (wndPtr->parent)
 651         {
 652             offset->x += wndPtr->rectClient.left;
 653             offset->y += wndPtr->rectClient.top;
 654             WIN_UpdateWndPtr(&wndPtr,wndPtr->parent);
 655         }
 656         WIN_ReleaseWndPtr(wndPtr);
 657     }
 658
 659       /* Translate origin to destination window coords */
 660     if (hwndTo)
 661     {
 662         if (!(wndPtr = WIN_FindWndPtr( hwndTo )))
 663         {
 664             ERR("bad hwndTo = %04x\n", hwndTo );
 665             return;
 666         }
 667         while (wndPtr->parent)
 668         {
 669             offset->x -= wndPtr->rectClient.left;
 670             offset->y -= wndPtr->rectClient.top;
 671             WIN_UpdateWndPtr(&wndPtr,wndPtr->parent);
 672         }
 673         WIN_ReleaseWndPtr(wndPtr);
 674     }
 675 }
 676
 677
 678 /*******************************************************************
 679  *              MapWindowPoints (USER.258)
 680  */
 681 void WINAPI MapWindowPoints16( HWND16 hwndFrom, HWND16 hwndTo,
 682                                LPPOINT16 lppt, UINT16 count )
 683 {
 684     POINT offset;
 685
 686     WINPOS_GetWinOffset( hwndFrom, hwndTo, &offset );
 687     while (count--)
 688     {
 689         lppt->x += offset.x;
 690         lppt->y += offset.y;
 691         lppt++;
 692     }
 693 }
 694
 695
 696 /*******************************************************************
 697  *              MapWindowPoints (USER32.@)
 698  */
 699 INT WINAPI MapWindowPoints( HWND hwndFrom, HWND hwndTo,
 700                                LPPOINT lppt, UINT count )
 701 {
 702     POINT offset;
 703
 704     WINPOS_GetWinOffset( hwndFrom, hwndTo, &offset );
 705     while (count--)
 706     {
 707         lppt->x += offset.x;
 708         lppt->y += offset.y;
 709         lppt++;
 710     }
 711     return MAKELONG( LOWORD(offset.x), LOWORD(offset.y) );
 712 }
 713
 714
 715 /***********************************************************************
 716  *              IsIconic (USER.31)
 717  */
 718 BOOL16 WINAPI IsIconic16(HWND16 hWnd)
 719 {
 720     return IsIconic(hWnd);
 721 }
 722
 723
 724 /***********************************************************************
 725  *              IsIconic (USER32.@)
 726  */
 727 BOOL WINAPI IsIconic(HWND hWnd)
 728 {
 729     BOOL retvalue;
 730     WND * wndPtr = WIN_FindWndPtr(hWnd);
 731     if (wndPtr == NULL) return FALSE;
 732     retvalue = (wndPtr->dwStyle & WS_MINIMIZE) != 0;
 733     WIN_ReleaseWndPtr(wndPtr);
 734     return retvalue;
 735 }
 736
 737
 738 /***********************************************************************
 739  *              IsZoomed (USER.272)
 740  */
 741 BOOL16 WINAPI IsZoomed16(HWND16 hWnd)
 742 {
 743     return IsZoomed(hWnd);
 744 }
 745
 746
 747 /***********************************************************************
 748  *              IsZoomed (USER32.@)
 749  */
 750 BOOL WINAPI IsZoomed(HWND hWnd)
 751 {
 752     BOOL retvalue;
 753     WND * wndPtr = WIN_FindWndPtr(hWnd);
 754     if (wndPtr == NULL) return FALSE;
 755     retvalue = (wndPtr->dwStyle & WS_MAXIMIZE) != 0;
 756     WIN_ReleaseWndPtr(wndPtr);
 757     return retvalue;
 758 }
 759
 760
 761 /*******************************************************************
 762  *              GetActiveWindow (USER.60)
 763  */
 764 HWND16 WINAPI GetActiveWindow16(void)
 765 {
 766     return (HWND16)GetActiveWindow();
 767 }
 768
 769 /*******************************************************************
 770  *              GetActiveWindow (USER32.@)
 771  */
 772 HWND WINAPI GetActiveWindow(void)
 773 {
 774     MESSAGEQUEUE *pCurMsgQ = 0;
 775
 776     /* Get the messageQ for the current thread */
 777     if (!(pCurMsgQ = QUEUE_Current()))
 778 {
 779         WARN("\tCurrent message queue not found. Exiting!\n" );
 780         return 0;
 781     }
 782
 783     /* Return the current active window from the perQ data of the current message Q */
 784     return PERQDATA_GetActiveWnd( pCurMsgQ->pQData );
 785 }
 786
 787
 788 /*******************************************************************
 789  *         WINPOS_CanActivate
 790  */
 791 static BOOL WINPOS_CanActivate(WND* pWnd)
 792 {
 793     if( pWnd && ( (pWnd->dwStyle & (WS_DISABLED | WS_VISIBLE | WS_CHILD))
 794        == WS_VISIBLE ) ) return TRUE;
 795     return FALSE;
 796 }
 797
 798
 799 /*******************************************************************
 800  *              SetActiveWindow (USER.59)
 801  */
 802 HWND16 WINAPI SetActiveWindow16( HWND16 hwnd )
 803 {
 804     return SetActiveWindow(hwnd);
 805 }
 806
 807
 808 /*******************************************************************
 809  *              SetActiveWindow (USER32.@)
 810  */
 811 HWND WINAPI SetActiveWindow( HWND hwnd )
 812 {
 813     HWND prev = 0;
 814     WND *wndPtr = WIN_FindWndPtr( hwnd );
 815     MESSAGEQUEUE *pMsgQ = 0, *pCurMsgQ = 0;
 816
 817     if (!wndPtr || (wndPtr->dwStyle & (WS_DISABLED | WS_CHILD)))
 818     {
 819         prev = 0;
 820         goto end;
 821     }
 822
 823     /* Get the messageQ for the current thread */
 824     if (!(pCurMsgQ = QUEUE_Current()))
 825     {
 826         WARN("\tCurrent message queue not found. Exiting!\n" );
 827         goto CLEANUP;
 828     }
 829
 830     /* Retrieve the message queue associated with this window */
 831     pMsgQ = (MESSAGEQUEUE *)QUEUE_Lock( wndPtr->hmemTaskQ );
 832     if ( !pMsgQ )
 833     {
 834         WARN("\tWindow message queue not found. Exiting!\n" );
 835         goto CLEANUP;
 836     }
 837
 838     /* Make sure that the window is associated with the calling threads
 839      * message queue. It must share the same perQ data.
 840      */
 841
 842     if ( pCurMsgQ->pQData != pMsgQ->pQData )
 843         goto CLEANUP;
 844
 845     /* Save current active window */
 846     prev = PERQDATA_GetActiveWnd( pMsgQ->pQData );
 847
 848     WINPOS_SetActiveWindow( hwnd, 0, 0 );
 849
 850 CLEANUP:
 851     /* Unlock the queues before returning */
 852     if ( pMsgQ )
 853         QUEUE_Unlock( pMsgQ );
 854
 855 end:
 856     WIN_ReleaseWndPtr(wndPtr);
 857     return prev;
 858 }
 859
 860
 861 /*******************************************************************
 862  *              GetForegroundWindow (USER.608)
 863  */
 864 HWND16 WINAPI GetForegroundWindow16(void)
 865 {
 866     return (HWND16)GetForegroundWindow();
 867 }
 868
 869
 870 /*******************************************************************
 871  *              SetForegroundWindow (USER.609)
 872  */
 873 BOOL16 WINAPI SetForegroundWindow16( HWND16 hwnd )
 874 {
 875     return SetForegroundWindow( hwnd );
 876 }
 877
 878
 879 /*******************************************************************
 880  *              GetForegroundWindow (USER32.@)
 881  */
 882 HWND WINAPI GetForegroundWindow(void)
 883 {
 884     HWND hwndActive = 0;
 885
 886     /* Get the foreground window (active window of hActiveQueue) */
 887     if ( hActiveQueue )
 888     {
 889         MESSAGEQUEUE *pActiveQueue = QUEUE_Lock( hActiveQueue );
 890         if ( pActiveQueue )
 891             hwndActive = PERQDATA_GetActiveWnd( pActiveQueue->pQData );
 892
 893         QUEUE_Unlock( pActiveQueue );
 894     }
 895
 896     return hwndActive;
 897 }
 898
 899 /*******************************************************************
 900  *              SetForegroundWindow (USER32.@)
 901  */
 902 BOOL WINAPI SetForegroundWindow( HWND hwnd )
 903 {
 904     return WINPOS_ChangeActiveWindow( hwnd, FALSE );
 905 }
 906
 907
 908 /*******************************************************************
 909  *              AllowSetForegroundWindow (USER32.@)
 910  */
 911 BOOL WINAPI AllowSetForegroundWindow( DWORD procid )
 912 {
 913     /* FIXME: If Win98/2000 style SetForegroundWindow behavior is
 914      * implemented, then fix this function. */
 915     return TRUE;
 916 }
 917
 918
 919 /*******************************************************************
 920  *              LockSetForegroundWindow (USER32.@)
 921  */
 922 BOOL WINAPI LockSetForegroundWindow( UINT lockcode )
 923 {
 924     /* FIXME: If Win98/2000 style SetForegroundWindow behavior is
 925      * implemented, then fix this function. */
 926     return TRUE;
 927 }
 928
 929
 930 /*******************************************************************
 931  *              GetShellWindow (USER.600)
 932  */
 933 HWND16 WINAPI GetShellWindow16(void)
 934 {
 935     return GetShellWindow();
 936 }
 937
 938 /*******************************************************************
 939  *              SetShellWindow (USER32.@)
 940  */
 941 HWND WINAPI SetShellWindow(HWND hwndshell)
 942 {   WARN("(hWnd=%08x) semi stub\n",hwndshell );
 943
 944     hGlobalShellWindow = hwndshell;
 945     return hGlobalShellWindow;
 946 }
 947
 948
 949 /*******************************************************************
 950  *              GetShellWindow (USER32.@)
 951  */
 952 HWND WINAPI GetShellWindow(void)
 953 {   WARN("(hWnd=%x) semi stub\n",hGlobalShellWindow );
 954
 955     return hGlobalShellWindow;
 956 }
 957
 958
 959 /***********************************************************************
 960  *              BringWindowToTop (USER.45)
 961  */
 962 BOOL16 WINAPI BringWindowToTop16( HWND16 hwnd )
 963 {
 964     return BringWindowToTop(hwnd);
 965 }
 966
 967
 968 /***********************************************************************
 969  *              BringWindowToTop (USER32.@)
 970  */
 971 BOOL WINAPI BringWindowToTop( HWND hwnd )
 972 {
 973     return SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE );
 974 }
 975
 976
 977 /***********************************************************************
 978  *              MoveWindow (USER.56)
 979  */
 980 BOOL16 WINAPI MoveWindow16( HWND16 hwnd, INT16 x, INT16 y, INT16 cx, INT16 cy,
 981                             BOOL16 repaint )
 982 {
 983     return MoveWindow(hwnd,x,y,cx,cy,repaint);
 984 }
 985
 986
 987 /***********************************************************************
 988  *              MoveWindow (USER32.@)
 989  */
 990 BOOL WINAPI MoveWindow( HWND hwnd, INT x, INT y, INT cx, INT cy,
 991                             BOOL repaint )
 992 {
 993     int flags = SWP_NOZORDER | SWP_NOACTIVATE;
 994     if (!repaint) flags |= SWP_NOREDRAW;
 995     TRACE("%04x %d,%d %dx%d %d\n",
 996             hwnd, x, y, cx, cy, repaint );
 997     return SetWindowPos( hwnd, 0, x, y, cx, cy, flags );
 998 }
 999
1000 /***********************************************************************
1001  *           WINPOS_InitInternalPos
1002  */
1003 static LPINTERNALPOS WINPOS_InitInternalPos( WND* wnd, POINT pt,
1004                                              LPRECT restoreRect )
1005 {
1006     LPINTERNALPOS lpPos = (LPINTERNALPOS) GetPropA( wnd->hwndSelf,
1007                                                       atomInternalPos );
1008     if( !lpPos )
1009     {
1010         /* this happens when the window is minimized/maximized
1011          * for the first time (rectWindow is not adjusted yet) */
1012
1013         lpPos = HeapAlloc( GetProcessHeap(), 0, sizeof(INTERNALPOS) );
1014         if( !lpPos ) return NULL;
1015
1016         SetPropA( wnd->hwndSelf, atomInternalPos, (HANDLE)lpPos );
1017         lpPos->hwndIconTitle = 0; /* defer until needs to be shown */
1018         CONV_RECT32TO16( &wnd->rectWindow, &lpPos->rectNormal );
1019         *(UINT*)&lpPos->ptIconPos = *(UINT*)&lpPos->ptMaxPos = 0xFFFFFFFF;
1020     }
1021
1022     if( wnd->dwStyle & WS_MINIMIZE )
1023         CONV_POINT32TO16( &pt, &lpPos->ptIconPos );
1024     else if( wnd->dwStyle & WS_MAXIMIZE )
1025         CONV_POINT32TO16( &pt, &lpPos->ptMaxPos );
1026     else if( restoreRect )
1027         CONV_RECT32TO16( restoreRect, &lpPos->rectNormal );
1028
1029     return lpPos;
1030 }
1031
1032 /***********************************************************************
1033  *           WINPOS_RedrawIconTitle
1034  */
1035 BOOL WINPOS_RedrawIconTitle( HWND hWnd )
1036 {
1037     LPINTERNALPOS lpPos = (LPINTERNALPOS)GetPropA( hWnd, atomInternalPos );
1038     if( lpPos )
1039     {
1040         if( lpPos->hwndIconTitle )
1041         {
1042             SendMessageA( lpPos->hwndIconTitle, WM_SHOWWINDOW, TRUE, 0);
1043             InvalidateRect( lpPos->hwndIconTitle, NULL, TRUE );
1044             return TRUE;
1045         }
1046     }
1047     return FALSE;
1048 }
1049
1050 /***********************************************************************
1051  *           WINPOS_ShowIconTitle
1052  */
1053 BOOL WINPOS_ShowIconTitle( WND* pWnd, BOOL bShow )
1054 {
1055     LPINTERNALPOS lpPos = (LPINTERNALPOS)GetPropA( pWnd->hwndSelf, atomInternalPos );
1056
1057     if( lpPos && !(pWnd->dwExStyle & WS_EX_MANAGED))
1058     {
1059         HWND16 hWnd = lpPos->hwndIconTitle;
1060
1061         TRACE("0x%04x %i\n", pWnd->hwndSelf, (bShow != 0) );
1062
1063         if( !hWnd )
1064             lpPos->hwndIconTitle = hWnd = ICONTITLE_Create( pWnd );
1065         if( bShow )
1066         {
1067             if( ( pWnd = WIN_FindWndPtr(hWnd) ) != NULL)
1068             {
1069                 if( !(pWnd->dwStyle & WS_VISIBLE) )
1070                 {
1071                    SendMessageA( hWnd, WM_SHOWWINDOW, TRUE, 0 );
1072                    SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
1073                                  SWP_NOACTIVATE | SWP_NOZORDER | SWP_SHOWWINDOW );
1074                 }
1075                 WIN_ReleaseWndPtr(pWnd);
1076             }
1077         }
1078         else ShowWindow( hWnd, SW_HIDE );
1079     }
1080     return FALSE;
1081 }
1082
1083 /*******************************************************************
1084  *           WINPOS_GetMinMaxInfo
1085  *
1086  * Get the minimized and maximized information for a window.
1087  */
1088 void WINPOS_GetMinMaxInfo( WND *wndPtr, POINT *maxSize, POINT *maxPos,
1089                            POINT *minTrack, POINT *maxTrack )
1090 {
1091     LPINTERNALPOS lpPos;
1092     MINMAXINFO MinMax;
1093     INT xinc, yinc;
1094
1095     /* Compute default values */
1096
1097     MinMax.ptMaxSize.x = GetSystemMetrics(SM_CXSCREEN);
1098     MinMax.ptMaxSize.y = GetSystemMetrics(SM_CYSCREEN);
1099     MinMax.ptMinTrackSize.x = GetSystemMetrics(SM_CXMINTRACK);
1100     MinMax.ptMinTrackSize.y = GetSystemMetrics(SM_CYMINTRACK);
1101     MinMax.ptMaxTrackSize.x = GetSystemMetrics(SM_CXSCREEN);
1102     MinMax.ptMaxTrackSize.y = GetSystemMetrics(SM_CYSCREEN);
1103
1104     if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1105     {
1106         xinc = GetSystemMetrics(SM_CXDLGFRAME);
1107         yinc = GetSystemMetrics(SM_CYDLGFRAME);
1108     }
1109     else
1110     {
1111         xinc = yinc = 0;
1112         if (HAS_THICKFRAME(wndPtr->dwStyle))
1113         {
1114             xinc += GetSystemMetrics(SM_CXFRAME);
1115             yinc += GetSystemMetrics(SM_CYFRAME);
1116         }
1117         if (wndPtr->dwStyle & WS_BORDER)
1118         {
1119             xinc += GetSystemMetrics(SM_CXBORDER);
1120             yinc += GetSystemMetrics(SM_CYBORDER);
1121         }
1122     }
1123     MinMax.ptMaxSize.x += 2 * xinc;
1124     MinMax.ptMaxSize.y += 2 * yinc;
1125
1126     lpPos = (LPINTERNALPOS)GetPropA( wndPtr->hwndSelf, atomInternalPos );
1127     if( lpPos && !EMPTYPOINT(lpPos->ptMaxPos) )
1128         CONV_POINT16TO32( &lpPos->ptMaxPos, &MinMax.ptMaxPosition );
1129     else
1130     {
1131         MinMax.ptMaxPosition.x = -xinc;
1132         MinMax.ptMaxPosition.y = -yinc;
1133     }
1134
1135     SendMessageA( wndPtr->hwndSelf, WM_GETMINMAXINFO, 0, (LPARAM)&MinMax );
1136
1137       /* Some sanity checks */
1138
1139     TRACE("%ld %ld / %ld %ld / %ld %ld / %ld %ld\n",
1140                       MinMax.ptMaxSize.x, MinMax.ptMaxSize.y,
1141                       MinMax.ptMaxPosition.x, MinMax.ptMaxPosition.y,
1142                       MinMax.ptMaxTrackSize.x, MinMax.ptMaxTrackSize.y,
1143                       MinMax.ptMinTrackSize.x, MinMax.ptMinTrackSize.y);
1144     MinMax.ptMaxTrackSize.x = max( MinMax.ptMaxTrackSize.x,
1145                                    MinMax.ptMinTrackSize.x );
1146     MinMax.ptMaxTrackSize.y = max( MinMax.ptMaxTrackSize.y,
1147                                    MinMax.ptMinTrackSize.y );
1148
1149     if (maxSize) *maxSize = MinMax.ptMaxSize;
1150     if (maxPos) *maxPos = MinMax.ptMaxPosition;
1151     if (minTrack) *minTrack = MinMax.ptMinTrackSize;
1152     if (maxTrack) *maxTrack = MinMax.ptMaxTrackSize;
1153 }
1154
1155 /***********************************************************************
1156  *              ShowWindowAsync (USER32.@)
1157  *
1158  * doesn't wait; returns immediately.
1159  * used by threads to toggle windows in other (possibly hanging) threads
1160  */
1161 BOOL WINAPI ShowWindowAsync( HWND hwnd, INT cmd )
1162 {
1163     /* FIXME: does ShowWindow() return immediately ? */
1164     return ShowWindow(hwnd, cmd);
1165 }
1166
1167
1168 /***********************************************************************
1169  *              ShowWindow (USER.42)
1170  */
1171 BOOL16 WINAPI ShowWindow16( HWND16 hwnd, INT16 cmd )
1172 {
1173     return ShowWindow(hwnd,cmd);
1174 }
1175
1176
1177 /***********************************************************************
1178  *              ShowWindow (USER32.@)
1179  */
1180 BOOL WINAPI ShowWindow( HWND hwnd, INT cmd )
1181 {
1182     return USER_Driver.pShowWindow( hwnd, cmd );
1183 }
1184
1185
1186 /***********************************************************************
1187  *              GetInternalWindowPos (USER.460)
1188  */
1189 UINT16 WINAPI GetInternalWindowPos16( HWND16 hwnd, LPRECT16 rectWnd,
1190                                       LPPOINT16 ptIcon )
1191 {
1192     WINDOWPLACEMENT16 wndpl;
1193     if (GetWindowPlacement16( hwnd, &wndpl ))
1194     {
1195         if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
1196         if (ptIcon)  *ptIcon = wndpl.ptMinPosition;
1197         return wndpl.showCmd;
1198     }
1199     return 0;
1200 }
1201
1202
1203 /***********************************************************************
1204  *              GetInternalWindowPos (USER32.@)
1205  */
1206 UINT WINAPI GetInternalWindowPos( HWND hwnd, LPRECT rectWnd,
1207                                       LPPOINT ptIcon )
1208 {
1209     WINDOWPLACEMENT wndpl;
1210     if (GetWindowPlacement( hwnd, &wndpl ))
1211     {
1212         if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
1213         if (ptIcon)  *ptIcon = wndpl.ptMinPosition;
1214         return wndpl.showCmd;
1215     }
1216     return 0;
1217 }
1218
1219 /***********************************************************************
1220  *              GetWindowPlacement (USER.370)
1221  */
1222 BOOL16 WINAPI GetWindowPlacement16( HWND16 hwnd, WINDOWPLACEMENT16 *wndpl )
1223 {
1224     WND *pWnd = WIN_FindWndPtr( hwnd );
1225     LPINTERNALPOS lpPos;
1226
1227     if(!pWnd ) return FALSE;
1228
1229     lpPos = (LPINTERNALPOS)WINPOS_InitInternalPos( pWnd,
1230                              *(LPPOINT)&pWnd->rectWindow.left, &pWnd->rectWindow );
1231         wndpl->length  = sizeof(*wndpl);
1232         if( pWnd->dwStyle & WS_MINIMIZE )
1233             wndpl->showCmd = SW_SHOWMINIMIZED;
1234         else
1235             wndpl->showCmd = ( pWnd->dwStyle & WS_MAXIMIZE )
1236                              ? SW_SHOWMAXIMIZED : SW_SHOWNORMAL ;
1237         if( pWnd->flags & WIN_RESTORE_MAX )
1238             wndpl->flags = WPF_RESTORETOMAXIMIZED;
1239         else
1240             wndpl->flags = 0;
1241         wndpl->ptMinPosition = lpPos->ptIconPos;
1242         wndpl->ptMaxPosition = lpPos->ptMaxPos;
1243         wndpl->rcNormalPosition = lpPos->rectNormal;
1244
1245     WIN_ReleaseWndPtr(pWnd);
1246         return TRUE;
1247     }
1248
1249
1250 /***********************************************************************
1251  *              GetWindowPlacement (USER32.@)
1252  *
1253  * Win95:
1254  * Fails if wndpl->length of Win95 (!) apps is invalid.
1255  */
1256 BOOL WINAPI GetWindowPlacement( HWND hwnd, WINDOWPLACEMENT *pwpl32 )
1257 {
1258     if( pwpl32 )
1259     {
1260         WINDOWPLACEMENT16 wpl;
1261         wpl.length = sizeof(wpl);
1262         if( GetWindowPlacement16( hwnd, &wpl ) )
1263         {
1264             pwpl32->length = sizeof(*pwpl32);
1265             pwpl32->flags = wpl.flags;
1266             pwpl32->showCmd = wpl.showCmd;
1267             CONV_POINT16TO32( &wpl.ptMinPosition, &pwpl32->ptMinPosition );
1268             CONV_POINT16TO32( &wpl.ptMaxPosition, &pwpl32->ptMaxPosition );
1269             CONV_RECT16TO32( &wpl.rcNormalPosition, &pwpl32->rcNormalPosition );
1270             return TRUE;
1271         }
1272     }
1273     return FALSE;
1274 }
1275
1276
1277 /***********************************************************************
1278  *           WINPOS_SetPlacement
1279  */
1280 static BOOL WINPOS_SetPlacement( HWND hwnd, const WINDOWPLACEMENT16 *wndpl,
1281                                                 UINT flags )
1282 {
1283     WND *pWnd = WIN_FindWndPtr( hwnd );
1284     if( pWnd )
1285     {
1286         LPINTERNALPOS lpPos = (LPINTERNALPOS)WINPOS_InitInternalPos( pWnd,
1287                              *(LPPOINT)&pWnd->rectWindow.left, &pWnd->rectWindow );
1288
1289         if( flags & PLACE_MIN ) lpPos->ptIconPos = wndpl->ptMinPosition;
1290         if( flags & PLACE_MAX ) lpPos->ptMaxPos = wndpl->ptMaxPosition;
1291         if( flags & PLACE_RECT) lpPos->rectNormal = wndpl->rcNormalPosition;
1292
1293         if( pWnd->dwStyle & WS_MINIMIZE )
1294         {
1295             WINPOS_ShowIconTitle( pWnd, FALSE );
1296             if( wndpl->flags & WPF_SETMINPOSITION && !EMPTYPOINT(lpPos->ptIconPos))
1297                 SetWindowPos( hwnd, 0, lpPos->ptIconPos.x, lpPos->ptIconPos.y,
1298                                 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
1299         }
1300         else if( pWnd->dwStyle & WS_MAXIMIZE )
1301         {
1302             if( !EMPTYPOINT(lpPos->ptMaxPos) )
1303                 SetWindowPos( hwnd, 0, lpPos->ptMaxPos.x, lpPos->ptMaxPos.y,
1304                                 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
1305         }
1306         else if( flags & PLACE_RECT )
1307                 SetWindowPos( hwnd, 0, lpPos->rectNormal.left, lpPos->rectNormal.top,
1308                                 lpPos->rectNormal.right - lpPos->rectNormal.left,
1309                                 lpPos->rectNormal.bottom - lpPos->rectNormal.top,
1310                                 SWP_NOZORDER | SWP_NOACTIVATE );
1311
1312         ShowWindow( hwnd, wndpl->showCmd );
1313         if( IsWindow(hwnd) && pWnd->dwStyle & WS_MINIMIZE )
1314         {
1315             if( pWnd->dwStyle & WS_VISIBLE ) WINPOS_ShowIconTitle( pWnd, TRUE );
1316
1317             /* SDK: ...valid only the next time... */
1318             if( wndpl->flags & WPF_RESTORETOMAXIMIZED ) pWnd->flags |= WIN_RESTORE_MAX;
1319         }
1320         WIN_ReleaseWndPtr(pWnd);
1321         return TRUE;
1322     }
1323     return FALSE;
1324 }
1325
1326
1327 /***********************************************************************
1328  *              SetWindowPlacement (USER.371)
1329  */
1330 BOOL16 WINAPI SetWindowPlacement16(HWND16 hwnd, const WINDOWPLACEMENT16 *wndpl)
1331 {
1332     return WINPOS_SetPlacement( hwnd, wndpl,
1333                                 PLACE_MIN | PLACE_MAX | PLACE_RECT );
1334 }
1335
1336 /***********************************************************************
1337  *              SetWindowPlacement (USER32.@)
1338  *
1339  * Win95:
1340  * Fails if wndpl->length of Win95 (!) apps is invalid.
1341  */
1342 BOOL WINAPI SetWindowPlacement( HWND hwnd, const WINDOWPLACEMENT *pwpl32 )
1343 {
1344     if( pwpl32 )
1345     {
1346         WINDOWPLACEMENT16 wpl;
1347
1348         wpl.length = sizeof(WINDOWPLACEMENT16);
1349         wpl.flags = pwpl32->flags;
1350         wpl.showCmd = pwpl32->showCmd;
1351         wpl.ptMinPosition.x = pwpl32->ptMinPosition.x;
1352         wpl.ptMinPosition.y = pwpl32->ptMinPosition.y;
1353         wpl.ptMaxPosition.x = pwpl32->ptMaxPosition.x;
1354         wpl.ptMaxPosition.y = pwpl32->ptMaxPosition.y;
1355         wpl.rcNormalPosition.left = pwpl32->rcNormalPosition.left;
1356         wpl.rcNormalPosition.top = pwpl32->rcNormalPosition.top;
1357         wpl.rcNormalPosition.right = pwpl32->rcNormalPosition.right;
1358         wpl.rcNormalPosition.bottom = pwpl32->rcNormalPosition.bottom;
1359
1360         return WINPOS_SetPlacement( hwnd, &wpl, PLACE_MIN | PLACE_MAX | PLACE_RECT );
1361     }
1362     return FALSE;
1363 }
1364
1365
1366 /***********************************************************************
1367  *              SetInternalWindowPos (USER.461)
1368  */
1369 void WINAPI SetInternalWindowPos16( HWND16 hwnd, UINT16 showCmd,
1370                                     LPRECT16 rect, LPPOINT16 pt )
1371 {
1372     if( IsWindow16(hwnd) )
1373     {
1374         WINDOWPLACEMENT16 wndpl;
1375         UINT flags;
1376
1377         wndpl.length  = sizeof(wndpl);
1378         wndpl.showCmd = showCmd;
1379         wndpl.flags = flags = 0;
1380
1381         if( pt )
1382         {
1383             flags |= PLACE_MIN;
1384             wndpl.flags |= WPF_SETMINPOSITION;
1385             wndpl.ptMinPosition = *pt;
1386         }
1387         if( rect )
1388         {
1389             flags |= PLACE_RECT;
1390             wndpl.rcNormalPosition = *rect;
1391         }
1392         WINPOS_SetPlacement( hwnd, &wndpl, flags );
1393     }
1394 }
1395
1396 /***********************************************************************
1397  *              AnimateWindow (USER32.@)
1398  *              Shows/Hides a window with an animation
1399  *              NO ANIMATION YET
1400  */
1401 BOOL WINAPI AnimateWindow(HWND hwnd, DWORD dwTime, DWORD dwFlags)
1402 {
1403         FIXME("partial stub\n");
1404
1405         /* If trying to show/hide and it's already   *
1406          * shown/hidden or invalid window, fail with *
1407          * invalid parameter                         */
1408         if(!IsWindow(hwnd) ||
1409            (IsWindowVisible(hwnd) && !(dwFlags & AW_HIDE)) ||
1410            (!IsWindowVisible(hwnd) && (dwFlags & AW_HIDE)))
1411         {
1412                 SetLastError(ERROR_INVALID_PARAMETER);
1413                 return FALSE;
1414         }
1415
1416         ShowWindow(hwnd, (dwFlags & AW_HIDE) ? SW_HIDE : ((dwFlags & AW_ACTIVATE) ? SW_SHOW : SW_SHOWNA));
1417
1418         return TRUE;
1419 }
1420
1421 /***********************************************************************
1422  *              SetInternalWindowPos (USER32.@)
1423  */
1424 void WINAPI SetInternalWindowPos( HWND hwnd, UINT showCmd,
1425                                     LPRECT rect, LPPOINT pt )
1426 {
1427     if( IsWindow(hwnd) )
1428     {
1429         WINDOWPLACEMENT16 wndpl;
1430         UINT flags;
1431
1432         wndpl.length  = sizeof(wndpl);
1433         wndpl.showCmd = showCmd;
1434         wndpl.flags = flags = 0;
1435
1436         if( pt )
1437         {
1438             flags |= PLACE_MIN;
1439             wndpl.flags |= WPF_SETMINPOSITION;
1440             CONV_POINT32TO16( pt, &wndpl.ptMinPosition );
1441         }
1442         if( rect )
1443         {
1444             flags |= PLACE_RECT;
1445             CONV_RECT32TO16( rect, &wndpl.rcNormalPosition );
1446         }
1447         WINPOS_SetPlacement( hwnd, &wndpl, flags );
1448     }
1449 }
1450
1451 /*******************************************************************
1452  *         WINPOS_SetActiveWindow
1453  *
1454  * SetActiveWindow() back-end. This is the only function that
1455  * can assign active status to a window. It must be called only
1456  * for the top level windows.
1457  */
1458 BOOL WINPOS_SetActiveWindow( HWND hWnd, BOOL fMouse, BOOL fChangeFocus)
1459 {
1460     WND*     wndPtr=0, *wndTemp;
1461     HQUEUE16 hOldActiveQueue, hNewActiveQueue;
1462     MESSAGEQUEUE *pOldActiveQueue = 0, *pNewActiveQueue = 0;
1463     WORD     wIconized = 0;
1464     HWND     hwndActive = 0;
1465     BOOL     bRet = 0;
1466
1467     TRACE("(%04x, %d, %d)\n", hWnd, fMouse, fChangeFocus );
1468
1469     /* Get current active window from the active queue */
1470     if ( hActiveQueue )
1471     {
1472         pOldActiveQueue = QUEUE_Lock( hActiveQueue );
1473         if ( pOldActiveQueue )
1474             hwndActive = PERQDATA_GetActiveWnd( pOldActiveQueue->pQData );
1475     }
1476
1477     /* paranoid checks */
1478     if( hWnd == GetDesktopWindow() || (bRet = (hWnd == hwndActive)) )
1479         goto CLEANUP_END;
1480
1481 /*  if (wndPtr && (GetFastQueue16() != wndPtr->hmemTaskQ))
1482  *      return 0;
1483  */
1484     wndPtr = WIN_FindWndPtr(hWnd);
1485     hOldActiveQueue = hActiveQueue;
1486
1487     if( (wndTemp = WIN_FindWndPtr(hwndActive)) )
1488     {
1489         wIconized = HIWORD(wndTemp->dwStyle & WS_MINIMIZE);
1490         WIN_ReleaseWndPtr(wndTemp);
1491     }
1492     else
1493         TRACE("no current active window.\n");
1494
1495     /* call CBT hook chain */
1496     if (HOOK_IsHooked( WH_CBT ))
1497     {
1498         CBTACTIVATESTRUCT cbt;
1499         cbt.fMouse     = fMouse;
1500         cbt.hWndActive = hwndActive;
1501         if (HOOK_CallHooksA( WH_CBT, HCBT_ACTIVATE, hWnd, (LPARAM)&cbt )) goto CLEANUP_END;
1502     }
1503
1504     /* set prev active wnd to current active wnd and send notification */
1505     if ((hwndPrevActive = hwndActive) && IsWindow(hwndPrevActive))
1506     {
1507         MESSAGEQUEUE *pTempActiveQueue = 0;
1508
1509         if (!SendMessageA( hwndPrevActive, WM_NCACTIVATE, FALSE, 0 ))
1510         {
1511             if (GetSysModalWindow16() != hWnd)
1512                 goto CLEANUP_END;
1513             /* disregard refusal if hWnd is sysmodal */
1514         }
1515
1516         SendMessageA( hwndPrevActive, WM_ACTIVATE,
1517                         MAKEWPARAM( WA_INACTIVE, wIconized ),
1518                         (LPARAM)hWnd );
1519
1520         /* check if something happened during message processing
1521          * (global active queue may have changed)
1522          */
1523         pTempActiveQueue = QUEUE_Lock( hActiveQueue );
1524         if(!pTempActiveQueue)
1525             goto CLEANUP_END;
1526
1527         hwndActive = PERQDATA_GetActiveWnd( pTempActiveQueue->pQData );
1528         QUEUE_Unlock( pTempActiveQueue );
1529         if( hwndPrevActive != hwndActive )
1530             goto CLEANUP_END;
1531     }
1532
1533     /* Set new active window in the message queue */
1534     hwndActive = hWnd;
1535     if ( wndPtr )
1536     {
1537         pNewActiveQueue = QUEUE_Lock( wndPtr->hmemTaskQ );
1538         if ( pNewActiveQueue )
1539             PERQDATA_SetActiveWnd( pNewActiveQueue->pQData, hwndActive );
1540     }
1541     else /* have to do this or MDI frame activation goes to hell */
1542         if( pOldActiveQueue )
1543             PERQDATA_SetActiveWnd( pOldActiveQueue->pQData, 0 );
1544
1545     /* send palette messages */
1546     if (hWnd && SendMessage16( hWnd, WM_QUERYNEWPALETTE, 0, 0L))
1547         SendMessage16((HWND16)-1, WM_PALETTEISCHANGING, (WPARAM16)hWnd, 0L );
1548
1549     /* if prev wnd is minimized redraw icon title */
1550     if( IsIconic( hwndPrevActive ) ) WINPOS_RedrawIconTitle(hwndPrevActive);
1551
1552     /* managed windows will get ConfigureNotify event */
1553     if (wndPtr && !(wndPtr->dwStyle & WS_CHILD) && !(wndPtr->dwExStyle & WS_EX_MANAGED))
1554     {
1555         /* check Z-order and bring hWnd to the top */
1556         for (wndTemp = WIN_LockWndPtr(WIN_GetDesktop()->child); wndTemp; WIN_UpdateWndPtr(&wndTemp,wndTemp->next))
1557         {
1558             if (wndTemp->dwStyle & WS_VISIBLE) break;
1559         }
1560         WIN_ReleaseDesktop();
1561         WIN_ReleaseWndPtr(wndTemp);
1562
1563         if( wndTemp != wndPtr )
1564             SetWindowPos(hWnd, HWND_TOP, 0,0,0,0,
1565                            SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
1566         if (!IsWindow(hWnd))
1567             goto CLEANUP;
1568     }
1569
1570     /* Get a handle to the new active queue */
1571     hNewActiveQueue = wndPtr ? wndPtr->hmemTaskQ : 0;
1572
1573     /* send WM_ACTIVATEAPP if necessary */
1574     if (hOldActiveQueue != hNewActiveQueue)
1575     {
1576         WND **list, **ppWnd;
1577         WND *pDesktop = WIN_GetDesktop();
1578
1579         if ((list = WIN_BuildWinArray( pDesktop, 0, NULL )))
1580         {
1581             DWORD new_thread = GetWindowThreadProcessId( hwndActive, NULL );
1582             for (ppWnd = list; *ppWnd; ppWnd++)
1583             {
1584                 if (!IsWindow( (*ppWnd)->hwndSelf )) continue;
1585
1586                 if ((*ppWnd)->hmemTaskQ == hOldActiveQueue)
1587                     SendMessageW( (*ppWnd)->hwndSelf, WM_ACTIVATEAPP, 0, new_thread );
1588             }
1589             WIN_ReleaseWinArray(list);
1590         }
1591
1592         hActiveQueue = hNewActiveQueue;
1593
1594         if ((list = WIN_BuildWinArray(pDesktop, 0, NULL )))
1595         {
1596             DWORD old_thread = GetWindowThreadProcessId( hwndPrevActive, NULL );
1597             for (ppWnd = list; *ppWnd; ppWnd++)
1598             {
1599                 if (!IsWindow( (*ppWnd)->hwndSelf )) continue;
1600
1601                 if ((*ppWnd)->hmemTaskQ == hNewActiveQueue)
1602                     SendMessageW( (*ppWnd)->hwndSelf, WM_ACTIVATEAPP, 1, old_thread );
1603             }
1604             WIN_ReleaseWinArray(list);
1605         }
1606         WIN_ReleaseDesktop();
1607
1608         if (hWnd && !IsWindow(hWnd)) goto CLEANUP;
1609     }
1610
1611     if (hWnd)
1612     {
1613         /* walk up to the first unowned window */
1614         wndTemp = WIN_LockWndPtr(wndPtr);
1615         while (wndTemp->owner)
1616         {
1617             WIN_UpdateWndPtr(&wndTemp,wndTemp->owner);
1618         }
1619         /* and set last active owned popup */
1620         wndTemp->hwndLastActive = hWnd;
1621
1622         wIconized = HIWORD(wndTemp->dwStyle & WS_MINIMIZE);
1623         WIN_ReleaseWndPtr(wndTemp);
1624         SendMessageA( hWnd, WM_NCACTIVATE, TRUE, 0 );
1625         SendMessageA( hWnd, WM_ACTIVATE,
1626                  MAKEWPARAM( (fMouse) ? WA_CLICKACTIVE : WA_ACTIVE, wIconized),
1627                  (LPARAM)hwndPrevActive );
1628         if( !IsWindow(hWnd) ) goto CLEANUP;
1629     }
1630
1631     /* change focus if possible */
1632     if ( fChangeFocus )
1633     {
1634         if ( pNewActiveQueue )
1635         {
1636             HWND hOldFocus = PERQDATA_GetFocusWnd( pNewActiveQueue->pQData );
1637
1638             if ( hOldFocus && WIN_GetTopParent( hOldFocus ) != hwndActive )
1639                 FOCUS_SwitchFocus( pNewActiveQueue, hOldFocus,
1640                                    (wndPtr && (wndPtr->dwStyle & WS_MINIMIZE))?
1641                                    0 : hwndActive );
1642         }
1643
1644         if ( pOldActiveQueue &&
1645              ( !pNewActiveQueue ||
1646                 pNewActiveQueue->pQData != pOldActiveQueue->pQData ) )
1647         {
1648             HWND hOldFocus = PERQDATA_GetFocusWnd( pOldActiveQueue->pQData );
1649             if ( hOldFocus )
1650                 FOCUS_SwitchFocus( pOldActiveQueue, hOldFocus, 0 );
1651         }
1652     }
1653
1654     if( !hwndPrevActive && wndPtr )
1655     {
1656         if (USER_Driver.pForceWindowRaise) USER_Driver.pForceWindowRaise( wndPtr->hwndSelf );
1657     }
1658
1659     /* if active wnd is minimized redraw icon title */
1660     if( IsIconic(hwndActive) ) WINPOS_RedrawIconTitle(hwndActive);
1661
1662     bRet = (hWnd == hwndActive);  /* Success? */
1663
1664 CLEANUP: /* Unlock the message queues before returning */
1665
1666     if ( pNewActiveQueue )
1667         QUEUE_Unlock( pNewActiveQueue );
1668
1669 CLEANUP_END:
1670
1671     if ( pOldActiveQueue )
1672         QUEUE_Unlock( pOldActiveQueue );
1673
1674     WIN_ReleaseWndPtr(wndPtr);
1675     return bRet;
1676 }
1677
1678 /*******************************************************************
1679  *         WINPOS_ActivateOtherWindow
1680  *
1681  *  Activates window other than pWnd.
1682  */
1683 BOOL WINPOS_ActivateOtherWindow(WND* pWnd)
1684 {
1685   BOOL  bRet = 0;
1686   WND*          pWndTo = NULL;
1687     HWND       hwndActive = 0;
1688
1689     /* Get current active window from the active queue */
1690     if ( hActiveQueue )
1691     {
1692         MESSAGEQUEUE *pActiveQueue = QUEUE_Lock( hActiveQueue );
1693         if ( pActiveQueue )
1694         {
1695             hwndActive = PERQDATA_GetActiveWnd( pActiveQueue->pQData );
1696             QUEUE_Unlock( pActiveQueue );
1697         }
1698     }
1699
1700   if( pWnd->hwndSelf == hwndPrevActive )
1701       hwndPrevActive = 0;
1702
1703   if( hwndActive != pWnd->hwndSelf &&
1704     ( hwndActive || QUEUE_IsExitingQueue(pWnd->hmemTaskQ)) )
1705       return 0;
1706
1707   if( !(pWnd->dwStyle & WS_POPUP) || !(pWnd->owner) ||
1708       !WINPOS_CanActivate((pWndTo = WIN_GetTopParentPtr(pWnd->owner))) )
1709   {
1710       WND* pWndPtr = WIN_GetTopParentPtr(pWnd);
1711
1712       WIN_ReleaseWndPtr(pWndTo);
1713       pWndTo = WIN_FindWndPtr(hwndPrevActive);
1714
1715       while( !WINPOS_CanActivate(pWndTo) )
1716       {
1717          /* by now owned windows should've been taken care of */
1718           WIN_UpdateWndPtr(&pWndTo,pWndPtr->next);
1719           WIN_UpdateWndPtr(&pWndPtr,pWndTo);
1720           if( !pWndTo ) break;
1721       }
1722       WIN_ReleaseWndPtr(pWndPtr);
1723   }
1724
1725   bRet = WINPOS_SetActiveWindow( pWndTo ? pWndTo->hwndSelf : 0, FALSE, TRUE );
1726
1727   if( pWndTo ) WIN_ReleaseWndPtr(pWndTo);
1728
1729   hwndPrevActive = 0;
1730   return bRet;
1731 }
1732
1733 /*******************************************************************
1734  *         WINPOS_ChangeActiveWindow
1735  *
1736  */
1737 BOOL WINPOS_ChangeActiveWindow( HWND hWnd, BOOL mouseMsg )
1738 {
1739     WND *wndPtr;
1740     BOOL retvalue;
1741     HWND hwndActive = 0;
1742
1743     /* Get current active window from the active queue */
1744     if ( hActiveQueue )
1745     {
1746         MESSAGEQUEUE *pActiveQueue = QUEUE_Lock( hActiveQueue );
1747         if ( pActiveQueue )
1748         {
1749             hwndActive = PERQDATA_GetActiveWnd( pActiveQueue->pQData );
1750             QUEUE_Unlock( pActiveQueue );
1751         }
1752     }
1753
1754     if (!hWnd)
1755         return WINPOS_SetActiveWindow( 0, mouseMsg, TRUE );
1756
1757     wndPtr = WIN_FindWndPtr(hWnd);
1758     if( !wndPtr ) return FALSE;
1759
1760     /* child windows get WM_CHILDACTIVATE message */
1761     if( (wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) == WS_CHILD )
1762     {
1763         retvalue = SendMessageA(hWnd, WM_CHILDACTIVATE, 0, 0L);
1764         goto end;
1765     }
1766
1767     if( hWnd == hwndActive )
1768     {
1769         retvalue = FALSE;
1770         goto end;
1771     }
1772
1773     if( !WINPOS_SetActiveWindow(hWnd ,mouseMsg ,TRUE) )
1774     {
1775         retvalue = FALSE;
1776         goto end;
1777     }
1778
1779     retvalue = TRUE;
1780 end:
1781     WIN_ReleaseWndPtr(wndPtr);
1782     return retvalue;
1783 }
1784
1785
1786 /***********************************************************************
1787  *           WINPOS_SendNCCalcSize
1788  *
1789  * Send a WM_NCCALCSIZE message to a window.
1790  * All parameters are read-only except newClientRect.
1791  * oldWindowRect, oldClientRect and winpos must be non-NULL only
1792  * when calcValidRect is TRUE.
1793  */
1794 LONG WINPOS_SendNCCalcSize( HWND hwnd, BOOL calcValidRect,
1795                             RECT *newWindowRect, RECT *oldWindowRect,
1796                             RECT *oldClientRect, WINDOWPOS *winpos,
1797                             RECT *newClientRect )
1798 {
1799     NCCALCSIZE_PARAMS params;
1800     WINDOWPOS winposCopy;
1801     LONG result;
1802
1803     params.rgrc[0] = *newWindowRect;
1804     if (calcValidRect)
1805     {
1806         winposCopy = *winpos;
1807         params.rgrc[1] = *oldWindowRect;
1808         params.rgrc[2] = *oldClientRect;
1809         params.lppos = &winposCopy;
1810     }
1811     result = SendMessageA( hwnd, WM_NCCALCSIZE, calcValidRect,
1812                              (LPARAM)&params );
1813     TRACE("%d,%d-%d,%d\n",
1814                  params.rgrc[0].left, params.rgrc[0].top,
1815                  params.rgrc[0].right, params.rgrc[0].bottom );
1816
1817     /* If the application send back garbage, ignore it */
1818     if (params.rgrc[0].left <= params.rgrc[0].right && params.rgrc[0].top <= params.rgrc[0].bottom)
1819         *newClientRect = params.rgrc[0];
1820
1821     return result;
1822 }
1823
1824
1825 /***********************************************************************
1826  *           WINPOS_HandleWindowPosChanging16
1827  *
1828  * Default handling for a WM_WINDOWPOSCHANGING. Called from DefWindowProc().
1829  */
1830 LONG WINPOS_HandleWindowPosChanging16( WND *wndPtr, WINDOWPOS16 *winpos )
1831 {
1832     POINT maxSize, minTrack;
1833     if (winpos->flags & SWP_NOSIZE) return 0;
1834     if ((wndPtr->dwStyle & WS_THICKFRAME) ||
1835         ((wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) == 0))
1836     {
1837         WINPOS_GetMinMaxInfo( wndPtr, &maxSize, NULL, &minTrack, NULL );
1838         if (maxSize.x < winpos->cx) winpos->cx = maxSize.x;
1839         if (maxSize.y < winpos->cy) winpos->cy = maxSize.y;
1840         if (!(wndPtr->dwStyle & WS_MINIMIZE))
1841         {
1842             if (winpos->cx < minTrack.x ) winpos->cx = minTrack.x;
1843             if (winpos->cy < minTrack.y ) winpos->cy = minTrack.y;
1844         }
1845     }
1846     return 0;
1847 }
1848
1849
1850 /***********************************************************************
1851  *           WINPOS_HandleWindowPosChanging
1852  *
1853  * Default handling for a WM_WINDOWPOSCHANGING. Called from DefWindowProc().
1854  */
1855 LONG WINPOS_HandleWindowPosChanging( WND *wndPtr, WINDOWPOS *winpos )
1856 {
1857     POINT maxSize, minTrack;
1858     if (winpos->flags & SWP_NOSIZE) return 0;
1859     if ((wndPtr->dwStyle & WS_THICKFRAME) ||
1860         ((wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) == 0))
1861     {
1862         WINPOS_GetMinMaxInfo( wndPtr, &maxSize, NULL, &minTrack, NULL );
1863         winpos->cx = min( winpos->cx, maxSize.x );
1864         winpos->cy = min( winpos->cy, maxSize.y );
1865         if (!(wndPtr->dwStyle & WS_MINIMIZE))
1866         {
1867             if (winpos->cx < minTrack.x ) winpos->cx = minTrack.x;
1868             if (winpos->cy < minTrack.y ) winpos->cy = minTrack.y;
1869         }
1870     }
1871     return 0;
1872 }
1873
1874 /***********************************************************************
1875  *              SetWindowPos (USER.232)
1876  */
1877 BOOL16 WINAPI SetWindowPos16( HWND16 hwnd, HWND16 hwndInsertAfter,
1878                               INT16 x, INT16 y, INT16 cx, INT16 cy, WORD flags)
1879 {
1880     return SetWindowPos(hwnd,(INT)(INT16)hwndInsertAfter,x,y,cx,cy,flags);
1881 }
1882
1883 /***********************************************************************
1884  *              SetWindowPos (USER32.@)
1885  */
1886 BOOL WINAPI SetWindowPos( HWND hwnd, HWND hwndInsertAfter,
1887                           INT x, INT y, INT cx, INT cy, UINT flags )
1888 {
1889     WINDOWPOS winpos;
1890
1891     winpos.hwnd = hwnd;
1892     winpos.hwndInsertAfter = hwndInsertAfter;
1893     winpos.x = x;
1894     winpos.y = y;
1895     winpos.cx = cx;
1896     winpos.cy = cy;
1897     winpos.flags = flags;
1898     return USER_Driver.pSetWindowPos( &winpos );
1899 }
1900
1901
1902 /***********************************************************************
1903  *              BeginDeferWindowPos (USER.259)
1904  */
1905 HDWP16 WINAPI BeginDeferWindowPos16( INT16 count )
1906 {
1907     return BeginDeferWindowPos( count );
1908 }
1909
1910
1911 /***********************************************************************
1912  *              BeginDeferWindowPos (USER32.@)
1913  */
1914 HDWP WINAPI BeginDeferWindowPos( INT count )
1915 {
1916     HDWP handle;
1917     DWP *pDWP;
1918
1919     if (count < 0)
1920     {
1921         SetLastError(ERROR_INVALID_PARAMETER);
1922         return 0;
1923     }
1924     /* Windows allows zero count, in which case it allocates context for 8 moves */
1925     if (count == 0) count = 8;
1926
1927     handle = USER_HEAP_ALLOC( sizeof(DWP) + (count-1)*sizeof(WINDOWPOS) );
1928     if (!handle) return 0;
1929     pDWP = (DWP *) USER_HEAP_LIN_ADDR( handle );
1930     pDWP->actualCount    = 0;
1931     pDWP->suggestedCount = count;
1932     pDWP->valid          = TRUE;
1933     pDWP->wMagic         = DWP_MAGIC;
1934     pDWP->hwndParent     = 0;
1935     return handle;
1936 }
1937
1938
1939 /***********************************************************************
1940  *              DeferWindowPos (USER.260)
1941  */
1942 HDWP16 WINAPI DeferWindowPos16( HDWP16 hdwp, HWND16 hwnd, HWND16 hwndAfter,
1943                                 INT16 x, INT16 y, INT16 cx, INT16 cy,
1944                                 UINT16 flags )
1945 {
1946     return DeferWindowPos( hdwp, hwnd, (INT)(INT16)hwndAfter,
1947                              x, y, cx, cy, flags );
1948 }
1949
1950
1951 /***********************************************************************
1952  *              DeferWindowPos (USER32.@)
1953  */
1954 HDWP WINAPI DeferWindowPos( HDWP hdwp, HWND hwnd, HWND hwndAfter,
1955                                 INT x, INT y, INT cx, INT cy,
1956                                 UINT flags )
1957 {
1958     DWP *pDWP;
1959     int i;
1960     HDWP newhdwp = hdwp,retvalue;
1961     /* HWND parent; */
1962     WND *pWnd;
1963
1964     pDWP = (DWP *) USER_HEAP_LIN_ADDR( hdwp );
1965     if (!pDWP) return 0;
1966     if (hwnd == GetDesktopWindow()) return 0;
1967
1968     if (!(pWnd=WIN_FindWndPtr( hwnd ))) {
1969         USER_HEAP_FREE( hdwp );
1970         return 0;
1971     }
1972
1973 /* Numega Bounds Checker Demo dislikes the following code.
1974    In fact, I've not been able to find any "same parent" requirement in any docu
1975    [AM 980509]
1976  */
1977 #if 0
1978     /* All the windows of a DeferWindowPos() must have the same parent */
1979     parent = pWnd->parent->hwndSelf;
1980     if (pDWP->actualCount == 0) pDWP->hwndParent = parent;
1981     else if (parent != pDWP->hwndParent)
1982     {
1983         USER_HEAP_FREE( hdwp );
1984         retvalue = 0;
1985         goto END;
1986     }
1987 #endif
1988
1989     for (i = 0; i < pDWP->actualCount; i++)
1990     {
1991         if (pDWP->winPos[i].hwnd == hwnd)
1992         {
1993               /* Merge with the other changes */
1994             if (!(flags & SWP_NOZORDER))
1995             {
1996                 pDWP->winPos[i].hwndInsertAfter = hwndAfter;
1997             }
1998             if (!(flags & SWP_NOMOVE))
1999             {
2000                 pDWP->winPos[i].x = x;
2001                 pDWP->winPos[i].y = y;
2002             }
2003             if (!(flags & SWP_NOSIZE))
2004             {
2005                 pDWP->winPos[i].cx = cx;
2006                 pDWP->winPos[i].cy = cy;
2007             }
2008             pDWP->winPos[i].flags &= flags | ~(SWP_NOSIZE | SWP_NOMOVE |
2009                                                SWP_NOZORDER | SWP_NOREDRAW |
2010                                                SWP_NOACTIVATE | SWP_NOCOPYBITS|
2011                                                SWP_NOOWNERZORDER);
2012             pDWP->winPos[i].flags |= flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW |
2013                                               SWP_FRAMECHANGED);
2014             retvalue = hdwp;
2015             goto END;
2016         }
2017     }
2018     if (pDWP->actualCount >= pDWP->suggestedCount)
2019     {
2020         newhdwp = USER_HEAP_REALLOC( hdwp,
2021                       sizeof(DWP) + pDWP->suggestedCount*sizeof(WINDOWPOS) );
2022         if (!newhdwp)
2023         {
2024             retvalue = 0;
2025             goto END;
2026         }
2027         pDWP = (DWP *) USER_HEAP_LIN_ADDR( newhdwp );
2028         pDWP->suggestedCount++;
2029     }
2030     pDWP->winPos[pDWP->actualCount].hwnd = hwnd;
2031     pDWP->winPos[pDWP->actualCount].hwndInsertAfter = hwndAfter;
2032     pDWP->winPos[pDWP->actualCount].x = x;
2033     pDWP->winPos[pDWP->actualCount].y = y;
2034     pDWP->winPos[pDWP->actualCount].cx = cx;
2035     pDWP->winPos[pDWP->actualCount].cy = cy;
2036     pDWP->winPos[pDWP->actualCount].flags = flags;
2037     pDWP->actualCount++;
2038     retvalue = newhdwp;
2039 END:
2040     WIN_ReleaseWndPtr(pWnd);
2041     return retvalue;
2042 }
2043
2044
2045 /***********************************************************************
2046  *              EndDeferWindowPos (USER.261)
2047  */
2048 BOOL16 WINAPI EndDeferWindowPos16( HDWP16 hdwp )
2049 {
2050     return EndDeferWindowPos( hdwp );
2051 }
2052
2053
2054 /***********************************************************************
2055  *              EndDeferWindowPos (USER32.@)
2056  */
2057 BOOL WINAPI EndDeferWindowPos( HDWP hdwp )
2058 {
2059     DWP *pDWP;
2060     WINDOWPOS *winpos;
2061     BOOL res = TRUE;
2062     int i;
2063
2064     pDWP = (DWP *) USER_HEAP_LIN_ADDR( hdwp );
2065     if (!pDWP) return FALSE;
2066     for (i = 0, winpos = pDWP->winPos; i < pDWP->actualCount; i++, winpos++)
2067     {
2068         if (!(res = USER_Driver.pSetWindowPos( winpos ))) break;
2069     }
2070     USER_HEAP_FREE( hdwp );
2071     return res;
2072 }
2073
2074
2075 /***********************************************************************
2076  *              TileChildWindows (USER.199)
2077  */
2078 void WINAPI TileChildWindows16( HWND16 parent, WORD action )
2079 {
2080     FIXME("(%04x, %d): stub\n", parent, action);
2081 }
2082
2083 /***********************************************************************
2084  *              CascadeChildWindows (USER.198)
2085  */
2086 void WINAPI CascadeChildWindows16( HWND16 parent, WORD action )
2087 {
2088     FIXME("(%04x, %d): stub\n", parent, action);
2089 }
2090
2091 /***********************************************************************
2092  *              SetProgmanWindow (USER32.@)
2093  */
2094 HRESULT WINAPI SetProgmanWindow ( HWND hwnd )
2095 {
2096         hGlobalProgmanWindow = hwnd;
2097         return hGlobalProgmanWindow;
2098 }
2099
2100 /***********************************************************************
2101  *              GetProgmanWindow (USER32.@)
2102  */
2103 HRESULT WINAPI GetProgmanWindow ( )
2104 {
2105         return hGlobalProgmanWindow;
2106 }
2107
2108 /***********************************************************************
2109  *              SetShellWindowEx (USER32.@)
2110  * hwndProgman =  Progman[Program Manager]
2111  *                |-> SHELLDLL_DefView
2112  * hwndListView = |   |-> SysListView32
2113  *                |   |   |-> tooltips_class32
2114  *                |   |
2115  *                |   |-> SysHeader32
2116  *                |
2117  *                |-> ProxyTarget
2118  */
2119 HRESULT WINAPI SetShellWindowEx ( HWND hwndProgman, HWND hwndListView )
2120 {
2121         FIXME("0x%08x 0x%08x stub\n",hwndProgman ,hwndListView );
2122         hGlobalShellWindow = hwndProgman;
2123         return hGlobalShellWindow;
2124
2125 }
2126
2127 /***********************************************************************
2128  *              SetTaskmanWindow (USER32.@)
2129  * NOTES
2130  *   hwnd = MSTaskSwWClass
2131  *          |-> SysTabControl32
2132  */
2133 HRESULT WINAPI SetTaskmanWindow ( HWND hwnd )
2134 {
2135         hGlobalTaskmanWindow = hwnd;
2136         return hGlobalTaskmanWindow;
2137 }
2138
2139 /***********************************************************************
2140  *              GetTaskmanWindow (USER32.@)
2141  */
2142 HRESULT WINAPI GetTaskmanWindow ( )
2143 {
2144         return hGlobalTaskmanWindow;
2145 }