[Win32SS]
[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_XBUTTONUP:
725 case WM_NCXBUTTONUP:
726 if (HIWORD(wParam) == XBUTTON1 || HIWORD(wParam) == XBUTTON2)
727 {
728 co_IntSendMessage(UserHMGetHandle(Wnd), WM_APPCOMMAND, (WPARAM)UserHMGetHandle(Wnd),
729 MAKELPARAM(LOWORD(wParam), FAPPCOMMAND_MOUSE | HIWORD(wParam)));
730 }
731 break;
732
733
734 case WM_CONTEXTMENU:
735 {
736 if (Wnd->style & WS_CHILD)
737 {
738 co_IntSendMessage(UserHMGetHandle(IntGetParent(Wnd)), Msg, wParam, lParam);
739 }
740 else
741 {
742 POINT Pt;
743 LONG_PTR Style;
744 LONG HitCode;
745
746 Style = Wnd->style;
747
748 Pt.x = GET_X_LPARAM(lParam);
749 Pt.y = GET_Y_LPARAM(lParam);
750 if (Style & WS_CHILD)
751 {
752 IntScreenToClient(IntGetParent(Wnd), &Pt);
753 }
754
755 HitCode = GetNCHitEx(Wnd, Pt);
756
757 if (HitCode == HTCAPTION || HitCode == HTSYSMENU)
758 {
759 PMENU SystemMenu;
760 UINT Flags;
761
762 if((SystemMenu = IntGetSystemMenu(Wnd, FALSE)))
763 {
764 MENU_InitSysMenuPopup(SystemMenu, Wnd->style, Wnd->pcls->style, HitCode);
765
766 if(HitCode == HTCAPTION)
767 Flags = TPM_LEFTBUTTON | TPM_RIGHTBUTTON;
768 else
769 Flags = TPM_LEFTBUTTON;
770
771 IntTrackPopupMenuEx(SystemMenu, Flags|TPM_SYSTEM_MENU, Pt.x, Pt.y, Wnd, NULL);
772 }
773 }
774 if (HitCode == HTHSCROLL || HitCode == HTVSCROLL)
775 {
776 WARN("Scroll Menu Not Supported\n");
777 }
778 }
779 break;
780 }
781
782 case WM_KEYDOWN:
783 if (wParam == VK_F10)
784 {
785 pti->MessageQueue->QF_flags |= QF_FF10STATUS;
786
787 if (UserGetKeyState(VK_SHIFT) & 0x8000)
788 {
789 co_IntSendMessage(UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), MAKELPARAM(-1, -1));
790 }
791 }
792 break;
793
794 case WM_SYSKEYDOWN:
795 {
796 if (HIWORD(lParam) & KF_ALTDOWN)
797 { /* Previous state, if the key was down before this message,
798 this is a cheap way to ignore autorepeat keys. */
799 if ( !(HIWORD(lParam) & KF_REPEAT) )
800 {
801 if ( ( wParam == VK_MENU ||
802 wParam == VK_LMENU ||
803 wParam == VK_RMENU ) && !(pti->MessageQueue->QF_flags & QF_FMENUSTATUS)) //iMenuSysKey )
804 pti->MessageQueue->QF_flags |= QF_FMENUSTATUS; //iMenuSysKey = 1;
805 else
806 pti->MessageQueue->QF_flags &= ~QF_FMENUSTATUS; //iMenuSysKey = 0;
807 }
808
809 pti->MessageQueue->QF_flags &= ~QF_FF10STATUS; //iF10Key = 0;
810
811 if (wParam == VK_F4) /* Try to close the window */
812 {
813 PWND top = UserGetAncestor(Wnd, GA_ROOT);
814 if (!(top->style & CS_NOCLOSE))
815 UserPostMessage(UserHMGetHandle(top), WM_SYSCOMMAND, SC_CLOSE, 0);
816 }
817 else if (wParam == VK_SNAPSHOT) // Alt-VK_SNAPSHOT?
818 {
819 PWND pwnd = Wnd;
820 while (IntGetParent(pwnd) != NULL)
821 {
822 pwnd = IntGetParent(pwnd);
823 }
824 ERR("DefWndScreenshot\n");
825 DefWndScreenshot(pwnd);
826 }
827 else if ( wParam == VK_ESCAPE || wParam == VK_TAB ) // Alt-Tab/ESC Alt-Shift-Tab/ESC
828 {
829 WPARAM wParamTmp;
830 HWND Active = UserGetActiveWindow(); // Noticed MDI problem.
831 if (!Active)
832 {
833 FIXME("WM_SYSKEYDOWN VK_ESCAPE no active\n");
834 break;
835 }
836 wParamTmp = UserGetKeyState(VK_SHIFT) & 0x8000 ? SC_PREVWINDOW : SC_NEXTWINDOW;
837 co_IntSendMessage( Active, WM_SYSCOMMAND, wParamTmp, wParam );
838 }
839 }
840 else if( wParam == VK_F10 )
841 {
842 if (UserGetKeyState(VK_SHIFT) & 0x8000)
843 co_IntSendMessage( UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), MAKELPARAM(-1, -1) );
844 pti->MessageQueue->QF_flags |= QF_FF10STATUS; //iF10Key = 1;
845 }
846 else if( wParam == VK_ESCAPE && (UserGetKeyState(VK_SHIFT) & 0x8000))
847 co_IntSendMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_KEYMENU, ' ' );
848 break;
849 }
850
851 case WM_KEYUP:
852 case WM_SYSKEYUP:
853 {
854 /* Press and release F10 or ALT */
855 if (((wParam == VK_MENU || wParam == VK_LMENU || wParam == VK_RMENU)
856 && (pti->MessageQueue->QF_flags & (QF_FMENUSTATUS|QF_FMENUSTATUSBREAK)) == QF_FMENUSTATUS /*iMenuSysKey*/) ||
857 ((wParam == VK_F10) && pti->MessageQueue->QF_flags & QF_FF10STATUS /*iF10Key*/))
858 co_IntSendMessage( UserHMGetHandle(UserGetAncestor( Wnd, GA_ROOT )), WM_SYSCOMMAND, SC_KEYMENU, 0L );
859 pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK|QF_FF10STATUS); //iMenuSysKey = iF10Key = 0;
860 break;
861 }
862
863 case WM_SYSCHAR:
864 {
865 pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK); //iMenuSysKey = 0;
866 if (wParam == VK_RETURN && (Wnd->style & WS_MINIMIZE) != 0)
867 {
868 UserPostMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_RESTORE, 0L );
869 break;
870 }
871 if ((HIWORD(lParam) & KF_ALTDOWN) && wParam)
872 {
873 if (wParam == VK_TAB || wParam == VK_ESCAPE) break;
874 if (wParam == VK_SPACE && Wnd->style & WS_CHILD)
875 co_IntSendMessage( UserHMGetHandle(IntGetParent(Wnd)), Msg, wParam, lParam );
876 else
877 co_IntSendMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_KEYMENU, wParam );
878 }
879 else /* check for Ctrl-Esc */
880 if (wParam != VK_ESCAPE) UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, 0); //MessageBeep(0);
881 break;
882 }
883
884 case WM_CANCELMODE:
885 {
886 pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK);
887
888 MENU_EndMenu( Wnd );
889 if (IntGetCaptureWindow() == UserHMGetHandle(Wnd))
890 {
891 IntReleaseCapture();
892 }
893 break;
894 }
895
896 case WM_CLOSE:
897 co_UserDestroyWindow(Wnd);
898 break;
899
900 case WM_CTLCOLORMSGBOX:
901 case WM_CTLCOLOREDIT:
902 case WM_CTLCOLORLISTBOX:
903 case WM_CTLCOLORBTN:
904 case WM_CTLCOLORDLG:
905 case WM_CTLCOLORSTATIC:
906 case WM_CTLCOLORSCROLLBAR:
907 return (LRESULT) DefWndControlColor((HDC)wParam, Msg - WM_CTLCOLORMSGBOX);
908
909 case WM_CTLCOLOR:
910 return (LRESULT) DefWndControlColor((HDC)wParam, HIWORD(lParam));
911
912 case WM_SETCURSOR:
913 {
914 if (Wnd->style & WS_CHILD)
915 {
916 /* with the exception of the border around a resizable wnd,
917 * give the parent first chance to set the cursor */
918 if (LOWORD(lParam) < HTLEFT || LOWORD(lParam) > HTBOTTOMRIGHT)
919 {
920 PWND parent = Wnd->spwndParent;//IntGetParent( Wnd );
921 if (parent != UserGetDesktopWindow() &&
922 co_IntSendMessage( UserHMGetHandle(parent), WM_SETCURSOR, wParam, lParam))
923 return TRUE;
924 }
925 }
926 return DefWndHandleSetCursor(Wnd, wParam, lParam);
927 }
928
929 case WM_MOUSEACTIVATE:
930 if (Wnd->style & WS_CHILD)
931 {
932 LONG Ret;
933 HWND hwndParent;
934 PWND pwndParent = IntGetParent(Wnd);
935 hwndParent = pwndParent ? UserHMGetHandle(pwndParent) : NULL;
936 if (hwndParent) Ret = co_IntSendMessage(hwndParent, WM_MOUSEACTIVATE, wParam, lParam);
937 if (Ret) return (Ret);
938 }
939 return ( (HIWORD(lParam) == WM_LBUTTONDOWN && LOWORD(lParam) == HTCAPTION) ? MA_NOACTIVATE : MA_ACTIVATE );
940
941 case WM_ACTIVATE:
942 /* The default action in Windows is to set the keyboard focus to
943 * the window, if it's being activated and not minimized */
944 if (LOWORD(wParam) != WA_INACTIVE &&
945 !(Wnd->style & WS_MINIMIZE))
946 {
947 //ERR("WM_ACTIVATE %p\n",hWnd);
948 co_UserSetFocus(Wnd);
949 }
950 break;
951
952 case WM_MOUSEWHEEL:
953 if (Wnd->style & WS_CHILD)
954 {
955 HWND hwndParent;
956 PWND pwndParent = IntGetParent(Wnd);
957 hwndParent = pwndParent ? UserHMGetHandle(pwndParent) : NULL;
958 return co_IntSendMessage( hwndParent, WM_MOUSEWHEEL, wParam, lParam);
959 }
960 break;
961
962 case WM_ERASEBKGND:
963 case WM_ICONERASEBKGND:
964 {
965 RECT Rect;
966 HBRUSH hBrush = Wnd->pcls->hbrBackground;
967 if (!hBrush) return 0;
968 if (hBrush <= (HBRUSH)COLOR_MENUBAR)
969 {
970 hBrush = IntGetSysColorBrush((INT)hBrush);
971 }
972 if (Wnd->pcls->style & CS_PARENTDC)
973 {
974 /* can't use GetClipBox with a parent DC or we fill the whole parent */
975 IntGetClientRect(Wnd, &Rect);
976 GreDPtoLP((HDC)wParam, (LPPOINT)&Rect, 2);
977 }
978 else
979 {
980 GdiGetClipBox((HDC)wParam, &Rect);
981 }
982 FillRect((HDC)wParam, &Rect, hBrush);
983 return (1);
984 }
985
986 case WM_GETHOTKEY:
987 //ERR("WM_GETHOTKEY\n");
988 return DefWndGetHotKey(Wnd);
989 case WM_SETHOTKEY:
990 //ERR("WM_SETHOTKEY\n");
991 return DefWndSetHotKey(Wnd, wParam);
992
993 case WM_NCHITTEST:
994 {
995 POINT Point;
996 Point.x = GET_X_LPARAM(lParam);
997 Point.y = GET_Y_LPARAM(lParam);
998 return GetNCHitEx(Wnd, Point);
999 }
1000
1001 case WM_PRINT:
1002 {
1003 DefWndPrint(Wnd, (HDC)wParam, lParam);
1004 return (0);
1005 }
1006
1007 case WM_SYSCOLORCHANGE:
1008 {
1009 /* force to redraw non-client area */
1010 UserPaintCaption(Wnd, DC_NC);
1011 /* Use InvalidateRect to redraw client area, enable
1012 * erase to redraw all subcontrols otherwise send the
1013 * WM_SYSCOLORCHANGE to child windows/controls is required
1014 */
1015 co_UserRedrawWindow( Wnd, NULL, NULL, RDW_ALLCHILDREN|RDW_INVALIDATE|RDW_ERASE);
1016 return (0);
1017 }
1018
1019 case WM_PAINTICON:
1020 case WM_PAINT:
1021 {
1022 PAINTSTRUCT Ps;
1023 HDC hDC;
1024
1025 /* If already in Paint and Client area is not empty just return. */
1026 if (Wnd->state2 & WNDS2_STARTPAINT && !RECTL_bIsEmptyRect(&Wnd->rcClient))
1027 {
1028 ERR("In Paint and Client area is not empty!\n");
1029 return 0;
1030 }
1031
1032 hDC = IntBeginPaint(Wnd, &Ps);
1033 if (hDC)
1034 {
1035 if (((Wnd->style & WS_MINIMIZE) != 0) && (Wnd->pcls->spicn))
1036 {
1037 RECT ClientRect;
1038 INT x, y;
1039
1040 ERR("Doing Paint and Client area is empty!\n");
1041 IntGetClientRect(Wnd, &ClientRect);
1042 x = (ClientRect.right - ClientRect.left - UserGetSystemMetrics(SM_CXICON)) / 2;
1043 y = (ClientRect.bottom - ClientRect.top - UserGetSystemMetrics(SM_CYICON)) / 2;
1044 UserReferenceObject(Wnd->pcls->spicn);
1045 UserDrawIconEx(hDC, x, y, Wnd->pcls->spicn, 0, 0, 0, 0, DI_NORMAL | DI_COMPAT | DI_DEFAULTSIZE);
1046 UserDereferenceObject(Wnd->pcls->spicn);
1047 }
1048
1049 IntEndPaint(Wnd, &Ps);
1050 }
1051 return (0);
1052 }
1053
1054 case WM_SYNCPAINT:
1055 {
1056 HRGN hRgn;
1057 Wnd->state &= ~WNDS_SYNCPAINTPENDING;
1058 TRACE("WM_SYNCPAINT\n");
1059 hRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
1060 if (hRgn)
1061 {
1062 if (co_UserGetUpdateRgn(Wnd, hRgn, FALSE) != NULLREGION)
1063 {
1064 PREGION pRgn = REGION_LockRgn(hRgn);
1065 if (pRgn) REGION_UnlockRgn(pRgn);
1066 if (!wParam)
1067 wParam = (RDW_ERASENOW | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN);
1068 co_UserRedrawWindow(Wnd, NULL, pRgn, wParam);
1069 }
1070 GreDeleteObject(hRgn);
1071 }
1072 return 0;
1073 }
1074
1075 case WM_SETREDRAW:
1076 if (wParam)
1077 {
1078 if (!(Wnd->style & WS_VISIBLE))
1079 {
1080 IntSetStyle( Wnd, WS_VISIBLE, 0 );
1081 Wnd->state |= WNDS_SENDNCPAINT;
1082 }
1083 }
1084 else
1085 {
1086 if (Wnd->style & WS_VISIBLE)
1087 {
1088 co_UserRedrawWindow( Wnd, NULL, NULL, RDW_ALLCHILDREN | RDW_VALIDATE );
1089 IntSetStyle( Wnd, 0, WS_VISIBLE );
1090 }
1091 }
1092 return 0;
1093
1094 case WM_WINDOWPOSCHANGING:
1095 {
1096 return (DefWndHandleWindowPosChanging(Wnd, (WINDOWPOS*)lParam));
1097 }
1098
1099 case WM_WINDOWPOSCHANGED:
1100 {
1101 return (DefWndHandleWindowPosChanged(Wnd, (WINDOWPOS*)lParam));
1102 }
1103
1104 case WM_NCCALCSIZE:
1105 {
1106 return NC_HandleNCCalcSize( Wnd, wParam, (RECTL *)lParam, FALSE );
1107 }
1108
1109 case WM_NCACTIVATE:
1110 {
1111 return NC_HandleNCActivate( Wnd, wParam, lParam );
1112 }
1113
1114 //
1115 // NC Paint mode.
1116 //
1117 case WM_NCPAINT:
1118 {
1119 HDC hDC = UserGetDCEx(Wnd, (HRGN)wParam, DCX_WINDOW | DCX_INTERSECTRGN | DCX_USESTYLE | DCX_KEEPCLIPRGN);
1120 Wnd->state |= WNDS_FORCEMENUDRAW;
1121 NC_DoNCPaint(Wnd, hDC, -1);
1122 Wnd->state &= ~WNDS_FORCEMENUDRAW;
1123 UserReleaseDC(Wnd, hDC, FALSE);
1124 return 0;
1125 }
1126 //
1127 // Draw Caption mode.
1128 //
1129 // wParam are DC_* flags.
1130 //
1131 case WM_NCUAHDRAWCAPTION:
1132 {
1133 HDC hDC = UserGetDCEx(Wnd, NULL, DCX_WINDOW|DCX_USESTYLE);
1134 TRACE("WM_NCUAHDRAWCAPTION: wParam DC_ flags %08x\n",wParam);
1135 UserDrawCaptionBar(Wnd, hDC, wParam|DC_FRAME); // Include DC_FRAME to comp for drawing glich.
1136 UserReleaseDC(Wnd, hDC, FALSE);
1137 return 0;
1138 }
1139 //
1140 // Draw Frame mode.
1141 //
1142 // wParam is HDC, lParam are DC_ACTIVE and or DC_REDRAWHUNGWND.
1143 //
1144 case WM_NCUAHDRAWFRAME:
1145 {
1146 TRACE("WM_NCUAHDRAWFRAME: wParam hDC %p lParam DC_ flags %08x\n",wParam,lParam);
1147 NC_DoNCPaint(Wnd, (HDC)wParam, lParam|DC_NC);
1148 return 0;
1149 }
1150
1151 /* ReactOS only. */
1152 case WM_CBT:
1153 {
1154 switch (wParam)
1155 {
1156 case HCBT_MOVESIZE:
1157 {
1158 RECTL rt;
1159
1160 if (lParam)
1161 {
1162 _SEH2_TRY
1163 {
1164 ProbeForRead((PVOID)lParam,
1165 sizeof(RECT),
1166 1);
1167
1168 RtlCopyMemory(&rt,
1169 (PVOID)lParam,
1170 sizeof(RECT));
1171 }
1172 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1173 {
1174 lResult = 1;
1175 }
1176 _SEH2_END;
1177 }
1178 if (!lResult)
1179 lResult = co_HOOK_CallHooks(WH_CBT, HCBT_MOVESIZE, (WPARAM)Wnd->head.h, lParam ? (LPARAM)&rt : 0);
1180 }
1181 break;
1182 }
1183 break;
1184 }
1185 break;
1186 }
1187 return lResult;
1188 }
1189
1190 /* EOF */