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