e9db53fd70b04b2f0d299b342081ebd82836c95c
[reactos.git] / reactos / win32ss / user / ntuser / defwnd.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Win32k subsystem
4 * PURPOSE: Miscellaneous User functions
5 * FILE: win32ss/user/ntuser/defwnd.c
6 * PROGRAMER:
7 */
8
9 #include <win32k.h>
10 #include <windowsx.h>
11
12 DBG_DEFAULT_CHANNEL(UserDefwnd);
13
14 INT WINAPI DrawTextExWorker( HDC hdc, LPWSTR str, INT i_count,
15 LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp );
16
17 INT WINAPI DrawTextW( HDC hdc, LPCWSTR str, INT count, LPRECT rect, UINT flags )
18 {
19 DRAWTEXTPARAMS dtp;
20
21 memset (&dtp, 0, sizeof(dtp));
22 dtp.cbSize = sizeof(dtp);
23 if (flags & DT_TABSTOP)
24 {
25 dtp.iTabLength = (flags >> 8) & 0xff;
26 flags &= 0xffff00ff;
27 }
28 return DrawTextExWorker(hdc, (LPWSTR)str, count, rect, flags, &dtp);
29 }
30
31
32 HBRUSH FASTCALL
33 DefWndControlColor(HDC hDC, UINT ctlType)
34 {
35 if (ctlType == CTLCOLOR_SCROLLBAR)
36 {
37 HBRUSH hb = IntGetSysColorBrush(COLOR_SCROLLBAR);
38 COLORREF bk = IntGetSysColor(COLOR_3DHILIGHT);
39 IntGdiSetTextColor(hDC, IntGetSysColor(COLOR_3DFACE));
40 IntGdiSetBkColor(hDC, bk);
41
42 /* if COLOR_WINDOW happens to be the same as COLOR_3DHILIGHT
43 * we better use 0x55aa bitmap brush to make scrollbar's background
44 * look different from the window background.
45 */
46 if ( bk == IntGetSysColor(COLOR_WINDOW))
47 return gpsi->hbrGray;
48
49 NtGdiUnrealizeObject( hb );
50 return hb;
51 }
52
53 IntGdiSetTextColor(hDC, IntGetSysColor(COLOR_WINDOWTEXT));
54
55 if ((ctlType == CTLCOLOR_EDIT) || (ctlType == CTLCOLOR_LISTBOX))
56 {
57 IntGdiSetBkColor(hDC, IntGetSysColor(COLOR_WINDOW));
58 }
59 else
60 {
61 IntGdiSetBkColor(hDC, IntGetSysColor(COLOR_3DFACE));
62 return IntGetSysColorBrush(COLOR_3DFACE);
63 }
64
65 return IntGetSysColorBrush(COLOR_WINDOW);
66 }
67
68 LRESULT FASTCALL
69 DefWndHandleWindowPosChanging(PWND pWnd, WINDOWPOS* Pos)
70 {
71 POINT maxTrack, minTrack;
72 LONG style = pWnd->style;
73
74 if (Pos->flags & SWP_NOSIZE) return 0;
75 if ((style & WS_THICKFRAME) || ((style & (WS_POPUP | WS_CHILD)) == 0))
76 {
77 co_WinPosGetMinMaxInfo(pWnd, NULL, NULL, &minTrack, &maxTrack);
78 Pos->cx = min(Pos->cx, maxTrack.x);
79 Pos->cy = min(Pos->cy, maxTrack.y);
80 if (!(style & WS_MINIMIZE))
81 {
82 if (Pos->cx < minTrack.x) Pos->cx = minTrack.x;
83 if (Pos->cy < minTrack.y) Pos->cy = minTrack.y;
84 }
85 }
86 else
87 {
88 Pos->cx = max(Pos->cx, 0);
89 Pos->cy = max(Pos->cy, 0);
90 }
91 return 0;
92 }
93
94 LRESULT FASTCALL
95 DefWndHandleWindowPosChanged(PWND pWnd, WINDOWPOS* Pos)
96 {
97 RECT Rect;
98 LONG style = pWnd->style;
99
100 IntGetClientRect(pWnd, &Rect);
101 IntMapWindowPoints(pWnd, (style & WS_CHILD ? IntGetParent(pWnd) : NULL), (LPPOINT) &Rect, 2);
102
103 if (!(Pos->flags & SWP_NOCLIENTMOVE))
104 {
105 co_IntSendMessage(UserHMGetHandle(pWnd), WM_MOVE, 0, MAKELONG(Rect.left, Rect.top));
106 }
107
108 if (!(Pos->flags & SWP_NOCLIENTSIZE) || (Pos->flags & SWP_STATECHANGED))
109 {
110 if (style & WS_MINIMIZE) co_IntSendMessage(UserHMGetHandle(pWnd), WM_SIZE, SIZE_MINIMIZED, 0 );
111 else
112 {
113 WPARAM wp = (style & WS_MAXIMIZE) ? SIZE_MAXIMIZED : SIZE_RESTORED;
114 co_IntSendMessage(UserHMGetHandle(pWnd), WM_SIZE, wp, MAKELONG(Rect.right - Rect.left, Rect.bottom - Rect.top));
115 }
116 }
117 return 0;
118 }
119
120 //
121 // Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
122 //
123 LRESULT FASTCALL
124 DefWndHandleSysCommand(PWND pWnd, WPARAM wParam, LPARAM lParam)
125 {
126 LRESULT lResult = 0;
127 BOOL Hook = FALSE;
128
129 if (ISITHOOKED(WH_CBT) || (pWnd->head.rpdesk->pDeskInfo->fsHooks & HOOKID_TO_FLAG(WH_CBT)))
130 {
131 Hook = TRUE;
132 lResult = co_HOOK_CallHooks(WH_CBT, HCBT_SYSCOMMAND, wParam, lParam);
133
134 if (lResult) return lResult;
135 }
136
137 switch (wParam & 0xfff0)
138 {
139 case SC_MOVE:
140 case SC_SIZE:
141 DefWndDoSizeMove(pWnd, wParam);
142 break;
143
144 case SC_MINIMIZE:
145 if (UserHMGetHandle(pWnd) == UserGetActiveWindow())
146 IntShowOwnedPopups(pWnd,FALSE); // This is done in ShowWindow! Need to retest!
147 co_WinPosShowWindow( pWnd, SW_MINIMIZE );
148 break;
149
150 case SC_MAXIMIZE:
151 if (((pWnd->style & WS_MINIMIZE) != 0) && UserHMGetHandle(pWnd) == UserGetActiveWindow())
152 IntShowOwnedPopups(pWnd,TRUE);
153 co_WinPosShowWindow( pWnd, SW_MAXIMIZE );
154 break;
155
156 case SC_RESTORE:
157 if (((pWnd->style & WS_MINIMIZE) != 0) && UserHMGetHandle(pWnd) == UserGetActiveWindow())
158 IntShowOwnedPopups(pWnd,TRUE);
159 co_WinPosShowWindow( pWnd, SW_RESTORE );
160 break;
161
162 case SC_CLOSE:
163 return co_IntSendMessage(UserHMGetHandle(pWnd), WM_CLOSE, 0, 0);
164
165 case SC_SCREENSAVE:
166 ERR("Screensaver Called!\n");
167 UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_START_SCREENSAVE, 0); // always lParam 0 == not Secure
168 break;
169
170 case SC_HOTKEY:
171 {
172 USER_REFERENCE_ENTRY Ref;
173
174 pWnd = ValidateHwndNoErr((HWND)lParam);
175 if (pWnd)
176 {
177 if (pWnd->spwndLastActive)
178 {
179 pWnd = pWnd->spwndLastActive;
180 }
181 UserRefObjectCo(pWnd, &Ref);
182 co_IntSetForegroundWindow(pWnd);
183 UserDerefObjectCo(pWnd);
184 if (pWnd->style & WS_MINIMIZE)
185 {
186 UserPostMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_RESTORE, 0);
187 }
188 }
189 }
190 break;
191 // case SC_DEFAULT:
192 case SC_MOUSEMENU:
193 {
194 POINT Pt;
195 Pt.x = (short)LOWORD(lParam);
196 Pt.y = (short)HIWORD(lParam);
197 MENU_TrackMouseMenuBar(pWnd, wParam & 0x000f, Pt);
198 }
199 break;
200
201 case SC_KEYMENU:
202 MENU_TrackKbdMenuBar(pWnd, wParam, (WCHAR)lParam);
203 break;
204
205
206 default:
207 // We do not support anything else here so we should return normal even when sending a hook.
208 return 0;
209 }
210
211 return(Hook ? 1 : 0); // Don't call us again from user space.
212 }
213
214 PWND FASTCALL
215 co_IntFindChildWindowToOwner(PWND Root, PWND Owner)
216 {
217 PWND Ret;
218 PWND Child, OwnerWnd;
219
220 for(Child = Root->spwndChild; Child; Child = Child->spwndNext)
221 {
222 OwnerWnd = Child->spwndOwner;
223 if(!OwnerWnd)
224 continue;
225
226 if (!(Child->style & WS_POPUP) ||
227 !(Child->style & WS_VISIBLE) ||
228 /* Fixes CMD pop up properties window from having foreground. */
229 Owner->head.pti->MessageQueue != Child->head.pti->MessageQueue)
230 continue;
231
232 if(OwnerWnd == Owner)
233 {
234 Ret = Child;
235 return Ret;
236 }
237 }
238 return NULL;
239 }
240
241 LRESULT
242 DefWndHandleSetCursor(PWND pWnd, WPARAM wParam, LPARAM lParam)
243 {
244 PWND pwndPopUP = NULL;
245 WORD Msg = HIWORD(lParam);
246
247 /* Not for child windows. */
248 if (UserHMGetHandle(pWnd) != (HWND)wParam)
249 {
250 return FALSE;
251 }
252
253 switch((short)LOWORD(lParam))
254 {
255 case HTERROR:
256 {
257 //// This is the real fix for CORE-6129! This was a "Code hole".
258 USER_REFERENCE_ENTRY Ref;
259
260 if (Msg == WM_LBUTTONDOWN)
261 {
262 // Find a pop up window to bring active.
263 pwndPopUP = co_IntFindChildWindowToOwner(UserGetDesktopWindow(), pWnd);
264 if (pwndPopUP)
265 {
266 // Not a child pop up from desktop.
267 if ( pwndPopUP != UserGetDesktopWindow()->spwndChild )
268 {
269 // Get original active window.
270 PWND pwndOrigActive = gpqForeground->spwndActive;
271
272 co_WinPosSetWindowPos(pWnd, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
273
274 UserRefObjectCo(pwndPopUP, &Ref);
275 //UserSetActiveWindow(pwndPopUP);
276 co_IntSetForegroundWindow(pwndPopUP); // HACK
277 UserDerefObjectCo(pwndPopUP);
278
279 // If the change was made, break out.
280 if (pwndOrigActive != gpqForeground->spwndActive)
281 break;
282 }
283 }
284 }
285 ////
286 if (Msg == WM_LBUTTONDOWN || Msg == WM_MBUTTONDOWN ||
287 Msg == WM_RBUTTONDOWN || Msg == WM_XBUTTONDOWN)
288 {
289 if (pwndPopUP)
290 {
291 FLASHWINFO fwi =
292 {sizeof(FLASHWINFO),
293 UserHMGetHandle(pwndPopUP),
294 FLASHW_ALL,
295 gspv.dwForegroundFlashCount,
296 (gpsi->dtCaretBlink >> 3)};
297
298 // Now shake that window!
299 IntFlashWindowEx(pwndPopUP, &fwi);
300 }
301 UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, 0);
302 }
303 break;
304 }
305
306 case HTCLIENT:
307 {
308 if (pWnd->pcls->spcur)
309 {
310 IntSystemSetCursor(pWnd->pcls->spcur);
311 }
312 return FALSE;
313 }
314
315 case HTLEFT:
316 case HTRIGHT:
317 {
318 if (pWnd->style & WS_MAXIMIZE)
319 {
320 break;
321 }
322 IntSystemSetCursor(SYSTEMCUR(SIZEWE));
323 return TRUE;
324 }
325
326 case HTTOP:
327 case HTBOTTOM:
328 {
329 if (pWnd->style & WS_MAXIMIZE)
330 {
331 break;
332 }
333 IntSystemSetCursor(SYSTEMCUR(SIZENS));
334 return TRUE;
335 }
336
337 case HTTOPLEFT:
338 case HTBOTTOMRIGHT:
339 {
340 if (pWnd->style & WS_MAXIMIZE)
341 {
342 break;
343 }
344 IntSystemSetCursor(SYSTEMCUR(SIZENWSE));
345 return TRUE;
346 }
347
348 case HTBOTTOMLEFT:
349 case HTTOPRIGHT:
350 {
351 if (pWnd->style & WS_MAXIMIZE)
352 {
353 break;
354 }
355 IntSystemSetCursor(SYSTEMCUR(SIZENESW));
356 return TRUE;
357 }
358 }
359 IntSystemSetCursor(SYSTEMCUR(ARROW));
360 return FALSE;
361 }
362
363 VOID FASTCALL DefWndPrint( PWND pwnd, HDC hdc, ULONG uFlags)
364 {
365 /*
366 * Visibility flag.
367 */
368 if ( (uFlags & PRF_CHECKVISIBLE) &&
369 !IntIsWindowVisible(pwnd) )
370 return;
371
372 /*
373 * Unimplemented flags.
374 */
375 if ( (uFlags & PRF_CHILDREN) ||
376 (uFlags & PRF_OWNED) ||
377 (uFlags & PRF_NONCLIENT) )
378 {
379 FIXME("WM_PRINT message with unsupported flags\n");
380 }
381
382 /*
383 * Background
384 */
385 if ( uFlags & PRF_ERASEBKGND)
386 co_IntSendMessage(UserHMGetHandle(pwnd), WM_ERASEBKGND, (WPARAM)hdc, 0);
387
388 /*
389 * Client area
390 */
391 if ( uFlags & PRF_CLIENT)
392 co_IntSendMessage(UserHMGetHandle(pwnd), WM_PRINTCLIENT, (WPARAM)hdc, uFlags);
393 }
394
395 BOOL
396 UserPaintCaption(PWND pWnd, INT Flags)
397 {
398 BOOL Ret = FALSE;
399
400 if ( (pWnd->style & WS_VISIBLE) && ((pWnd->style & WS_CAPTION) == WS_CAPTION) )
401 {
402 if (pWnd->state & WNDS_HASCAPTION && pWnd->head.pti->MessageQueue == gpqForeground)
403 Flags |= DC_ACTIVE;
404 /*
405 * When themes are not enabled we can go on and paint the non client area.
406 * However if we do that with themes enabled we will draw a classic frame.
407 * This is solved by sending a themes specific message to notify the themes
408 * engine that the caption needs to be redrawn
409 */
410 if (gpsi->dwSRVIFlags & SRVINFO_APIHOOK)
411 {
412 /*
413 * This will cause uxtheme to either paint the themed caption or call
414 * RealUserDrawCaption in order to draw the classic caption when themes
415 * are disabled but the themes service is enabled
416 */
417 TRACE("UDCB Flags %08x\n");
418 co_IntSendMessage(UserHMGetHandle(pWnd), WM_NCUAHDRAWCAPTION, Flags, 0);
419 }
420 else
421 {
422 HDC hDC = UserGetDCEx(pWnd, NULL, DCX_WINDOW|DCX_USESTYLE);
423 UserDrawCaptionBar(pWnd, hDC, Flags);
424 UserReleaseDC(pWnd, hDC, FALSE);
425 }
426 Ret = TRUE;
427 }
428 // Support window tray
429 return Ret;
430 }
431
432 // WM_SETICON
433 LRESULT FASTCALL
434 DefWndSetIcon(PWND pWnd, WPARAM wParam, LPARAM lParam)
435 {
436 HICON hIcon, hIconSmall, hIconOld;
437
438 if ( wParam > ICON_SMALL2 )
439 {
440 EngSetLastError(ERROR_INVALID_PARAMETER);
441 return 0;
442 }
443 hIconSmall = UserGetProp(pWnd, gpsi->atomIconSmProp, TRUE);
444 hIcon = UserGetProp(pWnd, gpsi->atomIconProp, TRUE);
445
446 hIconOld = wParam == ICON_BIG ? hIcon : hIconSmall;
447
448 switch(wParam)
449 {
450 case ICON_BIG:
451 hIcon = (HICON)lParam;
452 break;
453 case ICON_SMALL:
454 hIconSmall = (HICON)lParam;
455 break;
456 case ICON_SMALL2:
457 ERR("FIXME: Set ICON_SMALL2 support!\n");
458 default:
459 break;
460 }
461
462 UserSetProp(pWnd, gpsi->atomIconProp, hIcon, TRUE);
463 UserSetProp(pWnd, gpsi->atomIconSmProp, hIconSmall, TRUE);
464
465 if ((pWnd->style & WS_CAPTION ) == WS_CAPTION)
466 UserPaintCaption(pWnd, DC_ICON);
467
468 return (LRESULT)hIconOld;
469 }
470
471 LRESULT FASTCALL
472 DefWndGetIcon(PWND pWnd, WPARAM wParam, LPARAM lParam)
473 {
474 HICON hIconRet;
475 if ( wParam > ICON_SMALL2 )
476 {
477 EngSetLastError(ERROR_INVALID_PARAMETER);
478 return 0;
479 }
480 switch(wParam)
481 {
482 case ICON_BIG:
483 hIconRet = UserGetProp(pWnd, gpsi->atomIconProp, TRUE);
484 break;
485 case ICON_SMALL:
486 case ICON_SMALL2:
487 hIconRet = UserGetProp(pWnd, gpsi->atomIconSmProp, TRUE);
488 break;
489 default:
490 break;
491 }
492 return (LRESULT)hIconRet;
493 }
494
495 VOID FASTCALL
496 DefWndScreenshot(PWND pWnd)
497 {
498 RECT rect;
499 HDC hdc;
500 INT w;
501 INT h;
502 HBITMAP hbitmap;
503 HDC hdc2;
504 SETCLIPBDATA scd = {FALSE, FALSE};
505
506 UserOpenClipboard(UserHMGetHandle(pWnd));
507 UserEmptyClipboard();
508
509 hdc = UserGetWindowDC(pWnd);
510 IntGetWindowRect(pWnd, &rect);
511 w = rect.right - rect.left;
512 h = rect.bottom - rect.top;
513
514 hbitmap = NtGdiCreateCompatibleBitmap(hdc, w, h);
515 hdc2 = NtGdiCreateCompatibleDC(hdc);
516 NtGdiSelectBitmap(hdc2, hbitmap);
517
518 NtGdiBitBlt(hdc2, 0, 0, w, h, hdc, 0, 0, SRCCOPY, 0, 0);
519
520 UserSetClipboardData(CF_BITMAP, hbitmap, &scd);
521
522 UserReleaseDC(pWnd, hdc, FALSE);
523 UserReleaseDC(pWnd, hdc2, FALSE);
524
525 UserCloseClipboard();
526 }
527
528 /*
529 Win32k counterpart of User DefWindowProc
530 */
531 LRESULT FASTCALL
532 IntDefWindowProc(
533 PWND Wnd,
534 UINT Msg,
535 WPARAM wParam,
536 LPARAM lParam,
537 BOOL Ansi)
538 {
539 PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
540 LRESULT lResult = 0;
541 USER_REFERENCE_ENTRY Ref;
542
543 if (Msg > WM_USER) return 0;
544
545 switch (Msg)
546 {
547 case WM_GETTEXTLENGTH:
548 {
549 PWSTR buf;
550 ULONG len;
551
552 if (Wnd != NULL && Wnd->strName.Length != 0)
553 {
554 buf = Wnd->strName.Buffer;
555 if (buf != NULL &&
556 NT_SUCCESS(RtlUnicodeToMultiByteSize(&len,
557 buf,
558 Wnd->strName.Length)))
559 {
560 lResult = (LRESULT) (Wnd->strName.Length / sizeof(WCHAR));
561 }
562 }
563 else lResult = 0L;
564
565 break;
566 }
567
568 case WM_GETTEXT: // FIXME: Handle Ansi
569 {
570 PWSTR buf = NULL;
571 PWSTR outbuf = (PWSTR)lParam;
572
573 if (Wnd != NULL && wParam != 0)
574 {
575 if (Wnd->strName.Buffer != NULL)
576 buf = Wnd->strName.Buffer;
577 else
578 outbuf[0] = L'\0';
579
580 if (buf != NULL)
581 {
582 if (Wnd->strName.Length != 0)
583 {
584 lResult = min(Wnd->strName.Length / sizeof(WCHAR), wParam - 1);
585 RtlCopyMemory(outbuf,
586 buf,
587 lResult * sizeof(WCHAR));
588 outbuf[lResult] = L'\0';
589 }
590 else
591 outbuf[0] = L'\0';
592 }
593 }
594 break;
595 }
596
597 case WM_SETTEXT: // FIXME: Handle Ansi
598 {
599 DefSetText(Wnd, (PCWSTR)lParam);
600
601 if ((Wnd->style & WS_CAPTION) == WS_CAPTION)
602 UserPaintCaption(Wnd, DC_TEXT);
603 IntNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, Wnd, OBJID_WINDOW, CHILDID_SELF, 0);
604 lResult = 1;
605 break;
606 }
607
608 case WM_SYSCOMMAND:
609 {
610 TRACE("hwnd %p WM_SYSCOMMAND %lx %lx\n", Wnd->head.h, wParam, lParam );
611 lResult = DefWndHandleSysCommand(Wnd, wParam, lParam);
612 break;
613 }
614
615 case WM_SHOWWINDOW:
616 {
617 if ((Wnd->style & WS_VISIBLE) && wParam) break;
618 if (!(Wnd->style & WS_VISIBLE) && !wParam) break;
619 if (!Wnd->spwndOwner) break;
620 if (LOWORD(lParam))
621 {
622 if (wParam)
623 {
624 if (!(Wnd->state & WNDS_HIDDENPOPUP)) break;
625 Wnd->state &= ~WNDS_HIDDENPOPUP;
626 }
627 else
628 Wnd->state |= WNDS_HIDDENPOPUP;
629
630 co_WinPosShowWindow(Wnd, wParam ? SW_SHOWNOACTIVATE : SW_HIDE);
631 }
632 break;
633 }
634
635 case WM_CLIENTSHUTDOWN:
636 return IntClientShutdown(Wnd, wParam, lParam);
637
638 case WM_APPCOMMAND:
639 if ( (Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD &&
640 Wnd != co_GetDesktopWindow(Wnd) )
641 {
642 if (!co_HOOK_CallHooks(WH_SHELL, HSHELL_APPCOMMAND, wParam, lParam))
643 co_IntShellHookNotify(HSHELL_APPCOMMAND, wParam, lParam);
644 break;
645 }
646 UserRefObjectCo(Wnd->spwndParent, &Ref);
647 lResult = co_IntSendMessage(UserHMGetHandle(Wnd->spwndParent), WM_APPCOMMAND, wParam, lParam);
648 UserDerefObjectCo(Wnd->spwndParent);
649 break;
650
651 case WM_KEYF1:
652 {
653 HELPINFO hi;
654 HMENU hMenu = UlongToHandle(Wnd->IDMenu);
655 PWND pwndActive = MENU_IsMenuActive();
656 hi.cbSize = sizeof(HELPINFO);
657 hi.MousePos = gpsi->ptCursor;
658 hi.iContextType = HELPINFO_MENUITEM;
659 hi.hItemHandle = pwndActive ? UserHMGetHandle(pwndActive) : UserHMGetHandle(Wnd);
660 hi.iCtrlId = (Wnd->style & (WS_POPUP|WS_CHILD)) == WS_CHILD ? IntMenuItemFromPoint(Wnd, hMenu, hi.MousePos) : 0;
661 hi.dwContextId = IntGetWindowContextHelpId(Wnd);
662
663 co_IntSendMessage( UserHMGetHandle(Wnd), WM_HELP, 0, (LPARAM)&hi );
664 break;
665 }
666
667 case WM_SETICON:
668 {
669 return DefWndSetIcon(Wnd, wParam, lParam);
670 }
671
672 case WM_GETICON:
673 {
674 return DefWndGetIcon(Wnd, wParam, lParam);
675 }
676
677 case WM_HELP:
678 {
679 PWND Parent = IntGetParent(Wnd);
680 co_IntSendMessage(UserHMGetHandle(Parent), Msg, wParam, lParam);
681 break;
682 }
683
684 case WM_LBUTTONDOWN:
685 case WM_RBUTTONDOWN:
686 case WM_MBUTTONDOWN:
687 pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK);
688 break;
689
690 case WM_NCLBUTTONDOWN:
691 return NC_HandleNCLButtonDown(Wnd, wParam, lParam);
692
693 case WM_NCRBUTTONDOWN:
694 return NC_HandleNCRButtonDown(Wnd, wParam, lParam);
695
696 case WM_LBUTTONDBLCLK:
697 return NC_HandleNCLButtonDblClk(Wnd, HTCLIENT, lParam);
698
699 case WM_NCLBUTTONDBLCLK:
700 return NC_HandleNCLButtonDblClk(Wnd, wParam, lParam);
701
702 case WM_RBUTTONUP:
703 {
704 POINT Pt;
705
706 Pt.x = GET_X_LPARAM(lParam);
707 Pt.y = GET_Y_LPARAM(lParam);
708 IntClientToScreen(Wnd, &Pt);
709 lParam = MAKELPARAM(Pt.x, Pt.y);
710 co_IntSendMessage(UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), lParam);
711 break;
712 }
713
714 case WM_NCRBUTTONUP:
715 /*
716 * FIXME : we must NOT send WM_CONTEXTMENU on a WM_NCRBUTTONUP (checked
717 * in Windows), but what _should_ we do? According to MSDN :
718 * "If it is appropriate to do so, the system sends the WM_SYSCOMMAND
719 * message to the window". When is it appropriate?
720 */
721 ERR("WM_NCRBUTTONUP\n");
722 break;
723
724 case WM_CONTEXTMENU:
725 {
726 if (Wnd->style & WS_CHILD)
727 {
728 co_IntSendMessage(UserHMGetHandle(IntGetParent(Wnd)), Msg, wParam, lParam);
729 }
730 else
731 {
732 POINT Pt;
733 LONG_PTR Style;
734 LONG HitCode;
735
736 Style = Wnd->style;
737
738 Pt.x = GET_X_LPARAM(lParam);
739 Pt.y = GET_Y_LPARAM(lParam);
740 if (Style & WS_CHILD)
741 {
742 IntScreenToClient(IntGetParent(Wnd), &Pt);
743 }
744
745 HitCode = GetNCHitEx(Wnd, Pt);
746
747 if (HitCode == HTCAPTION || HitCode == HTSYSMENU)
748 {
749 PMENU SystemMenu;
750 UINT Flags;
751
752 if((SystemMenu = IntGetSystemMenu(Wnd, FALSE)))
753 {
754 MENU_InitSysMenuPopup(SystemMenu, Wnd->style, Wnd->pcls->style, HitCode);
755
756 if(HitCode == HTCAPTION)
757 Flags = TPM_LEFTBUTTON | TPM_RIGHTBUTTON;
758 else
759 Flags = TPM_LEFTBUTTON;
760
761 IntTrackPopupMenuEx(SystemMenu, Flags|TPM_SYSTEM_MENU, Pt.x, Pt.y, Wnd, NULL);
762 }
763 }
764 if (HitCode == HTHSCROLL || HitCode == HTVSCROLL)
765 {
766 WARN("Scroll Menu Not Supported\n");
767 }
768 }
769 break;
770 }
771
772 case WM_KEYDOWN:
773 if (wParam == VK_F10)
774 {
775 pti->MessageQueue->QF_flags |= QF_FF10STATUS;
776
777 if (UserGetKeyState(VK_SHIFT) & 0x8000)
778 {
779 co_IntSendMessage(UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), MAKELPARAM(-1, -1));
780 }
781 }
782 break;
783
784 case WM_SYSKEYDOWN:
785 {
786 if (HIWORD(lParam) & KF_ALTDOWN)
787 { /* Previous state, if the key was down before this message,
788 this is a cheap way to ignore autorepeat keys. */
789 if ( !(HIWORD(lParam) & KF_REPEAT) )
790 {
791 if ( ( wParam == VK_MENU ||
792 wParam == VK_LMENU ||
793 wParam == VK_RMENU ) && !(pti->MessageQueue->QF_flags & QF_FMENUSTATUS)) //iMenuSysKey )
794 pti->MessageQueue->QF_flags |= QF_FMENUSTATUS; //iMenuSysKey = 1;
795 else
796 pti->MessageQueue->QF_flags &= ~QF_FMENUSTATUS; //iMenuSysKey = 0;
797 }
798
799 pti->MessageQueue->QF_flags &= ~QF_FF10STATUS; //iF10Key = 0;
800
801 if (wParam == VK_F4) /* Try to close the window */
802 {
803 PWND top = UserGetAncestor(Wnd, GA_ROOT);
804 if (!(top->style & CS_NOCLOSE))
805 UserPostMessage(UserHMGetHandle(top), WM_SYSCOMMAND, SC_CLOSE, 0);
806 }
807 else if (wParam == VK_SNAPSHOT) // Alt-VK_SNAPSHOT?
808 {
809 PWND pwnd = Wnd;
810 while (IntGetParent(pwnd) != NULL)
811 {
812 pwnd = IntGetParent(pwnd);
813 }
814 ERR("DefWndScreenshot\n");
815 DefWndScreenshot(pwnd);
816 }
817 else if ( wParam == VK_ESCAPE || wParam == VK_TAB ) // Alt-Tab/ESC Alt-Shift-Tab/ESC
818 {
819 WPARAM wParamTmp;
820 HWND Active = UserGetActiveWindow(); // Noticed MDI problem.
821 if (!Active)
822 {
823 FIXME("WM_SYSKEYDOWN VK_ESCAPE no active\n");
824 break;
825 }
826 wParamTmp = UserGetKeyState(VK_SHIFT) & 0x8000 ? SC_PREVWINDOW : SC_NEXTWINDOW;
827 co_IntSendMessage( Active, WM_SYSCOMMAND, wParamTmp, wParam );
828 }
829 }
830 else if( wParam == VK_F10 )
831 {
832 if (UserGetKeyState(VK_SHIFT) & 0x8000)
833 co_IntSendMessage( UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), MAKELPARAM(-1, -1) );
834 pti->MessageQueue->QF_flags |= QF_FF10STATUS; //iF10Key = 1;
835 }
836 else if( wParam == VK_ESCAPE && (UserGetKeyState(VK_SHIFT) & 0x8000))
837 co_IntSendMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_KEYMENU, ' ' );
838 break;
839 }
840
841 case WM_KEYUP:
842 case WM_SYSKEYUP:
843 {
844 /* Press and release F10 or ALT */
845 if (((wParam == VK_MENU || wParam == VK_LMENU || wParam == VK_RMENU)
846 && (pti->MessageQueue->QF_flags & (QF_FMENUSTATUS|QF_FMENUSTATUSBREAK)) == QF_FMENUSTATUS /*iMenuSysKey*/) ||
847 ((wParam == VK_F10) && pti->MessageQueue->QF_flags & QF_FF10STATUS /*iF10Key*/))
848 co_IntSendMessage( UserHMGetHandle(UserGetAncestor( Wnd, GA_ROOT )), WM_SYSCOMMAND, SC_KEYMENU, 0L );
849 pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK|QF_FF10STATUS); //iMenuSysKey = iF10Key = 0;
850 break;
851 }
852
853 case WM_SYSCHAR:
854 {
855 pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK); //iMenuSysKey = 0;
856 if (wParam == VK_RETURN && (Wnd->style & WS_MINIMIZE) != 0)
857 {
858 UserPostMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_RESTORE, 0L );
859 break;
860 }
861 if ((HIWORD(lParam) & KF_ALTDOWN) && wParam)
862 {
863 if (wParam == VK_TAB || wParam == VK_ESCAPE) break;
864 if (wParam == VK_SPACE && Wnd->style & WS_CHILD)
865 co_IntSendMessage( UserHMGetHandle(IntGetParent(Wnd)), Msg, wParam, lParam );
866 else
867 co_IntSendMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_KEYMENU, wParam );
868 }
869 else /* check for Ctrl-Esc */
870 if (wParam != VK_ESCAPE) UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, 0); //MessageBeep(0);
871 break;
872 }
873
874 case WM_CANCELMODE:
875 {
876 pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK);
877
878 MENU_EndMenu( Wnd );
879 if (IntGetCaptureWindow() == UserHMGetHandle(Wnd))
880 {
881 IntReleaseCapture();
882 }
883 break;
884 }
885
886 case WM_CLOSE:
887 co_UserDestroyWindow(Wnd);
888 break;
889
890 case WM_CTLCOLORMSGBOX:
891 case WM_CTLCOLOREDIT:
892 case WM_CTLCOLORLISTBOX:
893 case WM_CTLCOLORBTN:
894 case WM_CTLCOLORDLG:
895 case WM_CTLCOLORSTATIC:
896 case WM_CTLCOLORSCROLLBAR:
897 return (LRESULT) DefWndControlColor((HDC)wParam, Msg - WM_CTLCOLORMSGBOX);
898
899 case WM_CTLCOLOR:
900 return (LRESULT) DefWndControlColor((HDC)wParam, HIWORD(lParam));
901
902 case WM_SETCURSOR:
903 {
904 if (Wnd->style & WS_CHILD)
905 {
906 /* with the exception of the border around a resizable wnd,
907 * give the parent first chance to set the cursor */
908 if (LOWORD(lParam) < HTLEFT || LOWORD(lParam) > HTBOTTOMRIGHT)
909 {
910 PWND parent = Wnd->spwndParent;//IntGetParent( Wnd );
911 if (parent != UserGetDesktopWindow() &&
912 co_IntSendMessage( UserHMGetHandle(parent), WM_SETCURSOR, wParam, lParam))
913 return TRUE;
914 }
915 }
916 return DefWndHandleSetCursor(Wnd, wParam, lParam);
917 }
918
919 case WM_MOUSEACTIVATE:
920 if (Wnd->style & WS_CHILD)
921 {
922 LONG Ret;
923 HWND hwndParent;
924 PWND pwndParent = IntGetParent(Wnd);
925 hwndParent = pwndParent ? UserHMGetHandle(pwndParent) : NULL;
926 if (hwndParent) Ret = co_IntSendMessage(hwndParent, WM_MOUSEACTIVATE, wParam, lParam);
927 if (Ret) return (Ret);
928 }
929 return ( (HIWORD(lParam) == WM_LBUTTONDOWN && LOWORD(lParam) == HTCAPTION) ? MA_NOACTIVATE : MA_ACTIVATE );
930
931 case WM_ACTIVATE:
932 /* The default action in Windows is to set the keyboard focus to
933 * the window, if it's being activated and not minimized */
934 if (LOWORD(wParam) != WA_INACTIVE &&
935 !(Wnd->style & WS_MINIMIZE))
936 {
937 //ERR("WM_ACTIVATE %p\n",hWnd);
938 co_UserSetFocus(Wnd);
939 }
940 break;
941
942 case WM_MOUSEWHEEL:
943 if (Wnd->style & WS_CHILD)
944 {
945 HWND hwndParent;
946 PWND pwndParent = IntGetParent(Wnd);
947 hwndParent = pwndParent ? UserHMGetHandle(pwndParent) : NULL;
948 return co_IntSendMessage( hwndParent, WM_MOUSEWHEEL, wParam, lParam);
949 }
950 break;
951
952 case WM_ERASEBKGND:
953 case WM_ICONERASEBKGND:
954 {
955 RECT Rect;
956 HBRUSH hBrush = Wnd->pcls->hbrBackground;
957 if (!hBrush) return 0;
958 if (hBrush <= (HBRUSH)COLOR_MENUBAR)
959 {
960 hBrush = IntGetSysColorBrush((INT)hBrush);
961 }
962 if (Wnd->pcls->style & CS_PARENTDC)
963 {
964 /* can't use GetClipBox with a parent DC or we fill the whole parent */
965 IntGetClientRect(Wnd, &Rect);
966 GreDPtoLP((HDC)wParam, (LPPOINT)&Rect, 2);
967 }
968 else
969 {
970 GdiGetClipBox((HDC)wParam, &Rect);
971 }
972 FillRect((HDC)wParam, &Rect, hBrush);
973 return (1);
974 }
975
976 case WM_GETHOTKEY:
977 //ERR("WM_GETHOTKEY\n");
978 return DefWndGetHotKey(Wnd);
979 case WM_SETHOTKEY:
980 //ERR("WM_SETHOTKEY\n");
981 return DefWndSetHotKey(Wnd, wParam);
982
983 case WM_NCHITTEST:
984 {
985 POINT Point;
986 Point.x = GET_X_LPARAM(lParam);
987 Point.y = GET_Y_LPARAM(lParam);
988 return GetNCHitEx(Wnd, Point);
989 }
990
991 case WM_PRINT:
992 {
993 DefWndPrint(Wnd, (HDC)wParam, lParam);
994 return (0);
995 }
996
997 case WM_SYSCOLORCHANGE:
998 {
999 /* force to redraw non-client area */
1000 UserPaintCaption(Wnd, DC_NC);
1001 /* Use InvalidateRect to redraw client area, enable
1002 * erase to redraw all subcontrols otherwise send the
1003 * WM_SYSCOLORCHANGE to child windows/controls is required
1004 */
1005 co_UserRedrawWindow( Wnd, NULL, NULL, RDW_ALLCHILDREN|RDW_INVALIDATE|RDW_ERASE);
1006 return (0);
1007 }
1008
1009 case WM_PAINTICON:
1010 case WM_PAINT:
1011 {
1012 PAINTSTRUCT Ps;
1013 HDC hDC;
1014
1015 /* If already in Paint and Client area is not empty just return. */
1016 if (Wnd->state2 & WNDS2_STARTPAINT && !RECTL_bIsEmptyRect(&Wnd->rcClient))
1017 {
1018 ERR("In Paint and Client area is not empty!\n");
1019 return 0;
1020 }
1021
1022 hDC = IntBeginPaint(Wnd, &Ps);
1023 if (hDC)
1024 {
1025 if (((Wnd->style & WS_MINIMIZE) != 0) && (Wnd->pcls->spicn))
1026 {
1027 RECT ClientRect;
1028 INT x, y;
1029
1030 ERR("Doing Paint and Client area is empty!\n");
1031 IntGetClientRect(Wnd, &ClientRect);
1032 x = (ClientRect.right - ClientRect.left - UserGetSystemMetrics(SM_CXICON)) / 2;
1033 y = (ClientRect.bottom - ClientRect.top - UserGetSystemMetrics(SM_CYICON)) / 2;
1034 UserReferenceObject(Wnd->pcls->spicn);
1035 UserDrawIconEx(hDC, x, y, Wnd->pcls->spicn, 0, 0, 0, 0, DI_NORMAL | DI_COMPAT | DI_DEFAULTSIZE);
1036 UserDereferenceObject(Wnd->pcls->spicn);
1037 }
1038
1039 IntEndPaint(Wnd, &Ps);
1040 }
1041 return (0);
1042 }
1043
1044 case WM_SYNCPAINT:
1045 {
1046 HRGN hRgn;
1047 Wnd->state &= ~WNDS_SYNCPAINTPENDING;
1048 TRACE("WM_SYNCPAINT\n");
1049 hRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
1050 if (hRgn)
1051 {
1052 if (co_UserGetUpdateRgn(Wnd, hRgn, FALSE) != NULLREGION)
1053 {
1054 PREGION pRgn = REGION_LockRgn(hRgn);
1055 if (pRgn) REGION_UnlockRgn(pRgn);
1056 if (!wParam)
1057 wParam = (RDW_ERASENOW | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN);
1058 co_UserRedrawWindow(Wnd, NULL, pRgn, wParam);
1059 }
1060 GreDeleteObject(hRgn);
1061 }
1062 return 0;
1063 }
1064
1065 case WM_SETREDRAW:
1066 if (wParam)
1067 {
1068 if (!(Wnd->style & WS_VISIBLE))
1069 {
1070 IntSetStyle( Wnd, WS_VISIBLE, 0 );
1071 Wnd->state |= WNDS_SENDNCPAINT;
1072 }
1073 }
1074 else
1075 {
1076 if (Wnd->style & WS_VISIBLE)
1077 {
1078 co_UserRedrawWindow( Wnd, NULL, NULL, RDW_ALLCHILDREN | RDW_VALIDATE );
1079 IntSetStyle( Wnd, 0, WS_VISIBLE );
1080 }
1081 }
1082 return 0;
1083
1084 case WM_WINDOWPOSCHANGING:
1085 {
1086 return (DefWndHandleWindowPosChanging(Wnd, (WINDOWPOS*)lParam));
1087 }
1088
1089 case WM_WINDOWPOSCHANGED:
1090 {
1091 return (DefWndHandleWindowPosChanged(Wnd, (WINDOWPOS*)lParam));
1092 }
1093
1094 case WM_NCCALCSIZE:
1095 {
1096 return NC_HandleNCCalcSize( Wnd, wParam, (RECTL *)lParam, FALSE );
1097 }
1098
1099 case WM_NCACTIVATE:
1100 {
1101 return NC_HandleNCActivate( Wnd, wParam, lParam );
1102 }
1103
1104 //
1105 // NC Paint mode.
1106 //
1107 case WM_NCPAINT:
1108 {
1109 HDC hDC = UserGetDCEx(Wnd, (HRGN)wParam, DCX_WINDOW | DCX_INTERSECTRGN | DCX_USESTYLE | DCX_KEEPCLIPRGN);
1110 Wnd->state |= WNDS_FORCEMENUDRAW;
1111 NC_DoNCPaint(Wnd, hDC, -1);
1112 Wnd->state &= ~WNDS_FORCEMENUDRAW;
1113 UserReleaseDC(Wnd, hDC, FALSE);
1114 return 0;
1115 }
1116 //
1117 // Draw Caption mode.
1118 //
1119 // wParam are DC_* flags.
1120 //
1121 case WM_NCUAHDRAWCAPTION:
1122 {
1123 HDC hDC = UserGetDCEx(Wnd, NULL, DCX_WINDOW|DCX_USESTYLE);
1124 TRACE("WM_NCUAHDRAWCAPTION: wParam DC_ flags %08x\n",wParam);
1125 UserDrawCaptionBar(Wnd, hDC, wParam|DC_FRAME); // Include DC_FRAME to comp for drawing glich.
1126 UserReleaseDC(Wnd, hDC, FALSE);
1127 return 0;
1128 }
1129 //
1130 // Draw Frame mode.
1131 //
1132 // wParam is HDC, lParam are DC_ACTIVE and or DC_REDRAWHUNGWND.
1133 //
1134 case WM_NCUAHDRAWFRAME:
1135 {
1136 TRACE("WM_NCUAHDRAWFRAME: wParam hDC %p lParam DC_ flags %08x\n",wParam,lParam);
1137 NC_DoNCPaint(Wnd, (HDC)wParam, lParam|DC_NC);
1138 return 0;
1139 }
1140
1141 /* ReactOS only. */
1142 case WM_CBT:
1143 {
1144 switch (wParam)
1145 {
1146 case HCBT_MOVESIZE:
1147 {
1148 RECTL rt;
1149
1150 if (lParam)
1151 {
1152 _SEH2_TRY
1153 {
1154 ProbeForRead((PVOID)lParam,
1155 sizeof(RECT),
1156 1);
1157
1158 RtlCopyMemory(&rt,
1159 (PVOID)lParam,
1160 sizeof(RECT));
1161 }
1162 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1163 {
1164 lResult = 1;
1165 }
1166 _SEH2_END;
1167 }
1168 if (!lResult)
1169 lResult = co_HOOK_CallHooks(WH_CBT, HCBT_MOVESIZE, (WPARAM)Wnd->head.h, lParam ? (LPARAM)&rt : 0);
1170 }
1171 break;
1172 }
1173 break;
1174 }
1175 break;
1176 }
1177 return lResult;
1178 }
1179
1180 /* EOF */