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

   1 /*
   2  * Window related functions
   3  *
   4  * Copyright 1993, 1994 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <assert.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include "windef.h"
  28 #include "wine/winbase16.h"
  29 #include "wine/winuser16.h"
  30 #include "wownt32.h"
  31 #include "wine/server.h"
  32 #include "wine/unicode.h"
  33 #include "win.h"
  34 #include "user.h"
  35 #include "dce.h"
  36 #include "controls.h"
  37 #include "cursoricon.h"
  38 #include "hook.h"
  39 #include "message.h"
  40 #include "queue.h"
  41 #include "winpos.h"
  42 #include "winerror.h"
  43 #include "stackframe.h"
  44 #include "wine/debug.h"
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(win);
  47 WINE_DECLARE_DEBUG_CHANNEL(msg);
  48
  49 #define NB_USER_HANDLES  (LAST_USER_HANDLE - FIRST_USER_HANDLE + 1)
  50
  51 /**********************************************************************/
  52
  53 /* Desktop window */
  54 static WND *pWndDesktop = NULL;
  55
  56 static WORD wDragWidth = 4;
  57 static WORD wDragHeight= 3;
  58
  59 static void *user_handles[NB_USER_HANDLES];
  60
  61 /* thread safeness */
  62 extern SYSLEVEL USER_SysLevel;  /* FIXME */
  63
  64 /***********************************************************************
  65  *           WIN_SuspendWndsLock
  66  *
  67  *   Suspend the lock on WND structures.
  68  *   Returns the number of locks suspended
  69  */
  70 int WIN_SuspendWndsLock( void )
  71 {
  72     int isuspendedLocks = _ConfirmSysLevel( &USER_SysLevel );
  73     int count = isuspendedLocks;
  74
  75     while ( count-- > 0 )
  76         _LeaveSysLevel( &USER_SysLevel );
  77
  78     return isuspendedLocks;
  79 }
  80
  81 /***********************************************************************
  82  *           WIN_RestoreWndsLock
  83  *
  84  *  Restore the suspended locks on WND structures
  85  */
  86 void WIN_RestoreWndsLock( int ipreviousLocks )
  87 {
  88     while ( ipreviousLocks-- > 0 )
  89         _EnterSysLevel( &USER_SysLevel );
  90 }
  91
  92 /***********************************************************************
  93  *           create_window_handle
  94  *
  95  * Create a window handle with the server.
  96  */
  97 static WND *create_window_handle( HWND parent, HWND owner, ATOM atom, INT size )
  98 {
  99     BOOL res;
 100     user_handle_t handle = 0;
 101     WORD index;
 102     WND *win = HeapAlloc( GetProcessHeap(), 0, size );
 103
 104     if (!win) return NULL;
 105
 106     USER_Lock();
 107
 108     SERVER_START_REQ( create_window )
 109     {
 110         req->parent = parent;
 111         req->owner = owner;
 112         req->atom = atom;
 113         if ((res = !wine_server_call_err( req ))) handle = reply->handle;
 114     }
 115     SERVER_END_REQ;
 116
 117     if (!res)
 118     {
 119         USER_Unlock();
 120         HeapFree( GetProcessHeap(), 0, win );
 121         return NULL;
 122     }
 123     index = LOWORD(handle) - FIRST_USER_HANDLE;
 124     assert( index < NB_USER_HANDLES );
 125     user_handles[index] = win;
 126     win->hwndSelf = handle;
 127     win->dwMagic = WND_MAGIC;
 128     win->irefCount = 1;
 129     return win;
 130 }
 131
 132
 133 /***********************************************************************
 134  *           free_window_handle
 135  *
 136  * Free a window handle.
 137  */
 138 static WND *free_window_handle( HWND hwnd )
 139 {
 140     WND *ptr;
 141     WORD index = LOWORD(hwnd) - FIRST_USER_HANDLE;
 142
 143     if (index >= NB_USER_HANDLES) return NULL;
 144     USER_Lock();
 145     if ((ptr = user_handles[index]))
 146     {
 147         SERVER_START_REQ( destroy_window )
 148         {
 149             req->handle = hwnd;
 150             if (!wine_server_call_err( req ))
 151                 user_handles[index] = NULL;
 152             else
 153                 ptr = NULL;
 154         }
 155         SERVER_END_REQ;
 156     }
 157     USER_Unlock();
 158     if (ptr) HeapFree( GetProcessHeap(), 0, ptr );
 159     return ptr;
 160 }
 161
 162
 163 /*******************************************************************
 164  *           list_window_children
 165  *
 166  * Build an array of the children of a given window. The array must be
 167  * freed with HeapFree. Returns NULL when no windows are found.
 168  */
 169 static HWND *list_window_children( HWND hwnd, ATOM atom, DWORD tid )
 170 {
 171     HWND *list;
 172     int size = 32;
 173
 174     for (;;)
 175     {
 176         int count = 0;
 177
 178         if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) break;
 179
 180         SERVER_START_REQ( get_window_children )
 181         {
 182             req->parent = hwnd;
 183             req->atom = atom;
 184             req->tid = tid;
 185             wine_server_set_reply( req, list, (size-1) * sizeof(HWND) );
 186             if (!wine_server_call( req )) count = reply->count;
 187         }
 188         SERVER_END_REQ;
 189         if (count && count < size)
 190         {
 191             list[count] = 0;
 192             return list;
 193         }
 194         HeapFree( GetProcessHeap(), 0, list );
 195         if (!count) break;
 196         size = count + 1;  /* restart with a large enough buffer */
 197     }
 198     return NULL;
 199 }
 200
 201
 202 /*******************************************************************
 203  *           send_parent_notify
 204  */
 205 static void send_parent_notify( HWND hwnd, UINT msg )
 206 {
 207     if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)) return;
 208     if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_NOPARENTNOTIFY) return;
 209     SendMessageW( GetParent(hwnd), WM_PARENTNOTIFY,
 210                   MAKEWPARAM( msg, GetWindowLongW( hwnd, GWL_ID )), (LPARAM)hwnd );
 211 }
 212
 213
 214 /*******************************************************************
 215  *              get_server_window_text
 216  *
 217  * Retrieve the window text from the server.
 218  */
 219 static void get_server_window_text( HWND hwnd, LPWSTR text, INT count )
 220 {
 221     size_t len = 0;
 222
 223     SERVER_START_REQ( get_window_text )
 224     {
 225         req->handle = hwnd;
 226         wine_server_set_reply( req, text, (count - 1) * sizeof(WCHAR) );
 227         if (!wine_server_call_err( req )) len = wine_server_reply_size(reply);
 228     }
 229     SERVER_END_REQ;
 230     text[len / sizeof(WCHAR)] = 0;
 231 }
 232
 233
 234 /***********************************************************************
 235  *           WIN_GetPtr
 236  *
 237  * Return a pointer to the WND structure if local to the process,
 238  * or WND_OTHER_PROCESS if handle may be valid in other process.
 239  * If ret value is a valid pointer, it must be released with WIN_ReleasePtr.
 240  */
 241 WND *WIN_GetPtr( HWND hwnd )
 242 {
 243     WND * ptr;
 244     WORD index = LOWORD(hwnd) - FIRST_USER_HANDLE;
 245
 246     if (index >= NB_USER_HANDLES) return NULL;
 247
 248     USER_Lock();
 249     if ((ptr = user_handles[index]))
 250     {
 251         if (ptr->dwMagic == WND_MAGIC && (!HIWORD(hwnd) || hwnd == ptr->hwndSelf))
 252             return ptr;
 253         ptr = NULL;
 254     }
 255     else ptr = WND_OTHER_PROCESS;
 256     USER_Unlock();
 257     return ptr;
 258 }
 259
 260
 261 /***********************************************************************
 262  *           WIN_IsCurrentProcess
 263  *
 264  * Check whether a given window belongs to the current process (and return the full handle).
 265  */
 266 HWND WIN_IsCurrentProcess( HWND hwnd )
 267 {
 268     WND *ptr;
 269     HWND ret;
 270
 271     if (!(ptr = WIN_GetPtr( hwnd )) || ptr == WND_OTHER_PROCESS) return 0;
 272     ret = ptr->hwndSelf;
 273     WIN_ReleasePtr( ptr );
 274     return ret;
 275 }
 276
 277
 278 /***********************************************************************
 279  *           WIN_IsCurrentThread
 280  *
 281  * Check whether a given window belongs to the current thread (and return the full handle).
 282  */
 283 HWND WIN_IsCurrentThread( HWND hwnd )
 284 {
 285     WND *ptr;
 286     HWND ret = 0;
 287
 288     if ((ptr = WIN_GetPtr( hwnd )) && ptr != WND_OTHER_PROCESS)
 289     {
 290         if (ptr->tid == GetCurrentThreadId()) ret = ptr->hwndSelf;
 291         WIN_ReleasePtr( ptr );
 292     }
 293     return ret;
 294 }
 295
 296
 297 /***********************************************************************
 298  *           WIN_Handle32
 299  *
 300  * Convert a 16-bit window handle to a full 32-bit handle.
 301  */
 302 HWND WIN_Handle32( HWND16 hwnd16 )
 303 {
 304     WND *ptr;
 305     HWND hwnd = (HWND)(ULONG_PTR)hwnd16;
 306
 307     if (hwnd16 <= 1 || hwnd16 == 0xffff) return hwnd;
 308     /* do sign extension for -2 and -3 */
 309     if (hwnd16 >= (HWND16)-3) return (HWND)(LONG_PTR)(INT16)hwnd16;
 310
 311     if (!(ptr = WIN_GetPtr( hwnd ))) return hwnd;
 312
 313     if (ptr != WND_OTHER_PROCESS)
 314     {
 315         hwnd = ptr->hwndSelf;
 316         WIN_ReleasePtr( ptr );
 317     }
 318     else  /* may belong to another process */
 319     {
 320         SERVER_START_REQ( get_window_info )
 321         {
 322             req->handle = hwnd;
 323             if (!wine_server_call_err( req )) hwnd = reply->full_handle;
 324         }
 325         SERVER_END_REQ;
 326     }
 327     return hwnd;
 328 }
 329
 330
 331 /***********************************************************************
 332  *           WIN_FindWndPtr
 333  *
 334  * Return a pointer to the WND structure corresponding to a HWND.
 335  */
 336 WND * WIN_FindWndPtr( HWND hwnd )
 337 {
 338     WND * ptr;
 339
 340     if (!hwnd) return NULL;
 341
 342     if ((ptr = WIN_GetPtr( hwnd )))
 343     {
 344         if (ptr != WND_OTHER_PROCESS)
 345         {
 346             /* increment destruction monitoring */
 347             ptr->irefCount++;
 348             return ptr;
 349         }
 350         if (IsWindow( hwnd )) /* check other processes */
 351         {
 352             ERR( "window %04x belongs to other process\n", hwnd );
 353             /* DbgBreakPoint(); */
 354         }
 355     }
 356     SetLastError( ERROR_INVALID_WINDOW_HANDLE );
 357     return NULL;
 358 }
 359
 360
 361 /***********************************************************************
 362  *           WIN_ReleaseWndPtr
 363  *
 364  * Release the pointer to the WND structure.
 365  */
 366 void WIN_ReleaseWndPtr(WND *wndPtr)
 367 {
 368     if(!wndPtr) return;
 369
 370     /* Decrement destruction monitoring value */
 371      wndPtr->irefCount--;
 372      /* Check if it's time to release the memory */
 373      if(wndPtr->irefCount == 0 && !wndPtr->dwMagic)
 374      {
 375          /* Release memory */
 376          free_window_handle( wndPtr->hwndSelf );
 377      }
 378      else if(wndPtr->irefCount < 0)
 379      {
 380          /* This else if is useful to monitor the WIN_ReleaseWndPtr function */
 381          ERR("forgot a Lock on %p somewhere\n",wndPtr);
 382      }
 383      /* unlock all WND structures for thread safeness */
 384      USER_Unlock();
 385 }
 386
 387
 388 /***********************************************************************
 389  *           WIN_UnlinkWindow
 390  *
 391  * Remove a window from the siblings linked list.
 392  */
 393 void WIN_UnlinkWindow( HWND hwnd )
 394 {
 395     WIN_LinkWindow( hwnd, 0, 0 );
 396 }
 397
 398
 399 /***********************************************************************
 400  *           WIN_LinkWindow
 401  *
 402  * Insert a window into the siblings linked list.
 403  * The window is inserted after the specified window, which can also
 404  * be specified as HWND_TOP or HWND_BOTTOM.
 405  * If parent is 0, window is unlinked from the tree.
 406  */
 407 void WIN_LinkWindow( HWND hwnd, HWND parent, HWND hwndInsertAfter )
 408 {
 409     WND *wndPtr = WIN_GetPtr( hwnd );
 410
 411     if (!wndPtr) return;
 412     if (wndPtr == WND_OTHER_PROCESS)
 413     {
 414         if (IsWindow(hwnd)) ERR(" cannot link other process window %x\n", hwnd );
 415         return;
 416     }
 417
 418     SERVER_START_REQ( link_window )
 419     {
 420         req->handle   = hwnd;
 421         req->parent   = parent;
 422         req->previous = hwndInsertAfter;
 423         if (!wine_server_call( req ))
 424         {
 425             if (reply->full_parent) wndPtr->parent = reply->full_parent;
 426         }
 427
 428     }
 429     SERVER_END_REQ;
 430     WIN_ReleasePtr( wndPtr );
 431 }
 432
 433
 434 /***********************************************************************
 435  *           WIN_SetOwner
 436  *
 437  * Change the owner of a window.
 438  */
 439 HWND WIN_SetOwner( HWND hwnd, HWND owner )
 440 {
 441     WND *win = WIN_GetPtr( hwnd );
 442     HWND ret = 0;
 443
 444     if (!win) return 0;
 445     if (win == WND_OTHER_PROCESS)
 446     {
 447         if (IsWindow(hwnd)) ERR( "cannot set owner %x on other process window %x\n", owner, hwnd );
 448         return 0;
 449     }
 450     SERVER_START_REQ( set_window_owner )
 451     {
 452         req->handle = hwnd;
 453         req->owner  = owner;
 454         if (!wine_server_call( req ))
 455         {
 456             win->owner = reply->full_owner;
 457             ret = reply->prev_owner;
 458         }
 459     }
 460     SERVER_END_REQ;
 461     WIN_ReleasePtr( win );
 462     return ret;
 463 }
 464
 465
 466 /***********************************************************************
 467  *           WIN_SetStyle
 468  *
 469  * Change the style of a window.
 470  */
 471 LONG WIN_SetStyle( HWND hwnd, LONG style )
 472 {
 473     BOOL ok;
 474     LONG ret = 0;
 475     WND *win = WIN_GetPtr( hwnd );
 476
 477     if (!win) return 0;
 478     if (win == WND_OTHER_PROCESS)
 479     {
 480         if (IsWindow(hwnd))
 481             ERR( "cannot set style %lx on other process window %x\n", style, hwnd );
 482         return 0;
 483     }
 484     if (style == win->dwStyle)
 485     {
 486         WIN_ReleasePtr( win );
 487         return style;
 488     }
 489     SERVER_START_REQ( set_window_info )
 490     {
 491         req->handle = hwnd;
 492         req->flags  = SET_WIN_STYLE;
 493         req->style  = style;
 494         if ((ok = !wine_server_call( req )))
 495         {
 496             ret = reply->old_style;
 497             win->dwStyle = style;
 498         }
 499     }
 500     SERVER_END_REQ;
 501     WIN_ReleasePtr( win );
 502     if (ok && USER_Driver.pSetWindowStyle) USER_Driver.pSetWindowStyle( hwnd, ret );
 503     return ret;
 504 }
 505
 506
 507 /***********************************************************************
 508  *           WIN_SetExStyle
 509  *
 510  * Change the extended style of a window.
 511  */
 512 LONG WIN_SetExStyle( HWND hwnd, LONG style )
 513 {
 514     LONG ret = 0;
 515     WND *win = WIN_GetPtr( hwnd );
 516
 517     if (!win) return 0;
 518     if (win == WND_OTHER_PROCESS)
 519     {
 520         if (IsWindow(hwnd))
 521             ERR( "cannot set exstyle %lx on other process window %x\n", style, hwnd );
 522         return 0;
 523     }
 524     if (style == win->dwExStyle)
 525     {
 526         WIN_ReleasePtr( win );
 527         return style;
 528     }
 529     SERVER_START_REQ( set_window_info )
 530     {
 531         req->handle   = hwnd;
 532         req->flags    = SET_WIN_EXSTYLE;
 533         req->ex_style = style;
 534         if (!wine_server_call( req ))
 535         {
 536             ret = reply->old_ex_style;
 537             win->dwExStyle = style;
 538         }
 539     }
 540     SERVER_END_REQ;
 541     WIN_ReleasePtr( win );
 542     return ret;
 543 }
 544
 545
 546 /***********************************************************************
 547  *           WIN_SetRectangles
 548  *
 549  * Set the window and client rectangles.
 550  */
 551 void WIN_SetRectangles( HWND hwnd, const RECT *rectWindow, const RECT *rectClient )
 552 {
 553     WND *win = WIN_GetPtr( hwnd );
 554     BOOL ret;
 555
 556     if (!win) return;
 557     if (win == WND_OTHER_PROCESS)
 558     {
 559         if (IsWindow( hwnd )) ERR( "cannot set rectangles of other process window %x\n", hwnd );
 560         return;
 561     }
 562     SERVER_START_REQ( set_window_rectangles )
 563     {
 564         req->handle        = hwnd;
 565         req->window.left   = rectWindow->left;
 566         req->window.top    = rectWindow->top;
 567         req->window.right  = rectWindow->right;
 568         req->window.bottom = rectWindow->bottom;
 569         req->client.left   = rectClient->left;
 570         req->client.top    = rectClient->top;
 571         req->client.right  = rectClient->right;
 572         req->client.bottom = rectClient->bottom;
 573         ret = !wine_server_call( req );
 574     }
 575     SERVER_END_REQ;
 576     if (ret)
 577     {
 578         win->rectWindow = *rectWindow;
 579         win->rectClient = *rectClient;
 580
 581         TRACE( "win %x window (%d,%d)-(%d,%d) client (%d,%d)-(%d,%d)\n", hwnd,
 582                rectWindow->left, rectWindow->top, rectWindow->right, rectWindow->bottom,
 583                rectClient->left, rectClient->top, rectClient->right, rectClient->bottom );
 584     }
 585     WIN_ReleasePtr( win );
 586 }
 587
 588
 589 /***********************************************************************
 590  *           WIN_GetRectangles
 591  *
 592  * Get the window and client rectangles.
 593  */
 594 BOOL WIN_GetRectangles( HWND hwnd, RECT *rectWindow, RECT *rectClient )
 595 {
 596     WND *win = WIN_GetPtr( hwnd );
 597     BOOL ret = TRUE;
 598
 599     if (!win) return FALSE;
 600     if (win == WND_OTHER_PROCESS)
 601     {
 602         SERVER_START_REQ( get_window_rectangles )
 603         {
 604             req->handle = hwnd;
 605             if ((ret = !wine_server_call( req )))
 606             {
 607                 if (rectWindow)
 608                 {
 609                     rectWindow->left   = reply->window.left;
 610                     rectWindow->top    = reply->window.top;
 611                     rectWindow->right  = reply->window.right;
 612                     rectWindow->bottom = reply->window.bottom;
 613                 }
 614                 if (rectClient)
 615                 {
 616                     rectClient->left   = reply->client.left;
 617                     rectClient->top    = reply->client.top;
 618                     rectClient->right  = reply->client.right;
 619                     rectClient->bottom = reply->client.bottom;
 620                 }
 621             }
 622         }
 623         SERVER_END_REQ;
 624     }
 625     else
 626     {
 627         if (rectWindow) *rectWindow = win->rectWindow;
 628         if (rectClient) *rectClient = win->rectClient;
 629         WIN_ReleasePtr( win );
 630     }
 631     return ret;
 632 }
 633
 634
 635 /***********************************************************************
 636  *           WIN_DestroyWindow
 637  *
 638  * Destroy storage associated to a window. "Internals" p.358
 639  */
 640 LRESULT WIN_DestroyWindow( HWND hwnd )
 641 {
 642     WND *wndPtr;
 643     HWND *list;
 644
 645     TRACE("%04x\n", hwnd );
 646
 647     if (!(hwnd = WIN_IsCurrentThread( hwnd )))
 648     {
 649         ERR( "window doesn't belong to current thread\n" );
 650         return 0;
 651     }
 652
 653     /* free child windows */
 654     if ((list = WIN_ListChildren( hwnd )))
 655     {
 656         int i;
 657         for (i = 0; list[i]; i++)
 658         {
 659             if (WIN_IsCurrentThread( list[i] )) WIN_DestroyWindow( list[i] );
 660             else SendMessageW( list[i], WM_WINE_DESTROYWINDOW, 0, 0 );
 661         }
 662         HeapFree( GetProcessHeap(), 0, list );
 663     }
 664
 665     /*
 666      * Clear the update region to make sure no WM_PAINT messages will be
 667      * generated for this window while processing the WM_NCDESTROY.
 668      */
 669     RedrawWindow( hwnd, NULL, 0,
 670                   RDW_VALIDATE | RDW_NOFRAME | RDW_NOERASE | RDW_NOINTERNALPAINT | RDW_NOCHILDREN);
 671
 672     /*
 673      * Send the WM_NCDESTROY to the window being destroyed.
 674      */
 675     SendMessageA( hwnd, WM_NCDESTROY, 0, 0);
 676
 677     /* FIXME: do we need to fake QS_MOUSEMOVE wakebit? */
 678
 679     WINPOS_CheckInternalPos( hwnd );
 680     if( hwnd == GetCapture()) ReleaseCapture();
 681
 682     /* free resources associated with the window */
 683
 684     TIMER_RemoveWindowTimers( hwnd );
 685
 686     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return 0;
 687
 688     if (!(wndPtr->dwStyle & WS_CHILD))
 689     {
 690         HMENU menu = (HMENU)SetWindowLongW( hwnd, GWL_ID, 0 );
 691         if (menu) DestroyMenu( menu );
 692     }
 693     if (wndPtr->hSysMenu)
 694     {
 695         DestroyMenu( wndPtr->hSysMenu );
 696         wndPtr->hSysMenu = 0;
 697     }
 698     USER_Driver.pDestroyWindow( hwnd );
 699     DCE_FreeWindowDCE( hwnd );    /* Always do this to catch orphaned DCs */
 700     WINPROC_FreeProc( wndPtr->winproc, WIN_PROC_WINDOW );
 701     CLASS_RemoveWindow( wndPtr->class );
 702     wndPtr->class = NULL;
 703     wndPtr->dwMagic = 0;  /* Mark it as invalid */
 704     WIN_ReleaseWndPtr( wndPtr );
 705     return 0;
 706 }
 707
 708 /***********************************************************************
 709  *           WIN_DestroyThreadWindows
 710  *
 711  * Destroy all children of 'wnd' owned by the current thread.
 712  * Return TRUE if something was done.
 713  */
 714 void WIN_DestroyThreadWindows( HWND hwnd )
 715 {
 716     HWND *list;
 717     int i;
 718
 719     if (!(list = WIN_ListChildren( hwnd ))) return;
 720     for (i = 0; list[i]; i++)
 721     {
 722         if (WIN_IsCurrentThread( list[i] ))
 723             DestroyWindow( list[i] );
 724         else
 725             WIN_DestroyThreadWindows( list[i] );
 726     }
 727     HeapFree( GetProcessHeap(), 0, list );
 728 }
 729
 730 /***********************************************************************
 731  *           WIN_CreateDesktopWindow
 732  *
 733  * Create the desktop window.
 734  */
 735 BOOL WIN_CreateDesktopWindow(void)
 736 {
 737     struct tagCLASS *class;
 738     HWND hwndDesktop;
 739     INT wndExtra;
 740     DWORD clsStyle;
 741     WNDPROC winproc;
 742     DCE *dce;
 743     CREATESTRUCTA cs;
 744     RECT rect;
 745
 746     TRACE("Creating desktop window\n");
 747
 748     if (!WINPOS_CreateInternalPosAtom() ||
 749         !(class = CLASS_AddWindow( (ATOM)LOWORD(DESKTOP_CLASS_ATOM), 0, WIN_PROC_32W,
 750                                    &wndExtra, &winproc, &clsStyle, &dce )))
 751         return FALSE;
 752
 753     pWndDesktop = create_window_handle( 0, 0, LOWORD(DESKTOP_CLASS_ATOM),
 754                                         sizeof(WND) + wndExtra - sizeof(pWndDesktop->wExtra) );
 755     if (!pWndDesktop) return FALSE;
 756     hwndDesktop = pWndDesktop->hwndSelf;
 757
 758     pWndDesktop->tid               = 0;  /* nobody owns the desktop */
 759     pWndDesktop->parent            = 0;
 760     pWndDesktop->owner             = 0;
 761     pWndDesktop->class             = class;
 762     pWndDesktop->text              = NULL;
 763     pWndDesktop->hrgnUpdate        = 0;
 764     pWndDesktop->clsStyle          = clsStyle;
 765     pWndDesktop->dce               = NULL;
 766     pWndDesktop->pVScroll          = NULL;
 767     pWndDesktop->pHScroll          = NULL;
 768     pWndDesktop->helpContext       = 0;
 769     pWndDesktop->flags             = 0;
 770     pWndDesktop->hSysMenu          = 0;
 771     pWndDesktop->winproc           = winproc;
 772     pWndDesktop->cbWndExtra        = wndExtra;
 773
 774     cs.lpCreateParams = NULL;
 775     cs.hInstance      = 0;
 776     cs.hMenu          = 0;
 777     cs.hwndParent     = 0;
 778     cs.x              = 0;
 779     cs.y              = 0;
 780     cs.cx             = GetSystemMetrics( SM_CXSCREEN );
 781     cs.cy             = GetSystemMetrics( SM_CYSCREEN );
 782     cs.style          = pWndDesktop->dwStyle;
 783     cs.dwExStyle      = pWndDesktop->dwExStyle;
 784     cs.lpszName       = NULL;
 785     cs.lpszClass      = DESKTOP_CLASS_ATOM;
 786
 787     SetRect( &rect, 0, 0, cs.cx, cs.cy );
 788     WIN_SetRectangles( hwndDesktop, &rect, &rect );
 789
 790     SERVER_START_REQ( set_window_info )
 791     {
 792         req->handle = hwndDesktop;
 793         req->flags  = 0;  /* don't set anything, just retrieve */
 794         wine_server_call( req );
 795         pWndDesktop->dwStyle   = reply->old_style;
 796         pWndDesktop->dwExStyle = reply->old_ex_style;
 797         pWndDesktop->hInstance = (ULONG_PTR)reply->old_instance;
 798         pWndDesktop->userdata  = (ULONG_PTR)reply->old_user_data;
 799         pWndDesktop->wIDmenu   = reply->old_id;
 800     }
 801     SERVER_END_REQ;
 802
 803     if (!USER_Driver.pCreateWindow( hwndDesktop, &cs, FALSE ))
 804     {
 805         WIN_ReleaseWndPtr( pWndDesktop );
 806         return FALSE;
 807     }
 808
 809     pWndDesktop->flags |= WIN_NEEDS_ERASEBKGND;
 810     WIN_ReleaseWndPtr( pWndDesktop );
 811     return TRUE;
 812 }
 813
 814
 815 /***********************************************************************
 816  *           WIN_FixCoordinates
 817  *
 818  * Fix the coordinates - Helper for WIN_CreateWindowEx.
 819  * returns default show mode in sw.
 820  * Note: the feature presented as undocumented *is* in the MSDN since 1993.
 821  */
 822 static void WIN_FixCoordinates( CREATESTRUCTA *cs, INT *sw)
 823 {
 824     if (cs->x == CW_USEDEFAULT || cs->x == CW_USEDEFAULT16 ||
 825         cs->cx == CW_USEDEFAULT || cs->cx == CW_USEDEFAULT16)
 826     {
 827         if (cs->style & (WS_CHILD | WS_POPUP))
 828         {
 829             if (cs->x == CW_USEDEFAULT || cs->x == CW_USEDEFAULT16) cs->x = cs->y = 0;
 830             if (cs->cx == CW_USEDEFAULT || cs->cx == CW_USEDEFAULT16) cs->cx = cs->cy = 0;
 831         }
 832         else  /* overlapped window */
 833         {
 834             STARTUPINFOA info;
 835
 836             GetStartupInfoA( &info );
 837
 838             if (cs->x == CW_USEDEFAULT || cs->x == CW_USEDEFAULT16)
 839             {
 840                 /* Never believe Microsoft's documentation... CreateWindowEx doc says
 841                  * that if an overlapped window is created with WS_VISIBLE style bit
 842                  * set and the x parameter is set to CW_USEDEFAULT, the system ignores
 843                  * the y parameter. However, disassembling NT implementation (WIN32K.SYS)
 844                  * reveals that
 845                  *
 846                  * 1) not only it checks for CW_USEDEFAULT but also for CW_USEDEFAULT16
 847                  * 2) it does not ignore the y parameter as the docs claim; instead, it
 848                  *    uses it as second parameter to ShowWindow() unless y is either
 849                  *    CW_USEDEFAULT or CW_USEDEFAULT16.
 850                  *
 851                  * The fact that we didn't do 2) caused bogus windows pop up when wine
 852                  * was running apps that were using this obscure feature. Example -
 853                  * calc.exe that comes with Win98 (only Win98, it's different from
 854                  * the one that comes with Win95 and NT)
 855                  */
 856                 if (cs->y != CW_USEDEFAULT && cs->y != CW_USEDEFAULT16) *sw = cs->y;
 857                 cs->x = (info.dwFlags & STARTF_USEPOSITION) ? info.dwX : 0;
 858                 cs->y = (info.dwFlags & STARTF_USEPOSITION) ? info.dwY : 0;
 859             }
 860
 861             if (cs->cx == CW_USEDEFAULT || cs->cx == CW_USEDEFAULT16)
 862             {
 863                 if (info.dwFlags & STARTF_USESIZE)
 864                 {
 865                     cs->cx = info.dwXSize;
 866                     cs->cy = info.dwYSize;
 867                 }
 868                 else  /* if no other hint from the app, pick 3/4 of the screen real estate */
 869                 {
 870                     RECT r;
 871                     SystemParametersInfoA( SPI_GETWORKAREA, 0, &r, 0);
 872                     cs->cx = (((r.right - r.left) * 3) / 4) - cs->x;
 873                     cs->cy = (((r.bottom - r.top) * 3) / 4) - cs->y;
 874                 }
 875             }
 876         }
 877     }
 878     else
 879     {
 880         /* neither x nor cx are default. Check the y values .
 881          * In the trace we see Outlook and Outlook Express using
 882          * cy set to CW_USEDEFAULT when opening the address book.
 883          */
 884         if (cs->cy == CW_USEDEFAULT || cs->cy == CW_USEDEFAULT16) {
 885             RECT r;
 886             FIXME("Strange use of CW_USEDEFAULT in nHeight\n");
 887             SystemParametersInfoA( SPI_GETWORKAREA, 0, &r, 0);
 888             cs->cy = (((r.bottom - r.top) * 3) / 4) - cs->y;
 889         }
 890     }
 891 }
 892
 893 /***********************************************************************
 894  *           dump_window_styles
 895  */
 896 static void dump_window_styles( DWORD style, DWORD exstyle )
 897 {
 898     TRACE( "style:" );
 899     if(style & WS_POPUP) DPRINTF(" WS_POPUP");
 900     if(style & WS_CHILD) DPRINTF(" WS_CHILD");
 901     if(style & WS_MINIMIZE) DPRINTF(" WS_MINIMIZE");
 902     if(style & WS_VISIBLE) DPRINTF(" WS_VISIBLE");
 903     if(style & WS_DISABLED) DPRINTF(" WS_DISABLED");
 904     if(style & WS_CLIPSIBLINGS) DPRINTF(" WS_CLIPSIBLINGS");
 905     if(style & WS_CLIPCHILDREN) DPRINTF(" WS_CLIPCHILDREN");
 906     if(style & WS_MAXIMIZE) DPRINTF(" WS_MAXIMIZE");
 907     if((style & WS_CAPTION) == WS_CAPTION) DPRINTF(" WS_CAPTION");
 908     else
 909     {
 910         if(style & WS_BORDER) DPRINTF(" WS_BORDER");
 911         if(style & WS_DLGFRAME) DPRINTF(" WS_DLGFRAME");
 912     }
 913     if(style & WS_VSCROLL) DPRINTF(" WS_VSCROLL");
 914     if(style & WS_HSCROLL) DPRINTF(" WS_HSCROLL");
 915     if(style & WS_SYSMENU) DPRINTF(" WS_SYSMENU");
 916     if(style & WS_THICKFRAME) DPRINTF(" WS_THICKFRAME");
 917     if(style & WS_GROUP) DPRINTF(" WS_GROUP");
 918     if(style & WS_TABSTOP) DPRINTF(" WS_TABSTOP");
 919     if(style & WS_MINIMIZEBOX) DPRINTF(" WS_MINIMIZEBOX");
 920     if(style & WS_MAXIMIZEBOX) DPRINTF(" WS_MAXIMIZEBOX");
 921
 922     /* FIXME: Add dumping of BS_/ES_/SBS_/LBS_/CBS_/DS_/etc. styles */
 923 #define DUMPED_STYLES \
 924     (WS_POPUP | \
 925      WS_CHILD | \
 926      WS_MINIMIZE | \
 927      WS_VISIBLE | \
 928      WS_DISABLED | \
 929      WS_CLIPSIBLINGS | \
 930      WS_CLIPCHILDREN | \
 931      WS_MAXIMIZE | \
 932      WS_BORDER | \
 933      WS_DLGFRAME | \
 934      WS_VSCROLL | \
 935      WS_HSCROLL | \
 936      WS_SYSMENU | \
 937      WS_THICKFRAME | \
 938      WS_GROUP | \
 939      WS_TABSTOP | \
 940      WS_MINIMIZEBOX | \
 941      WS_MAXIMIZEBOX)
 942
 943     if(style & ~DUMPED_STYLES) DPRINTF(" %08lx", style & ~DUMPED_STYLES);
 944     DPRINTF("\n");
 945 #undef DUMPED_STYLES
 946
 947     TRACE( "exstyle:" );
 948     if(exstyle & WS_EX_DLGMODALFRAME) DPRINTF(" WS_EX_DLGMODALFRAME");
 949     if(exstyle & WS_EX_DRAGDETECT) DPRINTF(" WS_EX_DRAGDETECT");
 950     if(exstyle & WS_EX_NOPARENTNOTIFY) DPRINTF(" WS_EX_NOPARENTNOTIFY");
 951     if(exstyle & WS_EX_TOPMOST) DPRINTF(" WS_EX_TOPMOST");
 952     if(exstyle & WS_EX_ACCEPTFILES) DPRINTF(" WS_EX_ACCEPTFILES");
 953     if(exstyle & WS_EX_TRANSPARENT) DPRINTF(" WS_EX_TRANSPARENT");
 954     if(exstyle & WS_EX_MDICHILD) DPRINTF(" WS_EX_MDICHILD");
 955     if(exstyle & WS_EX_TOOLWINDOW) DPRINTF(" WS_EX_TOOLWINDOW");
 956     if(exstyle & WS_EX_WINDOWEDGE) DPRINTF(" WS_EX_WINDOWEDGE");
 957     if(exstyle & WS_EX_CLIENTEDGE) DPRINTF(" WS_EX_CLIENTEDGE");
 958     if(exstyle & WS_EX_CONTEXTHELP) DPRINTF(" WS_EX_CONTEXTHELP");
 959     if(exstyle & WS_EX_RIGHT) DPRINTF(" WS_EX_RIGHT");
 960     if(exstyle & WS_EX_RTLREADING) DPRINTF(" WS_EX_RTLREADING");
 961     if(exstyle & WS_EX_LEFTSCROLLBAR) DPRINTF(" WS_EX_LEFTSCROLLBAR");
 962     if(exstyle & WS_EX_CONTROLPARENT) DPRINTF(" WS_EX_CONTROLPARENT");
 963     if(exstyle & WS_EX_STATICEDGE) DPRINTF(" WS_EX_STATICEDGE");
 964     if(exstyle & WS_EX_APPWINDOW) DPRINTF(" WS_EX_APPWINDOW");
 965     if(exstyle & WS_EX_LAYERED) DPRINTF(" WS_EX_LAYERED");
 966
 967 #define DUMPED_EX_STYLES \
 968     (WS_EX_DLGMODALFRAME | \
 969      WS_EX_DRAGDETECT | \
 970      WS_EX_NOPARENTNOTIFY | \
 971      WS_EX_TOPMOST | \
 972      WS_EX_ACCEPTFILES | \
 973      WS_EX_TRANSPARENT | \
 974      WS_EX_MDICHILD | \
 975      WS_EX_TOOLWINDOW | \
 976      WS_EX_WINDOWEDGE | \
 977      WS_EX_CLIENTEDGE | \
 978      WS_EX_CONTEXTHELP | \
 979      WS_EX_RIGHT | \
 980      WS_EX_RTLREADING | \
 981      WS_EX_LEFTSCROLLBAR | \
 982      WS_EX_CONTROLPARENT | \
 983      WS_EX_STATICEDGE | \
 984      WS_EX_APPWINDOW | \
 985      WS_EX_LAYERED)
 986
 987     if(exstyle & ~DUMPED_EX_STYLES) DPRINTF(" %08lx", exstyle & ~DUMPED_EX_STYLES);
 988     DPRINTF("\n");
 989 #undef DUMPED_EX_STYLES
 990 }
 991
 992
 993 /***********************************************************************
 994  *           WIN_CreateWindowEx
 995  *
 996  * Implementation of CreateWindowEx().
 997  */
 998 static HWND WIN_CreateWindowEx( CREATESTRUCTA *cs, ATOM classAtom,
 999                                 WINDOWPROCTYPE type )
1000 {
1001     INT sw = SW_SHOW;
1002     struct tagCLASS *classPtr;
1003     WND *wndPtr;
1004     HWND hwnd, parent, owner;
1005     INT wndExtra;
1006     DWORD clsStyle;
1007     WNDPROC winproc;
1008     DCE *dce;
1009     BOOL unicode = (type == WIN_PROC_32W);
1010
1011     TRACE("%s %s ex=%08lx style=%08lx %d,%d %dx%d parent=%04x menu=%04x inst=%08x params=%p\n",
1012           (type == WIN_PROC_32W) ? debugstr_w((LPWSTR)cs->lpszName) : debugstr_a(cs->lpszName),
1013           (type == WIN_PROC_32W) ? debugstr_w((LPWSTR)cs->lpszClass) : debugstr_a(cs->lpszClass),
1014           cs->dwExStyle, cs->style, cs->x, cs->y, cs->cx, cs->cy,
1015           cs->hwndParent, cs->hMenu, cs->hInstance, cs->lpCreateParams );
1016
1017     if(TRACE_ON(win)) dump_window_styles( cs->style, cs->dwExStyle );
1018
1019     TRACE("winproc type is %d (%s)\n", type, (type == WIN_PROC_16) ? "WIN_PROC_16" :
1020             ((type == WIN_PROC_32A) ? "WIN_PROC_32A" : "WIN_PROC_32W") );
1021
1022     /* Find the parent window */
1023
1024     parent = GetDesktopWindow();
1025     owner = 0;
1026
1027     if (cs->hwndParent == HWND_MESSAGE)
1028     {
1029       /* native ole32.OleInitialize uses HWND_MESSAGE to create the
1030        * message window (style: WS_POPUP|WS_DISABLED)
1031        */
1032       FIXME("Parent is HWND_MESSAGE\n");
1033     }
1034     else if (cs->hwndParent)
1035     {
1036         /* Make sure parent is valid */
1037         if (!IsWindow( cs->hwndParent ))
1038         {
1039             WARN("Bad parent %04x\n", cs->hwndParent );
1040             return 0;
1041         }
1042         if ((cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
1043             parent = WIN_GetFullHandle(cs->hwndParent);
1044         else
1045             owner = GetAncestor( cs->hwndParent, GA_ROOT );
1046     }
1047     else if ((cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
1048     {
1049         WARN("No parent for child window\n" );
1050         return 0;  /* WS_CHILD needs a parent, but WS_POPUP doesn't */
1051     }
1052
1053     /* Find the window class */
1054     if (!(classPtr = CLASS_AddWindow( classAtom, cs->hInstance, type,
1055                                       &wndExtra, &winproc, &clsStyle, &dce )))
1056     {
1057         WARN("Bad class '%s'\n", cs->lpszClass );
1058         return 0;
1059     }
1060
1061     WIN_FixCoordinates(cs, &sw); /* fix default coordinates */
1062
1063     /* Correct the window style - stage 1
1064      *
1065      * These are patches that appear to affect both the style loaded into the
1066      * WIN structure and passed in the CreateStruct to the WM_CREATE etc.
1067      *
1068      * WS_EX_WINDOWEDGE appears to be enforced based on the other styles, so
1069      * why does the user get to set it?
1070      */
1071
1072     /* This has been tested for WS_CHILD | WS_VISIBLE.  It has not been
1073      * tested for WS_POPUP
1074      */
1075     if ((cs->dwExStyle & WS_EX_DLGMODALFRAME) ||
1076         ((!(cs->dwExStyle & WS_EX_STATICEDGE)) &&
1077           (cs->style & (WS_DLGFRAME | WS_THICKFRAME))))
1078         cs->dwExStyle |= WS_EX_WINDOWEDGE;
1079     else
1080         cs->dwExStyle &= ~WS_EX_WINDOWEDGE;
1081
1082     /* Create the window structure */
1083
1084     if (!(wndPtr = create_window_handle( parent, owner, classAtom,
1085                                          sizeof(*wndPtr) + wndExtra - sizeof(wndPtr->wExtra) )))
1086     {
1087         TRACE("out of memory\n" );
1088         return 0;
1089     }
1090     hwnd = wndPtr->hwndSelf;
1091
1092     /* Fill the window structure */
1093
1094     wndPtr->tid            = GetCurrentThreadId();
1095     wndPtr->owner          = owner;
1096     wndPtr->parent         = parent;
1097     wndPtr->class          = classPtr;
1098     wndPtr->winproc        = winproc;
1099     wndPtr->hInstance      = cs->hInstance;
1100     wndPtr->text           = NULL;
1101     wndPtr->hrgnUpdate     = 0;
1102     wndPtr->hrgnWnd        = 0;
1103     wndPtr->dwStyle        = cs->style & ~WS_VISIBLE;
1104     wndPtr->dwExStyle      = cs->dwExStyle;
1105     wndPtr->clsStyle       = clsStyle;
1106     wndPtr->wIDmenu        = 0;
1107     wndPtr->helpContext    = 0;
1108     wndPtr->flags          = (type == WIN_PROC_16) ? 0 : WIN_ISWIN32;
1109     wndPtr->pVScroll       = NULL;
1110     wndPtr->pHScroll       = NULL;
1111     wndPtr->userdata       = 0;
1112     wndPtr->hSysMenu       = (wndPtr->dwStyle & WS_SYSMENU)
1113                              ? MENU_GetSysMenu( hwnd, 0 ) : 0;
1114     wndPtr->cbWndExtra     = wndExtra;
1115
1116     if (wndExtra) memset( wndPtr->wExtra, 0, wndExtra);
1117
1118     /* Correct the window style - stage 2 */
1119
1120     if (!(cs->style & WS_CHILD))
1121     {
1122         wndPtr->dwStyle |= WS_CLIPSIBLINGS;
1123         if (!(cs->style & WS_POPUP))
1124         {
1125             wndPtr->dwStyle |= WS_CAPTION;
1126             wndPtr->flags |= WIN_NEED_SIZE;
1127         }
1128     }
1129     SERVER_START_REQ( set_window_info )
1130     {
1131         req->handle    = hwnd;
1132         req->flags     = SET_WIN_STYLE | SET_WIN_EXSTYLE | SET_WIN_INSTANCE;
1133         req->style     = wndPtr->dwStyle;
1134         req->ex_style  = wndPtr->dwExStyle;
1135         req->instance  = (void *)wndPtr->hInstance;
1136         wine_server_call( req );
1137     }
1138     SERVER_END_REQ;
1139
1140     /* Get class or window DC if needed */
1141
1142     if (clsStyle & CS_OWNDC) wndPtr->dce = DCE_AllocDCE(hwnd,DCE_WINDOW_DC);
1143     else if (clsStyle & CS_CLASSDC) wndPtr->dce = dce;
1144     else wndPtr->dce = NULL;
1145
1146     /* Set the window menu */
1147
1148     if ((wndPtr->dwStyle & (WS_CAPTION | WS_CHILD)) == WS_CAPTION )
1149     {
1150         if (cs->hMenu) SetMenu(hwnd, cs->hMenu);
1151         else
1152         {
1153             LPCSTR menuName = (LPCSTR)GetClassLongA( hwnd, GCL_MENUNAME );
1154             if (menuName)
1155             {
1156                 if (HIWORD(cs->hInstance))
1157                     cs->hMenu = LoadMenuA(cs->hInstance,menuName);
1158                 else
1159                     cs->hMenu = LoadMenu16(cs->hInstance,menuName);
1160
1161                 if (cs->hMenu) SetMenu( hwnd, cs->hMenu );
1162             }
1163         }
1164     }
1165     else SetWindowLongW( hwnd, GWL_ID, (UINT)cs->hMenu );
1166     WIN_ReleaseWndPtr( wndPtr );
1167
1168     if (!USER_Driver.pCreateWindow( hwnd, cs, unicode))
1169     {
1170         WIN_DestroyWindow( hwnd );
1171         return 0;
1172     }
1173
1174     /* Notify the parent window only */
1175
1176     send_parent_notify( hwnd, WM_CREATE );
1177     if (!IsWindow( hwnd )) return 0;
1178
1179     if (cs->style & WS_VISIBLE)
1180     {
1181         /* in case WS_VISIBLE got set in the meantime */
1182         if (!(wndPtr = WIN_GetPtr( hwnd ))) return 0;
1183         WIN_SetStyle( hwnd, wndPtr->dwStyle & ~WS_VISIBLE );
1184         WIN_ReleasePtr( wndPtr );
1185         ShowWindow( hwnd, sw );
1186     }
1187
1188     /* Call WH_SHELL hook */
1189
1190     if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) && !GetWindow( hwnd, GW_OWNER ))
1191         HOOK_CallHooksA( WH_SHELL, HSHELL_WINDOWCREATED, (WPARAM)hwnd, 0 );
1192
1193     TRACE("created window %04x\n", hwnd);
1194     return hwnd;
1195 }
1196
1197
1198 /***********************************************************************
1199  *              CreateWindow (USER.41)
1200  */
1201 HWND16 WINAPI CreateWindow16( LPCSTR className, LPCSTR windowName,
1202                               DWORD style, INT16 x, INT16 y, INT16 width,
1203                               INT16 height, HWND16 parent, HMENU16 menu,
1204                               HINSTANCE16 instance, LPVOID data )
1205 {
1206     return CreateWindowEx16( 0, className, windowName, style,
1207                            x, y, width, height, parent, menu, instance, data );
1208 }
1209
1210
1211 /***********************************************************************
1212  *              CreateWindowEx (USER.452)
1213  */
1214 HWND16 WINAPI CreateWindowEx16( DWORD exStyle, LPCSTR className,
1215                                 LPCSTR windowName, DWORD style, INT16 x,
1216                                 INT16 y, INT16 width, INT16 height,
1217                                 HWND16 parent, HMENU16 menu,
1218                                 HINSTANCE16 instance, LPVOID data )
1219 {
1220     ATOM classAtom;
1221     CREATESTRUCTA cs;
1222     char buffer[256];
1223
1224     /* Find the class atom */
1225
1226     if (HIWORD(className))
1227     {
1228         if (!(classAtom = GlobalFindAtomA( className )))
1229         {
1230             ERR( "bad class name %s\n", debugstr_a(className) );
1231             return 0;
1232         }
1233     }
1234     else
1235     {
1236         classAtom = LOWORD(className);
1237         if (!GlobalGetAtomNameA( classAtom, buffer, sizeof(buffer) ))
1238         {
1239             ERR( "bad atom %x\n", classAtom);
1240             return 0;
1241         }
1242         className = buffer;
1243     }
1244
1245     /* Fix the coordinates */
1246
1247     cs.x  = (x == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)x;
1248     cs.y  = (y == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)y;
1249     cs.cx = (width == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)width;
1250     cs.cy = (height == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)height;
1251
1252     /* Create the window */
1253
1254     cs.lpCreateParams = data;
1255     cs.hInstance      = (HINSTANCE)instance;
1256     cs.hMenu          = (HMENU)menu;
1257     cs.hwndParent     = WIN_Handle32( parent );
1258     cs.style          = style;
1259     cs.lpszName       = windowName;
1260     cs.lpszClass      = className;
1261     cs.dwExStyle      = exStyle;
1262
1263     return HWND_16( WIN_CreateWindowEx( &cs, classAtom, WIN_PROC_16 ));
1264 }
1265
1266
1267 /***********************************************************************
1268  *              CreateWindowExA (USER32.@)
1269  */
1270 HWND WINAPI CreateWindowExA( DWORD exStyle, LPCSTR className,
1271                                  LPCSTR windowName, DWORD style, INT x,
1272                                  INT y, INT width, INT height,
1273                                  HWND parent, HMENU menu,
1274                                  HINSTANCE instance, LPVOID data )
1275 {
1276     ATOM classAtom;
1277     CREATESTRUCTA cs;
1278     char buffer[256];
1279
1280     if(!instance)
1281         instance=GetModuleHandleA(NULL);
1282
1283     if(exStyle & WS_EX_MDICHILD)
1284         return CreateMDIWindowA(className, windowName, style, x, y, width, height, parent, instance, (LPARAM)data);
1285
1286     /* Find the class atom */
1287
1288     if (HIWORD(className))
1289     {
1290         if (!(classAtom = GlobalFindAtomA( className )))
1291         {
1292             ERR( "bad class name %s\n", debugstr_a(className) );
1293             return 0;
1294         }
1295     }
1296     else
1297     {
1298         classAtom = LOWORD(className);
1299         if (!GlobalGetAtomNameA( classAtom, buffer, sizeof(buffer) ))
1300         {
1301             ERR( "bad atom %x\n", classAtom);
1302             return 0;
1303         }
1304         className = buffer;
1305     }
1306
1307     /* Create the window */
1308
1309     cs.lpCreateParams = data;
1310     cs.hInstance      = instance;
1311     cs.hMenu          = menu;
1312     cs.hwndParent     = parent;
1313     cs.x              = x;
1314     cs.y              = y;
1315     cs.cx             = width;
1316     cs.cy             = height;
1317     cs.style          = style;
1318     cs.lpszName       = windowName;
1319     cs.lpszClass      = className;
1320     cs.dwExStyle      = exStyle;
1321
1322     return WIN_CreateWindowEx( &cs, classAtom, WIN_PROC_32A );
1323 }
1324
1325
1326 /***********************************************************************
1327  *              CreateWindowExW (USER32.@)
1328  */
1329 HWND WINAPI CreateWindowExW( DWORD exStyle, LPCWSTR className,
1330                                  LPCWSTR windowName, DWORD style, INT x,
1331                                  INT y, INT width, INT height,
1332                                  HWND parent, HMENU menu,
1333                                  HINSTANCE instance, LPVOID data )
1334 {
1335     ATOM classAtom;
1336     CREATESTRUCTW cs;
1337     WCHAR buffer[256];
1338
1339     if(!instance)
1340         instance=GetModuleHandleA(NULL);
1341
1342     if(exStyle & WS_EX_MDICHILD)
1343         return CreateMDIWindowW(className, windowName, style, x, y, width, height, parent, instance, (LPARAM)data);
1344
1345     /* Find the class atom */
1346
1347     if (HIWORD(className))
1348     {
1349         if (!(classAtom = GlobalFindAtomW( className )))
1350         {
1351             ERR( "bad class name %s\n", debugstr_w(className) );
1352             return 0;
1353         }
1354     }
1355     else
1356     {
1357         classAtom = LOWORD(className);
1358         if (!GlobalGetAtomNameW( classAtom, buffer, sizeof(buffer)/sizeof(WCHAR) ))
1359         {
1360             ERR( "bad atom %x\n", classAtom);
1361             return 0;
1362         }
1363         className = buffer;
1364     }
1365
1366     /* Create the window */
1367
1368     cs.lpCreateParams = data;
1369     cs.hInstance      = instance;
1370     cs.hMenu          = menu;
1371     cs.hwndParent     = parent;
1372     cs.x              = x;
1373     cs.y              = y;
1374     cs.cx             = width;
1375     cs.cy             = height;
1376     cs.style          = style;
1377     cs.lpszName       = windowName;
1378     cs.lpszClass      = className;
1379     cs.dwExStyle      = exStyle;
1380
1381     /* Note: we rely on the fact that CREATESTRUCTA and */
1382     /* CREATESTRUCTW have the same layout. */
1383     return WIN_CreateWindowEx( (CREATESTRUCTA *)&cs, classAtom, WIN_PROC_32W );
1384 }
1385
1386
1387 /***********************************************************************
1388  *           WIN_SendDestroyMsg
1389  */
1390 static void WIN_SendDestroyMsg( HWND hwnd )
1391 {
1392     GUITHREADINFO info;
1393
1394     if (GetGUIThreadInfo( GetCurrentThreadId(), &info ))
1395     {
1396         if (hwnd == info.hwndCaret) DestroyCaret();
1397     }
1398     if (USER_Driver.pResetSelectionOwner)
1399         USER_Driver.pResetSelectionOwner( hwnd, TRUE );
1400
1401     /*
1402      * Send the WM_DESTROY to the window.
1403      */
1404     SendMessageA( hwnd, WM_DESTROY, 0, 0);
1405
1406     /*
1407      * This WM_DESTROY message can trigger re-entrant calls to DestroyWindow
1408      * make sure that the window still exists when we come back.
1409      */
1410     if (IsWindow(hwnd))
1411     {
1412         HWND* pWndArray;
1413         int i;
1414
1415         if (!(pWndArray = WIN_ListChildren( hwnd ))) return;
1416
1417         /* start from the end (FIXME: is this needed?) */
1418         for (i = 0; pWndArray[i]; i++) ;
1419
1420         while (--i >= 0)
1421         {
1422             if (IsWindow( pWndArray[i] )) WIN_SendDestroyMsg( pWndArray[i] );
1423         }
1424         HeapFree( GetProcessHeap(), 0, pWndArray );
1425     }
1426     else
1427       WARN("\tdestroyed itself while in WM_DESTROY!\n");
1428 }
1429
1430
1431 /***********************************************************************
1432  *              DestroyWindow (USER32.@)
1433  */
1434 BOOL WINAPI DestroyWindow( HWND hwnd )
1435 {
1436     BOOL is_child;
1437     HWND h;
1438
1439     if (!(hwnd = WIN_IsCurrentThread( hwnd )) || (hwnd == GetDesktopWindow()))
1440     {
1441         SetLastError( ERROR_ACCESS_DENIED );
1442         return FALSE;
1443     }
1444
1445     TRACE("(%04x)\n", hwnd);
1446
1447     /* Look whether the focus is within the tree of windows we will
1448      * be destroying.
1449      */
1450     h = GetFocus();
1451     if (h == hwnd || IsChild( hwnd, h ))
1452     {
1453         HWND parent = GetAncestor( hwnd, GA_PARENT );
1454         if (parent == GetDesktopWindow()) parent = 0;
1455         SetFocus( parent );
1456     }
1457
1458       /* Call hooks */
1459
1460     if( HOOK_CallHooksA( WH_CBT, HCBT_DESTROYWND, (WPARAM)hwnd, 0L) ) return FALSE;
1461
1462     is_child = (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) != 0;
1463
1464     if (is_child)
1465     {
1466         if (!USER_IsExitingThread( GetCurrentThreadId() ))
1467             send_parent_notify( hwnd, WM_DESTROY );
1468     }
1469     else if (!GetWindow( hwnd, GW_OWNER ))
1470     {
1471         HOOK_CallHooksA( WH_SHELL, HSHELL_WINDOWDESTROYED, (WPARAM)hwnd, 0L );
1472         /* FIXME: clean up palette - see "Internals" p.352 */
1473     }
1474
1475     if (!IsWindow(hwnd)) return TRUE;
1476
1477     if (USER_Driver.pResetSelectionOwner)
1478         USER_Driver.pResetSelectionOwner( hwnd, FALSE ); /* before the window is unmapped */
1479
1480       /* Hide the window */
1481
1482     if (!ShowWindow( hwnd, SW_HIDE ))
1483     {
1484         if (hwnd == GetActiveWindow()) WINPOS_ActivateOtherWindow( hwnd );
1485     }
1486     if (!IsWindow(hwnd)) return TRUE;
1487
1488       /* Recursively destroy owned windows */
1489
1490     if (!is_child)
1491     {
1492         for (;;)
1493         {
1494             int i, got_one = 0;
1495             HWND *list = WIN_ListChildren( GetDesktopWindow() );
1496             if (list)
1497             {
1498                 for (i = 0; list[i]; i++)
1499                 {
1500                     if (GetWindow( list[i], GW_OWNER ) != hwnd) continue;
1501                     if (WIN_IsCurrentThread( list[i] ))
1502                     {
1503                         DestroyWindow( list[i] );
1504                         got_one = 1;
1505                         continue;
1506                     }
1507                     WIN_SetOwner( list[i], 0 );
1508                 }
1509                 HeapFree( GetProcessHeap(), 0, list );
1510             }
1511             if (!got_one) break;
1512         }
1513     }
1514
1515       /* Send destroy messages */
1516
1517     WIN_SendDestroyMsg( hwnd );
1518     if (!IsWindow( hwnd )) return TRUE;
1519
1520       /* Unlink now so we won't bother with the children later on */
1521
1522     WIN_UnlinkWindow( hwnd );
1523
1524       /* Destroy the window storage */
1525
1526     WIN_DestroyWindow( hwnd );
1527     return TRUE;
1528 }
1529
1530
1531 /***********************************************************************
1532  *              CloseWindow (USER32.@)
1533  */
1534 BOOL WINAPI CloseWindow( HWND hwnd )
1535 {
1536     if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) return FALSE;
1537     ShowWindow( hwnd, SW_MINIMIZE );
1538     return TRUE;
1539 }
1540
1541
1542 /***********************************************************************
1543  *              OpenIcon (USER32.@)
1544  */
1545 BOOL WINAPI OpenIcon( HWND hwnd )
1546 {
1547     if (!IsIconic( hwnd )) return FALSE;
1548     ShowWindow( hwnd, SW_SHOWNORMAL );
1549     return TRUE;
1550 }
1551
1552
1553 /***********************************************************************
1554  *           WIN_FindWindow
1555  *
1556  * Implementation of FindWindow() and FindWindowEx().
1557  */
1558 static HWND WIN_FindWindow( HWND parent, HWND child, ATOM className, LPCWSTR title )
1559 {
1560     HWND *list = NULL;
1561     HWND retvalue = 0;
1562     int i = 0, len = 0;
1563     WCHAR *buffer = NULL;
1564
1565     if (!parent) parent = GetDesktopWindow();
1566     if (title)
1567     {
1568         len = strlenW(title) + 1;  /* one extra char to check for chars beyond the end */
1569         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) ))) return 0;
1570     }
1571
1572     if (!(list = list_window_children( parent, className, 0 ))) goto done;
1573
1574     if (child)
1575     {
1576         child = WIN_GetFullHandle( child );
1577         while (list[i] && list[i] != child) i++;
1578         if (!list[i]) goto done;
1579         i++;  /* start from next window */
1580     }
1581
1582     if (title)
1583     {
1584         while (list[i])
1585         {
1586             if (GetWindowTextW( list[i], buffer, len ) && !strcmpiW( buffer, title )) break;
1587             i++;
1588         }
1589     }
1590     retvalue = list[i];
1591
1592  done:
1593     if (list) HeapFree( GetProcessHeap(), 0, list );
1594     if (buffer) HeapFree( GetProcessHeap(), 0, buffer );
1595     return retvalue;
1596 }
1597
1598
1599
1600 /***********************************************************************
1601  *              FindWindowA (USER32.@)
1602  */
1603 HWND WINAPI FindWindowA( LPCSTR className, LPCSTR title )
1604 {
1605     HWND ret = FindWindowExA( 0, 0, className, title );
1606     if (!ret) SetLastError (ERROR_CANNOT_FIND_WND_CLASS);
1607     return ret;
1608 }
1609
1610
1611 /***********************************************************************
1612  *              FindWindowExA (USER32.@)
1613  */
1614 HWND WINAPI FindWindowExA( HWND parent, HWND child,
1615                                LPCSTR className, LPCSTR title )
1616 {
1617     ATOM atom = 0;
1618     LPWSTR buffer;
1619     HWND hwnd;
1620     INT len;
1621
1622     if (className)
1623     {
1624         /* If the atom doesn't exist, then no class */
1625         /* with this name exists either. */
1626         if (!(atom = GlobalFindAtomA( className )))
1627         {
1628             SetLastError (ERROR_CANNOT_FIND_WND_CLASS);
1629             return 0;
1630         }
1631     }
1632     if (!title) return WIN_FindWindow( parent, child, atom, NULL );
1633
1634     len = MultiByteToWideChar( CP_ACP, 0, title, -1, NULL, 0 );
1635     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return 0;
1636     MultiByteToWideChar( CP_ACP, 0, title, -1, buffer, len );
1637     hwnd = WIN_FindWindow( parent, child, atom, buffer );
1638     HeapFree( GetProcessHeap(), 0, buffer );
1639     return hwnd;
1640 }
1641
1642
1643 /***********************************************************************
1644  *              FindWindowExW (USER32.@)
1645  */
1646 HWND WINAPI FindWindowExW( HWND parent, HWND child,
1647                                LPCWSTR className, LPCWSTR title )
1648 {
1649     ATOM atom = 0;
1650
1651     if (className)
1652     {
1653         /* If the atom doesn't exist, then no class */
1654         /* with this name exists either. */
1655         if (!(atom = GlobalFindAtomW( className )))
1656         {
1657             SetLastError (ERROR_CANNOT_FIND_WND_CLASS);
1658             return 0;
1659         }
1660     }
1661     return WIN_FindWindow( parent, child, atom, title );
1662 }
1663
1664
1665 /***********************************************************************
1666  *              FindWindowW (USER32.@)
1667  */
1668 HWND WINAPI FindWindowW( LPCWSTR className, LPCWSTR title )
1669 {
1670     return FindWindowExW( 0, 0, className, title );
1671 }
1672
1673
1674 /**********************************************************************
1675  *              GetDesktopWindow (USER32.@)
1676  */
1677 HWND WINAPI GetDesktopWindow(void)
1678 {
1679     if (pWndDesktop) return pWndDesktop->hwndSelf;
1680     ERR( "Wine init error: either you're trying to use an invalid native USER.EXE config, or some graphics/GUI libraries or DLLs didn't initialize properly. Aborting.\n" );
1681     ExitProcess(1);
1682     return 0;
1683 }
1684
1685
1686 /*******************************************************************
1687  *              EnableWindow (USER32.@)
1688  */
1689 BOOL WINAPI EnableWindow( HWND hwnd, BOOL enable )
1690 {
1691     WND *wndPtr;
1692     BOOL retvalue;
1693     LONG style;
1694     HWND full_handle;
1695
1696     if (!(full_handle = WIN_IsCurrentThread( hwnd )))
1697         return SendMessageW( hwnd, WM_WINE_ENABLEWINDOW, enable, 0 );
1698
1699     hwnd = full_handle;
1700
1701     TRACE("( %x, %d )\n", hwnd, enable);
1702
1703     if (!(wndPtr = WIN_GetPtr( hwnd ))) return FALSE;
1704     style = wndPtr->dwStyle;
1705     retvalue = ((style & WS_DISABLED) != 0);
1706     WIN_ReleasePtr( wndPtr );
1707
1708     if (enable && retvalue)
1709     {
1710         WIN_SetStyle( hwnd, style & ~WS_DISABLED );
1711         SendMessageA( hwnd, WM_ENABLE, TRUE, 0 );
1712     }
1713     else if (!enable && !retvalue)
1714     {
1715         SendMessageA( hwnd, WM_CANCELMODE, 0, 0);
1716
1717         WIN_SetStyle( hwnd, style | WS_DISABLED );
1718
1719         if (hwnd == GetFocus() || IsChild(hwnd, GetFocus()))
1720             SetFocus( 0 );  /* A disabled window can't have the focus */
1721
1722         if (hwnd == GetCapture() || IsChild(hwnd, GetCapture()))
1723             ReleaseCapture();  /* A disabled window can't capture the mouse */
1724
1725         SendMessageA( hwnd, WM_ENABLE, FALSE, 0 );
1726     }
1727     return retvalue;
1728 }
1729
1730
1731 /***********************************************************************
1732  *              IsWindowEnabled (USER32.@)
1733  */
1734 BOOL WINAPI IsWindowEnabled(HWND hWnd)
1735 {
1736     return !(GetWindowLongW( hWnd, GWL_STYLE ) & WS_DISABLED);
1737 }
1738
1739
1740 /***********************************************************************
1741  *              IsWindowUnicode (USER32.@)
1742  */
1743 BOOL WINAPI IsWindowUnicode( HWND hwnd )
1744 {
1745     WND * wndPtr;
1746     BOOL retvalue;
1747
1748     if (!(wndPtr = WIN_FindWndPtr(hwnd))) return FALSE;
1749     retvalue = (WINPROC_GetProcType( wndPtr->winproc ) == WIN_PROC_32W);
1750     WIN_ReleaseWndPtr(wndPtr);
1751     return retvalue;
1752 }
1753
1754
1755 /**********************************************************************
1756  *              GetWindowWord (USER32.@)
1757  */
1758 WORD WINAPI GetWindowWord( HWND hwnd, INT offset )
1759 {
1760     if (offset >= 0)
1761     {
1762         WORD retvalue = 0;
1763         WND *wndPtr = WIN_GetPtr( hwnd );
1764         if (!wndPtr)
1765         {
1766             SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1767             return 0;
1768         }
1769         if (wndPtr == WND_OTHER_PROCESS)
1770         {
1771             if (IsWindow( hwnd ))
1772                 FIXME( "(%d) not supported yet on other process window %x\n", offset, hwnd );
1773             SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1774             return 0;
1775         }
1776         if (offset > wndPtr->cbWndExtra - sizeof(WORD))
1777         {
1778             WARN("Invalid offset %d\n", offset );
1779             SetLastError( ERROR_INVALID_INDEX );
1780         }
1781         else retvalue = *(WORD *)(((char *)wndPtr->wExtra) + offset);
1782         WIN_ReleasePtr( wndPtr );
1783         return retvalue;
1784     }
1785
1786     switch(offset)
1787     {
1788     case GWL_HWNDPARENT:
1789         return GetWindowLongW( hwnd, offset );
1790     case GWL_ID:
1791     case GWL_HINSTANCE:
1792         {
1793             LONG ret = GetWindowLongW( hwnd, offset );
1794             if (HIWORD(ret))
1795                 WARN("%d: discards high bits of 0x%08lx!\n", offset, ret );
1796             return LOWORD(ret);
1797         }
1798     default:
1799         WARN("Invalid offset %d\n", offset );
1800         return 0;
1801     }
1802 }
1803
1804
1805 /**********************************************************************
1806  *              SetWindowWord (USER32.@)
1807  */
1808 WORD WINAPI SetWindowWord( HWND hwnd, INT offset, WORD newval )
1809 {
1810     WORD *ptr, retval;
1811     WND * wndPtr;
1812
1813     switch(offset)
1814     {
1815     case GWL_ID:
1816     case GWL_HINSTANCE:
1817     case GWL_HWNDPARENT:
1818         return SetWindowLongW( hwnd, offset, (UINT)newval );
1819     default:
1820         if (offset < 0)
1821         {
1822             WARN("Invalid offset %d\n", offset );
1823             SetLastError( ERROR_INVALID_INDEX );
1824             return 0;
1825         }
1826     }
1827
1828     wndPtr = WIN_GetPtr( hwnd );
1829     if (wndPtr == WND_OTHER_PROCESS)
1830     {
1831         if (IsWindow(hwnd))
1832             FIXME( "set %d <- %x not supported yet on other process window %x\n",
1833                    offset, newval, hwnd );
1834         wndPtr = NULL;
1835     }
1836     if (!wndPtr)
1837     {
1838        SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1839        return 0;
1840     }
1841
1842     if (offset > wndPtr->cbWndExtra - sizeof(WORD))
1843     {
1844         WARN("Invalid offset %d\n", offset );
1845         WIN_ReleasePtr(wndPtr);
1846         SetLastError( ERROR_INVALID_INDEX );
1847         return 0;
1848     }
1849     ptr = (WORD *)(((char *)wndPtr->wExtra) + offset);
1850     retval = *ptr;
1851     *ptr = newval;
1852     WIN_ReleasePtr(wndPtr);
1853     return retval;
1854 }
1855
1856
1857 /**********************************************************************
1858  *           WIN_GetWindowLong
1859  *
1860  * Helper function for GetWindowLong().
1861  */
1862 static LONG WIN_GetWindowLong( HWND hwnd, INT offset, WINDOWPROCTYPE type )
1863 {
1864     LONG retvalue = 0;
1865     WND *wndPtr;
1866
1867     if (offset == GWL_HWNDPARENT)
1868     {
1869         HWND parent = GetAncestor( hwnd, GA_PARENT );
1870         if (parent == GetDesktopWindow()) parent = GetWindow( hwnd, GW_OWNER );
1871         return (LONG)parent;
1872     }
1873
1874     if (!(wndPtr = WIN_GetPtr( hwnd )))
1875     {
1876         SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1877         return 0;
1878     }
1879
1880     if (wndPtr == WND_OTHER_PROCESS)
1881     {
1882         if (offset >= 0)
1883         {
1884             if (IsWindow(hwnd))
1885                 FIXME( "(%d) not supported on other process window %x\n", offset, hwnd );
1886             SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1887             return 0;
1888         }
1889         if (offset == GWL_WNDPROC)
1890         {
1891             SetLastError( ERROR_ACCESS_DENIED );
1892             return 0;
1893         }
1894         SERVER_START_REQ( set_window_info )
1895         {
1896             req->handle = hwnd;
1897             req->flags  = 0;  /* don't set anything, just retrieve */
1898             if (!wine_server_call_err( req ))
1899             {
1900                 switch(offset)
1901                 {
1902                 case GWL_STYLE:     retvalue = reply->old_style; break;
1903                 case GWL_EXSTYLE:   retvalue = reply->old_ex_style; break;
1904                 case GWL_ID:        retvalue = reply->old_id; break;
1905                 case GWL_HINSTANCE: retvalue = (ULONG_PTR)reply->old_instance; break;
1906                 case GWL_USERDATA:  retvalue = (ULONG_PTR)reply->old_user_data; break;
1907                 default:
1908                     SetLastError( ERROR_INVALID_INDEX );
1909                     break;
1910                 }
1911             }
1912         }
1913         SERVER_END_REQ;
1914         return retvalue;
1915     }
1916
1917     /* now we have a valid wndPtr */
1918
1919     if (offset >= 0)
1920     {
1921         if (offset > wndPtr->cbWndExtra - sizeof(LONG))
1922         {
1923           /*
1924             * Some programs try to access last element from 16 bit
1925             * code using illegal offset value. Hopefully this is
1926             * what those programs really expect.
1927             */
1928            if (type == WIN_PROC_16 &&
1929                wndPtr->cbWndExtra >= 4 &&
1930                offset == wndPtr->cbWndExtra - sizeof(WORD))
1931            {
1932                INT offset2 = wndPtr->cbWndExtra - sizeof(LONG);
1933
1934                ERR( "- replaced invalid offset %d with %d\n",
1935                     offset, offset2 );
1936
1937                 retvalue = *(LONG *)(((char *)wndPtr->wExtra) + offset2);
1938                 WIN_ReleasePtr( wndPtr );
1939                 return retvalue;
1940             }
1941             WARN("Invalid offset %d\n", offset );
1942             WIN_ReleasePtr( wndPtr );
1943             SetLastError( ERROR_INVALID_INDEX );
1944             return 0;
1945         }
1946         retvalue = *(LONG *)(((char *)wndPtr->wExtra) + offset);
1947         /* Special case for dialog window procedure */
1948         if ((offset == DWL_DLGPROC) && (wndPtr->flags & WIN_ISDIALOG))
1949             retvalue = (LONG)WINPROC_GetProc( (HWINDOWPROC)retvalue, type );
1950         WIN_ReleasePtr( wndPtr );
1951         return retvalue;
1952     }
1953
1954     switch(offset)
1955     {
1956     case GWL_USERDATA:   retvalue = wndPtr->userdata; break;
1957     case GWL_STYLE:      retvalue = wndPtr->dwStyle; break;
1958     case GWL_EXSTYLE:    retvalue = wndPtr->dwExStyle; break;
1959     case GWL_ID:         retvalue = (LONG)wndPtr->wIDmenu; break;
1960     case GWL_WNDPROC:    retvalue = (LONG)WINPROC_GetProc( wndPtr->winproc, type ); break;
1961     case GWL_HINSTANCE:  retvalue = wndPtr->hInstance; break;
1962     default:
1963         WARN("Unknown offset %d\n", offset );
1964         SetLastError( ERROR_INVALID_INDEX );
1965         break;
1966     }
1967     WIN_ReleasePtr(wndPtr);
1968     return retvalue;
1969 }
1970
1971
1972 /**********************************************************************
1973  *           WIN_SetWindowLong
1974  *
1975  * Helper function for SetWindowLong().
1976  *
1977  * 0 is the failure code. However, in the case of failure SetLastError
1978  * must be set to distinguish between a 0 return value and a failure.
1979  */
1980 static LONG WIN_SetWindowLong( HWND hwnd, INT offset, LONG newval,
1981                                WINDOWPROCTYPE type )
1982 {
1983     LONG retval = 0;
1984     WND *wndPtr;
1985
1986     TRACE( "%x %d %lx %x\n", hwnd, offset, newval, type );
1987
1988     if (!WIN_IsCurrentProcess( hwnd ))
1989     {
1990         if (offset == GWL_WNDPROC)
1991         {
1992             SetLastError( ERROR_ACCESS_DENIED );
1993             return 0;
1994         }
1995         return SendMessageW( hwnd, WM_WINE_SETWINDOWLONG, offset, newval );
1996     }
1997
1998     wndPtr = WIN_GetPtr( hwnd );
1999     if (wndPtr->hwndSelf == GetDesktopWindow())
2000     {
2001         /* can't change anything on the desktop window */
2002         WIN_ReleasePtr( wndPtr );
2003         SetLastError( ERROR_ACCESS_DENIED );
2004         return 0;
2005     }
2006
2007     if (offset >= 0)
2008     {
2009         LONG *ptr = (LONG *)(((char *)wndPtr->wExtra) + offset);
2010         if (offset > wndPtr->cbWndExtra - sizeof(LONG))
2011         {
2012             WARN("Invalid offset %d\n", offset );
2013             WIN_ReleasePtr( wndPtr );
2014             SetLastError( ERROR_INVALID_INDEX );
2015             return 0;
2016         }
2017         /* Special case for dialog window procedure */
2018         if ((offset == DWL_DLGPROC) && (wndPtr->flags & WIN_ISDIALOG))
2019         {
2020             retval = (LONG)WINPROC_GetProc( (HWINDOWPROC)*ptr, type );
2021             WINPROC_SetProc( (HWINDOWPROC *)ptr, (WNDPROC16)newval,
2022                              type, WIN_PROC_WINDOW );
2023             WIN_ReleasePtr( wndPtr );
2024             return retval;
2025         }
2026         retval = *ptr;
2027         *ptr = newval;
2028         WIN_ReleasePtr( wndPtr );
2029     }
2030     else
2031     {
2032         STYLESTRUCT style;
2033         BOOL ok;
2034
2035         /* first some special cases */
2036         switch( offset )
2037         {
2038         case GWL_STYLE:
2039         case GWL_EXSTYLE:
2040             style.styleOld = wndPtr->dwStyle;
2041             style.styleNew = newval;
2042             WIN_ReleasePtr( wndPtr );
2043             SendMessageW( hwnd, WM_STYLECHANGING, offset, (LPARAM)&style );
2044             if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return 0;
2045             newval = style.styleNew;
2046             break;
2047         case GWL_HWNDPARENT:
2048             if (wndPtr->parent == GetDesktopWindow())
2049             {
2050                 WIN_ReleasePtr( wndPtr );
2051                 return (LONG)WIN_SetOwner( hwnd, (HWND)newval );
2052             }
2053             else
2054             {
2055                 WIN_ReleasePtr( wndPtr );
2056                 return (LONG)SetParent( hwnd, (HWND)newval );
2057             }
2058         case GWL_WNDPROC:
2059             retval = (LONG)WINPROC_GetProc( wndPtr->winproc, type );
2060             WINPROC_SetProc( &wndPtr->winproc, (WNDPROC16)newval,
2061                              type, WIN_PROC_WINDOW );
2062             WIN_ReleasePtr( wndPtr );
2063             return retval;
2064         case GWL_ID:
2065         case GWL_HINSTANCE:
2066         case GWL_USERDATA:
2067             break;
2068         default:
2069             WIN_ReleasePtr( wndPtr );
2070             WARN("Invalid offset %d\n", offset );
2071             SetLastError( ERROR_INVALID_INDEX );
2072             return 0;
2073         }
2074
2075         SERVER_START_REQ( set_window_info )
2076         {
2077             req->handle = hwnd;
2078             switch(offset)
2079             {
2080             case GWL_STYLE:
2081                 req->flags = SET_WIN_STYLE;
2082                 req->style = newval;
2083                 break;
2084             case GWL_EXSTYLE:
2085                 req->flags = SET_WIN_EXSTYLE;
2086                 req->ex_style = newval;
2087                 break;
2088             case GWL_ID:
2089                 req->flags = SET_WIN_ID;
2090                 req->id = newval;
2091                 break;
2092             case GWL_HINSTANCE:
2093                 req->flags = SET_WIN_INSTANCE;
2094                 req->instance = (void *)newval;
2095                 break;
2096             case GWL_USERDATA:
2097                 req->flags = SET_WIN_USERDATA;
2098                 req->user_data = (void *)newval;
2099                 break;
2100             }
2101             if ((ok = !wine_server_call_err( req )))
2102             {
2103                 switch(offset)
2104                 {
2105                 case GWL_STYLE:
2106                     wndPtr->dwStyle = newval;
2107                     retval = reply->old_style;
2108                     break;
2109                 case GWL_EXSTYLE:
2110                     wndPtr->dwExStyle = newval;
2111                     retval = reply->old_ex_style;
2112                     break;
2113                 case GWL_ID:
2114                     wndPtr->wIDmenu = newval;
2115                     retval = reply->old_id;
2116                     break;
2117                 case GWL_HINSTANCE:
2118                     wndPtr->hInstance = newval;
2119                     retval = (HINSTANCE)reply->old_instance;
2120                     break;
2121                 case GWL_USERDATA:
2122                     wndPtr->userdata = newval;
2123                     retval = (ULONG_PTR)reply->old_user_data;
2124                     break;
2125                 }
2126             }
2127         }
2128         SERVER_END_REQ;
2129         WIN_ReleasePtr( wndPtr );
2130
2131         if (!ok) return 0;
2132
2133         if (offset == GWL_STYLE && USER_Driver.pSetWindowStyle)
2134             USER_Driver.pSetWindowStyle( hwnd, retval );
2135
2136         if (offset == GWL_STYLE || offset == GWL_EXSTYLE)
2137             SendMessageW( hwnd, WM_STYLECHANGED, offset, (LPARAM)&style );
2138
2139     }
2140     return retval;
2141 }
2142
2143
2144 /**********************************************************************
2145  *              GetWindowLong (USER.135)
2146  */
2147 LONG WINAPI GetWindowLong16( HWND16 hwnd, INT16 offset )
2148 {
2149     return WIN_GetWindowLong( WIN_Handle32(hwnd), offset, WIN_PROC_16 );
2150 }
2151
2152
2153 /**********************************************************************
2154  *              GetWindowLongA (USER32.@)
2155  */
2156 LONG WINAPI GetWindowLongA( HWND hwnd, INT offset )
2157 {
2158     return WIN_GetWindowLong( hwnd, offset, WIN_PROC_32A );
2159 }
2160
2161
2162 /**********************************************************************
2163  *              GetWindowLongW (USER32.@)
2164  */
2165 LONG WINAPI GetWindowLongW( HWND hwnd, INT offset )
2166 {
2167     return WIN_GetWindowLong( hwnd, offset, WIN_PROC_32W );
2168 }
2169
2170
2171 /**********************************************************************
2172  *              SetWindowLong (USER.136)
2173  */
2174 LONG WINAPI SetWindowLong16( HWND16 hwnd, INT16 offset, LONG newval )
2175 {
2176     return WIN_SetWindowLong( WIN_Handle32(hwnd), offset, newval, WIN_PROC_16 );
2177 }
2178
2179
2180 /**********************************************************************
2181  *              SetWindowLongA (USER32.@)
2182  */
2183 LONG WINAPI SetWindowLongA( HWND hwnd, INT offset, LONG newval )
2184 {
2185     return WIN_SetWindowLong( hwnd, offset, newval, WIN_PROC_32A );
2186 }
2187
2188
2189 /**********************************************************************
2190  *              SetWindowLongW (USER32.@) Set window attribute
2191  *
2192  * SetWindowLong() alters one of a window's attributes or sets a 32-bit (long)
2193  * value in a window's extra memory.
2194  *
2195  * The _hwnd_ parameter specifies the window.  is the handle to a
2196  * window that has extra memory. The _newval_ parameter contains the
2197  * new attribute or extra memory value.  If positive, the _offset_
2198  * parameter is the byte-addressed location in the window's extra
2199  * memory to set.  If negative, _offset_ specifies the window
2200  * attribute to set, and should be one of the following values:
2201  *
2202  * GWL_EXSTYLE      The window's extended window style
2203  *
2204  * GWL_STYLE        The window's window style.
2205  *
2206  * GWL_WNDPROC      Pointer to the window's window procedure.
2207  *
2208  * GWL_HINSTANCE    The window's pplication instance handle.
2209  *
2210  * GWL_ID           The window's identifier.
2211  *
2212  * GWL_USERDATA     The window's user-specified data.
2213  *
2214  * If the window is a dialog box, the _offset_ parameter can be one of
2215  * the following values:
2216  *
2217  * DWL_DLGPROC      The address of the window's dialog box procedure.
2218  *
2219  * DWL_MSGRESULT    The return value of a message
2220  *                  that the dialog box procedure processed.
2221  *
2222  * DWL_USER         Application specific information.
2223  *
2224  * RETURNS
2225  *
2226  * If successful, returns the previous value located at _offset_. Otherwise,
2227  * returns 0.
2228  *
2229  * NOTES
2230  *
2231  * Extra memory for a window class is specified by a nonzero cbWndExtra
2232  * parameter of the WNDCLASS structure passed to RegisterClass() at the
2233  * time of class creation.
2234  *
2235  * Using GWL_WNDPROC to set a new window procedure effectively creates
2236  * a window subclass. Use CallWindowProc() in the new windows procedure
2237  * to pass messages to the superclass's window procedure.
2238  *
2239  * The user data is reserved for use by the application which created
2240  * the window.
2241  *
2242  * Do not use GWL_STYLE to change the window's WS_DISABLED style;
2243  * instead, call the EnableWindow() function to change the window's
2244  * disabled state.
2245  *
2246  * Do not use GWL_HWNDPARENT to reset the window's parent, use
2247  * SetParent() instead.
2248  *
2249  * Win95:
2250  * When offset is GWL_STYLE and the calling app's ver is 4.0,
2251  * it sends WM_STYLECHANGING before changing the settings
2252  * and WM_STYLECHANGED afterwards.
2253  * App ver 4.0 can't use SetWindowLong to change WS_EX_TOPMOST.
2254  */
2255 LONG WINAPI SetWindowLongW(
2256     HWND hwnd,  /* [in] window to alter */
2257     INT offset, /* [in] offset, in bytes, of location to alter */
2258     LONG newval /* [in] new value of location */
2259 ) {
2260     return WIN_SetWindowLong( hwnd, offset, newval, WIN_PROC_32W );
2261 }
2262
2263
2264 /*******************************************************************
2265  *              GetWindowTextA (USER32.@)
2266  */
2267 INT WINAPI GetWindowTextA( HWND hwnd, LPSTR lpString, INT nMaxCount )
2268 {
2269     WCHAR *buffer;
2270
2271     if (WIN_IsCurrentProcess( hwnd ))
2272         return (INT)SendMessageA( hwnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString );
2273
2274     /* when window belongs to other process, don't send a message */
2275     if (nMaxCount <= 0) return 0;
2276     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, nMaxCount * sizeof(WCHAR) ))) return 0;
2277     get_server_window_text( hwnd, buffer, nMaxCount );
2278     if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, lpString, nMaxCount, NULL, NULL ))
2279         lpString[nMaxCount-1] = 0;
2280     HeapFree( GetProcessHeap(), 0, buffer );
2281     return strlen(lpString);
2282 }
2283
2284
2285 /*******************************************************************
2286  *              InternalGetWindowText (USER32.@)
2287  */
2288 INT WINAPI InternalGetWindowText(HWND hwnd,LPWSTR lpString,INT nMaxCount )
2289 {
2290     WND *win;
2291
2292     if (nMaxCount <= 0) return 0;
2293     if (!(win = WIN_GetPtr( hwnd ))) return 0;
2294     if (win != WND_OTHER_PROCESS)
2295     {
2296         if (win->text) lstrcpynW( lpString, win->text, nMaxCount );
2297         else lpString[0] = 0;
2298         WIN_ReleasePtr( win );
2299     }
2300     else
2301     {
2302         get_server_window_text( hwnd, lpString, nMaxCount );
2303     }
2304     return strlenW(lpString);
2305 }
2306
2307
2308 /*******************************************************************
2309  *              GetWindowTextW (USER32.@)
2310  */
2311 INT WINAPI GetWindowTextW( HWND hwnd, LPWSTR lpString, INT nMaxCount )
2312 {
2313     if (WIN_IsCurrentProcess( hwnd ))
2314         return (INT)SendMessageW( hwnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString );
2315
2316     /* when window belongs to other process, don't send a message */
2317     if (nMaxCount <= 0) return 0;
2318     get_server_window_text( hwnd, lpString, nMaxCount );
2319     return strlenW(lpString);
2320 }
2321
2322
2323 /*******************************************************************
2324  *              SetWindowText  (USER32.@)
2325  *              SetWindowTextA (USER32.@)
2326  */
2327 BOOL WINAPI SetWindowTextA( HWND hwnd, LPCSTR lpString )
2328 {
2329     if (!WIN_IsCurrentProcess( hwnd ))
2330     {
2331         FIXME( "cannot set text %s of other process window %x\n", debugstr_a(lpString), hwnd );
2332         SetLastError( ERROR_ACCESS_DENIED );
2333         return FALSE;
2334     }
2335     return (BOOL)SendMessageA( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
2336 }
2337
2338
2339 /*******************************************************************
2340  *              SetWindowTextW (USER32.@)
2341  */
2342 BOOL WINAPI SetWindowTextW( HWND hwnd, LPCWSTR lpString )
2343 {
2344     if (!WIN_IsCurrentProcess( hwnd ))
2345     {
2346         FIXME( "cannot set text %s of other process window %x\n", debugstr_w(lpString), hwnd );
2347         SetLastError( ERROR_ACCESS_DENIED );
2348         return FALSE;
2349     }
2350     return (BOOL)SendMessageW( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
2351 }
2352
2353
2354 /*******************************************************************
2355  *              GetWindowTextLengthA (USER32.@)
2356  */
2357 INT WINAPI GetWindowTextLengthA( HWND hwnd )
2358 {
2359     return SendMessageA( hwnd, WM_GETTEXTLENGTH, 0, 0 );
2360 }
2361
2362 /*******************************************************************
2363  *              GetWindowTextLengthW (USER32.@)
2364  */
2365 INT WINAPI GetWindowTextLengthW( HWND hwnd )
2366 {
2367     return SendMessageW( hwnd, WM_GETTEXTLENGTH, 0, 0 );
2368 }
2369
2370
2371 /*******************************************************************
2372  *              IsWindow (USER32.@)
2373  */
2374 BOOL WINAPI IsWindow( HWND hwnd )
2375 {
2376     WND *ptr;
2377     BOOL ret;
2378
2379     if (!(ptr = WIN_GetPtr( hwnd ))) return FALSE;
2380
2381     if (ptr != WND_OTHER_PROCESS)
2382     {
2383         WIN_ReleasePtr( ptr );
2384         return TRUE;
2385     }
2386
2387     /* check other processes */
2388     SERVER_START_REQ( get_window_info )
2389     {
2390         req->handle = hwnd;
2391         ret = !wine_server_call_err( req );
2392     }
2393     SERVER_END_REQ;
2394     return ret;
2395 }
2396
2397
2398 /***********************************************************************
2399  *              GetWindowThreadProcessId (USER32.@)
2400  */
2401 DWORD WINAPI GetWindowThreadProcessId( HWND hwnd, LPDWORD process )
2402 {
2403     WND *ptr;
2404     DWORD tid = 0;
2405
2406     if (!(ptr = WIN_GetPtr( hwnd )))
2407     {
2408         SetLastError( ERROR_INVALID_WINDOW_HANDLE);
2409         return 0;
2410     }
2411
2412     if (ptr != WND_OTHER_PROCESS)
2413     {
2414         /* got a valid window */
2415         tid = ptr->tid;
2416         if (process) *process = GetCurrentProcessId();
2417         WIN_ReleasePtr( ptr );
2418         return tid;
2419     }
2420
2421     /* check other processes */
2422     SERVER_START_REQ( get_window_info )
2423     {
2424         req->handle = hwnd;
2425         if (!wine_server_call_err( req ))
2426         {
2427             tid = (DWORD)reply->tid;
2428             if (process) *process = (DWORD)reply->pid;
2429         }
2430     }
2431     SERVER_END_REQ;
2432     return tid;
2433 }
2434
2435
2436 /*****************************************************************
2437  *              GetParent (USER32.@)
2438  */
2439 HWND WINAPI GetParent( HWND hwnd )
2440 {
2441     WND *wndPtr;
2442     HWND retvalue = 0;
2443
2444     if (!(wndPtr = WIN_GetPtr( hwnd )))
2445     {
2446         SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2447         return 0;
2448     }
2449     if (wndPtr == WND_OTHER_PROCESS)
2450     {
2451         LONG style = GetWindowLongW( hwnd, GWL_STYLE );
2452         if (style & (WS_POPUP | WS_CHILD))
2453         {
2454             SERVER_START_REQ( get_window_tree )
2455             {
2456                 req->handle = hwnd;
2457                 if (!wine_server_call_err( req ))
2458                 {
2459                     if (style & WS_POPUP) retvalue = reply->owner;
2460                     else if (style & WS_CHILD) retvalue = reply->parent;
2461                 }
2462             }
2463             SERVER_END_REQ;
2464         }
2465     }
2466     else
2467     {
2468         if (wndPtr->dwStyle & WS_POPUP) retvalue = wndPtr->owner;
2469         else if (wndPtr->dwStyle & WS_CHILD) retvalue = wndPtr->parent;
2470         WIN_ReleasePtr( wndPtr );
2471     }
2472     return retvalue;
2473 }
2474
2475
2476 /*****************************************************************
2477  *              GetAncestor (USER32.@)
2478  */
2479 HWND WINAPI GetAncestor( HWND hwnd, UINT type )
2480 {
2481     WND *win;
2482     HWND *list, ret = 0;
2483
2484     switch(type)
2485     {
2486     case GA_PARENT:
2487         if (!(win = WIN_GetPtr( hwnd )))
2488         {
2489             SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2490             return 0;
2491         }
2492         if (win != WND_OTHER_PROCESS)
2493         {
2494             ret = win->parent;
2495             WIN_ReleasePtr( win );
2496         }
2497         else /* need to query the server */
2498         {
2499             SERVER_START_REQ( get_window_tree )
2500             {
2501                 req->handle = hwnd;
2502                 if (!wine_server_call_err( req )) ret = reply->parent;
2503             }
2504             SERVER_END_REQ;
2505         }
2506         break;
2507
2508     case GA_ROOT:
2509         if (!(list = WIN_ListParents( hwnd ))) return 0;
2510
2511         if (!list[0] || !list[1]) ret = WIN_GetFullHandle( hwnd );  /* top-level window */
2512         else
2513         {
2514             int count = 2;
2515             while (list[count]) count++;
2516             ret = list[count - 2];  /* get the one before the desktop */
2517         }
2518         HeapFree( GetProcessHeap(), 0, list );
2519         break;
2520
2521     case GA_ROOTOWNER:
2522         if ((ret = WIN_GetFullHandle( hwnd )) == GetDesktopWindow()) return 0;
2523         for (;;)
2524         {
2525             HWND parent = GetParent( ret );
2526             if (!parent) break;
2527             ret = parent;
2528         }
2529         break;
2530     }
2531     return ret;
2532 }
2533
2534
2535 /*****************************************************************
2536  *              SetParent (USER32.@)
2537  */
2538 HWND WINAPI SetParent( HWND hwnd, HWND parent )
2539 {
2540     WND *wndPtr;
2541     HWND retvalue, full_handle;
2542     BOOL was_visible;
2543
2544     if (!parent) parent = GetDesktopWindow();
2545     else parent = WIN_GetFullHandle( parent );
2546
2547     if (!IsWindow( parent ))
2548     {
2549         SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2550         return 0;
2551     }
2552
2553     if (!(full_handle = WIN_IsCurrentThread( hwnd )))
2554         return (HWND)SendMessageW( hwnd, WM_WINE_SETPARENT, (WPARAM)parent, 0 );
2555
2556     hwnd = full_handle;
2557
2558     if (USER_Driver.pSetParent)
2559         return USER_Driver.pSetParent( hwnd, parent );
2560
2561     /* Windows hides the window first, then shows it again
2562      * including the WM_SHOWWINDOW messages and all */
2563     was_visible = ShowWindow( hwnd, SW_HIDE );
2564
2565     if (!IsWindow( parent )) return 0;
2566     if (!(wndPtr = WIN_GetPtr(hwnd)) || wndPtr == WND_OTHER_PROCESS) return 0;
2567
2568     retvalue = wndPtr->parent;  /* old parent */
2569     if (parent != retvalue)
2570     {
2571         WIN_LinkWindow( hwnd, parent, HWND_TOP );
2572
2573         if (parent != GetDesktopWindow()) /* a child window */
2574         {
2575             if (!(wndPtr->dwStyle & WS_CHILD))
2576             {
2577                 HMENU menu = (HMENU)SetWindowLongW( hwnd, GWL_ID, 0 );
2578                 if (menu) DestroyMenu( menu );
2579             }
2580         }
2581     }
2582     WIN_ReleasePtr( wndPtr );
2583
2584     /* SetParent additionally needs to make hwnd the topmost window
2585        in the x-order and send the expected WM_WINDOWPOSCHANGING and
2586        WM_WINDOWPOSCHANGED notification messages.
2587     */
2588     SetWindowPos( hwnd, HWND_TOPMOST, 0, 0, 0, 0,
2589                   SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | (was_visible ? SWP_SHOWWINDOW : 0) );
2590     /* FIXME: a WM_MOVE is also generated (in the DefWindowProc handler
2591      * for WM_WINDOWPOSCHANGED) in Windows, should probably remove SWP_NOMOVE */
2592     return retvalue;
2593 }
2594
2595
2596 /*******************************************************************
2597  *              IsChild (USER32.@)
2598  */
2599 BOOL WINAPI IsChild( HWND parent, HWND child )
2600 {
2601     HWND *list = WIN_ListParents( child );
2602     int i;
2603     BOOL ret;
2604
2605     if (!list) return FALSE;
2606     parent = WIN_GetFullHandle( parent );
2607     for (i = 0; list[i]; i++) if (list[i] == parent) break;
2608     ret = (list[i] != 0);
2609     HeapFree( GetProcessHeap(), 0, list );
2610     return ret;
2611 }
2612
2613
2614 /***********************************************************************
2615  *              IsWindowVisible (USER32.@)
2616  */
2617 BOOL WINAPI IsWindowVisible( HWND hwnd )
2618 {
2619     HWND *list;
2620     BOOL retval;
2621     int i;
2622
2623     if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE)) return FALSE;
2624     if (!(list = WIN_ListParents( hwnd ))) return TRUE;
2625     for (i = 0; list[i]; i++)
2626         if (!(GetWindowLongW( list[i], GWL_STYLE ) & WS_VISIBLE)) break;
2627     retval = !list[i];
2628     HeapFree( GetProcessHeap(), 0, list );
2629     return retval;
2630 }
2631
2632
2633 /***********************************************************************
2634  *           WIN_IsWindowDrawable
2635  *
2636  * hwnd is drawable when it is visible, all parents are not
2637  * minimized, and it is itself not minimized unless we are
2638  * trying to draw its default class icon.
2639  */
2640 BOOL WIN_IsWindowDrawable( HWND hwnd, BOOL icon )
2641 {
2642     HWND *list;
2643     BOOL retval;
2644     int i;
2645     LONG style = GetWindowLongW( hwnd, GWL_STYLE );
2646
2647     if (!(style & WS_VISIBLE)) return FALSE;
2648     if ((style & WS_MINIMIZE) && icon && GetClassLongA( hwnd, GCL_HICON ))  return FALSE;
2649
2650     if (!(list = WIN_ListParents( hwnd ))) return TRUE;
2651     for (i = 0; list[i]; i++)
2652         if ((GetWindowLongW( list[i], GWL_STYLE ) & (WS_VISIBLE|WS_MINIMIZE)) != WS_VISIBLE)
2653             break;
2654     retval = !list[i];
2655     HeapFree( GetProcessHeap(), 0, list );
2656     return retval;
2657 }
2658
2659
2660 /*******************************************************************
2661  *              GetTopWindow (USER32.@)
2662  */
2663 HWND WINAPI GetTopWindow( HWND hwnd )
2664 {
2665     if (!hwnd) hwnd = GetDesktopWindow();
2666     return GetWindow( hwnd, GW_CHILD );
2667 }
2668
2669
2670 /*******************************************************************
2671  *              GetWindow (USER32.@)
2672  */
2673 HWND WINAPI GetWindow( HWND hwnd, UINT rel )
2674 {
2675     HWND retval = 0;
2676
2677     if (rel == GW_OWNER)  /* this one may be available locally */
2678     {
2679         WND *wndPtr = WIN_GetPtr( hwnd );
2680         if (!wndPtr)
2681         {
2682             SetLastError( ERROR_INVALID_HANDLE );
2683             return 0;
2684         }
2685         if (wndPtr != WND_OTHER_PROCESS)
2686         {
2687             retval = wndPtr->owner;
2688             WIN_ReleasePtr( wndPtr );
2689             return retval;
2690         }
2691         /* else fall through to server call */
2692     }
2693
2694     SERVER_START_REQ( get_window_tree )
2695     {
2696         req->handle = hwnd;
2697         if (!wine_server_call_err( req ))
2698         {
2699             switch(rel)
2700             {
2701             case GW_HWNDFIRST:
2702                 retval = reply->first_sibling;
2703                 break;
2704             case GW_HWNDLAST:
2705                 retval = reply->last_sibling;
2706                 break;
2707             case GW_HWNDNEXT:
2708                 retval = reply->next_sibling;
2709                 break;
2710             case GW_HWNDPREV:
2711                 retval = reply->prev_sibling;
2712                 break;
2713             case GW_OWNER:
2714                 retval = reply->owner;
2715                 break;
2716             case GW_CHILD:
2717                 retval = reply->first_child;
2718                 break;
2719             }
2720         }
2721     }
2722     SERVER_END_REQ;
2723     return retval;
2724 }
2725
2726
2727 /***********************************************************************
2728  *           WIN_InternalShowOwnedPopups
2729  *
2730  * Internal version of ShowOwnedPopups; Wine functions should use this
2731  * to avoid interfering with application calls to ShowOwnedPopups
2732  * and to make sure the application can't prevent showing/hiding.
2733  *
2734  * Set unmanagedOnly to TRUE to show/hide unmanaged windows only.
2735  *
2736  */
2737
2738 BOOL WIN_InternalShowOwnedPopups( HWND owner, BOOL fShow, BOOL unmanagedOnly )
2739 {
2740     int count = 0;
2741     WND *pWnd;
2742     HWND *win_array = WIN_ListChildren( GetDesktopWindow() );
2743
2744     if (!win_array) return TRUE;
2745
2746     /*
2747      * Show windows Lowest first, Highest last to preserve Z-Order
2748      */
2749     while (win_array[count]) count++;
2750     while (--count >= 0)
2751     {
2752         if (GetWindow( win_array[count], GW_OWNER ) != owner) continue;
2753         if (!(pWnd = WIN_FindWndPtr( win_array[count] ))) continue;
2754
2755         if (pWnd->dwStyle & WS_POPUP)
2756         {
2757             if (fShow)
2758             {
2759                 /* check in window was flagged for showing in previous WIN_InternalShowOwnedPopups call */
2760                 if (pWnd->flags & WIN_NEEDS_INTERNALSOP)
2761                 {
2762                     /*
2763                      * Call ShowWindow directly because an application can intercept WM_SHOWWINDOW messages
2764                      */
2765                     ShowWindow(pWnd->hwndSelf,SW_SHOW);
2766                     pWnd->flags &= ~WIN_NEEDS_INTERNALSOP; /* remove the flag */
2767                 }
2768             }
2769             else
2770             {
2771                 if ( IsWindowVisible(pWnd->hwndSelf) &&                   /* hide only if window is visible */
2772                      !( pWnd->flags & WIN_NEEDS_INTERNALSOP ) &&          /* don't hide if previous call already did it */
2773                      !( unmanagedOnly && (pWnd->dwExStyle & WS_EX_MANAGED) ) ) /* don't hide managed windows if unmanagedOnly is TRUE */
2774                 {
2775                     /*
2776                      * Call ShowWindow directly because an application can intercept WM_SHOWWINDOW messages
2777                      */
2778                     ShowWindow(pWnd->hwndSelf,SW_HIDE);
2779                     /* flag the window for showing on next WIN_InternalShowOwnedPopups call */
2780                     pWnd->flags |= WIN_NEEDS_INTERNALSOP;
2781                 }
2782             }
2783         }
2784         WIN_ReleaseWndPtr( pWnd );
2785     }
2786     HeapFree( GetProcessHeap(), 0, win_array );
2787
2788     return TRUE;
2789 }
2790
2791 /*******************************************************************
2792  *              ShowOwnedPopups (USER32.@)
2793  */
2794 BOOL WINAPI ShowOwnedPopups( HWND owner, BOOL fShow )
2795 {
2796     int count = 0;
2797     WND *pWnd;
2798     HWND *win_array = WIN_ListChildren( GetDesktopWindow() );
2799
2800     if (!win_array) return TRUE;
2801
2802     while (win_array[count]) count++;
2803     while (--count >= 0)
2804     {
2805         if (GetWindow( win_array[count], GW_OWNER ) != owner) continue;
2806         if (!(pWnd = WIN_FindWndPtr( win_array[count] ))) continue;
2807
2808         if (pWnd->dwStyle & WS_POPUP)
2809         {
2810             if (fShow)
2811             {
2812                 if (pWnd->flags & WIN_NEEDS_SHOW_OWNEDPOPUP)
2813                 {
2814                     /* In Windows, ShowOwnedPopups(TRUE) generates
2815                      * WM_SHOWWINDOW messages with SW_PARENTOPENING,
2816                      * regardless of the state of the owner
2817                      */
2818                     SendMessageA(pWnd->hwndSelf, WM_SHOWWINDOW, SW_SHOW, SW_PARENTOPENING);
2819                     pWnd->flags &= ~WIN_NEEDS_SHOW_OWNEDPOPUP;
2820                 }
2821             }
2822             else
2823             {
2824                 if (IsWindowVisible(pWnd->hwndSelf))
2825                 {
2826                     /* In Windows, ShowOwnedPopups(FALSE) generates
2827                      * WM_SHOWWINDOW messages with SW_PARENTCLOSING,
2828                      * regardless of the state of the owner
2829                      */
2830                     SendMessageA(pWnd->hwndSelf, WM_SHOWWINDOW, SW_HIDE, SW_PARENTCLOSING);
2831                     pWnd->flags |= WIN_NEEDS_SHOW_OWNEDPOPUP;
2832                 }
2833             }
2834         }
2835         WIN_ReleaseWndPtr( pWnd );
2836     }
2837     HeapFree( GetProcessHeap(), 0, win_array );
2838     return TRUE;
2839 }
2840
2841
2842 /*******************************************************************
2843  *              GetLastActivePopup (USER32.@)
2844  */
2845 HWND WINAPI GetLastActivePopup( HWND hwnd )
2846 {
2847     HWND retval = hwnd;
2848
2849     SERVER_START_REQ( get_window_info )
2850     {
2851         req->handle = hwnd;
2852         if (!wine_server_call_err( req )) retval = reply->last_active;
2853     }
2854     SERVER_END_REQ;
2855     return retval;
2856 }
2857
2858
2859 /*******************************************************************
2860  *           WIN_ListParents
2861  *
2862  * Build an array of all parents of a given window, starting with
2863  * the immediate parent. The array must be freed with HeapFree.
2864  * Returns NULL if window is a top-level window.
2865  */
2866 HWND *WIN_ListParents( HWND hwnd )
2867 {
2868     WND *win;
2869     HWND current, *list;
2870     int pos = 0, size = 16, count = 0;
2871
2872     if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) return NULL;
2873
2874     current = hwnd;
2875     for (;;)
2876     {
2877         if (!(win = WIN_GetPtr( current ))) goto empty;
2878         if (win == WND_OTHER_PROCESS) break;  /* need to do it the hard way */
2879         list[pos] = win->parent;
2880         WIN_ReleasePtr( win );
2881         if (!(current = list[pos]))
2882         {
2883             if (!pos) goto empty;
2884             return list;
2885         }
2886         if (++pos == size - 1)
2887         {
2888             /* need to grow the list */
2889             HWND *new_list = HeapReAlloc( GetProcessHeap(), 0, list, (size+16) * sizeof(HWND) );
2890             if (!new_list) goto empty;
2891             list = new_list;
2892             size += 16;
2893         }
2894     }
2895
2896     /* at least one parent belongs to another process, have to query the server */
2897
2898     for (;;)
2899     {
2900         count = 0;
2901         SERVER_START_REQ( get_window_parents )
2902         {
2903             req->handle = hwnd;
2904             wine_server_set_reply( req, list, (size-1) * sizeof(HWND) );
2905             if (!wine_server_call( req )) count = reply->count;
2906         }
2907         SERVER_END_REQ;
2908         if (!count) goto empty;
2909         if (size > count)
2910         {
2911             list[count] = 0;
2912             return list;
2913         }
2914         HeapFree( GetProcessHeap(), 0, list );
2915         size = count + 1;
2916         if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) return NULL;
2917     }
2918
2919  empty:
2920     HeapFree( GetProcessHeap(), 0, list );
2921     return NULL;
2922 }
2923
2924
2925 /*******************************************************************
2926  *           WIN_ListChildren
2927  *
2928  * Build an array of the children of a given window. The array must be
2929  * freed with HeapFree. Returns NULL when no windows are found.
2930  */
2931 HWND *WIN_ListChildren( HWND hwnd )
2932 {
2933     return list_window_children( hwnd, 0, 0 );
2934 }
2935
2936
2937 /*******************************************************************
2938  *              EnumWindows (USER32.@)
2939  */
2940 BOOL WINAPI EnumWindows( WNDENUMPROC lpEnumFunc, LPARAM lParam )
2941 {
2942     HWND *list;
2943     BOOL ret = TRUE;
2944     int i, iWndsLocks;
2945
2946     /* We have to build a list of all windows first, to avoid */
2947     /* unpleasant side-effects, for instance if the callback */
2948     /* function changes the Z-order of the windows.          */
2949
2950     if (!(list = WIN_ListChildren( GetDesktopWindow() ))) return TRUE;
2951
2952     /* Now call the callback function for every window */
2953
2954     iWndsLocks = WIN_SuspendWndsLock();
2955     for (i = 0; list[i]; i++)
2956     {
2957         /* Make sure that the window still exists */
2958         if (!IsWindow( list[i] )) continue;
2959         if (!(ret = lpEnumFunc( list[i], lParam ))) break;
2960     }
2961     WIN_RestoreWndsLock(iWndsLocks);
2962     HeapFree( GetProcessHeap(), 0, list );
2963     return ret;
2964 }
2965
2966
2967 /**********************************************************************
2968  *              EnumThreadWindows (USER32.@)
2969  */
2970 BOOL WINAPI EnumThreadWindows( DWORD id, WNDENUMPROC func, LPARAM lParam )
2971 {
2972     HWND *list;
2973     int i, iWndsLocks;
2974
2975     if (!(list = list_window_children( GetDesktopWindow(), 0, id ))) return TRUE;
2976
2977     /* Now call the callback function for every window */
2978
2979     iWndsLocks = WIN_SuspendWndsLock();
2980     for (i = 0; list[i]; i++)
2981         if (!func( list[i], lParam )) break;
2982     WIN_RestoreWndsLock(iWndsLocks);
2983     HeapFree( GetProcessHeap(), 0, list );
2984     return TRUE;
2985 }
2986
2987
2988 /**********************************************************************
2989  *           WIN_EnumChildWindows
2990  *
2991  * Helper function for EnumChildWindows().
2992  */
2993 static BOOL WIN_EnumChildWindows( HWND *list, WNDENUMPROC func, LPARAM lParam )
2994 {
2995     HWND *childList;
2996     BOOL ret = FALSE;
2997
2998     for ( ; *list; list++)
2999     {
3000         /* Make sure that the window still exists */
3001         if (!IsWindow( *list )) continue;
3002         /* skip owned windows */
3003         if (GetWindow( *list, GW_OWNER )) continue;
3004         /* Build children list first */
3005         childList = WIN_ListChildren( *list );
3006
3007         ret = func( *list, lParam );
3008
3009         if (childList)
3010         {
3011             if (ret) ret = WIN_EnumChildWindows( childList, func, lParam );
3012             HeapFree( GetProcessHeap(), 0, childList );
3013         }
3014         if (!ret) return FALSE;
3015     }
3016     return TRUE;
3017 }
3018
3019
3020 /**********************************************************************
3021  *              EnumChildWindows (USER32.@)
3022  */
3023 BOOL WINAPI EnumChildWindows( HWND parent, WNDENUMPROC func, LPARAM lParam )
3024 {
3025     HWND *list;
3026     int iWndsLocks;
3027
3028     if (!(list = WIN_ListChildren( parent ))) return FALSE;
3029     iWndsLocks = WIN_SuspendWndsLock();
3030     WIN_EnumChildWindows( list, func, lParam );
3031     WIN_RestoreWndsLock(iWndsLocks);
3032     HeapFree( GetProcessHeap(), 0, list );
3033     return TRUE;
3034 }
3035
3036
3037 /*******************************************************************
3038  *              AnyPopup (USER.52)
3039  */
3040 BOOL16 WINAPI AnyPopup16(void)
3041 {
3042     return AnyPopup();
3043 }
3044
3045
3046 /*******************************************************************
3047  *              AnyPopup (USER32.@)
3048  */
3049 BOOL WINAPI AnyPopup(void)
3050 {
3051     int i;
3052     BOOL retvalue;
3053     HWND *list = WIN_ListChildren( GetDesktopWindow() );
3054
3055     if (!list) return FALSE;
3056     for (i = 0; list[i]; i++)
3057     {
3058         if (IsWindowVisible( list[i] ) && GetWindow( list[i], GW_OWNER )) break;
3059     }
3060     retvalue = (list[i] != 0);
3061     HeapFree( GetProcessHeap(), 0, list );
3062     return retvalue;
3063 }
3064
3065
3066 /*******************************************************************
3067  *              FlashWindow (USER32.@)
3068  */
3069 BOOL WINAPI FlashWindow( HWND hWnd, BOOL bInvert )
3070 {
3071     WND *wndPtr = WIN_FindWndPtr(hWnd);
3072
3073     TRACE("%04x\n", hWnd);
3074
3075     if (!wndPtr) return FALSE;
3076     hWnd = wndPtr->hwndSelf;  /* make it a full handle */
3077
3078     if (wndPtr->dwStyle & WS_MINIMIZE)
3079     {
3080         if (bInvert && !(wndPtr->flags & WIN_NCACTIVATED))
3081         {
3082             HDC hDC = GetDC(hWnd);
3083
3084             if (!SendMessageW( hWnd, WM_ERASEBKGND, (WPARAM)hDC, 0 ))
3085                 wndPtr->flags |= WIN_NEEDS_ERASEBKGND;
3086
3087             ReleaseDC( hWnd, hDC );
3088             wndPtr->flags |= WIN_NCACTIVATED;
3089         }
3090         else
3091         {
3092             RedrawWindow( hWnd, 0, 0, RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_FRAME );
3093             wndPtr->flags &= ~WIN_NCACTIVATED;
3094         }
3095         WIN_ReleaseWndPtr(wndPtr);
3096         return TRUE;
3097     }
3098     else
3099     {
3100         WPARAM16 wparam;
3101         if (bInvert) wparam = !(wndPtr->flags & WIN_NCACTIVATED);
3102         else wparam = (hWnd == GetForegroundWindow());
3103
3104         WIN_ReleaseWndPtr(wndPtr);
3105         SendMessageW( hWnd, WM_NCACTIVATE, wparam, (LPARAM)0 );
3106         return wparam;
3107     }
3108 }
3109
3110
3111 /*******************************************************************
3112  *              GetWindowContextHelpId (USER32.@)
3113  */
3114 DWORD WINAPI GetWindowContextHelpId( HWND hwnd )
3115 {
3116     DWORD retval;
3117     WND *wnd = WIN_FindWndPtr( hwnd );
3118     if (!wnd) return 0;
3119     retval = wnd->helpContext;
3120     WIN_ReleaseWndPtr(wnd);
3121     return retval;
3122 }
3123
3124
3125 /*******************************************************************
3126  *              SetWindowContextHelpId (USER32.@)
3127  */
3128 BOOL WINAPI SetWindowContextHelpId( HWND hwnd, DWORD id )
3129 {
3130     WND *wnd = WIN_FindWndPtr( hwnd );
3131     if (!wnd) return FALSE;
3132     wnd->helpContext = id;
3133     WIN_ReleaseWndPtr(wnd);
3134     return TRUE;
3135 }
3136
3137
3138 /*******************************************************************
3139  *                      DRAG_QueryUpdate16
3140  *
3141  * recursively find a child that contains spDragInfo->pt point
3142  * and send WM_QUERYDROPOBJECT
3143  */
3144 static BOOL16 DRAG_QueryUpdate16( HWND hQueryWnd, SEGPTR spDragInfo )
3145 {
3146     BOOL16 wParam, bResult = 0;
3147     POINT pt, client_pt;
3148     LPDRAGINFO16 ptrDragInfo = MapSL(spDragInfo);
3149     RECT tempRect;
3150
3151     if (!ptrDragInfo) return FALSE;
3152
3153     CONV_POINT16TO32( &ptrDragInfo->pt, &pt );
3154
3155     GetWindowRect(hQueryWnd,&tempRect);
3156
3157     if( !PtInRect(&tempRect,pt) || !IsWindowEnabled(hQueryWnd)) return FALSE;
3158
3159     if (!IsIconic( hQueryWnd ))
3160     {
3161         GetClientRect( hQueryWnd, &tempRect );
3162         MapWindowPoints( hQueryWnd, 0, (LPPOINT)&tempRect, 2 );
3163
3164         if (PtInRect( &tempRect, pt))
3165         {
3166             int i;
3167             HWND *list = WIN_ListChildren( hQueryWnd );
3168
3169             wParam = 0;
3170
3171             if (list)
3172             {
3173                 for (i = 0; list[i]; i++)
3174                 {
3175                     if (GetWindowLongW( list[i], GWL_STYLE ) & WS_VISIBLE)
3176                     {
3177                         GetWindowRect( list[i], &tempRect );
3178                         if (PtInRect( &tempRect, pt )) break;
3179                     }
3180                 }
3181                 if (list[i])
3182                 {
3183                     if (IsWindowEnabled( list[i] ))
3184                         bResult = DRAG_QueryUpdate16( list[i], spDragInfo );
3185                 }
3186                 HeapFree( GetProcessHeap(), 0, list );
3187             }
3188             if(bResult) return bResult;
3189         }
3190         else wParam = 1;
3191     }
3192     else wParam = 1;
3193
3194     client_pt = pt;
3195     ScreenToClient( hQueryWnd, &client_pt );
3196     ptrDragInfo->pt.x = client_pt.x;
3197     ptrDragInfo->pt.y = client_pt.y;
3198     ptrDragInfo->hScope = HWND_16(hQueryWnd);
3199
3200     bResult = SendMessage16( HWND_16(hQueryWnd), WM_QUERYDROPOBJECT, (WPARAM16)wParam, spDragInfo );
3201
3202     if( !bResult ) CONV_POINT32TO16( &pt, &ptrDragInfo->pt );
3203
3204     return bResult;
3205 }
3206
3207
3208 /*******************************************************************
3209  *              DragDetect (USER32.@)
3210  */
3211 BOOL WINAPI DragDetect( HWND hWnd, POINT pt )
3212 {
3213     MSG msg;
3214     RECT rect;
3215
3216     rect.left = pt.x - wDragWidth;
3217     rect.right = pt.x + wDragWidth;
3218
3219     rect.top = pt.y - wDragHeight;
3220     rect.bottom = pt.y + wDragHeight;
3221
3222     SetCapture(hWnd);
3223
3224     while(1)
3225     {
3226         while(PeekMessageA(&msg ,0 ,WM_MOUSEFIRST ,WM_MOUSELAST ,PM_REMOVE))
3227         {
3228             if( msg.message == WM_LBUTTONUP )
3229             {
3230                 ReleaseCapture();
3231                 return 0;
3232             }
3233             if( msg.message == WM_MOUSEMOVE )
3234             {
3235                 POINT tmp;
3236                 tmp.x = LOWORD(msg.lParam);
3237                 tmp.y = HIWORD(msg.lParam);
3238                 if( !PtInRect( &rect, tmp ))
3239                 {
3240                     ReleaseCapture();
3241                     return 1;
3242                 }
3243             }
3244         }
3245         WaitMessage();
3246     }
3247     return 0;
3248 }
3249
3250 /******************************************************************************
3251  *              DragObject (USER.464)
3252  */
3253 DWORD WINAPI DragObject16( HWND16 hwndScope, HWND16 hWnd, UINT16 wObj,
3254                            HANDLE16 hOfStruct, WORD szList, HCURSOR16 hCursor )
3255 {
3256     MSG msg;
3257     LPDRAGINFO16 lpDragInfo;
3258     SEGPTR      spDragInfo;
3259     HCURSOR     hOldCursor=0, hBummer=0;
3260     HGLOBAL16   hDragInfo  = GlobalAlloc16( GMEM_SHARE | GMEM_ZEROINIT, 2*sizeof(DRAGINFO16));
3261     HCURSOR     hCurrentCursor = 0;
3262     HWND16      hCurrentWnd = 0;
3263
3264     lpDragInfo = (LPDRAGINFO16) GlobalLock16(hDragInfo);
3265     spDragInfo = K32WOWGlobalLock16(hDragInfo);
3266
3267     if( !lpDragInfo || !spDragInfo ) return 0L;
3268
3269     if (!(hBummer = LoadCursorA(0, MAKEINTRESOURCEA(OCR_NO))))
3270     {
3271         GlobalFree16(hDragInfo);
3272         return 0L;
3273     }
3274
3275     if(hCursor) hOldCursor = SetCursor(HCURSOR_32(hCursor));
3276
3277     lpDragInfo->hWnd   = hWnd;
3278     lpDragInfo->hScope = 0;
3279     lpDragInfo->wFlags = wObj;
3280     lpDragInfo->hList  = szList; /* near pointer! */
3281     lpDragInfo->hOfStruct = hOfStruct;
3282     lpDragInfo->l = 0L;
3283
3284     SetCapture(WIN_Handle32(hWnd));
3285     ShowCursor( TRUE );
3286
3287     do
3288     {
3289         GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST );
3290
3291        *(lpDragInfo+1) = *lpDragInfo;
3292
3293         lpDragInfo->pt.x = msg.pt.x;
3294         lpDragInfo->pt.y = msg.pt.y;
3295
3296         /* update DRAGINFO struct */
3297         TRACE_(msg)("lpDI->hScope = %04x\n",lpDragInfo->hScope);
3298
3299         if( DRAG_QueryUpdate16(WIN_Handle32(hwndScope), spDragInfo) > 0 )
3300             hCurrentCursor = HCURSOR_32(hCursor);
3301         else
3302         {
3303             hCurrentCursor = hBummer;
3304             lpDragInfo->hScope = 0;
3305         }
3306         if( hCurrentCursor )
3307             SetCursor(hCurrentCursor);
3308
3309         /* send WM_DRAGLOOP */
3310         SendMessage16( hWnd, WM_DRAGLOOP, (WPARAM16)(hCurrentCursor != hBummer),
3311                                           (LPARAM) spDragInfo );
3312         /* send WM_DRAGSELECT or WM_DRAGMOVE */
3313         if( hCurrentWnd != lpDragInfo->hScope )
3314         {
3315             if( hCurrentWnd )
3316                 SendMessage16( hCurrentWnd, WM_DRAGSELECT, 0,
3317                        (LPARAM)MAKELONG(LOWORD(spDragInfo)+sizeof(DRAGINFO16),
3318                                         HIWORD(spDragInfo)) );
3319             hCurrentWnd = lpDragInfo->hScope;
3320             if( hCurrentWnd )
3321                 SendMessage16( hCurrentWnd, WM_DRAGSELECT, 1, (LPARAM)spDragInfo);
3322         }
3323         else
3324             if( hCurrentWnd )
3325                 SendMessage16( hCurrentWnd, WM_DRAGMOVE, 0, (LPARAM)spDragInfo);
3326
3327     } while( msg.message != WM_LBUTTONUP && msg.message != WM_NCLBUTTONUP );
3328
3329     ReleaseCapture();
3330     ShowCursor( FALSE );
3331
3332     if( hCursor ) SetCursor(hOldCursor);
3333
3334     if( hCurrentCursor != hBummer )
3335         msg.lParam = SendMessage16( lpDragInfo->hScope, WM_DROPOBJECT,
3336                                    (WPARAM16)hWnd, (LPARAM)spDragInfo );
3337     else
3338         msg.lParam = 0;
3339     GlobalFree16(hDragInfo);
3340
3341     return (DWORD)(msg.lParam);
3342 }
3343
3344
3345 /******************************************************************************
3346  *              GetWindowModuleFileNameA (USER32.@)
3347  */
3348 UINT WINAPI GetWindowModuleFileNameA( HWND hwnd, LPSTR lpszFileName, UINT cchFileNameMax)
3349 {
3350     FIXME("GetWindowModuleFileNameA(hwnd 0x%x, lpszFileName %p, cchFileNameMax %u) stub!\n",
3351           hwnd, lpszFileName, cchFileNameMax);
3352     return 0;
3353 }
3354
3355 /******************************************************************************
3356  *              GetWindowModuleFileNameW (USER32.@)
3357  */
3358 UINT WINAPI GetWindowModuleFileNameW( HWND hwnd, LPSTR lpszFileName, UINT cchFileNameMax)
3359 {
3360     FIXME("GetWindowModuleFileNameW(hwnd 0x%x, lpszFileName %p, cchFileNameMax %u) stub!\n",
3361           hwnd, lpszFileName, cchFileNameMax);
3362     return 0;
3363 }
3364
3365 /******************************************************************************
3366  *              GetWindowInfo (USER32.@)
3367  * hwnd: in
3368  * pwi:  out.
3369  * MS Documentation mentions that pwi->cbSize must be set to SIZEOF(WINDOWINFO)
3370  *    this may be because this structure changed over time. If this is the
3371  *    the case, then please: FIXME.
3372  *    Using the structure described in MSDN for 98/ME/NT(4.0 SP3)/2000/XP.
3373  */
3374 BOOL WINAPI GetWindowInfo( HWND hwnd, PWINDOWINFO pwi)
3375 {
3376     WND *wndInfo = NULL;
3377     if (!pwi) return FALSE;
3378     if (pwi->cbSize != sizeof(WINDOWINFO))
3379     {
3380         FIXME("windowinfo->cbSize != sizeof(WINDOWINFO). Please report\n");
3381         return FALSE;
3382     }
3383     wndInfo = WIN_GetPtr(hwnd);
3384     if (!wndInfo) return FALSE;
3385     if (wndInfo == WND_OTHER_PROCESS)
3386     {
3387         FIXME("window belong to other process\n");
3388         return FALSE;
3389     }
3390
3391     pwi->rcWindow = wndInfo->rectWindow;
3392     pwi->rcClient = wndInfo->rectClient;
3393     pwi->dwStyle = wndInfo->dwStyle;
3394     pwi->dwExStyle = wndInfo->dwExStyle;
3395     pwi->dwWindowStatus = ((GetActiveWindow() == hwnd) ? WS_ACTIVECAPTION : 0);
3396                     /* if active WS_ACTIVECAPTION, else 0 */
3397
3398     pwi->cxWindowBorders = ((wndInfo->dwStyle & WS_BORDER) ?
3399                     GetSystemMetrics(SM_CXBORDER) : 0);
3400     pwi->cyWindowBorders = ((wndInfo->dwStyle & WS_BORDER) ?
3401                     GetSystemMetrics(SM_CYBORDER) : 0);
3402     /* above two: I'm presuming that borders widths are the same
3403      * for each window - so long as its actually using a border.. */
3404
3405     pwi->atomWindowType = GetClassLongA( hwnd, GCW_ATOM );
3406     pwi->wCreatorVersion = GetVersion();
3407                     /* Docs say this should be the version that
3408                      * CREATED the window. But eh?.. Isn't that just the
3409                      * version we are running.. Unless ofcourse its some wacky
3410                      * RPC stuff or something */
3411
3412     WIN_ReleasePtr(wndInfo);
3413     return TRUE;
3414 }