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