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