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/server.h"
  38 #include "wine/exception.h"
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(win);
  42
  43   /* bits in the dwKeyData */
  44 #define KEYDATA_ALT             0x2000
  45 #define KEYDATA_PREVSTATE       0x4000
  46
  47 #define DRAG_FILE  0x454C4946
  48
  49 static short iF10Key = 0;
  50 static short iMenuSysKey = 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_Get55AABrush();
 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 /***********************************************************************
 228  *           DEFWND_DefWinProc
 229  *
 230  * Default window procedure for messages that are the same in Ansi and Unicode.
 231  */
 232 static LRESULT DEFWND_DefWinProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
 233 {
 234     switch(msg)
 235     {
 236     case WM_NCPAINT:
 237         return NC_HandleNCPaint( hwnd, (HRGN)wParam );
 238
 239     case WM_NCHITTEST:
 240         {
 241             POINT pt;
 242             pt.x = (short)LOWORD(lParam);
 243             pt.y = (short)HIWORD(lParam);
 244             return NC_HandleNCHitTest( hwnd, pt );
 245         }
 246
 247     case WM_NCCALCSIZE:
 248         return NC_HandleNCCalcSize( hwnd, wParam, (RECT *)lParam );
 249
 250     case WM_WINDOWPOSCHANGING:
 251         return WINPOS_HandleWindowPosChanging( hwnd, (WINDOWPOS *)lParam );
 252
 253     case WM_WINDOWPOSCHANGED:
 254         DEFWND_HandleWindowPosChanged( hwnd, (const WINDOWPOS *)lParam );
 255         break;
 256
 257     case WM_LBUTTONDOWN:
 258     case WM_RBUTTONDOWN:
 259     case WM_MBUTTONDOWN:
 260         iF10Key = iMenuSysKey = 0;
 261         break;
 262
 263     case WM_NCLBUTTONDOWN:
 264         return NC_HandleNCLButtonDown( hwnd, wParam, lParam );
 265
 266     case WM_LBUTTONDBLCLK:
 267         return NC_HandleNCLButtonDblClk( hwnd, HTCLIENT, lParam );
 268
 269     case WM_NCLBUTTONDBLCLK:
 270         return NC_HandleNCLButtonDblClk( hwnd, wParam, lParam );
 271
 272     case WM_NCRBUTTONDOWN:
 273         return NC_HandleNCRButtonDown( hwnd, wParam, lParam );
 274
 275     case WM_RBUTTONUP:
 276         {
 277             POINT pt;
 278             pt.x = (short)LOWORD(lParam);
 279             pt.y = (short)HIWORD(lParam);
 280             ClientToScreen(hwnd, &pt);
 281             SendMessageW( hwnd, WM_CONTEXTMENU, (WPARAM)hwnd, MAKELPARAM(pt.x, pt.y) );
 282         }
 283         break;
 284
 285     case WM_NCRBUTTONUP:
 286         /*
 287          * FIXME : we must NOT send WM_CONTEXTMENU on a WM_NCRBUTTONUP (checked
 288          * in Windows), but what _should_ we do? According to MSDN :
 289          * "If it is appropriate to do so, the system sends the WM_SYSCOMMAND
 290          * message to the window". When is it appropriate?
 291          */
 292         break;
 293
 294     case WM_CONTEXTMENU:
 295         if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)
 296             SendMessageW( GetParent(hwnd), msg, wParam, lParam );
 297         else
 298         {
 299             LONG hitcode;
 300             POINT pt;
 301             WND *wndPtr = WIN_GetPtr( hwnd );
 302             HMENU hMenu = wndPtr->hSysMenu;
 303             WIN_ReleasePtr( wndPtr );
 304             if (!hMenu) return 0;
 305             pt.x = (short)LOWORD(lParam);
 306             pt.y = (short)HIWORD(lParam);
 307             hitcode = NC_HandleNCHitTest(hwnd, pt);
 308
 309             /* Track system popup if click was in the caption area. */
 310             if (hitcode==HTCAPTION || hitcode==HTSYSMENU)
 311                TrackPopupMenu(GetSystemMenu(hwnd, FALSE),
 312                                TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
 313                                pt.x, pt.y, 0, hwnd, NULL);
 314         }
 315         break;
 316
 317     case WM_POPUPSYSTEMMENU:
 318         {
 319             /* This is an undocumented message used by the windows taskbar to
 320                display the system menu of windows that belong to other processes. */
 321             HMENU menu = GetSystemMenu(hwnd, FALSE);
 322
 323             if (menu)
 324                 TrackPopupMenu(menu, TPM_LEFTBUTTON|TPM_RIGHTBUTTON,
 325                                LOWORD(lParam), HIWORD(lParam), 0, hwnd, NULL);
 326             return 0;
 327         }
 328
 329     case WM_NCACTIVATE:
 330         return NC_HandleNCActivate( hwnd, wParam, lParam );
 331
 332     case WM_NCDESTROY:
 333         {
 334             WND *wndPtr = WIN_GetPtr( hwnd );
 335             if (!wndPtr) return 0;
 336             HeapFree( GetProcessHeap(), 0, wndPtr->text );
 337             wndPtr->text = NULL;
 338             HeapFree( GetProcessHeap(), 0, wndPtr->pScroll );
 339             wndPtr->pScroll = NULL;
 340             WIN_ReleasePtr( wndPtr );
 341             return 0;
 342         }
 343
 344     case WM_PRINT:
 345         DEFWND_Print(hwnd, (HDC)wParam, lParam);
 346         return 0;
 347
 348     case WM_PAINTICON:
 349     case WM_PAINT:
 350         {
 351             PAINTSTRUCT ps;
 352             HDC hdc = BeginPaint( hwnd, &ps );
 353             if( hdc )
 354             {
 355               HICON hIcon;
 356               if (IsIconic(hwnd) && ((hIcon = (HICON)GetClassLongPtrW( hwnd, GCLP_HICON))) )
 357               {
 358                   RECT rc;
 359                   int x, y;
 360
 361                   GetClientRect( hwnd, &rc );
 362                   x = (rc.right - rc.left - GetSystemMetrics(SM_CXICON))/2;
 363                   y = (rc.bottom - rc.top - GetSystemMetrics(SM_CYICON))/2;
 364                   TRACE("Painting class icon: vis rect=(%s)\n",
 365                         wine_dbgstr_rect(&ps.rcPaint));
 366                   DrawIcon( hdc, x, y, hIcon );
 367               }
 368               EndPaint( hwnd, &ps );
 369             }
 370             return 0;
 371         }
 372
 373     case WM_SYNCPAINT:
 374         RedrawWindow ( hwnd, NULL, 0, RDW_ERASENOW | RDW_ERASE | RDW_ALLCHILDREN );
 375         return 0;
 376
 377     case WM_SETREDRAW:
 378         if (wParam) WIN_SetStyle( hwnd, WS_VISIBLE, 0 );
 379         else
 380         {
 381             RedrawWindow( hwnd, NULL, 0, RDW_ALLCHILDREN | RDW_VALIDATE );
 382             WIN_SetStyle( hwnd, 0, WS_VISIBLE );
 383         }
 384         return 0;
 385
 386     case WM_CLOSE:
 387         DestroyWindow( hwnd );
 388         return 0;
 389
 390     case WM_MOUSEACTIVATE:
 391         if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)
 392         {
 393             LONG ret = SendMessageW( GetParent(hwnd), WM_MOUSEACTIVATE, wParam, lParam );
 394             if (ret) return ret;
 395         }
 396
 397         /* Caption clicks are handled by NC_HandleNCLButtonDown() */
 398         return MA_ACTIVATE;
 399
 400     case WM_ACTIVATE:
 401         /* The default action in Windows is to set the keyboard focus to
 402          * the window, if it's being activated and not minimized */
 403         if (LOWORD(wParam) != WA_INACTIVE) {
 404             if (!IsIconic(hwnd)) SetFocus(hwnd);
 405         }
 406         break;
 407
 408     case WM_MOUSEWHEEL:
 409         if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)
 410             return SendMessageW( GetParent(hwnd), WM_MOUSEWHEEL, wParam, lParam );
 411         break;
 412
 413     case WM_ERASEBKGND:
 414     case WM_ICONERASEBKGND:
 415         {
 416             RECT rect;
 417             HDC hdc = (HDC)wParam;
 418             HBRUSH hbr = (HBRUSH)GetClassLongPtrW( hwnd, GCLP_HBRBACKGROUND );
 419             if (!hbr) return 0;
 420
 421             if (GetClassLongW( hwnd, GCL_STYLE ) & CS_PARENTDC)
 422             {
 423                 /* can't use GetClipBox with a parent DC or we fill the whole parent */
 424                 GetClientRect( hwnd, &rect );
 425                 DPtoLP( hdc, (LPPOINT)&rect, 2 );
 426             }
 427             else GetClipBox( hdc, &rect );
 428             FillRect( hdc, &rect, hbr );
 429             return 1;
 430         }
 431
 432     case WM_GETDLGCODE:
 433         return 0;
 434
 435     case WM_CTLCOLORMSGBOX:
 436     case WM_CTLCOLOREDIT:
 437     case WM_CTLCOLORLISTBOX:
 438     case WM_CTLCOLORBTN:
 439     case WM_CTLCOLORDLG:
 440     case WM_CTLCOLORSTATIC:
 441     case WM_CTLCOLORSCROLLBAR:
 442         return (LRESULT)DEFWND_ControlColor( (HDC)wParam, msg - WM_CTLCOLORMSGBOX );
 443
 444     case WM_CTLCOLOR:
 445         return (LRESULT)DEFWND_ControlColor( (HDC)wParam, HIWORD(lParam) );
 446
 447     case WM_SETCURSOR:
 448         if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)
 449         {
 450             /* with the exception of the border around a resizable wnd,
 451              * give the parent first chance to set the cursor */
 452             if ((LOWORD(lParam) < HTSIZEFIRST) || (LOWORD(lParam) > HTSIZELAST))
 453             {
 454                 HWND parent = GetParent( hwnd );
 455                 if (parent != GetDesktopWindow() &&
 456                     SendMessageW( parent, WM_SETCURSOR, wParam, lParam )) return TRUE;
 457             }
 458         }
 459         NC_HandleSetCursor( hwnd, wParam, lParam );
 460         break;
 461
 462     case WM_SYSCOMMAND:
 463         return NC_HandleSysCommand( hwnd, wParam, lParam );
 464
 465     case WM_KEYDOWN:
 466         if(wParam == VK_F10) iF10Key = VK_F10;
 467         break;
 468
 469     case WM_SYSKEYDOWN:
 470         if( HIWORD(lParam) & KEYDATA_ALT )
 471         {
 472             /* if( HIWORD(lParam) & ~KEYDATA_PREVSTATE ) */
 473               if ( (wParam == VK_MENU || wParam == VK_LMENU
 474                     || wParam == VK_RMENU) && !iMenuSysKey )
 475                 iMenuSysKey = 1;
 476               else
 477                 iMenuSysKey = 0;
 478
 479             iF10Key = 0;
 480
 481             if( wParam == VK_F4 )       /* try to close the window */
 482             {
 483                 HWND top = GetAncestor( hwnd, GA_ROOT );
 484                 if (!(GetClassLongW( top, GCL_STYLE ) & CS_NOCLOSE))
 485                     PostMessageW( top, WM_SYSCOMMAND, SC_CLOSE, 0 );
 486             }
 487         }
 488         else if( wParam == VK_F10 )
 489         {
 490             if (GetKeyState(VK_SHIFT) & 0x8000)
 491                 SendMessageW( hwnd, WM_CONTEXTMENU, (WPARAM)hwnd, -1 );
 492             iF10Key = 1;
 493         }
 494         else if( wParam == VK_ESCAPE && (GetKeyState(VK_SHIFT) & 0x8000))
 495             SendMessageW( hwnd, WM_SYSCOMMAND, SC_KEYMENU, ' ' );
 496         break;
 497
 498     case WM_KEYUP:
 499     case WM_SYSKEYUP:
 500         /* Press and release F10 or ALT */
 501         if (((wParam == VK_MENU || wParam == VK_LMENU || wParam == VK_RMENU)
 502              && iMenuSysKey) || ((wParam == VK_F10) && iF10Key))
 503               SendMessageW( GetAncestor( hwnd, GA_ROOT ), WM_SYSCOMMAND, SC_KEYMENU, 0L );
 504         iMenuSysKey = iF10Key = 0;
 505         break;
 506
 507     case WM_SYSCHAR:
 508     {
 509         iMenuSysKey = 0;
 510         if (wParam == '\r' && IsIconic(hwnd))
 511         {
 512             PostMessageW( hwnd, WM_SYSCOMMAND, SC_RESTORE, 0L );
 513             break;
 514         }
 515         if ((HIWORD(lParam) & KEYDATA_ALT) && wParam)
 516         {
 517             if (wParam == '\t' || wParam == '\x1b') break;
 518             if (wParam == ' ' && (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD))
 519                 SendMessageW( GetParent(hwnd), msg, wParam, lParam );
 520             else
 521                 SendMessageW( hwnd, WM_SYSCOMMAND, SC_KEYMENU, wParam );
 522         }
 523         else /* check for Ctrl-Esc */
 524             if (wParam != '\x1b') MessageBeep(0);
 525         break;
 526     }
 527
 528     case WM_SHOWWINDOW:
 529         {
 530             LONG style = GetWindowLongW( hwnd, GWL_STYLE );
 531             WND *pWnd;
 532             if (!lParam) return 0; /* sent from ShowWindow */
 533             if ((style & WS_VISIBLE) && wParam) return 0;
 534             if (!(style & WS_VISIBLE) && !wParam) return 0;
 535             if (!GetWindow( hwnd, GW_OWNER )) return 0;
 536             if (!(pWnd = WIN_GetPtr( hwnd ))) return 0;
 537             if (pWnd == WND_OTHER_PROCESS) return 0;
 538             if (wParam)
 539             {
 540                 if (!(pWnd->flags & WIN_NEEDS_SHOW_OWNEDPOPUP))
 541                 {
 542                     WIN_ReleasePtr( pWnd );
 543                     return 0;
 544                 }
 545                 pWnd->flags &= ~WIN_NEEDS_SHOW_OWNEDPOPUP;
 546             }
 547             else pWnd->flags |= WIN_NEEDS_SHOW_OWNEDPOPUP;
 548             WIN_ReleasePtr( pWnd );
 549             ShowWindow( hwnd, wParam ? SW_SHOWNOACTIVATE : SW_HIDE );
 550             break;
 551         }
 552
 553     case WM_CANCELMODE:
 554         iMenuSysKey = 0;
 555         MENU_EndMenu( hwnd );
 556         if (GetCapture() == hwnd) ReleaseCapture();
 557         break;
 558
 559     case WM_VKEYTOITEM:
 560     case WM_CHARTOITEM:
 561         return -1;
 562
 563     case WM_DROPOBJECT:
 564         return DRAG_FILE;
 565
 566     case WM_QUERYDROPOBJECT:
 567         return (GetWindowLongA( hwnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES) != 0;
 568
 569     case WM_QUERYDRAGICON:
 570         {
 571             UINT len;
 572
 573             HICON hIcon = (HICON)GetClassLongPtrW( hwnd, GCLP_HICON );
 574             HINSTANCE instance = (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE );
 575             if (hIcon) return (LRESULT)hIcon;
 576             for(len=1; len<64; len++)
 577                 if((hIcon = LoadIconW(instance, MAKEINTRESOURCEW(len))))
 578                     return (LRESULT)hIcon;
 579             return (LRESULT)LoadIconW(0, (LPWSTR)IDI_APPLICATION);
 580         }
 581         break;
 582
 583     case WM_ISACTIVEICON:
 584         {
 585             WND *wndPtr = WIN_GetPtr( hwnd );
 586             BOOL ret = (wndPtr->flags & WIN_NCACTIVATED) != 0;
 587             WIN_ReleasePtr( wndPtr );
 588             return ret;
 589         }
 590
 591     case WM_NOTIFYFORMAT:
 592       if (IsWindowUnicode(hwnd)) return NFR_UNICODE;
 593       else return NFR_ANSI;
 594
 595     case WM_QUERYOPEN:
 596     case WM_QUERYENDSESSION:
 597         return 1;
 598
 599     case WM_SETICON:
 600         {
 601             HICON ret;
 602             WND *wndPtr = WIN_GetPtr( hwnd );
 603
 604             switch(wParam)
 605             {
 606             case ICON_SMALL:
 607                 ret = wndPtr->hIconSmall;
 608                 if (ret && !lParam && wndPtr->hIcon)
 609                 {
 610                     wndPtr->hIconSmall2 = CopyImage( wndPtr->hIcon, IMAGE_ICON,
 611                                                      GetSystemMetrics( SM_CXSMICON ),
 612                                                      GetSystemMetrics( SM_CYSMICON ), 0 );
 613                 }
 614                 else if (lParam && wndPtr->hIconSmall2)
 615                 {
 616                     DestroyIcon( wndPtr->hIconSmall2 );
 617                     wndPtr->hIconSmall2 = NULL;
 618                 }
 619                 wndPtr->hIconSmall = (HICON)lParam;
 620                 break;
 621             case ICON_BIG:
 622                 ret = wndPtr->hIcon;
 623                 if (wndPtr->hIconSmall2)
 624                 {
 625                     DestroyIcon( wndPtr->hIconSmall2 );
 626                     wndPtr->hIconSmall2 = NULL;
 627                 }
 628                 if (lParam && !wndPtr->hIconSmall)
 629                 {
 630                     wndPtr->hIconSmall2 = CopyImage( (HICON)lParam, IMAGE_ICON,
 631                                                      GetSystemMetrics( SM_CXSMICON ),
 632                                                      GetSystemMetrics( SM_CYSMICON ), 0 );
 633                 }
 634                 wndPtr->hIcon = (HICON)lParam;
 635                 break;
 636             default:
 637                 ret = 0;
 638                 break;
 639             }
 640             WIN_ReleasePtr( wndPtr );
 641
 642             USER_Driver->pSetWindowIcon( hwnd, wParam, (HICON)lParam );
 643
 644             if( (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CAPTION) == WS_CAPTION )
 645                 NC_HandleNCPaint( hwnd , (HRGN)1 );  /* Repaint caption */
 646
 647             return (LRESULT)ret;
 648         }
 649
 650     case WM_GETICON:
 651         {
 652             HICON ret;
 653             WND *wndPtr = WIN_GetPtr( hwnd );
 654
 655             switch(wParam)
 656             {
 657             case ICON_SMALL:
 658                 ret = wndPtr->hIconSmall;
 659                 break;
 660             case ICON_BIG:
 661                 ret = wndPtr->hIcon;
 662                 break;
 663             case ICON_SMALL2:
 664                 ret = wndPtr->hIconSmall ? wndPtr->hIconSmall : wndPtr->hIconSmall2;
 665                 break;
 666             default:
 667                 ret = 0;
 668                 break;
 669             }
 670             WIN_ReleasePtr( wndPtr );
 671             return (LRESULT)ret;
 672         }
 673
 674     case WM_HELP:
 675         SendMessageW( GetParent(hwnd), msg, wParam, lParam );
 676         break;
 677
 678     case WM_STYLECHANGED:
 679         if (wParam == GWL_STYLE && (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_LAYERED))
 680         {
 681             STYLESTRUCT *style = (STYLESTRUCT *)lParam;
 682             if ((style->styleOld ^ style->styleNew) & (WS_CAPTION|WS_THICKFRAME|WS_VSCROLL|WS_HSCROLL))
 683                 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOZORDER |
 684                               SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE );
 685         }
 686         break;
 687
 688     case WM_APPCOMMAND:
 689         {
 690             HWND parent = GetParent(hwnd);
 691             if(!parent)
 692                 HOOK_CallHooks(WH_SHELL, HSHELL_APPCOMMAND, wParam, lParam, TRUE);
 693             else
 694                 SendMessageW( parent, msg, wParam, lParam );
 695             break;
 696         }
 697     case WM_KEYF1:
 698         {
 699             HELPINFO hi;
 700
 701             hi.cbSize = sizeof(HELPINFO);
 702             GetCursorPos( &hi.MousePos );
 703             if (MENU_IsMenuActive())
 704             {
 705                 hi.iContextType = HELPINFO_MENUITEM;
 706                 hi.hItemHandle = MENU_IsMenuActive();
 707                 hi.iCtrlId = MenuItemFromPoint( hwnd, hi.hItemHandle, hi.MousePos );
 708                 hi.dwContextId = GetMenuContextHelpId( hi.hItemHandle );
 709             }
 710             else
 711             {
 712                 hi.iContextType = HELPINFO_WINDOW;
 713                 hi.hItemHandle = hwnd;
 714                 hi.iCtrlId = GetWindowLongPtrA( hwnd, GWLP_ID );
 715                 hi.dwContextId = GetWindowContextHelpId( hwnd );
 716             }
 717             SendMessageW( hwnd, WM_HELP, 0, (LPARAM)&hi );
 718             break;
 719         }
 720
 721     case WM_INPUTLANGCHANGEREQUEST:
 722         ActivateKeyboardLayout( (HKL)lParam, 0 );
 723         break;
 724
 725     case WM_INPUTLANGCHANGE:
 726         {
 727             int count = 0;
 728             HWND *win_array = WIN_ListChildren( hwnd );
 729
 730             if (!win_array)
 731                 break;
 732             while (win_array[count])
 733                 SendMessageW( win_array[count++], WM_INPUTLANGCHANGE, wParam, lParam);
 734             HeapFree(GetProcessHeap(),0,win_array);
 735             break;
 736         }
 737
 738     }
 739
 740     return 0;
 741 }
 742
 743 static LPARAM DEFWND_GetTextA( WND *wndPtr, LPSTR dest, WPARAM wParam )
 744 {
 745     LPARAM result = 0;
 746
 747     __TRY
 748     {
 749         if (wndPtr->text)
 750         {
 751             if (!WideCharToMultiByte( CP_ACP, 0, wndPtr->text, -1,
 752                                       dest, wParam, NULL, NULL )) dest[wParam-1] = 0;
 753             result = strlen( dest );
 754         }
 755         else dest[0] = '\0';
 756     }
 757     __EXCEPT_PAGE_FAULT
 758     {
 759         return 0;
 760     }
 761     __ENDTRY
 762     return result;
 763 }
 764
 765 /***********************************************************************
 766  *              DefWindowProcA (USER32.@)
 767  *
 768  * See DefWindowProcW.
 769  */
 770 LRESULT WINAPI DefWindowProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
 771 {
 772     LRESULT result = 0;
 773     HWND full_handle;
 774
 775     if (!(full_handle = WIN_IsCurrentProcess( hwnd )))
 776     {
 777         if (!IsWindow( hwnd )) return 0;
 778         ERR( "called for other process window %p\n", hwnd );
 779         return 0;
 780     }
 781     hwnd = full_handle;
 782
 783     SPY_EnterMessage( SPY_DEFWNDPROC, hwnd, msg, wParam, lParam );
 784
 785     switch(msg)
 786     {
 787     case WM_NCCREATE:
 788         if (lParam)
 789         {
 790             CREATESTRUCTA *cs = (CREATESTRUCTA *)lParam;
 791             /* check for string, as static icons, bitmaps (SS_ICON, SS_BITMAP)
 792              * may have child window IDs instead of window name */
 793             if (!IS_INTRESOURCE(cs->lpszName))
 794                 DEFWND_SetTextA( hwnd, cs->lpszName );
 795             result = 1;
 796
 797             if(cs->style & (WS_HSCROLL | WS_VSCROLL))
 798             {
 799                 SCROLLINFO si = {sizeof si, SIF_ALL, 0, 100, 0, 0, 0};
 800                 SetScrollInfo( hwnd, SB_HORZ, &si, FALSE );
 801                 SetScrollInfo( hwnd, SB_VERT, &si, FALSE );
 802             }
 803         }
 804         break;
 805
 806     case WM_GETTEXTLENGTH:
 807         {
 808             WND *wndPtr = WIN_GetPtr( hwnd );
 809             if (wndPtr && wndPtr->text)
 810                 result = WideCharToMultiByte( CP_ACP, 0, wndPtr->text, strlenW(wndPtr->text),
 811                                               NULL, 0, NULL, NULL );
 812             WIN_ReleasePtr( wndPtr );
 813         }
 814         break;
 815
 816     case WM_GETTEXT:
 817         if (wParam)
 818         {
 819             LPSTR dest = (LPSTR)lParam;
 820             WND *wndPtr = WIN_GetPtr( hwnd );
 821
 822             if (!wndPtr) break;
 823             result = DEFWND_GetTextA( wndPtr, dest, wParam );
 824
 825             WIN_ReleasePtr( wndPtr );
 826         }
 827         break;
 828
 829     case WM_SETTEXT:
 830         DEFWND_SetTextA( hwnd, (LPCSTR)lParam );
 831         if( (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CAPTION) == WS_CAPTION )
 832             NC_HandleNCPaint( hwnd , (HRGN)1 );  /* Repaint caption */
 833         result = 1; /* success. FIXME: check text length */
 834         break;
 835
 836     case WM_IME_CHAR:
 837         if (HIBYTE(wParam)) PostMessageA( hwnd, WM_CHAR, HIBYTE(wParam), lParam );
 838         PostMessageA( hwnd, WM_CHAR, LOBYTE(wParam), lParam );
 839         break;
 840
 841     case WM_IME_KEYDOWN:
 842         result = PostMessageA( hwnd, WM_KEYDOWN, wParam, lParam );
 843         break;
 844
 845     case WM_IME_KEYUP:
 846         result = PostMessageA( hwnd, WM_KEYUP, wParam, lParam );
 847         break;
 848
 849     case WM_IME_STARTCOMPOSITION:
 850     case WM_IME_COMPOSITION:
 851     case WM_IME_ENDCOMPOSITION:
 852     case WM_IME_SELECT:
 853     case WM_IME_NOTIFY:
 854     case WM_IME_CONTROL:
 855         {
 856             HWND hwndIME = ImmGetDefaultIMEWnd( hwnd );
 857             if (hwndIME)
 858                 result = SendMessageA( hwndIME, msg, wParam, lParam );
 859         }
 860         break;
 861     case WM_IME_SETCONTEXT:
 862         {
 863             HWND hwndIME = ImmGetDefaultIMEWnd( hwnd );
 864             if (hwndIME) result = ImmIsUIMessageA( hwndIME, msg, wParam, lParam );
 865         }
 866         break;
 867
 868     case WM_SYSCHAR:
 869     {
 870         CHAR ch = LOWORD(wParam);
 871         WCHAR wch;
 872         MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wch, 1);
 873         wParam = MAKEWPARAM( wch, HIWORD(wParam) );
 874     }
 875     /* fall through */
 876     default:
 877         result = DEFWND_DefWinProc( hwnd, msg, wParam, lParam );
 878         break;
 879     }
 880
 881     SPY_ExitMessage( SPY_RESULT_DEFWND, hwnd, msg, result, wParam, lParam );
 882     return result;
 883 }
 884
 885
 886 static LPARAM DEFWND_GetTextW( WND *wndPtr, LPWSTR dest, WPARAM wParam )
 887 {
 888     LPARAM result = 0;
 889
 890     __TRY
 891     {
 892         if (wndPtr->text)
 893         {
 894             lstrcpynW( dest, wndPtr->text, wParam );
 895             result = strlenW( dest );
 896         }
 897         else dest[0] = '\0';
 898     }
 899     __EXCEPT_PAGE_FAULT
 900     {
 901         return 0;
 902     }
 903     __ENDTRY
 904
 905     return result;
 906 }
 907
 908 /***********************************************************************
 909  *              DefWindowProcW (USER32.@) Calls default window message handler
 910  *
 911  * Calls default window procedure for messages not processed
 912  *  by application.
 913  *
 914  *  RETURNS
 915  *     Return value is dependent upon the message.
 916 */
 917 LRESULT WINAPI DefWindowProcW(
 918     HWND hwnd,      /* [in] window procedure receiving message */
 919     UINT msg,       /* [in] message identifier */
 920     WPARAM wParam,  /* [in] first message parameter */
 921     LPARAM lParam )   /* [in] second message parameter */
 922 {
 923     LRESULT result = 0;
 924     HWND full_handle;
 925
 926     if (!(full_handle = WIN_IsCurrentProcess( hwnd )))
 927     {
 928         if (!IsWindow( hwnd )) return 0;
 929         ERR( "called for other process window %p\n", hwnd );
 930         return 0;
 931     }
 932     hwnd = full_handle;
 933     SPY_EnterMessage( SPY_DEFWNDPROC, hwnd, msg, wParam, lParam );
 934
 935     switch(msg)
 936     {
 937     case WM_NCCREATE:
 938         if (lParam)
 939         {
 940             CREATESTRUCTW *cs = (CREATESTRUCTW *)lParam;
 941             /* check for string, as static icons, bitmaps (SS_ICON, SS_BITMAP)
 942              * may have child window IDs instead of window name */
 943             if (!IS_INTRESOURCE(cs->lpszName))
 944                 DEFWND_SetTextW( hwnd, cs->lpszName );
 945             result = 1;
 946
 947             if(cs->style & (WS_HSCROLL | WS_VSCROLL))
 948             {
 949                 SCROLLINFO si = {sizeof si, SIF_ALL, 0, 100, 0, 0, 0};
 950                 SetScrollInfo( hwnd, SB_HORZ, &si, FALSE );
 951                 SetScrollInfo( hwnd, SB_VERT, &si, FALSE );
 952             }
 953         }
 954         break;
 955
 956     case WM_GETTEXTLENGTH:
 957         {
 958             WND *wndPtr = WIN_GetPtr( hwnd );
 959             if (wndPtr && wndPtr->text) result = (LRESULT)strlenW(wndPtr->text);
 960             WIN_ReleasePtr( wndPtr );
 961         }
 962         break;
 963
 964     case WM_GETTEXT:
 965         if (wParam)
 966         {
 967             LPWSTR dest = (LPWSTR)lParam;
 968             WND *wndPtr = WIN_GetPtr( hwnd );
 969
 970             if (!wndPtr) break;
 971             result = DEFWND_GetTextW( wndPtr, dest, wParam );
 972             WIN_ReleasePtr( wndPtr );
 973         }
 974         break;
 975
 976     case WM_SETTEXT:
 977         DEFWND_SetTextW( hwnd, (LPCWSTR)lParam );
 978         if( (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CAPTION) == WS_CAPTION )
 979             NC_HandleNCPaint( hwnd , (HRGN)1 );  /* Repaint caption */
 980         result = 1; /* success. FIXME: check text length */
 981         break;
 982
 983     case WM_IME_CHAR:
 984         PostMessageW( hwnd, WM_CHAR, wParam, lParam );
 985         break;
 986
 987     case WM_IME_KEYDOWN:
 988         result = PostMessageW( hwnd, WM_KEYDOWN, wParam, lParam );
 989         break;
 990
 991     case WM_IME_KEYUP:
 992         result = PostMessageW( hwnd, WM_KEYUP, wParam, lParam );
 993         break;
 994
 995     case WM_IME_SETCONTEXT:
 996         {
 997             HWND hwndIME = ImmGetDefaultIMEWnd( hwnd );
 998             if (hwndIME) result = ImmIsUIMessageW( hwndIME, msg, wParam, lParam );
 999         }
1000         break;
1001
1002     case WM_IME_STARTCOMPOSITION:
1003     case WM_IME_COMPOSITION:
1004     case WM_IME_ENDCOMPOSITION:
1005     case WM_IME_SELECT:
1006     case WM_IME_NOTIFY:
1007     case WM_IME_CONTROL:
1008         {
1009             HWND hwndIME = ImmGetDefaultIMEWnd( hwnd );
1010             if (hwndIME)
1011                 result = SendMessageW( hwndIME, msg, wParam, lParam );
1012         }
1013         break;
1014
1015     default:
1016         result = DEFWND_DefWinProc( hwnd, msg, wParam, lParam );
1017         break;
1018     }
1019     SPY_ExitMessage( SPY_RESULT_DEFWND, hwnd, msg, result, wParam, lParam );
1020     return result;
1021 }