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