msi: Break out of the loop as soon as the assembly is detected in msi_load_assembly.
[wine] / 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_APPCOMMAND:
723         {
724             HWND parent = GetParent(hwnd);
725             if(!parent)
726                 HOOK_CallHooks(WH_SHELL, HSHELL_APPCOMMAND, wParam, lParam, TRUE);
727             else
728                 SendMessageW( parent, msg, wParam, lParam );
729             break;
730         }
731     case WM_KEYF1:
732         {
733             HELPINFO hi;
734
735             hi.cbSize = sizeof(HELPINFO);
736             GetCursorPos( &hi.MousePos );
737             if (MENU_IsMenuActive())
738             {
739                 hi.iContextType = HELPINFO_MENUITEM;
740                 hi.hItemHandle = MENU_IsMenuActive();
741                 hi.iCtrlId = MenuItemFromPoint( hwnd, hi.hItemHandle, hi.MousePos );
742                 hi.dwContextId = GetMenuContextHelpId( hi.hItemHandle );
743             }
744             else
745             {
746                 hi.iContextType = HELPINFO_WINDOW;
747                 hi.hItemHandle = hwnd;
748                 hi.iCtrlId = GetWindowLongPtrA( hwnd, GWLP_ID );
749                 hi.dwContextId = GetWindowContextHelpId( hwnd );
750             }
751             SendMessageW( hwnd, WM_HELP, 0, (LPARAM)&hi );
752             break;
753         }
754
755     case WM_INPUTLANGCHANGEREQUEST:
756         ActivateKeyboardLayout( (HKL)lParam, 0 );
757         break;
758
759     case WM_INPUTLANGCHANGE:
760         {
761             int count = 0;
762             HWND *win_array = WIN_ListChildren( hwnd );
763
764             if (!win_array)
765                 break;
766             while (win_array[count])
767                 SendMessageW( win_array[count++], WM_INPUTLANGCHANGE, wParam, lParam);
768             HeapFree(GetProcessHeap(),0,win_array);
769             break;
770         }
771
772     }
773
774     return 0;
775 }
776
777 static LPARAM DEFWND_GetTextA( WND *wndPtr, LPSTR dest, WPARAM wParam )
778 {
779     LPARAM result = 0;
780
781     __TRY
782     {
783         if (wndPtr->text)
784         {
785             if (!WideCharToMultiByte( CP_ACP, 0, wndPtr->text, -1,
786                                       dest, wParam, NULL, NULL )) dest[wParam-1] = 0;
787             result = strlen( dest );
788         }
789         else dest[0] = '\0';
790     }
791     __EXCEPT_PAGE_FAULT
792     {
793         return 0;
794     }
795     __ENDTRY
796     return result;
797 }
798
799 /***********************************************************************
800  *              DefWindowProcA (USER32.@)
801  *
802  * See DefWindowProcW.
803  */
804 LRESULT WINAPI DefWindowProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
805 {
806     LRESULT result = 0;
807     HWND full_handle;
808
809     if (!(full_handle = WIN_IsCurrentProcess( hwnd )))
810     {
811         if (!IsWindow( hwnd )) return 0;
812         ERR( "called for other process window %p\n", hwnd );
813         return 0;
814     }
815     hwnd = full_handle;
816
817     SPY_EnterMessage( SPY_DEFWNDPROC, hwnd, msg, wParam, lParam );
818
819     switch(msg)
820     {
821     case WM_NCCREATE:
822         if (lParam)
823         {
824             CREATESTRUCTA *cs = (CREATESTRUCTA *)lParam;
825             /* check for string, as static icons, bitmaps (SS_ICON, SS_BITMAP)
826              * may have child window IDs instead of window name */
827             if (!IS_INTRESOURCE(cs->lpszName))
828                 DEFWND_SetTextA( hwnd, cs->lpszName );
829             result = 1;
830         }
831         break;
832
833     case WM_GETTEXTLENGTH:
834         {
835             WND *wndPtr = WIN_GetPtr( hwnd );
836             if (wndPtr && wndPtr->text)
837                 result = WideCharToMultiByte( CP_ACP, 0, wndPtr->text, strlenW(wndPtr->text),
838                                               NULL, 0, NULL, NULL );
839             WIN_ReleasePtr( wndPtr );
840         }
841         break;
842
843     case WM_GETTEXT:
844         if (wParam)
845         {
846             LPSTR dest = (LPSTR)lParam;
847             WND *wndPtr = WIN_GetPtr( hwnd );
848
849             if (!wndPtr) break;
850             result = DEFWND_GetTextA( wndPtr, dest, wParam );
851
852             WIN_ReleasePtr( wndPtr );
853         }
854         break;
855
856     case WM_SETTEXT:
857         DEFWND_SetTextA( hwnd, (LPCSTR)lParam );
858         if( (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CAPTION) == WS_CAPTION )
859             NC_HandleNCPaint( hwnd , (HRGN)1 );  /* Repaint caption */
860         result = 1; /* success. FIXME: check text length */
861         break;
862
863     case WM_IME_CHAR:
864         if (HIBYTE(wParam)) PostMessageA( hwnd, WM_CHAR, HIBYTE(wParam), lParam );
865         PostMessageA( hwnd, WM_CHAR, LOBYTE(wParam), lParam );
866         break;
867
868     case WM_IME_KEYDOWN:
869         result = PostMessageA( hwnd, WM_KEYDOWN, wParam, lParam );
870         break;
871
872     case WM_IME_KEYUP:
873         result = PostMessageA( hwnd, WM_KEYUP, wParam, lParam );
874         break;
875
876     case WM_IME_STARTCOMPOSITION:
877     case WM_IME_COMPOSITION:
878     case WM_IME_ENDCOMPOSITION:
879     case WM_IME_SELECT:
880     case WM_IME_NOTIFY:
881         {
882             HWND hwndIME;
883
884             hwndIME = DEFWND_ImmGetDefaultIMEWnd( hwnd );
885             if (hwndIME)
886                 result = SendMessageA( hwndIME, msg, wParam, lParam );
887         }
888         break;
889     case WM_IME_SETCONTEXT:
890         {
891             HWND hwndIME;
892
893             hwndIME = DEFWND_ImmGetDefaultIMEWnd( hwnd );
894             if (hwndIME)
895                 result = DEFWND_ImmIsUIMessageA( hwndIME, msg, wParam, lParam );
896         }
897         break;
898
899     case WM_SYSCHAR:
900     {
901         CHAR ch = LOWORD(wParam);
902         WCHAR wch;
903         MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wch, 1);
904         wParam = MAKEWPARAM( wch, HIWORD(wParam) );
905     }
906     /* fall through */
907     default:
908         result = DEFWND_DefWinProc( hwnd, msg, wParam, lParam );
909         break;
910     }
911
912     SPY_ExitMessage( SPY_RESULT_DEFWND, hwnd, msg, result, wParam, lParam );
913     return result;
914 }
915
916
917 static LPARAM DEFWND_GetTextW( WND *wndPtr, LPWSTR dest, WPARAM wParam )
918 {
919     LPARAM result = 0;
920
921     __TRY
922     {
923         if (wndPtr->text)
924         {
925             lstrcpynW( dest, wndPtr->text, wParam );
926             result = strlenW( dest );
927         }
928         else dest[0] = '\0';
929     }
930     __EXCEPT_PAGE_FAULT
931     {
932         return 0;
933     }
934     __ENDTRY
935
936     return result;
937 }
938
939 /***********************************************************************
940  *              DefWindowProcW (USER32.@) Calls default window message handler
941  *
942  * Calls default window procedure for messages not processed
943  *  by application.
944  *
945  *  RETURNS
946  *     Return value is dependent upon the message.
947 */
948 LRESULT WINAPI DefWindowProcW(
949     HWND hwnd,      /* [in] window procedure receiving message */
950     UINT msg,       /* [in] message identifier */
951     WPARAM wParam,  /* [in] first message parameter */
952     LPARAM lParam )   /* [in] second message parameter */
953 {
954     LRESULT result = 0;
955     HWND full_handle;
956
957     if (!(full_handle = WIN_IsCurrentProcess( hwnd )))
958     {
959         if (!IsWindow( hwnd )) return 0;
960         ERR( "called for other process window %p\n", hwnd );
961         return 0;
962     }
963     hwnd = full_handle;
964     SPY_EnterMessage( SPY_DEFWNDPROC, hwnd, msg, wParam, lParam );
965
966     switch(msg)
967     {
968     case WM_NCCREATE:
969         if (lParam)
970         {
971             CREATESTRUCTW *cs = (CREATESTRUCTW *)lParam;
972             /* check for string, as static icons, bitmaps (SS_ICON, SS_BITMAP)
973              * may have child window IDs instead of window name */
974             if (!IS_INTRESOURCE(cs->lpszName))
975                 DEFWND_SetTextW( hwnd, cs->lpszName );
976             result = 1;
977         }
978         break;
979
980     case WM_GETTEXTLENGTH:
981         {
982             WND *wndPtr = WIN_GetPtr( hwnd );
983             if (wndPtr && wndPtr->text) result = (LRESULT)strlenW(wndPtr->text);
984             WIN_ReleasePtr( wndPtr );
985         }
986         break;
987
988     case WM_GETTEXT:
989         if (wParam)
990         {
991             LPWSTR dest = (LPWSTR)lParam;
992             WND *wndPtr = WIN_GetPtr( hwnd );
993
994             if (!wndPtr) break;
995             result = DEFWND_GetTextW( wndPtr, dest, wParam );
996             WIN_ReleasePtr( wndPtr );
997         }
998         break;
999
1000     case WM_SETTEXT:
1001         DEFWND_SetTextW( hwnd, (LPCWSTR)lParam );
1002         if( (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CAPTION) == WS_CAPTION )
1003             NC_HandleNCPaint( hwnd , (HRGN)1 );  /* Repaint caption */
1004         result = 1; /* success. FIXME: check text length */
1005         break;
1006
1007     case WM_IME_CHAR:
1008         PostMessageW( hwnd, WM_CHAR, wParam, lParam );
1009         break;
1010
1011     case WM_IME_KEYDOWN:
1012         result = PostMessageW( hwnd, WM_KEYDOWN, wParam, lParam );
1013         break;
1014
1015     case WM_IME_KEYUP:
1016         result = PostMessageW( hwnd, WM_KEYUP, wParam, lParam );
1017         break;
1018
1019     case WM_IME_SETCONTEXT:
1020         {
1021             HWND hwndIME;
1022
1023             hwndIME = DEFWND_ImmGetDefaultIMEWnd( hwnd );
1024             if (hwndIME)
1025                 result = DEFWND_ImmIsUIMessageW( hwndIME, msg, wParam, lParam );
1026         }
1027         break;
1028
1029     case WM_IME_STARTCOMPOSITION:
1030     case WM_IME_COMPOSITION:
1031     case WM_IME_ENDCOMPOSITION:
1032     case WM_IME_SELECT:
1033     case WM_IME_NOTIFY:
1034         {
1035             HWND hwndIME;
1036
1037             hwndIME = DEFWND_ImmGetDefaultIMEWnd( hwnd );
1038             if (hwndIME)
1039                 result = SendMessageW( hwndIME, msg, wParam, lParam );
1040         }
1041         break;
1042
1043     default:
1044         result = DEFWND_DefWinProc( hwnd, msg, wParam, lParam );
1045         break;
1046     }
1047     SPY_ExitMessage( SPY_RESULT_DEFWND, hwnd, msg, result, wParam, lParam );
1048     return result;
1049 }