git.oblomov.eu Git - wine/blob - dlls/user32/defwnd.c

   1 /*
   2  * Default window procedure
   3  *
   4  * Copyright 1993, 1996 Alexandre Julliard
   5  *           1995 Alex Korobka
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <string.h>
  26 #include <stdarg.h>
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "wingdi.h"
  31 #include "winnls.h"
  32 #include "win.h"
  33 #include "user_private.h"
  34 #include "controls.h"
  35 #include "wine/unicode.h"
  36 #include "wine/server.h"
  37 #include "wine/exception.h"
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(win);
  41
  42   /* bits in the dwKeyData */
  43 #define KEYDATA_ALT             0x2000
  44 #define KEYDATA_PREVSTATE       0x4000
  45
  46 #define DRAG_FILE  0x454C4946
  47
  48 static short iF10Key = 0;
  49 static short iMenuSysKey = 0;
  50 static const WCHAR imm32W[] = { 'i','m','m','3','2','\0' };
  51
  52 /***********************************************************************
  53  *           DEFWND_HandleWindowPosChanged
  54  *
  55  * Handle the WM_WINDOWPOSCHANGED message.
  56  */
  57 static void DEFWND_HandleWindowPosChanged( HWND hwnd, const WINDOWPOS *winpos )
  58 {
  59     RECT rect;
  60
  61     WIN_GetRectangles( hwnd, COORDS_PARENT, NULL, &rect );
  62     if (!(winpos->flags & SWP_NOCLIENTMOVE))
  63         SendMessageW( hwnd, WM_MOVE, 0, MAKELONG(rect.left, rect.top));
  64
  65     if (!(winpos->flags & SWP_NOCLIENTSIZE) || (winpos->flags & SWP_STATECHANGED))
  66     {
  67         if (IsIconic( hwnd ))
  68         {
  69             SendMessageW( hwnd, WM_SIZE, SIZE_MINIMIZED, 0 );
  70         }
  71         else
  72         {
  73             WPARAM wp = IsZoomed( hwnd ) ? SIZE_MAXIMIZED : SIZE_RESTORED;
  74
  75             SendMessageW( hwnd, WM_SIZE, wp, MAKELONG(rect.right-rect.left, rect.bottom-rect.top) );
  76         }
  77     }
  78 }
  79
  80
  81 /***********************************************************************
  82  *           DEFWND_SetTextA
  83  *
  84  * Set the window text.
  85  */
  86 static void DEFWND_SetTextA( HWND hwnd, LPCSTR text )
  87 {
  88     int count;
  89     WCHAR *textW;
  90     WND *wndPtr;
  91
  92     if (!text) text = "";
  93     count = MultiByteToWideChar( CP_ACP, 0, text, -1, NULL, 0 );
  94
  95     if (!(wndPtr = WIN_GetPtr( hwnd ))) return;
  96     if ((textW = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WCHAR))))
  97     {
  98         HeapFree(GetProcessHeap(), 0, wndPtr->text);
  99         wndPtr->text = textW;
 100         MultiByteToWideChar( CP_ACP, 0, text, -1, textW, count );
 101         SERVER_START_REQ( set_window_text )
 102         {
 103             req->handle = wine_server_user_handle( hwnd );
 104             wine_server_add_data( req, textW, (count-1) * sizeof(WCHAR) );
 105             wine_server_call( req );
 106         }
 107         SERVER_END_REQ;
 108     }
 109     else
 110         ERR("Not enough memory for window text\n");
 111     WIN_ReleasePtr( wndPtr );
 112
 113     USER_Driver->pSetWindowText( hwnd, textW );
 114 }
 115
 116 /***********************************************************************
 117  *           DEFWND_SetTextW
 118  *
 119  * Set the window text.
 120  */
 121 static void DEFWND_SetTextW( HWND hwnd, LPCWSTR text )
 122 {
 123     static const WCHAR empty_string[] = {0};
 124     WND *wndPtr;
 125     int count;
 126
 127     if (!text) text = empty_string;
 128     count = strlenW(text) + 1;
 129
 130     if (!(wndPtr = WIN_GetPtr( hwnd ))) return;
 131     HeapFree(GetProcessHeap(), 0, wndPtr->text);
 132     if ((wndPtr->text = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WCHAR))))
 133     {
 134         strcpyW( wndPtr->text, text );
 135         SERVER_START_REQ( set_window_text )
 136         {
 137             req->handle = wine_server_user_handle( hwnd );
 138             wine_server_add_data( req, wndPtr->text, (count-1) * sizeof(WCHAR) );
 139             wine_server_call( req );
 140         }
 141         SERVER_END_REQ;
 142     }
 143     else
 144         ERR("Not enough memory for window text\n");
 145     text = wndPtr->text;
 146     WIN_ReleasePtr( wndPtr );
 147
 148     USER_Driver->pSetWindowText( hwnd, text );
 149 }
 150
 151 /***********************************************************************
 152  *           DEFWND_ControlColor
 153  *
 154  * Default colors for control painting.
 155  */
 156 HBRUSH DEFWND_ControlColor( HDC hDC, UINT ctlType )
 157 {
 158     if( ctlType == CTLCOLOR_SCROLLBAR)
 159     {
 160         HBRUSH hb = GetSysColorBrush(COLOR_SCROLLBAR);
 161         COLORREF bk = GetSysColor(COLOR_3DHILIGHT);
 162         SetTextColor( hDC, GetSysColor(COLOR_3DFACE));
 163         SetBkColor( hDC, bk);
 164
 165         /* if COLOR_WINDOW happens to be the same as COLOR_3DHILIGHT
 166          * we better use 0x55aa bitmap brush to make scrollbar's background
 167          * look different from the window background.
 168          */
 169         if (bk == GetSysColor(COLOR_WINDOW))
 170             return SYSCOLOR_55AABrush;
 171
 172         UnrealizeObject( hb );
 173         return hb;
 174     }
 175
 176     SetTextColor( hDC, GetSysColor(COLOR_WINDOWTEXT));
 177
 178     if ((ctlType == CTLCOLOR_EDIT) || (ctlType == CTLCOLOR_LISTBOX))
 179         SetBkColor( hDC, GetSysColor(COLOR_WINDOW) );
 180     else {
 181         SetBkColor( hDC, GetSysColor(COLOR_3DFACE) );
 182         return GetSysColorBrush(COLOR_3DFACE);
 183     }
 184     return GetSysColorBrush(COLOR_WINDOW);
 185 }
 186
 187
 188 /***********************************************************************
 189  *           DEFWND_Print
 190  *
 191  * This method handles the default behavior for the WM_PRINT message.
 192  */
 193 static void DEFWND_Print( HWND hwnd, HDC hdc, ULONG uFlags)
 194 {
 195   /*
 196    * Visibility flag.
 197    */
 198   if ( (uFlags & PRF_CHECKVISIBLE) &&
 199        !IsWindowVisible(hwnd) )
 200       return;
 201
 202   /*
 203    * Unimplemented flags.
 204    */
 205   if ( (uFlags & PRF_CHILDREN) ||
 206        (uFlags & PRF_OWNED)    ||
 207        (uFlags & PRF_NONCLIENT) )
 208   {
 209     WARN("WM_PRINT message with unsupported flags\n");
 210   }
 211
 212   /*
 213    * Background
 214    */
 215   if ( uFlags & PRF_ERASEBKGND)
 216     SendMessageW(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
 217
 218   /*
 219    * Client area
 220    */
 221   if ( uFlags & PRF_CLIENT)
 222     SendMessageW(hwnd, WM_PRINTCLIENT, (WPARAM)hdc, uFlags);
 223 }
 224
 225
 226 /*
 227  * helpers for calling IMM32
 228  *
 229  * WM_IME_* messages are generated only by IMM32,
 230  * so I assume imm32 is already LoadLibrary-ed.
 231  */
 232 static HWND DEFWND_ImmGetDefaultIMEWnd( HWND hwnd )
 233 {
 234     HINSTANCE hInstIMM = GetModuleHandleW( imm32W );
 235     HWND (WINAPI *pFunc)(HWND);
 236     HWND hwndRet = 0;
 237
 238     if (!hInstIMM)
 239     {
 240         ERR( "cannot get IMM32 handle\n" );
 241         return 0;
 242     }
 243
 244     pFunc = (void*)GetProcAddress(hInstIMM,"ImmGetDefaultIMEWnd");
 245     if ( pFunc != NULL )
 246         hwndRet = (*pFunc)( hwnd );
 247
 248     return hwndRet;
 249 }
 250
 251 static BOOL DEFWND_ImmIsUIMessageA( HWND hwndIME, UINT msg, WPARAM wParam, LPARAM lParam )
 252 {
 253     HINSTANCE hInstIMM = GetModuleHandleW( imm32W );
 254     BOOL (WINAPI *pFunc)(HWND,UINT,WPARAM,LPARAM);
 255     BOOL fRet = FALSE;
 256
 257     if (!hInstIMM)
 258     {
 259         ERR( "cannot get IMM32 handle\n" );
 260         return FALSE;
 261     }
 262
 263     pFunc = (void*)GetProcAddress(hInstIMM,"ImmIsUIMessageA");
 264     if ( pFunc != NULL )
 265         fRet = (*pFunc)( hwndIME, msg, wParam, lParam );
 266
 267     return fRet;
 268 }
 269
 270 static BOOL DEFWND_ImmIsUIMessageW( HWND hwndIME, UINT msg, WPARAM wParam, LPARAM lParam )
 271 {
 272     HINSTANCE hInstIMM = GetModuleHandleW( imm32W );
 273     BOOL (WINAPI *pFunc)(HWND,UINT,WPARAM,LPARAM);
 274     BOOL fRet = FALSE;
 275
 276     if (!hInstIMM)
 277     {
 278         ERR( "cannot get IMM32 handle\n" );
 279         return FALSE;
 280     }
 281
 282     pFunc = (void*)GetProcAddress(hInstIMM,"ImmIsUIMessageW");
 283     if ( pFunc != NULL )
 284         fRet = (*pFunc)( hwndIME, msg, wParam, lParam );
 285
 286     return fRet;
 287 }
 288
 289
 290
 291 /***********************************************************************
 292  *           DEFWND_DefWinProc
 293  *
 294  * Default window procedure for messages that are the same in Ansi and Unicode.
 295  */
 296 static LRESULT DEFWND_DefWinProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
 297 {
 298     switch(msg)
 299     {
 300     case WM_NCPAINT:
 301         return NC_HandleNCPaint( hwnd, (HRGN)wParam );
 302
 303     case WM_NCHITTEST:
 304         {
 305             POINT pt;
 306             pt.x = (short)LOWORD(lParam);
 307             pt.y = (short)HIWORD(lParam);
 308             return NC_HandleNCHitTest( hwnd, pt );
 309         }
 310
 311     case WM_NCCALCSIZE:
 312         return NC_HandleNCCalcSize( hwnd, wParam, (RECT *)lParam );
 313
 314     case WM_WINDOWPOSCHANGING:
 315         return WINPOS_HandleWindowPosChanging( hwnd, (WINDOWPOS *)lParam );
 316
 317     case WM_WINDOWPOSCHANGED:
 318         DEFWND_HandleWindowPosChanged( hwnd, (const WINDOWPOS *)lParam );
 319         break;
 320
 321     case WM_LBUTTONDOWN:
 322     case WM_RBUTTONDOWN:
 323     case WM_MBUTTONDOWN:
 324         iF10Key = iMenuSysKey = 0;
 325         break;
 326
 327     case WM_NCLBUTTONDOWN:
 328         return NC_HandleNCLButtonDown( hwnd, wParam, lParam );
 329
 330     case WM_LBUTTONDBLCLK:
 331         return NC_HandleNCLButtonDblClk( hwnd, HTCLIENT, lParam );
 332
 333     case WM_NCLBUTTONDBLCLK:
 334         return NC_HandleNCLButtonDblClk( hwnd, wParam, lParam );
 335
 336     case WM_NCRBUTTONDOWN:
 337         return NC_HandleNCRButtonDown( hwnd, wParam, lParam );
 338
 339     case WM_RBUTTONUP:
 340         {
 341             POINT pt;
 342             pt.x = (short)LOWORD(lParam);
 343             pt.y = (short)HIWORD(lParam);
 344             ClientToScreen(hwnd, &pt);
 345             SendMessageW( hwnd, WM_CONTEXTMENU, (WPARAM)hwnd, MAKELPARAM(pt.x, pt.y) );
 346         }
 347         break;
 348
 349     case WM_NCRBUTTONUP:
 350         /*
 351          * FIXME : we must NOT send WM_CONTEXTMENU on a WM_NCRBUTTONUP (checked
 352          * in Windows), but what _should_ we do? According to MSDN :
 353          * "If it is appropriate to do so, the system sends the WM_SYSCOMMAND
 354          * message to the window". When is it appropriate?
 355          */
 356         break;
 357
 358     case WM_CONTEXTMENU:
 359         if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)
 360             SendMessageW( GetParent(hwnd), msg, wParam, lParam );
 361         else
 362         {
 363             LONG hitcode;
 364             POINT pt;
 365             WND *wndPtr = WIN_GetPtr( hwnd );
 366             HMENU hMenu = wndPtr->hSysMenu;
 367             WIN_ReleasePtr( wndPtr );
 368             if (!hMenu) return 0;
 369             pt.x = (short)LOWORD(lParam);
 370             pt.y = (short)HIWORD(lParam);
 371             hitcode = NC_HandleNCHitTest(hwnd, pt);
 372
 373             /* Track system popup if click was in the caption area. */
 374             if (hitcode==HTCAPTION || hitcode==HTSYSMENU)
 375                TrackPopupMenu(GetSystemMenu(hwnd, FALSE),
 376                                TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
 377                                pt.x, pt.y, 0, hwnd, NULL);
 378         }
 379         break;
 380
 381     case WM_POPUPSYSTEMMENU:
 382         {
 383             /* This is an undocumented message used by the windows taskbar to
 384                display the system menu of windows that belong to other processes. */
 385             HMENU menu = GetSystemMenu(hwnd, FALSE);
 386
 387             if (menu)
 388                 TrackPopupMenu(menu, TPM_LEFTBUTTON|TPM_RIGHTBUTTON,
 389                                LOWORD(lParam), HIWORD(lParam), 0, hwnd, NULL);
 390             return 0;
 391         }
 392
 393     case WM_NCACTIVATE:
 394         return NC_HandleNCActivate( hwnd, wParam, lParam );
 395
 396     case WM_NCDESTROY:
 397         {
 398             WND *wndPtr = WIN_GetPtr( hwnd );
 399             if (!wndPtr) return 0;
 400             HeapFree( GetProcessHeap(), 0, wndPtr->text );
 401             wndPtr->text = NULL;
 402             HeapFree( GetProcessHeap(), 0, wndPtr->pScroll );
 403             wndPtr->pScroll = NULL;
 404             WIN_ReleasePtr( wndPtr );
 405             return 0;
 406         }
 407
 408     case WM_PRINT:
 409         DEFWND_Print(hwnd, (HDC)wParam, lParam);
 410         return 0;
 411
 412     case WM_PAINTICON:
 413     case WM_PAINT:
 414         {
 415             PAINTSTRUCT ps;
 416             HDC hdc = BeginPaint( hwnd, &ps );
 417             if( hdc )
 418             {
 419               HICON hIcon;
 420               if (IsIconic(hwnd) && ((hIcon = (HICON)GetClassLongPtrW( hwnd, GCLP_HICON))) )
 421               {
 422                   RECT rc;
 423                   int x, y;
 424
 425                   GetClientRect( hwnd, &rc );
 426                   x = (rc.right - rc.left - GetSystemMetrics(SM_CXICON))/2;
 427                   y = (rc.bottom - rc.top - GetSystemMetrics(SM_CYICON))/2;
 428                   TRACE("Painting class icon: vis rect=(%s)\n",
 429                         wine_dbgstr_rect(&ps.rcPaint));
 430                   DrawIcon( hdc, x, y, hIcon );
 431               }
 432               EndPaint( hwnd, &ps );
 433             }
 434             return 0;
 435         }
 436
 437     case WM_SYNCPAINT:
 438         RedrawWindow ( hwnd, NULL, 0, RDW_ERASENOW | RDW_ERASE | RDW_ALLCHILDREN );
 439         return 0;
 440
 441     case WM_SETREDRAW:
 442         if (wParam) WIN_SetStyle( hwnd, WS_VISIBLE, 0 );
 443         else
 444         {
 445             RedrawWindow( hwnd, NULL, 0, RDW_ALLCHILDREN | RDW_VALIDATE );
 446             WIN_SetStyle( hwnd, 0, WS_VISIBLE );
 447         }
 448         return 0;
 449
 450     case WM_CLOSE:
 451         DestroyWindow( hwnd );
 452         return 0;
 453
 454     case WM_MOUSEACTIVATE:
 455         if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)
 456         {
 457             LONG ret = SendMessageW( GetParent(hwnd), WM_MOUSEACTIVATE, wParam, lParam );
 458             if (ret) return ret;
 459         }
 460
 461         /* Caption clicks are handled by NC_HandleNCLButtonDown() */
 462         return MA_ACTIVATE;
 463
 464     case WM_ACTIVATE:
 465         /* The default action in Windows is to set the keyboard focus to
 466          * the window, if it's being activated and not minimized */
 467         if (LOWORD(wParam) != WA_INACTIVE) {
 468             if (!IsIconic(hwnd)) SetFocus(hwnd);
 469         }
 470         break;
 471
 472     case WM_MOUSEWHEEL:
 473         if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)
 474             return SendMessageW( GetParent(hwnd), WM_MOUSEWHEEL, wParam, lParam );
 475         break;
 476
 477     case WM_ERASEBKGND:
 478     case WM_ICONERASEBKGND:
 479         {
 480             RECT rect;
 481             HDC hdc = (HDC)wParam;
 482             HBRUSH hbr = (HBRUSH)GetClassLongPtrW( hwnd, GCLP_HBRBACKGROUND );
 483             if (!hbr) return 0;
 484
 485             if (GetClassLongW( hwnd, GCL_STYLE ) & CS_PARENTDC)
 486             {
 487                 /* can't use GetClipBox with a parent DC or we fill the whole parent */
 488                 GetClientRect( hwnd, &rect );
 489                 DPtoLP( hdc, (LPPOINT)&rect, 2 );
 490             }
 491             else GetClipBox( hdc, &rect );
 492             FillRect( hdc, &rect, hbr );
 493             return 1;
 494         }
 495
 496     case WM_GETDLGCODE:
 497         return 0;
 498
 499     case WM_CTLCOLORMSGBOX:
 500     case WM_CTLCOLOREDIT:
 501     case WM_CTLCOLORLISTBOX:
 502     case WM_CTLCOLORBTN:
 503     case WM_CTLCOLORDLG:
 504     case WM_CTLCOLORSTATIC:
 505     case WM_CTLCOLORSCROLLBAR:
 506         return (LRESULT)DEFWND_ControlColor( (HDC)wParam, msg - WM_CTLCOLORMSGBOX );
 507
 508     case WM_CTLCOLOR:
 509         return (LRESULT)DEFWND_ControlColor( (HDC)wParam, HIWORD(lParam) );
 510
 511     case WM_SETCURSOR:
 512         if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)
 513         {
 514             /* with the exception of the border around a resizable wnd,
 515              * give the parent first chance to set the cursor */
 516             if ((LOWORD(lParam) < HTSIZEFIRST) || (LOWORD(lParam) > HTSIZELAST))
 517             {
 518                 HWND parent = GetParent( hwnd );
 519                 if (parent != GetDesktopWindow() &&
 520                     SendMessageW( parent, WM_SETCURSOR, wParam, lParam )) return TRUE;
 521             }
 522         }
 523         NC_HandleSetCursor( hwnd, wParam, lParam );
 524         break;
 525
 526     case WM_SYSCOMMAND:
 527         return NC_HandleSysCommand( hwnd, wParam, lParam );
 528
 529     case WM_KEYDOWN:
 530         if(wParam == VK_F10) iF10Key = VK_F10;
 531         break;
 532
 533     case WM_SYSKEYDOWN:
 534         if( HIWORD(lParam) & KEYDATA_ALT )
 535         {
 536             /* if( HIWORD(lParam) & ~KEYDATA_PREVSTATE ) */
 537               if ( (wParam == VK_MENU || wParam == VK_LMENU
 538                     || wParam == VK_RMENU) && !iMenuSysKey )
 539                 iMenuSysKey = 1;
 540               else
 541                 iMenuSysKey = 0;
 542
 543             iF10Key = 0;
 544
 545             if( wParam == VK_F4 )       /* try to close the window */
 546             {
 547                 HWND top = GetAncestor( hwnd, GA_ROOT );
 548                 if (!(GetClassLongW( top, GCL_STYLE ) & CS_NOCLOSE))
 549                     PostMessageW( top, WM_SYSCOMMAND, SC_CLOSE, 0 );
 550             }
 551         }
 552         else if( wParam == VK_F10 )
 553         {
 554             if (GetKeyState(VK_SHIFT) & 0x8000)
 555                 SendMessageW( hwnd, WM_CONTEXTMENU, (WPARAM)hwnd, -1 );
 556             iF10Key = 1;
 557         }
 558         else if( wParam == VK_ESCAPE && (GetKeyState(VK_SHIFT) & 0x8000))
 559             SendMessageW( hwnd, WM_SYSCOMMAND, SC_KEYMENU, ' ' );
 560         break;
 561
 562     case WM_KEYUP:
 563     case WM_SYSKEYUP:
 564         /* Press and release F10 or ALT */
 565         if (((wParam == VK_MENU || wParam == VK_LMENU || wParam == VK_RMENU)
 566              && iMenuSysKey) || ((wParam == VK_F10) && iF10Key))
 567               SendMessageW( GetAncestor( hwnd, GA_ROOT ), WM_SYSCOMMAND, SC_KEYMENU, 0L );
 568         iMenuSysKey = iF10Key = 0;
 569         break;
 570
 571     case WM_SYSCHAR:
 572     {
 573         iMenuSysKey = 0;
 574         if (wParam == '\r' && IsIconic(hwnd))
 575         {
 576             PostMessageW( hwnd, WM_SYSCOMMAND, SC_RESTORE, 0L );
 577             break;
 578         }
 579         if ((HIWORD(lParam) & KEYDATA_ALT) && wParam)
 580         {
 581             if (wParam == '\t' || wParam == '\x1b') break;
 582             if (wParam == ' ' && (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD))
 583                 SendMessageW( GetParent(hwnd), msg, wParam, lParam );
 584             else
 585                 SendMessageW( hwnd, WM_SYSCOMMAND, SC_KEYMENU, wParam );
 586         }
 587         else /* check for Ctrl-Esc */
 588             if (wParam != '\x1b') MessageBeep(0);
 589         break;
 590     }
 591
 592     case WM_SHOWWINDOW:
 593         {
 594             LONG style = GetWindowLongW( hwnd, GWL_STYLE );
 595             WND *pWnd;
 596             if (!lParam) return 0; /* sent from ShowWindow */
 597             if ((style & WS_VISIBLE) && wParam) return 0;
 598             if (!(style & WS_VISIBLE) && !wParam) return 0;
 599             if (!GetWindow( hwnd, GW_OWNER )) return 0;
 600             if (!(pWnd = WIN_GetPtr( hwnd ))) return 0;
 601             if (pWnd == WND_OTHER_PROCESS) return 0;
 602             if (wParam)
 603             {
 604                 if (!(pWnd->flags & WIN_NEEDS_SHOW_OWNEDPOPUP))
 605                 {
 606                     WIN_ReleasePtr( pWnd );
 607                     return 0;
 608                 }
 609                 pWnd->flags &= ~WIN_NEEDS_SHOW_OWNEDPOPUP;
 610             }
 611             else pWnd->flags |= WIN_NEEDS_SHOW_OWNEDPOPUP;
 612             WIN_ReleasePtr( pWnd );
 613             ShowWindow( hwnd, wParam ? SW_SHOWNOACTIVATE : SW_HIDE );
 614             break;
 615         }
 616
 617     case WM_CANCELMODE:
 618         iMenuSysKey = 0;
 619         MENU_EndMenu( hwnd );
 620         if (GetCapture() == hwnd) ReleaseCapture();
 621         break;
 622
 623     case WM_VKEYTOITEM:
 624     case WM_CHARTOITEM:
 625         return -1;
 626
 627     case WM_DROPOBJECT:
 628         return DRAG_FILE;
 629
 630     case WM_QUERYDROPOBJECT:
 631         return (GetWindowLongA( hwnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES) != 0;
 632
 633     case WM_QUERYDRAGICON:
 634         {
 635             UINT len;
 636
 637             HICON hIcon = (HICON)GetClassLongPtrW( hwnd, GCLP_HICON );
 638             HINSTANCE instance = (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE );
 639             if (hIcon) return (LRESULT)hIcon;
 640             for(len=1; len<64; len++)
 641                 if((hIcon = LoadIconW(instance, MAKEINTRESOURCEW(len))))
 642                     return (LRESULT)hIcon;
 643             return (LRESULT)LoadIconW(0, (LPWSTR)IDI_APPLICATION);
 644         }
 645         break;
 646
 647     case WM_ISACTIVEICON:
 648         {
 649             WND *wndPtr = WIN_GetPtr( hwnd );
 650             BOOL ret = (wndPtr->flags & WIN_NCACTIVATED) != 0;
 651             WIN_ReleasePtr( wndPtr );
 652             return ret;
 653         }
 654
 655     case WM_NOTIFYFORMAT:
 656       if (IsWindowUnicode(hwnd)) return NFR_UNICODE;
 657       else return NFR_ANSI;
 658
 659     case WM_QUERYOPEN:
 660     case WM_QUERYENDSESSION:
 661         return 1;
 662
 663     case WM_SETICON:
 664         {
 665             HICON ret;
 666             WND *wndPtr = WIN_GetPtr( hwnd );
 667
 668             switch(wParam)
 669             {
 670             case ICON_SMALL:
 671                 ret = wndPtr->hIconSmall;
 672                 wndPtr->hIconSmall = (HICON)lParam;
 673                 break;
 674             case ICON_BIG:
 675                 ret = wndPtr->hIcon;
 676                 wndPtr->hIcon = (HICON)lParam;
 677                 break;
 678             default:
 679                 ret = 0;
 680                 break;
 681             }
 682             WIN_ReleasePtr( wndPtr );
 683
 684             USER_Driver->pSetWindowIcon( hwnd, wParam, (HICON)lParam );
 685
 686             if( (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CAPTION) == WS_CAPTION )
 687                 NC_HandleNCPaint( hwnd , (HRGN)1 );  /* Repaint caption */
 688
 689             return (LRESULT)ret;
 690         }
 691
 692     case WM_GETICON:
 693         {
 694             HICON ret;
 695             WND *wndPtr = WIN_GetPtr( hwnd );
 696
 697             switch(wParam)
 698             {
 699             case ICON_SMALL:
 700                 ret = wndPtr->hIconSmall;
 701                 break;
 702             case ICON_BIG:
 703                 ret = wndPtr->hIcon;
 704                 break;
 705             case ICON_SMALL2:
 706                 ret = wndPtr->hIconSmall;
 707                 if (!ret) ret = (HICON)GetClassLongPtrW( hwnd, GCLP_HICONSM );
 708                 /* FIXME: should have a default here if class icon is null */
 709                 break;
 710             default:
 711                 ret = 0;
 712                 break;
 713             }
 714             WIN_ReleasePtr( wndPtr );
 715             return (LRESULT)ret;
 716         }
 717
 718     case WM_HELP:
 719         SendMessageW( GetParent(hwnd), msg, wParam, lParam );
 720         break;
 721
 722     case WM_STYLECHANGED:
 723         if (wParam == GWL_STYLE && (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_LAYERED))
 724         {
 725             STYLESTRUCT *style = (STYLESTRUCT *)lParam;
 726             if ((style->styleOld ^ style->styleNew) & (WS_CAPTION|WS_THICKFRAME|WS_VSCROLL|WS_HSCROLL))
 727                 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOZORDER |
 728                               SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE );
 729         }
 730         break;
 731
 732     case WM_APPCOMMAND:
 733         {
 734             HWND parent = GetParent(hwnd);
 735             if(!parent)
 736                 HOOK_CallHooks(WH_SHELL, HSHELL_APPCOMMAND, wParam, lParam, TRUE);
 737             else
 738                 SendMessageW( parent, msg, wParam, lParam );
 739             break;
 740         }
 741     case WM_KEYF1:
 742         {
 743             HELPINFO hi;
 744
 745             hi.cbSize = sizeof(HELPINFO);
 746             GetCursorPos( &hi.MousePos );
 747             if (MENU_IsMenuActive())
 748             {
 749                 hi.iContextType = HELPINFO_MENUITEM;
 750                 hi.hItemHandle = MENU_IsMenuActive();
 751                 hi.iCtrlId = MenuItemFromPoint( hwnd, hi.hItemHandle, hi.MousePos );
 752                 hi.dwContextId = GetMenuContextHelpId( hi.hItemHandle );
 753             }
 754             else
 755             {
 756                 hi.iContextType = HELPINFO_WINDOW;
 757                 hi.hItemHandle = hwnd;
 758                 hi.iCtrlId = GetWindowLongPtrA( hwnd, GWLP_ID );
 759                 hi.dwContextId = GetWindowContextHelpId( hwnd );
 760             }
 761             SendMessageW( hwnd, WM_HELP, 0, (LPARAM)&hi );
 762             break;
 763         }
 764
 765     case WM_INPUTLANGCHANGEREQUEST:
 766         ActivateKeyboardLayout( (HKL)lParam, 0 );
 767         break;
 768
 769     case WM_INPUTLANGCHANGE:
 770         {
 771             int count = 0;
 772             HWND *win_array = WIN_ListChildren( hwnd );
 773
 774             if (!win_array)
 775                 break;
 776             while (win_array[count])
 777                 SendMessageW( win_array[count++], WM_INPUTLANGCHANGE, wParam, lParam);
 778             HeapFree(GetProcessHeap(),0,win_array);
 779             break;
 780         }
 781
 782     }
 783
 784     return 0;
 785 }
 786
 787 static LPARAM DEFWND_GetTextA( WND *wndPtr, LPSTR dest, WPARAM wParam )
 788 {
 789     LPARAM result = 0;
 790
 791     __TRY
 792     {
 793         if (wndPtr->text)
 794         {
 795             if (!WideCharToMultiByte( CP_ACP, 0, wndPtr->text, -1,
 796                                       dest, wParam, NULL, NULL )) dest[wParam-1] = 0;
 797             result = strlen( dest );
 798         }
 799         else dest[0] = '\0';
 800     }
 801     __EXCEPT_PAGE_FAULT
 802     {
 803         return 0;
 804     }
 805     __ENDTRY
 806     return result;
 807 }
 808
 809 /***********************************************************************
 810  *              DefWindowProcA (USER32.@)
 811  *
 812  * See DefWindowProcW.
 813  */
 814 LRESULT WINAPI DefWindowProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
 815 {
 816     LRESULT result = 0;
 817     HWND full_handle;
 818
 819     if (!(full_handle = WIN_IsCurrentProcess( hwnd )))
 820     {
 821         if (!IsWindow( hwnd )) return 0;
 822         ERR( "called for other process window %p\n", hwnd );
 823         return 0;
 824     }
 825     hwnd = full_handle;
 826
 827     SPY_EnterMessage( SPY_DEFWNDPROC, hwnd, msg, wParam, lParam );
 828
 829     switch(msg)
 830     {
 831     case WM_NCCREATE:
 832         if (lParam)
 833         {
 834             CREATESTRUCTA *cs = (CREATESTRUCTA *)lParam;
 835             /* check for string, as static icons, bitmaps (SS_ICON, SS_BITMAP)
 836              * may have child window IDs instead of window name */
 837             if (!IS_INTRESOURCE(cs->lpszName))
 838                 DEFWND_SetTextA( hwnd, cs->lpszName );
 839             result = 1;
 840
 841             if(cs->style & (WS_HSCROLL | WS_VSCROLL))
 842             {
 843                 SCROLLINFO si = {sizeof si, SIF_ALL, 0, 100, 0, 0, 0};
 844                 SetScrollInfo( hwnd, SB_HORZ, &si, FALSE );
 845                 SetScrollInfo( hwnd, SB_VERT, &si, FALSE );
 846             }
 847         }
 848         break;
 849
 850     case WM_GETTEXTLENGTH:
 851         {
 852             WND *wndPtr = WIN_GetPtr( hwnd );
 853             if (wndPtr && wndPtr->text)
 854                 result = WideCharToMultiByte( CP_ACP, 0, wndPtr->text, strlenW(wndPtr->text),
 855                                               NULL, 0, NULL, NULL );
 856             WIN_ReleasePtr( wndPtr );
 857         }
 858         break;
 859
 860     case WM_GETTEXT:
 861         if (wParam)
 862         {
 863             LPSTR dest = (LPSTR)lParam;
 864             WND *wndPtr = WIN_GetPtr( hwnd );
 865
 866             if (!wndPtr) break;
 867             result = DEFWND_GetTextA( wndPtr, dest, wParam );
 868
 869             WIN_ReleasePtr( wndPtr );
 870         }
 871         break;
 872
 873     case WM_SETTEXT:
 874         DEFWND_SetTextA( hwnd, (LPCSTR)lParam );
 875         if( (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CAPTION) == WS_CAPTION )
 876             NC_HandleNCPaint( hwnd , (HRGN)1 );  /* Repaint caption */
 877         result = 1; /* success. FIXME: check text length */
 878         break;
 879
 880     case WM_IME_CHAR:
 881         if (HIBYTE(wParam)) PostMessageA( hwnd, WM_CHAR, HIBYTE(wParam), lParam );
 882         PostMessageA( hwnd, WM_CHAR, LOBYTE(wParam), lParam );
 883         break;
 884
 885     case WM_IME_KEYDOWN:
 886         result = PostMessageA( hwnd, WM_KEYDOWN, wParam, lParam );
 887         break;
 888
 889     case WM_IME_KEYUP:
 890         result = PostMessageA( hwnd, WM_KEYUP, wParam, lParam );
 891         break;
 892
 893     case WM_IME_STARTCOMPOSITION:
 894     case WM_IME_COMPOSITION:
 895     case WM_IME_ENDCOMPOSITION:
 896     case WM_IME_SELECT:
 897     case WM_IME_NOTIFY:
 898         {
 899             HWND hwndIME;
 900
 901             hwndIME = DEFWND_ImmGetDefaultIMEWnd( hwnd );
 902             if (hwndIME)
 903                 result = SendMessageA( hwndIME, msg, wParam, lParam );
 904         }
 905         break;
 906     case WM_IME_SETCONTEXT:
 907         {
 908             HWND hwndIME;
 909
 910             hwndIME = DEFWND_ImmGetDefaultIMEWnd( hwnd );
 911             if (hwndIME)
 912                 result = DEFWND_ImmIsUIMessageA( hwndIME, msg, wParam, lParam );
 913         }
 914         break;
 915
 916     case WM_SYSCHAR:
 917     {
 918         CHAR ch = LOWORD(wParam);
 919         WCHAR wch;
 920         MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wch, 1);
 921         wParam = MAKEWPARAM( wch, HIWORD(wParam) );
 922     }
 923     /* fall through */
 924     default:
 925         result = DEFWND_DefWinProc( hwnd, msg, wParam, lParam );
 926         break;
 927     }
 928
 929     SPY_ExitMessage( SPY_RESULT_DEFWND, hwnd, msg, result, wParam, lParam );
 930     return result;
 931 }
 932
 933
 934 static LPARAM DEFWND_GetTextW( WND *wndPtr, LPWSTR dest, WPARAM wParam )
 935 {
 936     LPARAM result = 0;
 937
 938     __TRY
 939     {
 940         if (wndPtr->text)
 941         {
 942             lstrcpynW( dest, wndPtr->text, wParam );
 943             result = strlenW( dest );
 944         }
 945         else dest[0] = '\0';
 946     }
 947     __EXCEPT_PAGE_FAULT
 948     {
 949         return 0;
 950     }
 951     __ENDTRY
 952
 953     return result;
 954 }
 955
 956 /***********************************************************************
 957  *              DefWindowProcW (USER32.@) Calls default window message handler
 958  *
 959  * Calls default window procedure for messages not processed
 960  *  by application.
 961  *
 962  *  RETURNS
 963  *     Return value is dependent upon the message.
 964 */
 965 LRESULT WINAPI DefWindowProcW(
 966     HWND hwnd,      /* [in] window procedure receiving message */
 967     UINT msg,       /* [in] message identifier */
 968     WPARAM wParam,  /* [in] first message parameter */
 969     LPARAM lParam )   /* [in] second message parameter */
 970 {
 971     LRESULT result = 0;
 972     HWND full_handle;
 973
 974     if (!(full_handle = WIN_IsCurrentProcess( hwnd )))
 975     {
 976         if (!IsWindow( hwnd )) return 0;
 977         ERR( "called for other process window %p\n", hwnd );
 978         return 0;
 979     }
 980     hwnd = full_handle;
 981     SPY_EnterMessage( SPY_DEFWNDPROC, hwnd, msg, wParam, lParam );
 982
 983     switch(msg)
 984     {
 985     case WM_NCCREATE:
 986         if (lParam)
 987         {
 988             CREATESTRUCTW *cs = (CREATESTRUCTW *)lParam;
 989             /* check for string, as static icons, bitmaps (SS_ICON, SS_BITMAP)
 990              * may have child window IDs instead of window name */
 991             if (!IS_INTRESOURCE(cs->lpszName))
 992                 DEFWND_SetTextW( hwnd, cs->lpszName );
 993             result = 1;
 994
 995             if(cs->style & (WS_HSCROLL | WS_VSCROLL))
 996             {
 997                 SCROLLINFO si = {sizeof si, SIF_ALL, 0, 100, 0, 0, 0};
 998                 SetScrollInfo( hwnd, SB_HORZ, &si, FALSE );
 999                 SetScrollInfo( hwnd, SB_VERT, &si, FALSE );
1000             }
1001         }
1002         break;
1003
1004     case WM_GETTEXTLENGTH:
1005         {
1006             WND *wndPtr = WIN_GetPtr( hwnd );
1007             if (wndPtr && wndPtr->text) result = (LRESULT)strlenW(wndPtr->text);
1008             WIN_ReleasePtr( wndPtr );
1009         }
1010         break;
1011
1012     case WM_GETTEXT:
1013         if (wParam)
1014         {
1015             LPWSTR dest = (LPWSTR)lParam;
1016             WND *wndPtr = WIN_GetPtr( hwnd );
1017
1018             if (!wndPtr) break;
1019             result = DEFWND_GetTextW( wndPtr, dest, wParam );
1020             WIN_ReleasePtr( wndPtr );
1021         }
1022         break;
1023
1024     case WM_SETTEXT:
1025         DEFWND_SetTextW( hwnd, (LPCWSTR)lParam );
1026         if( (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CAPTION) == WS_CAPTION )
1027             NC_HandleNCPaint( hwnd , (HRGN)1 );  /* Repaint caption */
1028         result = 1; /* success. FIXME: check text length */
1029         break;
1030
1031     case WM_IME_CHAR:
1032         PostMessageW( hwnd, WM_CHAR, wParam, lParam );
1033         break;
1034
1035     case WM_IME_KEYDOWN:
1036         result = PostMessageW( hwnd, WM_KEYDOWN, wParam, lParam );
1037         break;
1038
1039     case WM_IME_KEYUP:
1040         result = PostMessageW( hwnd, WM_KEYUP, wParam, lParam );
1041         break;
1042
1043     case WM_IME_SETCONTEXT:
1044         {
1045             HWND hwndIME;
1046
1047             hwndIME = DEFWND_ImmGetDefaultIMEWnd( hwnd );
1048             if (hwndIME)
1049                 result = DEFWND_ImmIsUIMessageW( hwndIME, msg, wParam, lParam );
1050         }
1051         break;
1052
1053     case WM_IME_STARTCOMPOSITION:
1054     case WM_IME_COMPOSITION:
1055     case WM_IME_ENDCOMPOSITION:
1056     case WM_IME_SELECT:
1057     case WM_IME_NOTIFY:
1058         {
1059             HWND hwndIME;
1060
1061             hwndIME = DEFWND_ImmGetDefaultIMEWnd( hwnd );
1062             if (hwndIME)
1063                 result = SendMessageW( hwndIME, msg, wParam, lParam );
1064         }
1065         break;
1066
1067     default:
1068         result = DEFWND_DefWinProc( hwnd, msg, wParam, lParam );
1069         break;
1070     }
1071     SPY_ExitMessage( SPY_RESULT_DEFWND, hwnd, msg, result, wParam, lParam );
1072     return result;
1073 }