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