ReactOS 0.4.15-dev-7704-gc07eb9f
defwnd.c File Reference
#include <win32k.h>
#include <windowsx.h>
Include dependency graph for defwnd.c:

Go to the source code of this file.

Functions

 DBG_DEFAULT_CHANNEL (UserDefwnd)
 
INT WINAPI DrawTextExWorker (HDC hdc, LPWSTR str, INT i_count, LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp)
 
INT WINAPI DrawTextW (HDC hdc, LPCWSTR str, INT count, LPRECT rect, UINT flags)
 
HBRUSH FASTCALL DefWndControlColor (HDC hDC, UINT ctlType)
 
LRESULT FASTCALL DefWndHandleWindowPosChanging (PWND pWnd, WINDOWPOS *Pos)
 
LRESULT FASTCALL DefWndHandleWindowPosChanged (PWND pWnd, WINDOWPOS *Pos)
 
LRESULT FASTCALL DefWndHandleSysCommand (PWND pWnd, WPARAM wParam, LPARAM lParam)
 
PWND FASTCALL co_IntFindChildWindowToOwner (PWND Root, PWND Owner)
 
LRESULT DefWndHandleSetCursor (PWND pWnd, WPARAM wParam, LPARAM lParam)
 
VOID FASTCALL DefWndPrint (PWND pwnd, HDC hdc, ULONG uFlags)
 
BOOL UserPaintCaption (PWND pWnd, INT Flags)
 
LRESULT FASTCALL DefWndSetIcon (PWND pWnd, WPARAM wParam, LPARAM lParam)
 
LRESULT FASTCALL DefWndGetIcon (PWND pWnd, WPARAM wParam, LPARAM lParam)
 
VOID FASTCALL DefWndScreenshot (PWND pWnd)
 
LRESULT FASTCALL IntDefWindowProc (PWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam, BOOL Ansi)
 

Function Documentation

◆ co_IntFindChildWindowToOwner()

PWND FASTCALL co_IntFindChildWindowToOwner ( PWND  Root,
PWND  Owner 
)

Definition at line 216 of file defwnd.c.

217{
218 PWND Ret;
219 PWND Child, OwnerWnd;
220
221 for(Child = Root->spwndChild; Child; Child = Child->spwndNext)
222 {
223 OwnerWnd = Child->spwndOwner;
224 if(!OwnerWnd)
225 continue;
226
227 if (!(Child->style & WS_POPUP) ||
228 !(Child->style & WS_VISIBLE) ||
229 /* Fixes CMD pop up properties window from having foreground. */
230 Owner->head.pti->MessageQueue != Child->head.pti->MessageQueue)
231 continue;
232
233 if(OwnerWnd == Owner)
234 {
235 Ret = Child;
236 return Ret;
237 }
238 }
239 return NULL;
240}
#define NULL
Definition: types.h:112
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ SaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ OwnerSize PSID Owner
Definition: rtlfuncs.h:1597
#define WS_POPUP
Definition: pedump.c:616
#define WS_VISIBLE
Definition: pedump.c:620
root entry for file system trees
Definition: entries.h:148
Definition: ntuser.h:694
struct _WND * spwndOwner
Definition: ntuser.h:715
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFDEVICE Child
Definition: wdffdo.h:536

Referenced by DefWndHandleSetCursor().

◆ DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL ( UserDefwnd  )

◆ DefWndControlColor()

HBRUSH FASTCALL DefWndControlColor ( HDC  hDC,
UINT  ctlType 
)

Definition at line 32 of file defwnd.c.

33{
34 if (ctlType == CTLCOLOR_SCROLLBAR)
35 {
40
41 /* if COLOR_WINDOW happens to be the same as COLOR_3DHILIGHT
42 * we better use 0x55aa bitmap brush to make scrollbar's background
43 * look different from the window background.
44 */
45 if ( bk == IntGetSysColor(COLOR_WINDOW))
46 return gpsi->hbrGray;
47
49 return hb;
50 }
51
53
54 if ((ctlType == CTLCOLOR_EDIT) || (ctlType == CTLCOLOR_LISTBOX))
55 {
57 }
58 else
59 {
62 }
63
65}
static HDC hDC
Definition: 3dtext.c:33
COLORREF FASTCALL IntGdiSetBkColor(_In_ HDC hDC, _In_ COLORREF Color)
COLORREF FASTCALL IntGdiSetTextColor(HDC hDC, COLORREF color)
Definition: dcutil.c:172
PSERVERINFO gpsi
Definition: imm.c:18
HGDIOBJ FASTCALL IntGetSysColorBrush(INT Object)
Definition: stockobj.c:317
DWORD FASTCALL IntGetSysColor(INT nIndex)
Definition: stockobj.c:323
__kernel_entry W32KAPI BOOL APIENTRY NtGdiUnrealizeObject(_In_ HANDLE h)
DWORD COLORREF
Definition: windef.h:300
#define CTLCOLOR_SCROLLBAR
Definition: winuser.h:955
#define COLOR_WINDOW
Definition: winuser.h:917
#define COLOR_SCROLLBAR
Definition: winuser.h:911
#define COLOR_WINDOWTEXT
Definition: winuser.h:920
#define CTLCOLOR_LISTBOX
Definition: winuser.h:952
#define CTLCOLOR_EDIT
Definition: winuser.h:951
#define COLOR_3DHILIGHT
Definition: winuser.h:936
#define COLOR_3DFACE
Definition: winuser.h:928

Referenced by IntDefWindowProc(), IntDrawScrollInterior(), and User32DefWindowProc().

◆ DefWndGetIcon()

LRESULT FASTCALL DefWndGetIcon ( PWND  pWnd,
WPARAM  wParam,
LPARAM  lParam 
)

Definition at line 476 of file defwnd.c.

477{
478 HICON hIconRet;
479 if ( wParam > ICON_SMALL2 )
480 {
482 return 0;
483 }
484 switch(wParam)
485 {
486 case ICON_BIG:
487 hIconRet = UserGetProp(pWnd, gpsi->atomIconProp, TRUE);
488 break;
489 case ICON_SMALL:
490 case ICON_SMALL2:
491 hIconRet = UserGetProp(pWnd, gpsi->atomIconSmProp, TRUE);
492 break;
494 }
495 return (LRESULT)hIconRet;
496}
WPARAM wParam
Definition: combotst.c:138
#define TRUE
Definition: types.h:120
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
static HICON
Definition: imagelist.c:84
#define DEFAULT_UNREACHABLE
ATOM atomIconProp
Definition: ntuser.h:1066
ATOM atomIconSmProp
Definition: ntuser.h:1065
#define ICON_BIG
Definition: tnclass.cpp:51
#define ICON_SMALL
Definition: tnclass.cpp:48
HANDLE FASTCALL UserGetProp(_In_ PWND Window, _In_ ATOM Atom, _In_ BOOLEAN SystemProp)
Definition: prop.c:46
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:22
LONG_PTR LRESULT
Definition: windef.h:209

Referenced by IntDefWindowProc(), and User32DefWindowProc().

◆ DefWndHandleSetCursor()

LRESULT DefWndHandleSetCursor ( PWND  pWnd,
WPARAM  wParam,
LPARAM  lParam 
)

Definition at line 243 of file defwnd.c.

244{
245 PWND pwndPopUP = NULL;
247
248 /* Not for child windows. */
249 if (UserHMGetHandle(pWnd) != (HWND)wParam)
250 {
251 return FALSE;
252 }
253
254 switch((short)LOWORD(lParam))
255 {
256 case HTERROR:
257 {
260
261 if (Msg == WM_LBUTTONDOWN)
262 {
263 // Find a pop up window to bring active.
265 if (pwndPopUP)
266 {
267 // Not a child pop up from desktop.
268 if ( pwndPopUP != UserGetDesktopWindow()->spwndChild )
269 {
270 // Get original active window.
271 PWND pwndOrigActive = gpqForeground->spwndActive;
272
274
275 UserRefObjectCo(pwndPopUP, &Ref);
276 //UserSetActiveWindow(pwndPopUP);
277 co_IntSetForegroundWindow(pwndPopUP); // HACK
278 UserDerefObjectCo(pwndPopUP);
279
280 // If the change was made, break out.
281 if (pwndOrigActive != gpqForeground->spwndActive)
282 break;
283 }
284 }
285 }
287 if (Msg == WM_LBUTTONDOWN || Msg == WM_MBUTTONDOWN ||
288 Msg == WM_RBUTTONDOWN || Msg == WM_XBUTTONDOWN)
289 {
290 if (pwndPopUP)
291 {
292 FLASHWINFO fwi =
293 {sizeof(FLASHWINFO),
294 UserHMGetHandle(pwndPopUP),
295 FLASHW_ALL,
297 (gpsi->dtCaretBlink >> 3)};
298
299 // Now shake that window!
300 IntFlashWindowEx(pwndPopUP, &fwi);
301 }
303 }
304 break;
305 }
306
307 case HTCLIENT:
308 {
309 if (pWnd->pcls->spcur)
310 {
312 }
313 return FALSE;
314 }
315
316 case HTLEFT:
317 case HTRIGHT:
318 {
319 if (pWnd->style & WS_MAXIMIZE)
320 {
321 break;
322 }
324 return TRUE;
325 }
326
327 case HTTOP:
328 case HTBOTTOM:
329 {
330 if (pWnd->style & WS_MAXIMIZE)
331 {
332 break;
333 }
335 return TRUE;
336 }
337
338 case HTTOPLEFT:
339 case HTBOTTOMRIGHT:
340 {
341 if (pWnd->style & WS_MAXIMIZE)
342 {
343 break;
344 }
345 IntSystemSetCursor(SYSTEMCUR(SIZENWSE));
346 return TRUE;
347 }
348
349 case HTBOTTOMLEFT:
350 case HTTOPRIGHT:
351 {
352 if (pWnd->style & WS_MAXIMIZE)
353 {
354 break;
355 }
356 IntSystemSetCursor(SYSTEMCUR(SIZENESW));
357 return TRUE;
358 }
359 }
361 return FALSE;
362}
struct @1628 Msg[]
LPARAM lParam
Definition: combotst.c:139
#define SYSTEMCUR(func)
Definition: cursoricon.h:129
#define FALSE
Definition: types.h:117
unsigned short WORD
Definition: ntddk_ex.h:93
PUSER_MESSAGE_QUEUE gpqForeground
Definition: focus.c:13
BOOL FASTCALL co_IntSetForegroundWindow(PWND Window)
Definition: focus.c:1549
#define UserHMGetHandle(obj)
Definition: ntuser.h:230
PWND FASTCALL co_IntFindChildWindowToOwner(PWND Root, PWND Owner)
Definition: defwnd.c:216
BOOLEAN FASTCALL co_WinPosSetWindowPos(PWND Window, HWND WndInsertAfter, INT x, INT y, INT cx, INT cy, UINT flags)
Definition: winpos.c:1786
HWND hwndSAS
Definition: winsta.c:24
static __inline VOID UserDerefObjectCo(PVOID obj)
Definition: object.h:40
static __inline VOID UserRefObjectCo(PVOID obj, PUSER_REFERENCE_ENTRY UserReferenceEntry)
Definition: object.h:27
#define LOWORD(l)
Definition: pedump.c:82
#define WS_MAXIMIZE
Definition: pedump.c:623
struct _CURICON_OBJECT * spcur
Definition: ntuser.h:586
DWORD dwForegroundFlashCount
Definition: sysparams.h:157
Definition: object.h:4
PCLS pcls
Definition: ntuser.h:720
DWORD style
Definition: ntuser.h:706
#define HIWORD(l)
Definition: typedefs.h:247
#define WM_LOGONNOTIFY
Definition: undocuser.h:37
#define LN_MESSAGE_BEEP
Definition: undocuser.h:120
BOOL FASTCALL IntFlashWindowEx(PWND pWnd, PFLASHWINFO pfwi)
Definition: painting.c:1304
PCURICON_OBJECT IntSystemSetCursor(PCURICON_OBJECT pcurNew)
Definition: cursoricon.c:230
PWND FASTCALL UserGetDesktopWindow(VOID)
Definition: desktop.c:1386
BOOL FASTCALL UserPostMessage(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1345
SPIVALUES gspv
Definition: sysparams.c:17
#define HTTOPRIGHT
Definition: winuser.h:2491
#define SWP_NOACTIVATE
Definition: winuser.h:1241
#define HTTOPLEFT
Definition: winuser.h:2490
#define HTBOTTOM
Definition: winuser.h:2492
#define HTERROR
Definition: winuser.h:2471
#define SWP_NOMOVE
Definition: winuser.h:1243
#define SWP_NOSIZE
Definition: winuser.h:1244
#define WM_LBUTTONDOWN
Definition: winuser.h:1775
#define WM_RBUTTONDOWN
Definition: winuser.h:1778
#define HTRIGHT
Definition: winuser.h:2488
#define HTCLIENT
Definition: winuser.h:2474
#define HTBOTTOMRIGHT
Definition: winuser.h:2494
#define HTBOTTOMLEFT
Definition: winuser.h:2493
#define HTTOP
Definition: winuser.h:2489
#define HTLEFT
Definition: winuser.h:2486
#define WM_MBUTTONDOWN
Definition: winuser.h:1781

Referenced by IntDefWindowProc().

◆ DefWndHandleSysCommand()

LRESULT FASTCALL DefWndHandleSysCommand ( PWND  pWnd,
WPARAM  wParam,
LPARAM  lParam 
)

Definition at line 125 of file defwnd.c.

126{
127 LRESULT lResult = 0;
128 BOOL Hook = FALSE;
129
130 if (ISITHOOKED(WH_CBT) || (pWnd->head.rpdesk->pDeskInfo->fsHooks & HOOKID_TO_FLAG(WH_CBT)))
131 {
132 Hook = TRUE;
134
135 if (lResult) return lResult;
136 }
137
138 switch (wParam & 0xfff0)
139 {
140 case SC_MOVE:
141 case SC_SIZE:
143 break;
144
145 case SC_MINIMIZE:
147 IntShowOwnedPopups(pWnd,FALSE); // This is done in ShowWindow! Need to retest!
149 break;
150
151 case SC_MAXIMIZE:
152 if (((pWnd->style & WS_MINIMIZE) != 0) && UserHMGetHandle(pWnd) == UserGetActiveWindow())
155 break;
156
157 case SC_RESTORE:
158 if (((pWnd->style & WS_MINIMIZE) != 0) && UserHMGetHandle(pWnd) == UserGetActiveWindow())
161 break;
162
163 case SC_CLOSE:
164 return co_IntSendMessage(UserHMGetHandle(pWnd), WM_CLOSE, 0, 0);
165
166 case SC_SCREENSAVE:
167 ERR("Screensaver Called!\n");
168 UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_START_SCREENSAVE, 0); // always lParam 0 == not Secure
169 break;
170
171 case SC_HOTKEY:
172 {
174
176 if (pWnd)
177 {
178 if (pWnd->spwndLastActive)
179 {
180 pWnd = pWnd->spwndLastActive;
181 }
182 UserRefObjectCo(pWnd, &Ref);
184 UserDerefObjectCo(pWnd);
185 if (pWnd->style & WS_MINIMIZE)
186 {
188 }
189 }
190 }
191 break;
192// case SC_DEFAULT:
193 case SC_MOUSEMENU:
194 {
195 POINT Pt;
196 Pt.x = (short)LOWORD(lParam);
197 Pt.y = (short)HIWORD(lParam);
198 MENU_TrackMouseMenuBar(pWnd, wParam & 0x000f, Pt);
199 }
200 break;
201
202 case SC_KEYMENU:
204 break;
205
206
207 default:
208 // We do not support anything else here so we should return normal even when sending a hook.
209 return 0;
210 }
211
212 return(Hook ? 1 : 0); // Don't call us again from user space.
213}
#define ERR(fmt,...)
Definition: debug.h:110
#define ValidateHwndNoErr(hwnd)
Definition: precomp.h:84
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:94
unsigned int BOOL
Definition: ntddk_ex.h:94
HWND FASTCALL UserGetActiveWindow(VOID)
Definition: focus.c:1429
#define ISITHOOKED(HookId)
Definition: hook.h:6
#define HOOKID_TO_FLAG(HookId)
Definition: hook.h:5
#define SC_SCREENSAVE
Definition: mmsystem.h:933
LRESULT APIENTRY co_HOOK_CallHooks(INT HookId, INT Code, WPARAM wParam, LPARAM lParam)
Definition: hook.c:1102
BOOLEAN FASTCALL co_WinPosShowWindow(PWND Wnd, INT Cmd)
Definition: winpos.c:2566
#define WS_MINIMIZE
Definition: pedump.c:622
struct _DESKTOP * rpdesk
Definition: ntuser.h:194
THRDESKHEAD head
Definition: ntuser.h:695
struct _WND * spwndLastActive
Definition: ntuser.h:739
long y
Definition: polytest.cpp:48
long x
Definition: polytest.cpp:48
#define LN_START_SCREENSAVE
Definition: undocuser.h:121
VOID MENU_TrackKbdMenuBar(PWND pwnd, UINT wParam, WCHAR wChar)
Definition: menu.c:4488
VOID MENU_TrackMouseMenuBar(PWND pWnd, ULONG ht, POINT pt)
Definition: menu.c:4458
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1445
VOID FASTCALL DefWndDoSizeMove(PWND pwnd, WORD wParam)
Definition: nonclient.c:239
BOOL FASTCALL IntShowOwnedPopups(PWND OwnerWnd, BOOL fShow)
Definition: window.c:4649
#define SC_MOUSEMENU
Definition: winuser.h:2594
#define WM_CLOSE
Definition: winuser.h:1620
#define WM_SYSCOMMAND
Definition: winuser.h:1740
#define SC_KEYMENU
Definition: winuser.h:2595
#define SW_MINIMIZE
Definition: winuser.h:775
#define WH_CBT
Definition: winuser.h:35
#define SC_SIZE
Definition: winuser.h:2583
#define SC_MINIMIZE
Definition: winuser.h:2585
#define SC_HOTKEY
Definition: winuser.h:2600
#define SC_CLOSE
Definition: winuser.h:2591
#define SC_MOVE
Definition: winuser.h:2584
#define SW_RESTORE
Definition: winuser.h:778
#define SW_MAXIMIZE
Definition: winuser.h:771
#define SC_RESTORE
Definition: winuser.h:2597
#define HCBT_SYSCOMMAND
Definition: winuser.h:63
#define SC_MAXIMIZE
Definition: winuser.h:2587
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by IntDefWindowProc(), and User32DefWindowProc().

◆ DefWndHandleWindowPosChanged()

LRESULT FASTCALL DefWndHandleWindowPosChanged ( PWND  pWnd,
WINDOWPOS Pos 
)

Definition at line 95 of file defwnd.c.

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 {
106 }
107
108 if (!(Pos->flags & SWP_NOCLIENTSIZE) || (Pos->flags & SWP_STATECHANGED))
109 {
111 else
112 {
114 co_IntSendMessage(UserHMGetHandle(pWnd), WM_SIZE, wp, MAKELONG(Rect.right - Rect.left, Rect.bottom - Rect.top));
115 }
116 }
117 return 0;
118}
Arabic default style
Definition: afstyles.h:94
#define SWP_NOCLIENTSIZE
Definition: msg.h:29
#define SWP_NOCLIENTMOVE
Definition: msg.h:30
ush Pos
Definition: deflate.h:92
#define SWP_STATECHANGED
Definition: msg.c:42
#define WS_CHILD
Definition: pedump.c:617
long LONG
Definition: pedump.c:60
#define MAKELONG(a, b)
Definition: typedefs.h:249
PWND FASTCALL IntGetParent(PWND Wnd)
Definition: window.c:204
INT FASTCALL IntMapWindowPoints(PWND FromWnd, PWND ToWnd, LPPOINT lpPoints, UINT cPoints)
Definition: winpos.c:144
VOID FASTCALL IntGetClientRect(PWND WindowObject, RECTL *Rect)
Definition: winpos.c:92
UINT_PTR WPARAM
Definition: windef.h:207
#define WM_SIZE
Definition: winuser.h:1610
#define SIZE_MINIMIZED
Definition: winuser.h:2505
#define SIZE_MAXIMIZED
Definition: winuser.h:2506
#define WM_MOVE
Definition: winuser.h:1609
#define SIZE_RESTORED
Definition: winuser.h:2504

Referenced by IntDefWindowProc().

◆ DefWndHandleWindowPosChanging()

LRESULT FASTCALL DefWndHandleWindowPosChanging ( PWND  pWnd,
WINDOWPOS Pos 
)

Definition at line 68 of file defwnd.c.

69{
70 POINT maxTrack, minTrack;
71 LONG style = pWnd->style;
72
73 if (Pos->flags & SWP_NOSIZE) return 0;
74 if ((style & WS_THICKFRAME) || ((style & (WS_POPUP | WS_CHILD)) == 0))
75 {
76 co_WinPosGetMinMaxInfo(pWnd, NULL, NULL, &minTrack, &maxTrack);
77 Pos->cx = min(Pos->cx, maxTrack.x);
78 Pos->cy = min(Pos->cy, maxTrack.y);
79 if (!(style & WS_MINIMIZE))
80 {
81 if (Pos->cx < minTrack.x) Pos->cx = minTrack.x;
82 if (Pos->cy < minTrack.y) Pos->cy = minTrack.y;
83 }
84 }
85 else
86 {
87 Pos->cx = max(Pos->cx, 0);
88 Pos->cy = max(Pos->cy, 0);
89 }
90 return 0;
91}
#define min(a, b)
Definition: monoChain.cc:55
UINT FASTCALL co_WinPosGetMinMaxInfo(PWND Window, POINT *MaxSize, POINT *MaxPos, POINT *MinTrack, POINT *MaxTrack)
Definition: winpos.c:934
#define WS_THICKFRAME
Definition: pedump.c:630
#define max(a, b)
Definition: svc.c:63

Referenced by IntDefWindowProc().

◆ DefWndPrint()

VOID FASTCALL DefWndPrint ( PWND  pwnd,
HDC  hdc,
ULONG  uFlags 
)

Definition at line 365 of file defwnd.c.

366{
367 /*
368 * Visibility flag.
369 */
370 if ( (uFlags & PRF_CHECKVISIBLE) &&
371 !IntIsWindowVisible(pwnd) )
372 return;
373
374 /*
375 * Unimplemented flags.
376 */
377 if ( (uFlags & PRF_CHILDREN) ||
378 (uFlags & PRF_OWNED) ||
380 {
381 FIXME("WM_PRINT message with unsupported flags\n");
382 }
383
384 /*
385 * Background
386 */
387 if ( uFlags & PRF_ERASEBKGND)
389
390 /*
391 * Client area
392 */
393 if ( uFlags & PRF_CLIENT)
395}
#define FIXME(fmt,...)
Definition: debug.h:111
UINT uFlags
Definition: api.c:59
HDC hdc
Definition: main.c:9
#define WM_PRINTCLIENT
Definition: richedit.h:70
BOOL FASTCALL IntIsWindowVisible(PWND Wnd)
Definition: window.c:189
#define WM_ERASEBKGND
Definition: winuser.h:1624
#define PRF_NONCLIENT
Definition: winuser.h:2523
#define PRF_ERASEBKGND
Definition: winuser.h:2525
#define PRF_OWNED
Definition: winuser.h:2527
#define PRF_CHILDREN
Definition: winuser.h:2526
#define PRF_CLIENT
Definition: winuser.h:2524
#define PRF_CHECKVISIBLE
Definition: winuser.h:2522

Referenced by IntDefWindowProc().

◆ DefWndScreenshot()

VOID FASTCALL DefWndScreenshot ( PWND  pWnd)

Definition at line 499 of file defwnd.c.

500{
501 RECT rect;
502 HDC hdc;
503 INT w;
504 INT h;
506 HDC hdc2;
507 SETCLIPBDATA scd = {FALSE, FALSE};
508
511
512 hdc = UserGetWindowDC(pWnd);
513 IntGetWindowRect(pWnd, &rect);
514 w = rect.right - rect.left;
515 h = rect.bottom - rect.top;
516
520
521 NtGdiBitBlt(hdc2, 0, 0, w, h, hdc, 0, 0, SRCCOPY, 0, 0);
522
524
525 UserReleaseDC(pWnd, hdc, FALSE);
526 UserReleaseDC(pWnd, hdc2, FALSE);
527
529}
static HBITMAP hbitmap
HDC hdc2
Definition: SelectObject.c:10
#define CF_BITMAP
Definition: constants.h:397
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
static HBITMAP
Definition: button.c:44
static HDC
Definition: imagelist.c:92
__kernel_entry W32KAPI HBITMAP APIENTRY NtGdiCreateCompatibleBitmap(_In_ HDC hdc, _In_ INT cx, _In_ INT cy)
__kernel_entry W32KAPI HDC APIENTRY NtGdiCreateCompatibleDC(_In_opt_ HDC hdc)
__kernel_entry W32KAPI BOOL APIENTRY NtGdiBitBlt(_In_ HDC hdcDst, _In_ INT x, _In_ INT y, _In_ INT cx, _In_ INT cy, _In_opt_ HDC hdcSrc, _In_ INT xSrc, _In_ INT ySrc, _In_ DWORD rop4, _In_ DWORD crBackColor, _In_ FLONG fl)
__kernel_entry W32KAPI HBITMAP APIENTRY NtGdiSelectBitmap(_In_ HDC hdc, _In_ HBITMAP hbm)
BOOL FASTCALL IntGetWindowRect(PWND Wnd, RECTL *Rect)
Definition: winpos.c:121
& rect
Definition: startmenu.cpp:1413
int32_t INT
Definition: typedefs.h:58
HDC FASTCALL UserGetWindowDC(PWND Wnd)
Definition: windc.c:947
INT FASTCALL UserReleaseDC(PWND Window, HDC hDc, BOOL EndPaint)
Definition: windc.c:918
BOOL NTAPI UserEmptyClipboard(VOID)
Definition: clipboard.c:680
BOOL NTAPI UserCloseClipboard(VOID)
Definition: clipboard.c:545
BOOL NTAPI UserOpenClipboard(HWND hWnd)
Definition: clipboard.c:488
HANDLE NTAPI UserSetClipboardData(UINT fmt, HANDLE hData, PSETCLIPBDATA scd)
Definition: clipboard.c:1023
#define SRCCOPY
Definition: wingdi.h:333

Referenced by IntDefWindowProc().

◆ DefWndSetIcon()

LRESULT FASTCALL DefWndSetIcon ( PWND  pWnd,
WPARAM  wParam,
LPARAM  lParam 
)

Definition at line 437 of file defwnd.c.

438{
439 HICON hIcon, hIconSmall, hIconOld;
440
441 if ( wParam > ICON_SMALL2 )
442 {
444 return 0;
445 }
446 hIconSmall = UserGetProp(pWnd, gpsi->atomIconSmProp, TRUE);
448
449 hIconOld = wParam == ICON_BIG ? hIcon : hIconSmall;
450
451 switch(wParam)
452 {
453 case ICON_BIG:
454 hIcon = (HICON)lParam;
455 break;
456 case ICON_SMALL:
457 hIconSmall = (HICON)lParam;
458 break;
459 case ICON_SMALL2:
460 ERR("FIXME: Set ICON_SMALL2 support!\n");
461 default:
462 break;
463 }
464
465 UserSetProp(pWnd, gpsi->atomIconProp, hIcon, TRUE);
466 UserSetProp(pWnd, gpsi->atomIconSmProp, hIconSmall, TRUE);
467
468 if ((pWnd->style & WS_CAPTION ) == WS_CAPTION)
470
471 return (LRESULT)hIconOld;
472}
HICON hIcon
Definition: msconfig.c:44
BOOL UserPaintCaption(PWND pWnd, INT Flags)
Definition: defwnd.c:398
#define WS_CAPTION
Definition: pedump.c:624
#define DC_ICON
Definition: winuser.h:429

Referenced by IntDefWindowProc().

◆ DrawTextExWorker()

INT WINAPI DrawTextExWorker ( HDC  hdc,
LPWSTR  str,
INT  i_count,
LPRECT  rect,
UINT  flags,
LPDRAWTEXTPARAMS  dtp 
)

Definition at line 1071 of file text.c.

1077{
1078 SIZE size;
1079 const WCHAR *strPtr;
1080 WCHAR *retstr, *p_retstr;
1081 size_t size_retstr;
1083 int len, lh, count=i_count;
1085 int lmargin = 0, rmargin = 0;
1086 int x = rect->left, y = rect->top;
1087 int width = rect->right - rect->left;
1088 int max_width = 0;
1089 int last_line;
1090 int tabwidth /* to keep gcc happy */ = 0;
1091 int prefix_offset;
1092 ellipsis_data ellip;
1093 BOOL invert_y=FALSE;
1094
1095 HRGN hrgn = 0;
1096
1097#ifdef _WIN32K_
1098 TRACE("%S, %d, %08x\n", str, count, flags);
1099#else
1100 TRACE("%s, %d, [%s] %08x\n", debugstr_wn (str, count), count,
1102#endif
1103 if (dtp) TRACE("Params: iTabLength=%d, iLeftMargin=%d, iRightMargin=%d\n",
1104 dtp->iTabLength, dtp->iLeftMargin, dtp->iRightMargin);
1105
1106 if (!str) return 0;
1107
1108 strPtr = str;
1109
1110 if (flags & DT_SINGLELINE)
1111 flags &= ~DT_WORDBREAK;
1112#ifdef _WIN32K_
1114#else
1116#endif
1118 lh = tm.tmHeight + tm.tmExternalLeading;
1119 else
1120 lh = tm.tmHeight;
1121
1122 if (str[0] && count == 0)
1123 return lh;
1124
1125 if (dtp && dtp->cbSize != sizeof(DRAWTEXTPARAMS))
1126 return 0;
1127#ifdef _WIN32K_
1129 {
1130 SIZE window_ext, viewport_ext;
1131 GreGetWindowExtEx(hdc, &window_ext);
1132 GreGetViewportExtEx(hdc, &viewport_ext);
1133 if ((window_ext.cy > 0) != (viewport_ext.cy > 0))
1134 invert_y = TRUE;
1135 }
1136#else
1138 {
1139 SIZE window_ext, viewport_ext;
1140 GetWindowExtEx(hdc, &window_ext);
1141 GetViewportExtEx(hdc, &viewport_ext);
1142 if ((window_ext.cy > 0) != (viewport_ext.cy > 0))
1143 invert_y = TRUE;
1144 }
1145#endif
1146 if (count == -1)
1147 {
1148#ifdef _WIN32K_
1149 count = wcslen(str);
1150#else
1151 count = strlenW(str);
1152#endif
1153 if (count == 0)
1154 {
1155 if( flags & DT_CALCRECT)
1156 {
1157 rect->right = rect->left;
1158 if( flags & DT_SINGLELINE)
1159 rect->bottom = rect->top + (invert_y ? -lh : lh);
1160 else
1161 rect->bottom = rect->top;
1162 }
1163 return lh;
1164 }
1165 }
1166
1167 if (dtp)
1168 {
1169 lmargin = dtp->iLeftMargin;
1170 rmargin = dtp->iRightMargin;
1171 if (!(flags & (DT_CENTER | DT_RIGHT)))
1172 x += lmargin;
1173 dtp->uiLengthDrawn = 0; /* This param RECEIVES number of chars processed */
1174 }
1175
1176 if (flags & DT_EXPANDTABS)
1177 {
1178 int tabstop = ((flags & DT_TABSTOP) && dtp && dtp->iTabLength) ? dtp->iTabLength : 8;
1179 tabwidth = tm.tmAveCharWidth * tabstop;
1180 }
1181
1182 if (flags & DT_CALCRECT) flags |= DT_NOCLIP;
1183#ifndef _WIN32K_
1184 if (!(flags & DT_NOCLIP) )
1185 {
1186 int hasClip;
1187 hrgn = CreateRectRgn(0,0,0,0);
1188 if (hrgn)
1189 {
1190 hasClip = GetClipRgn(hdc, hrgn);
1191 // If the region to be retrieved is NULL, the return value is 0.
1192 if (hasClip != 1)
1193 {
1195 hrgn = NULL;
1196 }
1197 IntersectClipRect(hdc, rect->left, rect->top, rect->right, rect->bottom);
1198 }
1199 }
1200#else
1201 if (!(flags & DT_NOCLIP) )
1202 {
1203 int hasClip;
1204 hrgn = NtGdiCreateRectRgn(0,0,0,0);
1205 if (hrgn)
1206 {
1207 hasClip = NtGdiGetRandomRgn(hdc, hrgn, CLIPRGN);
1208 if (hasClip != 1)
1209 {
1211 hrgn = NULL;
1212 }
1213 NtGdiIntersectClipRect(hdc, rect->left, rect->top, rect->right, rect->bottom);
1214 }
1215 }
1216#endif
1217 if (flags & DT_MODIFYSTRING)
1218 {
1219 size_retstr = (count + 4) * sizeof (WCHAR);
1220#ifdef _WIN32K_
1221 retstr = ExAllocatePoolWithTag(PagedPool, size_retstr, USERTAG_RTL);
1222#else
1223 retstr = HeapAlloc(GetProcessHeap(), 0, size_retstr);
1224#endif
1225 if (!retstr) return 0;
1226 memcpy (retstr, str, size_retstr);
1227 }
1228 else
1229 {
1230 size_retstr = 0;
1231 retstr = NULL;
1232 }
1233 p_retstr = retstr;
1234
1235 do
1236 {
1237 len = sizeof(line)/sizeof(line[0]);
1238 if (invert_y)
1239 last_line = !(flags & DT_NOCLIP) && y - ((flags & DT_EDITCONTROL) ? 2*lh-1 : lh) < rect->bottom;
1240 else
1241 last_line = !(flags & DT_NOCLIP) && y + ((flags & DT_EDITCONTROL) ? 2*lh-1 : lh) > rect->bottom;
1242 strPtr = TEXT_NextLineW(hdc, strPtr, &count, line, &len, width, flags, &size, last_line, &p_retstr, tabwidth, &prefix_offset, &ellip);
1243
1244#ifdef __REACTOS__
1245 if (flags & DT_CENTER)
1246 {
1247 if (((rect->right - rect->left) < size.cx) && (flags & DT_CALCRECT))
1248 {
1249 x = rect->left + size.cx;
1250 }
1251 else
1252 {
1253 x = (rect->left + rect->right - size.cx) / 2;
1254 }
1255 }
1256#else
1257 if (flags & DT_CENTER) x = (rect->left + rect->right -
1258 size.cx) / 2;
1259#endif
1260 else if (flags & DT_RIGHT) x = rect->right - size.cx;
1261
1262 if (flags & DT_SINGLELINE)
1263 {
1264#ifdef __REACTOS__
1265 if (flags & DT_VCENTER) y = rect->top +
1266 (rect->bottom - rect->top + (invert_y ? size.cy : -size.cy)) / 2;
1267 else if (flags & DT_BOTTOM)
1268 y = rect->bottom + (invert_y ? size.cy : -size.cy);
1269#else
1270 if (flags & DT_VCENTER) y = rect->top +
1271 (rect->bottom - rect->top) / 2 - size.cy / 2;
1272 else if (flags & DT_BOTTOM) y = rect->bottom - size.cy;
1273#endif
1274 }
1275
1276 if (!(flags & DT_CALCRECT))
1277 {
1278 const WCHAR *str = line;
1279 int xseg = x;
1280 while (len)
1281 {
1282 int len_seg;
1283 SIZE size;
1284 if ((flags & DT_EXPANDTABS))
1285 {
1286 const WCHAR *p;
1287 p = str; while (p < str+len && *p != TAB) p++;
1288 len_seg = p - str;
1289 if (len_seg != len &&
1290#ifdef _WIN32K_
1291 !GreGetTextExtentW(hdc, str, len_seg, &size, 0))
1292#else
1293 !GetTextExtentPointW(hdc, str, len_seg, &size))
1294#endif
1295 {
1296#ifdef _WIN32K_
1298#else
1299 HeapFree (GetProcessHeap(), 0, retstr);
1300#endif
1301 return 0;
1302 }
1303 }
1304 else
1305 len_seg = len;
1306#ifdef _WIN32K_
1307 if (!UserExtTextOutW( hdc, xseg, y,
1308 ((flags & DT_NOCLIP) ? 0 : ETO_CLIPPED) |
1309 ((flags & DT_RTLREADING) ? ETO_RTLREADING : 0),
1310 rect, str, len_seg))
1311#else
1312 if (!ExtTextOutW( hdc, xseg, y,
1313 ((flags & DT_NOCLIP) ? 0 : ETO_CLIPPED) |
1314 ((flags & DT_RTLREADING) ? ETO_RTLREADING : 0),
1315 rect, str, len_seg, NULL ))
1316#endif
1317 {
1318#ifdef _WIN32K_
1320#else
1321 HeapFree (GetProcessHeap(), 0, retstr);
1322#endif
1323 return 0;
1324 }
1325 if (prefix_offset != -1 && prefix_offset < len_seg)
1326 {
1327 TEXT_DrawUnderscore (hdc, xseg, y + tm.tmAscent + 1, str, prefix_offset, (flags & DT_NOCLIP) ? NULL : rect);
1328 }
1329 len -= len_seg;
1330 str += len_seg;
1331 if (len)
1332 {
1333 assert ((flags & DT_EXPANDTABS) && *str == TAB);
1334 len--; str++;
1335 xseg += ((size.cx/tabwidth)+1)*tabwidth;
1336 if (prefix_offset != -1)
1337 {
1338 if (prefix_offset < len_seg)
1339 {
1340 /* We have just drawn an underscore; we ought to
1341 * figure out where the next one is. I am going
1342 * to leave it for now until I have a better model
1343 * for the line, which will make reprefixing easier.
1344 * This is where ellip would be used.
1345 */
1346 prefix_offset = -1;
1347 }
1348 else
1349 prefix_offset -= len_seg;
1350 }
1351 }
1352 }
1353 }
1354 else if (size.cx > max_width)
1355 max_width = size.cx;
1356
1357 y += invert_y ? -lh : lh;
1358 if (dtp)
1359 dtp->uiLengthDrawn += len;
1360 }
1361 while (strPtr && !last_line);
1362
1363#ifndef _WIN32K_
1364 if (!(flags & DT_NOCLIP) )
1365 {
1366 SelectClipRgn(hdc, hrgn); // This should be NtGdiExtSelectClipRgn, but due to ReactOS build rules this option is next:
1367 GdiFlush(); // Flush the batch and level up! See CORE-16498.
1368 if (hrgn)
1369 {
1371 }
1372 }
1373#else
1374 if (!(flags & DT_NOCLIP) )
1375 {
1377 if (hrgn)
1378 {
1380 }
1381 }
1382#endif
1383
1384 if (flags & DT_CALCRECT)
1385 {
1386 rect->right = rect->left + max_width;
1387 rect->bottom = y;
1388 if (dtp)
1389 rect->right += lmargin + rmargin;
1390 }
1391 if (retstr)
1392 {
1393 memcpy (str, retstr, size_retstr);
1394#ifdef _WIN32K_
1396#else
1397 HeapFree (GetProcessHeap(), 0, retstr);
1398#endif
1399 }
1400 return y - rect->top;
1401}
static HRGN hrgn
static const char * wine_dbgstr_rect(const RECT *prc)
Definition: atltest.h:160
int FASTCALL GreGetGraphicsMode(HDC)
Definition: dcutil.c:306
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define PagedPool
Definition: env_spec_w32.h:308
pKey DeleteObject()
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLint GLint GLsizei width
Definition: gl.h:1546
GLsizeiptr size
Definition: glext.h:5919
GLbitfield flags
Definition: glext.h:7161
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLsizei len
Definition: glext.h:6722
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define debugstr_wn
Definition: kernel32.h:33
if(dx< 0)
Definition: linetemp.h:194
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
#define CLIPRGN
Definition: precomp.h:18
BOOL WINAPI GreGetViewportExtEx(_In_ HDC hdc, _Out_ LPSIZE lpSize)
Definition: coord.c:1416
BOOL WINAPI GreGetWindowExtEx(_In_ HDC hdc, _Out_ LPSIZE lpSize)
Definition: coord.c:1407
__kernel_entry W32KAPI HRGN APIENTRY NtGdiCreateRectRgn(_In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
__kernel_entry W32KAPI INT APIENTRY NtGdiExtSelectClipRgn(_In_ HDC hdc, _In_opt_ HRGN hrgn, _In_ INT iMode)
__kernel_entry W32KAPI INT APIENTRY NtGdiIntersectClipRect(_In_ HDC hdc, _In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
Definition: cliprgn.c:486
__kernel_entry W32KAPI INT APIENTRY NtGdiGetRandomRgn(_In_ HDC hdc, _In_ HRGN hrgn, _In_ INT iRgn)
#define strlenW(s)
Definition: unicode.h:28
const WCHAR * str
#define TRACE(s)
Definition: solgame.cpp:4
int iRightMargin
Definition: winuser.h:3099
UINT uiLengthDrawn
Definition: winuser.h:3100
LONG cy
Definition: kdterminal.h:28
Definition: parser.c:49
Definition: time.h:68
BOOL UserExtTextOutW(HDC hdc, INT x, INT y, UINT flags, PRECTL lprc, LPCWSTR lpString, UINT count)
BOOL NTAPI GreDeleteObject(HGDIOBJ hobj)
Definition: gdiobj.c:1158
BOOL FASTCALL GreGetTextExtentW(HDC hDC, LPCWSTR lpwsz, INT cwc, LPSIZE psize, UINT flOpts)
Definition: text.c:78
BOOL WINAPI GreGetTextMetricsW(_In_ HDC hdc, _Out_ LPTEXTMETRICW lptm)
Definition: text.c:193
#define USERTAG_RTL
Definition: tags.h:270
#define MAX_BUFFER
Definition: text.c:1065
static void TEXT_DrawUnderscore(HDC hdc, int x, int y, const WCHAR *str, int offset, const RECT *rect)
Definition: text.c:894
static const WCHAR * TEXT_NextLineW(HDC hdc, const WCHAR *str, int *count, WCHAR *dest, int *len, int width, DWORD format, SIZE *retsize, int last_line, WCHAR **p_retstr, int tabwidth, int *pprefix_offset, ellipsis_data *pellip)
Definition: text.c:666
#define TAB
Definition: text.c:109
#define assert(e)
Definition: text.c:47
#define GM_COMPATIBLE
Definition: wingdi.h:864
BOOL WINAPI GetTextMetricsW(_In_ HDC, _Out_ LPTEXTMETRICW)
Definition: text.c:221
HRGN WINAPI CreateRectRgn(_In_ int, _In_ int, _In_ int, _In_ int)
int WINAPI GetGraphicsMode(_In_ HDC)
int WINAPI IntersectClipRect(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int)
BOOL WINAPI GetTextExtentPointW(_In_ HDC hdc, _In_reads_(c) LPCWSTR lpString, _In_ int c, _Out_ LPSIZE lpsz)
BOOL WINAPI GdiFlush(void)
Definition: misc.c:44
int WINAPI GetClipRgn(_In_ HDC, _In_ HRGN)
#define RGN_COPY
Definition: wingdi.h:357
#define ETO_CLIPPED
Definition: wingdi.h:648
BOOL WINAPI ExtTextOutW(_In_ HDC hdc, _In_ int x, _In_ int y, _In_ UINT options, _In_opt_ const RECT *lprect, _In_reads_opt_(c) LPCWSTR lpString, _In_ UINT c, _In_reads_opt_(c) const INT *lpDx)
BOOL WINAPI GetWindowExtEx(_In_ HDC, _Out_ LPSIZE)
Definition: coord.c:411
BOOL WINAPI GetViewportExtEx(_In_ HDC, _Out_ LPSIZE)
Definition: coord.c:351
int WINAPI SelectClipRgn(_In_ HDC, _In_opt_ HRGN)
#define DT_EXTERNALLEADING
Definition: winuser.h:533
#define DT_CENTER
Definition: winuser.h:527
#define DT_SINGLELINE
Definition: winuser.h:540
#define DT_TABSTOP
Definition: winuser.h:541
#define DT_NOCLIP
Definition: winuser.h:536
#define DT_RTLREADING
Definition: winuser.h:539
#define DT_MODIFYSTRING
Definition: winuser.h:535
#define DT_VCENTER
Definition: winuser.h:543
#define DT_BOTTOM
Definition: winuser.h:525
#define DT_RIGHT
Definition: winuser.h:538
#define DT_EXPANDTABS
Definition: winuser.h:532
#define DT_CALCRECT
Definition: winuser.h:526
#define DT_EDITCONTROL
Definition: winuser.h:528

Referenced by DrawTextW().

◆ DrawTextW()

INT WINAPI DrawTextW ( HDC  hdc,
LPCWSTR  str,
INT  count,
LPRECT  rect,
UINT  flags 
)

Definition at line 16 of file defwnd.c.

17{
19
20 memset (&dtp, 0, sizeof(dtp));
21 dtp.cbSize = sizeof(dtp);
22 if (flags & DT_TABSTOP)
23 {
24 dtp.iTabLength = (flags >> 8) & 0xff;
25 flags &= 0xffff00ff;
26 }
27 return DrawTextExWorker(hdc, (LPWSTR)str, count, rect, flags, &dtp);
28}
INT WINAPI DrawTextExWorker(HDC hdc, LPWSTR str, INT i_count, LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp)
Definition: text.c:1071
#define memset(x, y, z)
Definition: compat.h:39
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by _check_txgetnaturalsize(), BUTTON_CalcLabelRect(), BUTTON_DrawTextCallback(), C1_SetData(), ProgressDlg::CalcTextRect(), CB_ThemedPaint(), CFn_WMPaint(), ConfirmMsgBox_Init(), ConfirmMsgBox_Paint(), SEALED_::ControlWindowProc(), CreateLayoutIcon(), DATETIME_Refresh(), DECLARE_INTERFACE_(), default_page_paint_hook(), DlgProc(), DoTestEntry(), DrawProc(), DrawShadowText(), DrawStatusTextW(), DrawTextFromResource(), CUIFBalloonButton::DrawTextProc(), DrawThemeText(), EditTypeDlg_OnDrawItem(), FillGrid(), CTextEditWindow::FixEditPos(), GetThemeTextExtent(), CUIFToolTip::GetTipWindowSize(), Graph_DrawCpuUsageGraph(), Graph_DrawMemUsageGraph(), HDropFromClipboard(), HEADER_DrawItem(), ICONTITLE_Paint(), ICONTITLE_SetTitlePos(), IPADDRESS_Draw(), LISTVIEW_DrawItemPart(), LISTVIEW_GetItemMetrics(), LrgCellWndProc(), MainWnd_OnDrawItem(), MENU_CalcItemSize(), MENU_DrawMenuItem(), MONTHCAL_PaintCalendar(), MONTHCAL_PaintTitle(), MONTHCAL_PaintTodayTitle(), MonthCalPaint(), MyDrawCaptionTemp(), MyDrawMenuBarTemp(), NT5_DrawLogoffCaptionText(), CFontsDialog::OnDrawItem(), CAutoComplete::OnDrawItem(), CCell::OnPaint(), OnPaint(), OSK_Paint(), PAINTING_DrawStateJam(), CUIFBalloonWindow::PaintMessageProc(), PaintText(), ProgressDlg::ProcessWindowMessage(), PROPSHEET_Paint(), REBAR_DrawBand(), ScrollProc(), SoftModalMessageBox(), STATIC_PaintTextfn(), TAB_DrawItemInterior(), taskdialog_get_text_extent(), test_DrawTextCalcRect(), Text(), TOOLBAR_CustomizeDialogProc(), TOOLBAR_DrawString(), TOOLBAR_MeasureString(), TOOLTIPS_CalcTipSize(), TOOLTIPS_Refresh(), TREEVIEW_CreateDragImage(), UserDrawCaptionText(), WndProc(), and ZoomWnd_OnDraw().

◆ IntDefWindowProc()

LRESULT FASTCALL IntDefWindowProc ( PWND  Wnd,
UINT  Msg,
WPARAM  wParam,
LPARAM  lParam,
BOOL  Ansi 
)

Definition at line 535 of file defwnd.c.

541{
543 LRESULT lResult = 0;
545
546 if (Msg > WM_USER) return 0;
547
548 switch (Msg)
549 {
550 case WM_DEVICECHANGE:
551 return TRUE;
552
553 case WM_GETTEXTLENGTH:
554 {
555 PWSTR buf;
556 ULONG len;
557
558 if (Wnd != NULL && Wnd->strName.Length != 0)
559 {
560 buf = Wnd->strName.Buffer;
561 if (buf != NULL &&
563 buf,
564 Wnd->strName.Length)))
565 {
566 lResult = (LRESULT) (Wnd->strName.Length / sizeof(WCHAR));
567 }
568 }
569 else lResult = 0L;
570
571 break;
572 }
573
574 case WM_GETTEXT: // FIXME: Handle Ansi
575 {
576 PWSTR buf = NULL;
577 PWSTR outbuf = (PWSTR)lParam;
578
579 if (Wnd != NULL && wParam != 0)
580 {
581 if (Wnd->strName.Buffer != NULL)
582 buf = Wnd->strName.Buffer;
583 else
584 outbuf[0] = L'\0';
585
586 if (buf != NULL)
587 {
588 if (Wnd->strName.Length != 0)
589 {
590 lResult = min(Wnd->strName.Length / sizeof(WCHAR), wParam - 1);
591 RtlCopyMemory(outbuf,
592 buf,
593 lResult * sizeof(WCHAR));
594 outbuf[lResult] = L'\0';
595 }
596 else
597 outbuf[0] = L'\0';
598 }
599 }
600 break;
601 }
602
603 case WM_SETTEXT: // FIXME: Handle Ansi
604 {
605 DefSetText(Wnd, (PCWSTR)lParam);
606
607 if ((Wnd->style & WS_CAPTION) == WS_CAPTION)
609 IntNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, Wnd, OBJID_WINDOW, CHILDID_SELF, 0);
610 lResult = 1;
611 break;
612 }
613
614 case WM_SYSCOMMAND:
615 {
616 TRACE("hwnd %p WM_SYSCOMMAND %lx %lx\n", UserHMGetHandle(Wnd), wParam, lParam );
617 lResult = DefWndHandleSysCommand(Wnd, wParam, lParam);
618 break;
619 }
620
621 case WM_SHOWWINDOW:
622 {
623 if ((Wnd->style & WS_VISIBLE) && wParam) break;
624 if (!(Wnd->style & WS_VISIBLE) && !wParam) break;
625 if (!Wnd->spwndOwner) break;
626 if (LOWORD(lParam))
627 {
629 }
630 break;
631 }
632
634 return IntClientShutdown(Wnd, wParam, lParam);
635
636 case WM_APPCOMMAND:
637 if ( (Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD &&
638 Wnd != co_GetDesktopWindow(Wnd) )
639 {
640 if (!co_HOOK_CallHooks(WH_SHELL, HSHELL_APPCOMMAND, wParam, lParam))
641 co_IntShellHookNotify(HSHELL_APPCOMMAND, wParam, lParam);
642 break;
643 }
644 UserRefObjectCo(Wnd->spwndParent, &Ref);
647 break;
648
649 case WM_KEYF1:
650 {
651 HELPINFO hi;
652 HMENU hMenu = UlongToHandle(Wnd->IDMenu);
653 PWND pwndActive = MENU_IsMenuActive();
654 hi.cbSize = sizeof(HELPINFO);
655 hi.MousePos = gpsi->ptCursor;
657 hi.hItemHandle = pwndActive ? UserHMGetHandle(pwndActive) : UserHMGetHandle(Wnd);
658 hi.iCtrlId = (Wnd->style & (WS_POPUP|WS_CHILD)) == WS_CHILD ? IntMenuItemFromPoint(Wnd, hMenu, hi.MousePos) : 0;
660
661 co_IntSendMessage( UserHMGetHandle(Wnd), WM_HELP, 0, (LPARAM)&hi );
662 break;
663 }
664
665 case WM_SETICON:
666 {
667 return DefWndSetIcon(Wnd, wParam, lParam);
668 }
669
670 case WM_GETICON:
671 {
672 return DefWndGetIcon(Wnd, wParam, lParam);
673 }
674
675 case WM_HELP:
676 {
677 PWND Parent = IntGetParent(Wnd);
679 break;
680 }
681
682 case WM_LBUTTONDOWN:
683 case WM_RBUTTONDOWN:
684 case WM_MBUTTONDOWN:
686 break;
687
688 case WM_NCLBUTTONDOWN:
690
691 case WM_NCRBUTTONDOWN:
693
694 case WM_LBUTTONDBLCLK:
696
699
700 case WM_RBUTTONUP:
701 {
702 POINT Pt;
703
704 Pt.x = GET_X_LPARAM(lParam);
705 Pt.y = GET_Y_LPARAM(lParam);
706 IntClientToScreen(Wnd, &Pt);
707 lParam = MAKELPARAM(Pt.x, Pt.y);
709 break;
710 }
711
712 case WM_NCRBUTTONUP:
713 /*
714 * FIXME : we must NOT send WM_CONTEXTMENU on a WM_NCRBUTTONUP (checked
715 * in Windows), but what _should_ we do? According to MSDN :
716 * "If it is appropriate to do so, the system sends the WM_SYSCOMMAND
717 * message to the window". When is it appropriate?
718 */
719 ERR("WM_NCRBUTTONUP\n");
720 break;
721
722 case WM_XBUTTONUP:
723 case WM_NCXBUTTONUP:
724 if (HIWORD(wParam) == XBUTTON1 || HIWORD(wParam) == XBUTTON2)
725 {
727 MAKELPARAM(LOWORD(wParam), FAPPCOMMAND_MOUSE | HIWORD(wParam)));
728 }
729 break;
730
731
732 case WM_CONTEXTMENU:
733 {
734 if (Wnd->style & WS_CHILD)
735 {
737 }
738 else
739 {
740 POINT Pt;
742 LONG HitCode;
743
744 Style = Wnd->style;
745
746 Pt.x = GET_X_LPARAM(lParam);
747 Pt.y = GET_Y_LPARAM(lParam);
748 if (Style & WS_CHILD)
749 {
751 }
752
753 HitCode = GetNCHitEx(Wnd, Pt);
754
755 if (HitCode == HTCAPTION || HitCode == HTSYSMENU)
756 {
757 PMENU SystemMenu;
758 UINT Flags;
759
760 if((SystemMenu = IntGetSystemMenu(Wnd, FALSE)))
761 {
762 MENU_InitSysMenuPopup(SystemMenu, Wnd->style, Wnd->pcls->style, HitCode);
763
764 if(HitCode == HTCAPTION)
766 else
768
769 IntTrackPopupMenuEx(SystemMenu, Flags|TPM_SYSTEM_MENU, Pt.x, Pt.y, Wnd, NULL);
770 }
771 }
772 if (HitCode == HTHSCROLL || HitCode == HTVSCROLL)
773 {
774 WARN("Scroll Menu Not Supported\n");
775 }
776 }
777 break;
778 }
779
780 case WM_KEYDOWN:
781 if (wParam == VK_F10)
782 {
783 pti->MessageQueue->QF_flags |= QF_FF10STATUS;
784
785 if (UserGetKeyState(VK_SHIFT) & 0x8000)
786 {
788 }
789 }
791 {
792 BOOL IsTaskBar;
793 DWORD StyleTB;
794 DWORD ExStyleTB;
795 HWND hwndTop = UserGetForegroundWindow();
796 PWND topWnd = UserGetWindowObject(hwndTop);
797
798 // MS Doc: foreground window can be NULL, e.g. when window is losing activation
799 if (!topWnd)
800 return 0;
801
802 // We want to forbid snapping operations on the TaskBar
803 // We use a heuristic for detecting the TaskBar Wnd by its typical Style & ExStyle Values
804 ExStyleTB = (topWnd->ExStyle & WS_EX_TOOLWINDOW);
805 StyleTB = (topWnd->style & (WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN));
806 IsTaskBar = (StyleTB == (WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN))
807 && (ExStyleTB == WS_EX_TOOLWINDOW);
808 TRACE("ExStyle=%x Style=%x IsTaskBar=%d\n", ExStyleTB, StyleTB, IsTaskBar);
809
810 if (!IsTaskBar)
811 {
812 if ((topWnd->style & WS_THICKFRAME) == 0)
813 return 0;
814
815 if (wParam == VK_DOWN)
816 {
817 if (topWnd->style & WS_MAXIMIZE)
818 {
820
821 /* "Normal size" must be erased after restoring, otherwise it will block next side snap actions */
822 RECTL_vSetEmptyRect(&topWnd->InternalPos.NormalRect);
823 }
824 else
825 {
827 }
828 }
829 else if (wParam == VK_UP)
830 {
831 RECT currentRect;
832 if ((topWnd->InternalPos.NormalRect.right == topWnd->InternalPos.NormalRect.left) ||
833 (topWnd->InternalPos.NormalRect.top == topWnd->InternalPos.NormalRect.bottom))
834 {
835 currentRect = topWnd->rcWindow;
836 }
837 else
838 {
839 currentRect = topWnd->InternalPos.NormalRect;
840 }
842
843 // save normal rect if maximazing snapped window
844 topWnd->InternalPos.NormalRect = currentRect;
845 }
846 else if (wParam == VK_LEFT || wParam == VK_RIGHT)
847 {
848 RECT snapRect, normalRect, windowRect;
849 BOOL snapped;
850 normalRect = topWnd->InternalPos.NormalRect;
851 snapped = (normalRect.left != 0 && normalRect.right != 0 &&
852 normalRect.top != 0 && normalRect.bottom != 0);
853
854 if (topWnd->style & WS_MAXIMIZE)
855 {
857 snapped = FALSE;
858 }
859 windowRect = topWnd->rcWindow;
860
861 UserSystemParametersInfo(SPI_GETWORKAREA, 0, &snapRect, 0);
862 if (wParam == VK_LEFT)
863 {
864 snapRect.right = (snapRect.left + snapRect.right) / 2;
865 }
866 else // VK_RIGHT
867 {
868 snapRect.left = (snapRect.left + snapRect.right) / 2;
869 }
870
871 if (snapped)
872 {
873 // if window was snapped but moved to other location - restore normal size
874 if (!IntEqualRect(&snapRect, &windowRect))
875 {
876 RECT empty = {0, 0, 0, 0};
878 0,
879 normalRect.left,
880 normalRect.top,
881 normalRect.right - normalRect.left,
882 normalRect.bottom - normalRect.top,
883 0);
884 topWnd->InternalPos.NormalRect = empty;
885 }
886 }
887 else
888 {
890 0,
891 snapRect.left,
892 snapRect.top,
893 snapRect.right - snapRect.left,
894 snapRect.bottom - snapRect.top,
895 0);
896 topWnd->InternalPos.NormalRect = windowRect;
897 }
898 }
899 }
900 }
901 break;
902
903 case WM_SYSKEYDOWN:
904 {
905 if (HIWORD(lParam) & KF_ALTDOWN)
906 { /* Previous state, if the key was down before this message,
907 this is a cheap way to ignore autorepeat keys. */
908 if ( !(HIWORD(lParam) & KF_REPEAT) )
909 {
910 if ( ( wParam == VK_MENU ||
911 wParam == VK_LMENU ||
912 wParam == VK_RMENU ) && !(pti->MessageQueue->QF_flags & QF_FMENUSTATUS)) //iMenuSysKey )
913 pti->MessageQueue->QF_flags |= QF_FMENUSTATUS; //iMenuSysKey = 1;
914 else
915 pti->MessageQueue->QF_flags &= ~QF_FMENUSTATUS; //iMenuSysKey = 0;
916 }
917
918 pti->MessageQueue->QF_flags &= ~QF_FF10STATUS; //iF10Key = 0;
919
920 if (wParam == VK_F4) /* Try to close the window */
921 {
923 if (!(top->style & CS_NOCLOSE))
925 }
926 else if (wParam == VK_SNAPSHOT) // Alt-VK_SNAPSHOT?
927 {
928 PWND pwnd = Wnd;
929 while (IntGetParent(pwnd) != NULL)
930 {
931 pwnd = IntGetParent(pwnd);
932 }
933 ERR("DefWndScreenshot\n");
934 DefWndScreenshot(pwnd);
935 }
936 else if ( wParam == VK_ESCAPE || wParam == VK_TAB ) // Alt-Tab/ESC Alt-Shift-Tab/ESC
937 {
938 WPARAM wParamTmp;
939 HWND Active = UserGetActiveWindow(); // Noticed MDI problem.
940 if (!Active)
941 {
942 FIXME("WM_SYSKEYDOWN VK_ESCAPE no active\n");
943 break;
944 }
945 wParamTmp = UserGetKeyState(VK_SHIFT) & 0x8000 ? SC_PREVWINDOW : SC_NEXTWINDOW;
947 }
948 }
949 else if( wParam == VK_F10 )
950 {
951 if (UserGetKeyState(VK_SHIFT) & 0x8000)
953 pti->MessageQueue->QF_flags |= QF_FF10STATUS; //iF10Key = 1;
954 }
955 else if( wParam == VK_ESCAPE && (UserGetKeyState(VK_SHIFT) & 0x8000))
957 break;
958 }
959
960 case WM_KEYUP:
961 case WM_SYSKEYUP:
962 {
963 /* Press and release F10 or ALT */
964 if (((wParam == VK_MENU || wParam == VK_LMENU || wParam == VK_RMENU)
965 && (pti->MessageQueue->QF_flags & (QF_FMENUSTATUS|QF_FMENUSTATUSBREAK)) == QF_FMENUSTATUS /*iMenuSysKey*/) ||
966 ((wParam == VK_F10) && pti->MessageQueue->QF_flags & QF_FF10STATUS /*iF10Key*/))
968 pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK|QF_FF10STATUS); //iMenuSysKey = iF10Key = 0;
969 break;
970 }
971
972 case WM_SYSCHAR:
973 {
974 pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK); //iMenuSysKey = 0;
975 if (wParam == VK_RETURN && (Wnd->style & WS_MINIMIZE) != 0)
976 {
978 break;
979 }
980 if ((HIWORD(lParam) & KF_ALTDOWN) && wParam)
981 {
982 if (wParam == VK_TAB || wParam == VK_ESCAPE) break;
983 if (wParam == VK_SPACE && Wnd->style & WS_CHILD)
985 else
987 }
988 else /* check for Ctrl-Esc */
990 break;
991 }
992
993 case WM_CANCELMODE:
994 {
996
997 MENU_EndMenu( Wnd );
999 {
1001 }
1002 break;
1003 }
1004
1005 case WM_CLOSE:
1007 break;
1008
1009 case WM_CTLCOLORMSGBOX:
1010 case WM_CTLCOLOREDIT:
1011 case WM_CTLCOLORLISTBOX:
1012 case WM_CTLCOLORBTN:
1013 case WM_CTLCOLORDLG:
1014 case WM_CTLCOLORSTATIC:
1017
1018 case WM_CTLCOLOR:
1020
1021 case WM_SETCURSOR:
1022 {
1023 if (Wnd->style & WS_CHILD)
1024 {
1025 /* with the exception of the border around a resizable wnd,
1026 * give the parent first chance to set the cursor */
1028 {
1029 PWND parent = Wnd->spwndParent;//IntGetParent( Wnd );
1030 if (parent != UserGetDesktopWindow() &&
1032 return TRUE;
1033 }
1034 }
1035 return DefWndHandleSetCursor(Wnd, wParam, lParam);
1036 }
1037
1038 case WM_MOUSEACTIVATE:
1039 if (Wnd->style & WS_CHILD)
1040 {
1041 LONG Ret;
1043 PWND pwndParent = IntGetParent(Wnd);
1044 hwndParent = pwndParent ? UserHMGetHandle(pwndParent) : NULL;
1046 if (Ret) return (Ret);
1047 }
1049
1050 case WM_ACTIVATE:
1051 /* The default action in Windows is to set the keyboard focus to
1052 * the window, if it's being activated and not minimized */
1053 if (LOWORD(wParam) != WA_INACTIVE &&
1054 !(Wnd->style & WS_MINIMIZE))
1055 {
1056 //ERR("WM_ACTIVATE %p\n",hWnd);
1057 co_UserSetFocus(Wnd);
1058 }
1059 break;
1060
1061 case WM_MOUSEWHEEL:
1062 if (Wnd->style & WS_CHILD)
1063 {
1065 PWND pwndParent = IntGetParent(Wnd);
1066 hwndParent = pwndParent ? UserHMGetHandle(pwndParent) : NULL;
1068 }
1069 break;
1070
1071 case WM_ERASEBKGND:
1072 case WM_ICONERASEBKGND:
1073 {
1074 RECT Rect;
1075 HBRUSH hBrush = Wnd->pcls->hbrBackground;
1076 if (!hBrush) return 0;
1077 if (hBrush <= (HBRUSH)COLOR_MENUBAR)
1078 {
1079 hBrush = IntGetSysColorBrush(HandleToUlong(hBrush));
1080 }
1081 if (Wnd->pcls->style & CS_PARENTDC)
1082 {
1083 /* can't use GetClipBox with a parent DC or we fill the whole parent */
1084 IntGetClientRect(Wnd, &Rect);
1086 }
1087 else
1088 {
1089 GdiGetClipBox((HDC)wParam, &Rect);
1090 }
1091 FillRect((HDC)wParam, &Rect, hBrush);
1092 return (1);
1093 }
1094
1095 case WM_GETHOTKEY:
1096 //ERR("WM_GETHOTKEY\n");
1097 return DefWndGetHotKey(Wnd);
1098 case WM_SETHOTKEY:
1099 //ERR("WM_SETHOTKEY\n");
1100 return DefWndSetHotKey(Wnd, wParam);
1101
1102 case WM_NCHITTEST:
1103 {
1104 POINT Point;
1107 return GetNCHitEx(Wnd, Point);
1108 }
1109
1110 case WM_PRINT:
1111 {
1112 DefWndPrint(Wnd, (HDC)wParam, lParam);
1113 return (0);
1114 }
1115
1116 case WM_SYSCOLORCHANGE:
1117 {
1118 /* force to redraw non-client area */
1119 UserPaintCaption(Wnd, DC_NC);
1120 /* Use InvalidateRect to redraw client area, enable
1121 * erase to redraw all subcontrols otherwise send the
1122 * WM_SYSCOLORCHANGE to child windows/controls is required
1123 */
1125 return (0);
1126 }
1127
1128 case WM_PAINTICON:
1129 case WM_PAINT:
1130 {
1131 PAINTSTRUCT Ps;
1132 HDC hDC;
1133
1134 /* If already in Paint and Client area is not empty just return. */
1135 if (Wnd->state2 & WNDS2_STARTPAINT && !RECTL_bIsEmptyRect(&Wnd->rcClient))
1136 {
1137 ERR("In Paint and Client area is not empty!\n");
1138 return 0;
1139 }
1140
1141 hDC = IntBeginPaint(Wnd, &Ps);
1142 if (hDC)
1143 {
1144 if (((Wnd->style & WS_MINIMIZE) != 0) && (Wnd->pcls->spicn))
1145 {
1146 RECT ClientRect;
1147 INT x, y;
1148
1149 ERR("Doing Paint and Client area is empty!\n");
1150 IntGetClientRect(Wnd, &ClientRect);
1151 x = (ClientRect.right - ClientRect.left - UserGetSystemMetrics(SM_CXICON)) / 2;
1152 y = (ClientRect.bottom - ClientRect.top - UserGetSystemMetrics(SM_CYICON)) / 2;
1154 UserDrawIconEx(hDC, x, y, Wnd->pcls->spicn, 0, 0, 0, 0, DI_NORMAL | DI_COMPAT | DI_DEFAULTSIZE);
1156 }
1157
1158 IntEndPaint(Wnd, &Ps);
1159 }
1160 return (0);
1161 }
1162
1163 case WM_SYNCPAINT:
1164 {
1165 HRGN hRgn;
1166 Wnd->state &= ~WNDS_SYNCPAINTPENDING;
1167 TRACE("WM_SYNCPAINT\n");
1168 hRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
1169 if (hRgn)
1170 {
1172 {
1173 PREGION pRgn = REGION_LockRgn(hRgn);
1174 if (pRgn) REGION_UnlockRgn(pRgn);
1175 if (!wParam)
1177 co_UserRedrawWindow(Wnd, NULL, pRgn, wParam);
1178 }
1180 }
1181 return 0;
1182 }
1183
1184 case WM_SETREDRAW:
1185 if (wParam)
1186 {
1187 if (!(Wnd->style & WS_VISIBLE))
1188 {
1189 IntSetStyle( Wnd, WS_VISIBLE, 0 );
1190 Wnd->state |= WNDS_SENDNCPAINT;
1191 }
1192 }
1193 else
1194 {
1195 if (Wnd->style & WS_VISIBLE)
1196 {
1198 IntSetStyle( Wnd, 0, WS_VISIBLE );
1199 }
1200 }
1201 return 0;
1202
1204 {
1206 }
1207
1209 {
1211 }
1212
1213 case WM_NCCALCSIZE:
1214 {
1215 return NC_HandleNCCalcSize( Wnd, wParam, (RECTL *)lParam, FALSE );
1216 }
1217
1218 case WM_NCACTIVATE:
1219 {
1220 return NC_HandleNCActivate( Wnd, wParam, lParam );
1221 }
1222
1223 //
1224 // NC Paint mode.
1225 //
1226 case WM_NCPAINT:
1227 {
1229 Wnd->state |= WNDS_FORCEMENUDRAW;
1230 NC_DoNCPaint(Wnd, hDC, -1);
1231 Wnd->state &= ~WNDS_FORCEMENUDRAW;
1232 UserReleaseDC(Wnd, hDC, FALSE);
1233 return 0;
1234 }
1235 //
1236 // Draw Caption mode.
1237 //
1238 // wParam are DC_* flags.
1239 //
1241 {
1243 TRACE("WM_NCUAHDRAWCAPTION: wParam DC_ flags %08x\n",wParam);
1244 UserDrawCaptionBar(Wnd, hDC, wParam | DC_FRAME); // Include DC_FRAME to comp for drawing glitch.
1245 UserReleaseDC(Wnd, hDC, FALSE);
1246 return 0;
1247 }
1248 //
1249 // Draw Frame mode.
1250 //
1251 // wParam is HDC, lParam are DC_ACTIVE and or DC_REDRAWHUNGWND.
1252 //
1253 case WM_NCUAHDRAWFRAME:
1254 {
1255 TRACE("WM_NCUAHDRAWFRAME: wParam hDC %p lParam DC_ flags %08x\n",wParam,lParam);
1257 return 0;
1258 }
1259
1260 /* ReactOS only. */
1261 case WM_CBT:
1262 {
1263 switch (wParam)
1264 {
1265 case HCBT_MOVESIZE:
1266 {
1267 RECTL rt;
1268
1269 if (lParam)
1270 {
1271 _SEH2_TRY
1272 {
1274 sizeof(RECT),
1275 1);
1276
1277 RtlCopyMemory(&rt,
1278 (PVOID)lParam,
1279 sizeof(RECT));
1280 }
1282 {
1283 lResult = 1;
1284 }
1285 _SEH2_END;
1286 }
1287 if (!lResult)
1289 }
1290 break;
1291 }
1292 break;
1293 }
1294 break;
1295 }
1296 return lResult;
1297}
#define DCX_USESTYLE
Definition: GetDCEx.c:10
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn UINT32 *TableIdx UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE Parent
Definition: acpixf.h:732
const DWORD Style
Definition: appswitch.c:71
#define UlongToHandle(ul)
Definition: basetsd.h:97
#define HandleToUlong(h)
Definition: basetsd.h:79
#define WARN(fmt,...)
Definition: debug.h:112
BOOL FASTCALL GreDPtoLP(HDC, LPPOINT, INT)
Definition: dcutil.c:7
static HWND hwndParent
Definition: cryptui.c:300
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
static const WCHAR empty[]
Definition: main.c:47
r parent
Definition: btrfs.c:3010
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
unsigned long DWORD
Definition: ntddk_ex.h:95
HWND FASTCALL co_UserSetFocus(PWND Window)
Definition: focus.c:1314
HWND FASTCALL IntGetCaptureWindow(VOID)
Definition: focus.c:34
BOOL FASTCALL IntReleaseCapture(VOID)
Definition: focus.c:1529
HWND FASTCALL UserGetForegroundWindow(VOID)
Definition: focus.c:1421
GLdouble GLdouble GLdouble GLdouble top
Definition: glext.h:10859
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define WNDS_SENDNCPAINT
Definition: ntuser.h:616
#define WNDS_FORCEMENUDRAW
Definition: ntuser.h:620
#define WNDS2_STARTPAINT
Definition: ntuser.h:643
static HRGN hRgn
Definition: mapping.c:33
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:63
#define WM_KEYF1
Definition: msg.c:47
DWORD FASTCALL UserGetKeyState(DWORD dwKey)
Definition: msgqueue.c:221
#define QF_FMENUSTATUSBREAK
Definition: msgqueue.h:96
#define QF_FMENUSTATUS
Definition: msgqueue.h:97
#define QF_FF10STATUS
Definition: msgqueue.h:98
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
unsigned int UINT
Definition: ndis.h:50
_Use_decl_annotations_ NTSTATUS NTAPI RtlUnicodeToMultiByteSize(_Out_ PULONG MbSize, _In_ PCWCH UnicodeString, _In_ ULONG UnicodeSize)
Definition: nlsboot.c:145
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
LRESULT FASTCALL DefWndHandleWindowPosChanged(PWND pWnd, WINDOWPOS *Pos)
Definition: defwnd.c:95
LRESULT DefWndHandleSetCursor(PWND pWnd, WPARAM wParam, LPARAM lParam)
Definition: defwnd.c:243
LRESULT FASTCALL DefWndGetIcon(PWND pWnd, WPARAM wParam, LPARAM lParam)
Definition: defwnd.c:476
VOID FASTCALL DefWndScreenshot(PWND pWnd)
Definition: defwnd.c:499
LRESULT FASTCALL DefWndHandleWindowPosChanging(PWND pWnd, WINDOWPOS *Pos)
Definition: defwnd.c:68
VOID FASTCALL DefWndPrint(PWND pwnd, HDC hdc, ULONG uFlags)
Definition: defwnd.c:365
LRESULT FASTCALL DefWndHandleSysCommand(PWND pWnd, WPARAM wParam, LPARAM lParam)
Definition: defwnd.c:125
LRESULT FASTCALL DefWndSetIcon(PWND pWnd, WPARAM wParam, LPARAM lParam)
Definition: defwnd.c:437
HBRUSH FASTCALL DefWndControlColor(HDC hDC, UINT ctlType)
Definition: defwnd.c:32
BOOL FASTCALL IntClientToScreen(PWND Wnd, LPPOINT lpPoint)
Definition: winpos.c:199
BOOL FASTCALL IntScreenToClient(PWND Wnd, LPPOINT lpPoint)
Definition: winpos.c:213
#define L(x)
Definition: ntvdm.h:50
#define LRESULT
Definition: ole.h:14
#define WS_CLIPSIBLINGS
Definition: pedump.c:618
#define WS_CLIPCHILDREN
Definition: pedump.c:619
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
#define WM_CONTEXTMENU
Definition: richedit.h:64
struct _CURICON_OBJECT * spicn
Definition: ntuser.h:585
HBRUSH hbrBackground
Definition: ntuser.h:587
UINT style
Definition: ntuser.h:580
Definition: region.h:8
struct _USER_MESSAGE_QUEUE * MessageQueue
Definition: win32.h:89
DWORD ExStyle
Definition: ntuser.h:704
DWORD state2
Definition: ntuser.h:702
RECT rcClient
Definition: ntuser.h:717
LARGE_UNICODE_STRING strName
Definition: ntuser.h:736
struct _WND::@5111 InternalPos
DWORD state
Definition: ntuser.h:701
UINT_PTR IDMenu
Definition: ntuser.h:731
RECT rcWindow
Definition: ntuser.h:716
struct _WND * spwndParent
Definition: ntuser.h:713
POINT MousePos
Definition: winuser.h:3316
int iCtrlId
Definition: winuser.h:3313
DWORD_PTR dwContextId
Definition: winuser.h:3315
HANDLE hItemHandle
Definition: winuser.h:3314
int iContextType
Definition: winuser.h:3312
UINT cbSize
Definition: winuser.h:3311
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
#define WM_MOUSEWHEEL
Definition: treelist.c:96
uint16_t * PWSTR
Definition: typedefs.h:56
const uint16_t * PCWSTR
Definition: typedefs.h:57
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
uint32_t ULONG
Definition: typedefs.h:59
#define DCX_KEEPCLIPRGN
Definition: undocuser.h:68
#define TPM_SYSTEM_MENU
Definition: undocuser.h:73
#define WM_NCUAHDRAWCAPTION
Definition: undocuser.h:46
#define DC_FRAME
Definition: undocuser.h:149
#define WM_CLIENTSHUTDOWN
Definition: undocuser.h:35
#define WM_CBT
Definition: undocuser.h:63
#define WM_NCUAHDRAWFRAME
Definition: undocuser.h:47
HDC FASTCALL IntBeginPaint(PWND Window, PPAINTSTRUCT Ps)
Definition: painting.c:1435
BOOL FASTCALL co_UserRedrawWindow(PWND Window, const RECTL *UpdateRect, PREGION UpdateRgn, ULONG Flags)
Definition: painting.c:888
BOOL FASTCALL IntEndPaint(PWND Wnd, PPAINTSTRUCT Ps)
Definition: painting.c:1532
INT FASTCALL co_UserGetUpdateRgn(PWND Window, HRGN hRgn, BOOL bErase)
Definition: painting.c:1784
DWORD FASTCALL IntGetWindowContextHelpId(PWND pWnd)
Definition: window.c:438
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:122
PWND FASTCALL UserGetAncestor(PWND Wnd, UINT Type)
Definition: window.c:3341
BOOLEAN co_UserDestroyWindow(PVOID Object)
Definition: window.c:2853
BOOL APIENTRY DefSetText(PWND Wnd, PCWSTR WindowText)
Definition: window.c:4372
HDC FASTCALL UserGetDCEx(PWND Window OPTIONAL, HANDLE ClipRegion, ULONG Flags)
FORCEINLINE BOOL RECTL_bIsEmptyRect(_In_ const RECTL *prcl)
Definition: rect.h:44
FORCEINLINE VOID RECTL_vSetEmptyRect(_Out_ RECTL *prcl)
Definition: rect.h:20
PREGION FASTCALL REGION_LockRgn(_In_ HRGN hrgn)
Definition: region.c:2358
VOID FASTCALL REGION_UnlockRgn(_In_ PREGION prgn)
Definition: region.c:2373
BOOL UserDrawIconEx(HDC hDc, INT xLeft, INT yTop, PCURICON_OBJECT pIcon, INT cxWidth, INT cyHeight, UINT istepIfAniCur, HBRUSH hbrFlickerFreeDraw, UINT diFlags)
Definition: cursoricon.c:1685
VOID co_IntShellHookNotify(WPARAM Message, WPARAM wParam, LPARAM lParam)
Definition: desktop.c:1692
PWND FASTCALL co_GetDesktopWindow(PWND pWnd)
Definition: desktop.c:1366
VOID FASTCALL IntNotifyWinEvent(DWORD Event, PWND pWnd, LONG idObject, LONG idChild, DWORD flags)
Definition: event.c:178
UINT FASTCALL DefWndGetHotKey(PWND pWnd)
Definition: hotkey.c:313
INT FASTCALL DefWndSetHotKey(PWND pWnd, WPARAM wParam)
Definition: hotkey.c:340
BYTE gafAsyncKeyState[256 *2/8]
Definition: keyboard.c:13
#define IS_KEY_DOWN(ks, vk)
Definition: input.h:101
PMENU FASTCALL IntGetSystemMenu(PWND Window, BOOL bRevert)
Definition: menu.c:5371
INT FASTCALL IntMenuItemFromPoint(PWND pWnd, HMENU hMenu, POINT ptScreen)
Definition: menu.c:1518
PWND MENU_IsMenuActive(VOID)
Definition: menu.c:2650
void MENU_EndMenu(PWND pwnd)
Definition: menu.c:2662
void FASTCALL MENU_InitSysMenuPopup(PMENU menu, DWORD style, DWORD clsStyle, LONG HitTest)
Definition: menu.c:1362
BOOL WINAPI IntTrackPopupMenuEx(PMENU menu, UINT wFlags, int x, int y, PWND pWnd, LPTPMPARAMS lpTpm)
Definition: menu.c:4549
LONG NTAPI UserGetSystemMetrics(ULONG Index)
Definition: metric.c:213
LRESULT NC_HandleNCLButtonDown(PWND pWnd, WPARAM wParam, LPARAM lParam)
Definition: nonclient.c:1542
VOID UserDrawCaptionBar(PWND pWnd, HDC hDC, INT Flags)
Definition: nonclient.c:922
DWORD FASTCALL GetNCHitEx(PWND pWnd, POINT pt)
Definition: nonclient.c:1952
LRESULT NC_HandleNCActivate(PWND Wnd, WPARAM wParam, LPARAM lParam)
Definition: nonclient.c:1405
LRESULT NC_DoNCPaint(PWND pWnd, HDC hDC, INT Flags)
Definition: nonclient.c:1064
LRESULT NC_HandleNCCalcSize(PWND Wnd, WPARAM wparam, RECTL *Rect, BOOL Suspended)
Definition: nonclient.c:1271
LRESULT NC_HandleNCRButtonDown(PWND pwnd, WPARAM wParam, LPARAM lParam)
Definition: nonclient.c:1692
LRESULT NC_HandleNCLButtonDblClk(PWND pWnd, WPARAM wParam, LPARAM lParam)
Definition: nonclient.c:1634
BOOL FASTCALL UserDereferenceObject(PVOID Object)
Definition: object.c:644
VOID FASTCALL UserReferenceObject(PVOID obj)
Definition: object.c:731
LRESULT IntClientShutdown(IN PWND pWindow, IN WPARAM wParam, IN LPARAM lParam)
Definition: shutdown.c:22
BOOL g_bWindowSnapEnabled
Definition: sysparams.c:20
BOOL FASTCALL UserSystemParametersInfo(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
Definition: sysparams.c:2105
ULONG FASTCALL IntSetStyle(PWND pwnd, ULONG set_bits, ULONG clear_bits)
Definition: window.c:143
#define OBJID_WINDOW
Definition: winable.h:15
#define CHILDID_SELF
Definition: winable.h:14
LONG_PTR LPARAM
Definition: windef.h:208
#define GET_Y_LPARAM(lp)
Definition: windowsx.h:300
#define WM_CTLCOLOR
Definition: windowsx.h:29
#define GET_X_LPARAM(lp)
Definition: windowsx.h:299
#define DI_COMPAT
Definition: wingdi.h:68
#define NULLREGION
Definition: wingdi.h:361
#define DI_NORMAL
Definition: wingdi.h:72
int WINAPI FillRect(HDC, LPCRECT, HBRUSH)
#define DI_DEFAULTSIZE
Definition: wingdi.h:69
FORCEINLINE BOOL IntEqualRect(RECTL *lprc1, RECTL *lprc2)
Definition: winpos.h:48
#define WM_PAINT
Definition: winuser.h:1619
#define WM_GETHOTKEY
Definition: winuser.h:1652
#define WM_CTLCOLORSTATIC
Definition: winuser.h:1771
#define WM_GETTEXTLENGTH
Definition: winuser.h:1618
#define SW_HIDE
Definition: winuser.h:767
#define VK_SNAPSHOT
Definition: winuser.h:2230
#define VK_TAB
Definition: winuser.h:2198
#define GA_ROOT
Definition: winuser.h:2788
#define MAKELPARAM(l, h)
Definition: winuser.h:4007
#define WM_KEYUP
Definition: winuser.h:1715
#define HTCAPTION
Definition: winuser.h:2475
#define DCX_WINDOW
Definition: winuser.h:2112
#define HELPINFO_MENUITEM
Definition: winuser.h:1170
#define VK_F10
Definition: winuser.h:2263
#define WM_SETHOTKEY
Definition: winuser.h:1651
#define WM_WINDOWPOSCHANGING
Definition: winuser.h:1660
#define TPM_RIGHTBUTTON
Definition: winuser.h:2379
#define WM_SYNCPAINT
Definition: winuser.h:1689
#define SC_PREVWINDOW
Definition: winuser.h:2590
#define VK_SPACE
Definition: winuser.h:2218
#define WM_CANCELMODE
Definition: winuser.h:1634
#define WM_LBUTTONDBLCLK
Definition: winuser.h:1777
#define KF_ALTDOWN
Definition: winuser.h:2448
#define HTVSCROLL
Definition: winuser.h:2481
#define MA_ACTIVATE
Definition: winuser.h:2500
#define HTHSCROLL
Definition: winuser.h:2480
#define WM_APPCOMMAND
Definition: winuser.h:1881
#define WM_NCHITTEST
Definition: winuser.h:1685
#define WS_EX_TOOLWINDOW
Definition: winuser.h:404
#define WM_RBUTTONUP
Definition: winuser.h:1779
#define VK_UP
Definition: winuser.h:2224
#define SW_SHOWNOACTIVATE
Definition: winuser.h:773
#define WH_SHELL
Definition: winuser.h:40
#define WM_GETTEXT
Definition: winuser.h:1617
#define RDW_ERASE
Definition: winuser.h:1210
#define WM_CTLCOLORSCROLLBAR
Definition: winuser.h:1770
#define WA_INACTIVE
Definition: winuser.h:2621
#define MA_NOACTIVATE
Definition: winuser.h:2502
#define WM_DEVICECHANGE
Definition: winuser.h:1810
#define WM_SYSCOLORCHANGE
Definition: winuser.h:1625
#define WM_CTLCOLORMSGBOX
Definition: winuser.h:1765
#define WM_NCLBUTTONDBLCLK
Definition: winuser.h:1693
#define WM_ACTIVATE
Definition: winuser.h:1611
#define WM_SHOWWINDOW
Definition: winuser.h:1627
#define WM_CTLCOLORBTN
Definition: winuser.h:1768
#define WM_SETTEXT
Definition: winuser.h:1616
#define SC_NEXTWINDOW
Definition: winuser.h:2589
#define DC_NC
Definition: winuser.h:440
#define DCX_INTERSECTRGN
Definition: winuser.h:2121
#define WM_NCACTIVATE
Definition: winuser.h:1687
#define WM_SYSCHAR
Definition: winuser.h:1720
#define VK_RETURN
Definition: winuser.h:2200
#define SM_CYICON
Definition: winuser.h:972
#define VK_RMENU
Definition: winuser.h:2286
#define RDW_ALLCHILDREN
Definition: winuser.h:1220
#define RDW_ERASENOW
Definition: winuser.h:1218
#define RDW_FRAME
Definition: winuser.h:1211
#define WM_SYSKEYUP
Definition: winuser.h:1719
#define HCBT_MOVESIZE
Definition: winuser.h:55
#define DC_TEXT
Definition: winuser.h:430
#define VK_LWIN
Definition: winuser.h:2234
struct tagHELPINFO HELPINFO
#define WM_MOUSEACTIVATE
Definition: winuser.h:1636
#define TPM_LEFTBUTTON
Definition: winuser.h:2378
#define VK_F4
Definition: winuser.h:2257
#define VK_LEFT
Definition: winuser.h:2223
#define VK_RIGHT
Definition: winuser.h:2225
#define VK_DOWN
Definition: winuser.h:2226
#define WM_SETCURSOR
Definition: winuser.h:1635
#define KF_REPEAT
Definition: winuser.h:2449
#define WM_USER
Definition: winuser.h:1894
#define WM_CTLCOLORLISTBOX
Definition: winuser.h:1767
#define VK_SHIFT
Definition: winuser.h:2201
#define WM_NCRBUTTONUP
Definition: winuser.h:1695
#define WM_KEYDOWN
Definition: winuser.h:1714
#define WM_ICONERASEBKGND
Definition: winuser.h:1641
#define HTSYSMENU
Definition: winuser.h:2476
#define WM_PRINT
Definition: winuser.h:1879
#define WM_NCCALCSIZE
Definition: winuser.h:1684
#define CS_PARENTDC
Definition: winuser.h:656
#define SM_CXICON
Definition: winuser.h:971
#define RDW_VALIDATE
Definition: winuser.h:1217
#define WM_CTLCOLOREDIT
Definition: winuser.h:1766
#define VK_ESCAPE
Definition: winuser.h:2213
#define WM_WINDOWPOSCHANGED
Definition: winuser.h:1661
#define WM_CTLCOLORDLG
Definition: winuser.h:1769
#define CS_NOCLOSE
Definition: winuser.h:654
#define WM_SYSKEYDOWN
Definition: winuser.h:1718
#define WM_NCLBUTTONDOWN
Definition: winuser.h:1691
#define RDW_INVALIDATE
Definition: winuser.h:1213
#define WM_PAINTICON
Definition: winuser.h:1640
#define VK_RWIN
Definition: winuser.h:2235
#define VK_LMENU
Definition: winuser.h:2285
#define VK_MENU
Definition: winuser.h:2203
#define WM_NCPAINT
Definition: winuser.h:1686
#define WM_NCRBUTTONDOWN
Definition: winuser.h:1694
#define WM_SETREDRAW
Definition: winuser.h:1615
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
_In_ ULONG _In_ BOOLEAN Active
Definition: potypes.h:561

Referenced by GetControlColor(), NtUserMessageCall(), PopupMenuWndProc(), and UserMessageWindowProc().

◆ UserPaintCaption()

BOOL UserPaintCaption ( PWND  pWnd,
INT  Flags 
)

Definition at line 398 of file defwnd.c.

399{
400 BOOL Ret = FALSE;
401
402 if ( (pWnd->style & WS_VISIBLE) && ((pWnd->style & WS_CAPTION) == WS_CAPTION) )
403 {
404 if (pWnd->state & WNDS_HASCAPTION && pWnd->head.pti->MessageQueue == gpqForeground)
405 Flags |= DC_ACTIVE;
406 /*
407 * When themes are not enabled we can go on and paint the non client area.
408 * However if we do that with themes enabled we will draw a classic frame.
409 * This is solved by sending a themes specific message to notify the themes
410 * engine that the caption needs to be redrawn.
411 */
413 {
414 /*
415 * This will cause uxtheme to either paint the themed caption or call
416 * RealUserDrawCaption in order to draw the classic caption when themes
417 * are disabled but the themes service is enabled.
418 */
419 TRACE("UDCB Flags %08x\n", Flags);
421 }
422 else
423 {
425 UserDrawCaptionBar(pWnd, hDC, Flags | DC_FRAME); // DCFRAME added as fix for CORE-10855.
426 UserReleaseDC(pWnd, hDC, FALSE);
427 }
428 Ret = TRUE;
429 }
430 // Support window tray
431 return Ret;
432}
#define DC_ACTIVE
Definition: dc21x4.h:120
#define SRVINFO_APIHOOK
Definition: ntuser.h:950
#define WNDS_HASCAPTION
Definition: ntuser.h:608
DWORD dwSRVIFlags
Definition: ntuser.h:1051

Referenced by DefWndSetIcon(), IntDefWindowProc(), IntEnableMenuItem(), NtUserCallTwoParam(), NtUserSetClassLong(), RealDefWindowProcA(), and RealDefWindowProcW().