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

Go to the source code of this file.

Macros

#define ID_NEXTLAYOUT   10003
 

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)
 

Macro Definition Documentation

◆ ID_NEXTLAYOUT

#define ID_NEXTLAYOUT   10003

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:689
struct _WND * spwndOwner
Definition: ntuser.h:710
_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:950
#define COLOR_WINDOW
Definition: winuser.h:912
#define COLOR_SCROLLBAR
Definition: winuser.h:906
#define COLOR_WINDOWTEXT
Definition: winuser.h:915
#define CTLCOLOR_LISTBOX
Definition: winuser.h:947
#define CTLCOLOR_EDIT
Definition: winuser.h:946
#define COLOR_3DHILIGHT
Definition: winuser.h:931
#define COLOR_3DFACE
Definition: winuser.h:923

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:1061
ATOM atomIconSmProp
Definition: ntuser.h:1060
#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:28
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 @1611 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:1550
#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:581
DWORD dwForegroundFlashCount
Definition: sysparams.h:157
Definition: object.h:4
PCLS pcls
Definition: ntuser.h:715
DWORD style
Definition: ntuser.h:701
#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:2482
#define SWP_NOACTIVATE
Definition: winuser.h:1232
#define HTTOPLEFT
Definition: winuser.h:2481
#define HTBOTTOM
Definition: winuser.h:2483
#define HTERROR
Definition: winuser.h:2462
#define SWP_NOMOVE
Definition: winuser.h:1234
#define SWP_NOSIZE
Definition: winuser.h:1235
#define WM_LBUTTONDOWN
Definition: winuser.h:1766
#define WM_RBUTTONDOWN
Definition: winuser.h:1769
#define HTRIGHT
Definition: winuser.h:2479
#define HTCLIENT
Definition: winuser.h:2465
#define HTBOTTOMRIGHT
Definition: winuser.h:2485
#define HTBOTTOMLEFT
Definition: winuser.h:2484
#define HTTOP
Definition: winuser.h:2480
#define HTLEFT
Definition: winuser.h:2477
#define WM_MBUTTONDOWN
Definition: winuser.h:1772

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:690
struct _WND * spwndLastActive
Definition: ntuser.h:734
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:4498
VOID MENU_TrackMouseMenuBar(PWND pWnd, ULONG ht, POINT pt)
Definition: menu.c:4468
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:4674
#define SC_MOUSEMENU
Definition: winuser.h:2585
#define WM_CLOSE
Definition: winuser.h:1611
#define WM_SYSCOMMAND
Definition: winuser.h:1731
#define SC_KEYMENU
Definition: winuser.h:2586
#define SW_MINIMIZE
Definition: winuser.h:770
#define WH_CBT
Definition: winuser.h:35
#define SC_SIZE
Definition: winuser.h:2574
#define SC_MINIMIZE
Definition: winuser.h:2576
#define SC_HOTKEY
Definition: winuser.h:2591
#define SC_CLOSE
Definition: winuser.h:2582
#define SC_MOVE
Definition: winuser.h:2575
#define SW_RESTORE
Definition: winuser.h:773
#define SW_MAXIMIZE
Definition: winuser.h:766
#define SC_RESTORE
Definition: winuser.h:2588
#define HCBT_SYSCOMMAND
Definition: winuser.h:63
#define SC_MAXIMIZE
Definition: winuser.h:2578
__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:1601
#define SIZE_MINIMIZED
Definition: winuser.h:2496
#define SIZE_MAXIMIZED
Definition: winuser.h:2497
#define WM_MOVE
Definition: winuser.h:1600
#define SIZE_RESTORED
Definition: winuser.h:2495

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:1615
#define PRF_NONCLIENT
Definition: winuser.h:2514
#define PRF_ERASEBKGND
Definition: winuser.h:2516
#define PRF_OWNED
Definition: winuser.h:2518
#define PRF_CHILDREN
Definition: winuser.h:2517
#define PRF_CLIENT
Definition: winuser.h:2515
#define PRF_CHECKVISIBLE
Definition: winuser.h:2513

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
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
static __inline const char * wine_dbgstr_rect(const RECT *rect)
Definition: debug.h:219
#define TRACE(s)
Definition: solgame.cpp:4
int iRightMargin
Definition: winuser.h:3090
UINT uiLengthDrawn
Definition: winuser.h:3091
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(), 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(), DrawThemeText(), EditTypeDlg_OnDrawItem(), FillGrid(), GetThemeTextExtent(), Graph_DrawCpuUsageGraph(), Graph_DrawMemUsageGraph(), HDropFromClipboard(), HEADER_DrawItem(), ICONTITLE_Paint(), ICONTITLE_SetTitlePos(), ImageView_DrawImage(), IPADDRESS_Draw(), LISTVIEW_DrawItemPart(), LISTVIEW_GetItemMetrics(), LrgCellWndProc(), MainWnd_OnDrawItem(), MENU_CalcItemSize(), MENU_DrawMenuItem(), MONTHCAL_PaintCalendar(), MONTHCAL_PaintTitle(), MONTHCAL_PaintTodayTitle(), MonthCalPaint(), MyDrawCaptionTemp(), MyDrawMenuBarTemp(), NT5_DrawLogoffCaptionText(), CAutoComplete::OnDrawItem(), CCell::OnPaint(), OnPaint(), OSK_Paint(), PAINTING_DrawStateJam(), PaintText(), ProgressDlg::ProcessWindowMessage(), PROPSHEET_Paint(), REBAR_DrawBand(), ScrollProc(), SoftModalMessageBox(), STATIC_PaintTextfn(), TAB_DrawItemInterior(), taskdialog_get_text_extent(), test_DrawTextCalcRect(), TOOLBAR_CustomizeDialogProc(), TOOLBAR_DrawString(), TOOLBAR_MeasureString(), TOOLTIPS_CalcTipSize(), TOOLTIPS_Refresh(), TREEVIEW_CreateDragImage(), UserDrawCaptionText(), and WndProc().

◆ IntDefWindowProc()

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

Definition at line 536 of file defwnd.c.

542{
544 LRESULT lResult = 0;
546
547 if (Msg > WM_USER) return 0;
548
549 switch (Msg)
550 {
551 case WM_DEVICECHANGE:
552 return TRUE;
553
554 case WM_GETTEXTLENGTH:
555 {
556 PWSTR buf;
557 ULONG len;
558
559 if (Wnd != NULL && Wnd->strName.Length != 0)
560 {
561 buf = Wnd->strName.Buffer;
562 if (buf != NULL &&
564 buf,
565 Wnd->strName.Length)))
566 {
567 lResult = (LRESULT) (Wnd->strName.Length / sizeof(WCHAR));
568 }
569 }
570 else lResult = 0L;
571
572 break;
573 }
574
575 case WM_GETTEXT: // FIXME: Handle Ansi
576 {
577 PWSTR buf = NULL;
578 PWSTR outbuf = (PWSTR)lParam;
579
580 if (Wnd != NULL && wParam != 0)
581 {
582 if (Wnd->strName.Buffer != NULL)
583 buf = Wnd->strName.Buffer;
584 else
585 outbuf[0] = L'\0';
586
587 if (buf != NULL)
588 {
589 if (Wnd->strName.Length != 0)
590 {
591 lResult = min(Wnd->strName.Length / sizeof(WCHAR), wParam - 1);
592 RtlCopyMemory(outbuf,
593 buf,
594 lResult * sizeof(WCHAR));
595 outbuf[lResult] = L'\0';
596 }
597 else
598 outbuf[0] = L'\0';
599 }
600 }
601 break;
602 }
603
604 case WM_SETTEXT: // FIXME: Handle Ansi
605 {
606 DefSetText(Wnd, (PCWSTR)lParam);
607
608 if ((Wnd->style & WS_CAPTION) == WS_CAPTION)
610 IntNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, Wnd, OBJID_WINDOW, CHILDID_SELF, 0);
611 lResult = 1;
612 break;
613 }
614
615 case WM_SYSCOMMAND:
616 {
617 TRACE("hwnd %p WM_SYSCOMMAND %lx %lx\n", Wnd->head.h, wParam, lParam );
618 lResult = DefWndHandleSysCommand(Wnd, wParam, lParam);
619 break;
620 }
621
622 case WM_SHOWWINDOW:
623 {
624 if ((Wnd->style & WS_VISIBLE) && wParam) break;
625 if (!(Wnd->style & WS_VISIBLE) && !wParam) break;
626 if (!Wnd->spwndOwner) break;
627 if (LOWORD(lParam))
628 {
630 }
631 break;
632 }
633
635 return IntClientShutdown(Wnd, wParam, lParam);
636
637 case WM_APPCOMMAND:
638 if ( (Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD &&
639 Wnd != co_GetDesktopWindow(Wnd) )
640 {
641 if (!co_HOOK_CallHooks(WH_SHELL, HSHELL_APPCOMMAND, wParam, lParam))
642 co_IntShellHookNotify(HSHELL_APPCOMMAND, wParam, lParam);
643 break;
644 }
645 UserRefObjectCo(Wnd->spwndParent, &Ref);
648 break;
649
650 case WM_KEYF1:
651 {
652 HELPINFO hi;
653 HMENU hMenu = UlongToHandle(Wnd->IDMenu);
654 PWND pwndActive = MENU_IsMenuActive();
655 hi.cbSize = sizeof(HELPINFO);
656 hi.MousePos = gpsi->ptCursor;
658 hi.hItemHandle = pwndActive ? UserHMGetHandle(pwndActive) : UserHMGetHandle(Wnd);
659 hi.iCtrlId = (Wnd->style & (WS_POPUP|WS_CHILD)) == WS_CHILD ? IntMenuItemFromPoint(Wnd, hMenu, hi.MousePos) : 0;
661
662 co_IntSendMessage( UserHMGetHandle(Wnd), WM_HELP, 0, (LPARAM)&hi );
663 break;
664 }
665
666 case WM_SETICON:
667 {
668 return DefWndSetIcon(Wnd, wParam, lParam);
669 }
670
671 case WM_GETICON:
672 {
673 return DefWndGetIcon(Wnd, wParam, lParam);
674 }
675
676 case WM_HELP:
677 {
678 PWND Parent = IntGetParent(Wnd);
680 break;
681 }
682
683 case WM_LBUTTONDOWN:
684 case WM_RBUTTONDOWN:
685 case WM_MBUTTONDOWN:
687 break;
688
689 case WM_NCLBUTTONDOWN:
691
692 case WM_NCRBUTTONDOWN:
694
695 case WM_LBUTTONDBLCLK:
697
700
701 case WM_RBUTTONUP:
702 {
703 POINT Pt;
704
705 Pt.x = GET_X_LPARAM(lParam);
706 Pt.y = GET_Y_LPARAM(lParam);
707 IntClientToScreen(Wnd, &Pt);
708 lParam = MAKELPARAM(Pt.x, Pt.y);
710 break;
711 }
712
713 case WM_NCRBUTTONUP:
714 /*
715 * FIXME : we must NOT send WM_CONTEXTMENU on a WM_NCRBUTTONUP (checked
716 * in Windows), but what _should_ we do? According to MSDN :
717 * "If it is appropriate to do so, the system sends the WM_SYSCOMMAND
718 * message to the window". When is it appropriate?
719 */
720 ERR("WM_NCRBUTTONUP\n");
721 break;
722
723 case WM_XBUTTONUP:
724 case WM_NCXBUTTONUP:
725 if (HIWORD(wParam) == XBUTTON1 || HIWORD(wParam) == XBUTTON2)
726 {
728 MAKELPARAM(LOWORD(wParam), FAPPCOMMAND_MOUSE | HIWORD(wParam)));
729 }
730 break;
731
732
733 case WM_CONTEXTMENU:
734 {
735 if (Wnd->style & WS_CHILD)
736 {
738 }
739 else
740 {
741 POINT Pt;
743 LONG HitCode;
744
745 Style = Wnd->style;
746
747 Pt.x = GET_X_LPARAM(lParam);
748 Pt.y = GET_Y_LPARAM(lParam);
749 if (Style & WS_CHILD)
750 {
752 }
753
754 HitCode = GetNCHitEx(Wnd, Pt);
755
756 if (HitCode == HTCAPTION || HitCode == HTSYSMENU)
757 {
758 PMENU SystemMenu;
759 UINT Flags;
760
761 if((SystemMenu = IntGetSystemMenu(Wnd, FALSE)))
762 {
763 MENU_InitSysMenuPopup(SystemMenu, Wnd->style, Wnd->pcls->style, HitCode);
764
765 if(HitCode == HTCAPTION)
767 else
769
770 IntTrackPopupMenuEx(SystemMenu, Flags|TPM_SYSTEM_MENU, Pt.x, Pt.y, Wnd, NULL);
771 }
772 }
773 if (HitCode == HTHSCROLL || HitCode == HTVSCROLL)
774 {
775 WARN("Scroll Menu Not Supported\n");
776 }
777 }
778 break;
779 }
780
781 case WM_KEYDOWN:
782 if (wParam == VK_F10)
783 {
784 pti->MessageQueue->QF_flags |= QF_FF10STATUS;
785
786 if (UserGetKeyState(VK_SHIFT) & 0x8000)
787 {
789 }
790 }
792 {
793 BOOL IsTaskBar;
794 DWORD StyleTB;
795 DWORD ExStyleTB;
796 HWND hwndTop = UserGetForegroundWindow();
797 PWND topWnd = UserGetWindowObject(hwndTop);
798
799 // MS Doc: foreground window can be NULL, e.g. when window is losing activation
800 if (!topWnd)
801 return 0;
802
803 // We want to forbid snapping operations on the TaskBar
804 // We use a heuristic for detecting the TaskBar Wnd by its typical Style & ExStyle Values
805 ExStyleTB = (topWnd->ExStyle & WS_EX_TOOLWINDOW);
806 StyleTB = (topWnd->style & (WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN));
807 IsTaskBar = (StyleTB == (WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN))
808 && (ExStyleTB == WS_EX_TOOLWINDOW);
809 TRACE("ExStyle=%x Style=%x IsTaskBar=%d\n", ExStyleTB, StyleTB, IsTaskBar);
810
811 if (!IsTaskBar)
812 {
813 if ((topWnd->style & WS_THICKFRAME) == 0)
814 return 0;
815
816 if (wParam == VK_DOWN)
817 {
818 if (topWnd->style & WS_MAXIMIZE)
819 {
821
822 /* "Normal size" must be erased after restoring, otherwise it will block next side snap actions */
823 RECTL_vSetEmptyRect(&topWnd->InternalPos.NormalRect);
824 }
825 else
826 {
828 }
829 }
830 else if (wParam == VK_UP)
831 {
832 RECT currentRect;
833 if ((topWnd->InternalPos.NormalRect.right == topWnd->InternalPos.NormalRect.left) ||
834 (topWnd->InternalPos.NormalRect.top == topWnd->InternalPos.NormalRect.bottom))
835 {
836 currentRect = topWnd->rcWindow;
837 }
838 else
839 {
840 currentRect = topWnd->InternalPos.NormalRect;
841 }
843
844 // save normal rect if maximazing snapped window
845 topWnd->InternalPos.NormalRect = currentRect;
846 }
847 else if (wParam == VK_LEFT || wParam == VK_RIGHT)
848 {
849 RECT snapRect, normalRect, windowRect;
850 BOOL snapped;
851 normalRect = topWnd->InternalPos.NormalRect;
852 snapped = (normalRect.left != 0 && normalRect.right != 0 &&
853 normalRect.top != 0 && normalRect.bottom != 0);
854
855 if (topWnd->style & WS_MAXIMIZE)
856 {
858 snapped = FALSE;
859 }
860 windowRect = topWnd->rcWindow;
861
862 UserSystemParametersInfo(SPI_GETWORKAREA, 0, &snapRect, 0);
863 if (wParam == VK_LEFT)
864 {
865 snapRect.right = (snapRect.left + snapRect.right) / 2;
866 }
867 else // VK_RIGHT
868 {
869 snapRect.left = (snapRect.left + snapRect.right) / 2;
870 }
871
872 if (snapped)
873 {
874 // if window was snapped but moved to other location - restore normal size
875 if (!IntEqualRect(&snapRect, &windowRect))
876 {
877 RECT empty = {0, 0, 0, 0};
879 0,
880 normalRect.left,
881 normalRect.top,
882 normalRect.right - normalRect.left,
883 normalRect.bottom - normalRect.top,
884 0);
885 topWnd->InternalPos.NormalRect = empty;
886 }
887 }
888 else
889 {
891 0,
892 snapRect.left,
893 snapRect.top,
894 snapRect.right - snapRect.left,
895 snapRect.bottom - snapRect.top,
896 0);
897 topWnd->InternalPos.NormalRect = windowRect;
898 }
899 }
900 }
901 }
902 break;
903
904 case WM_SYSKEYDOWN:
905 {
906 if (HIWORD(lParam) & KF_ALTDOWN)
907 { /* Previous state, if the key was down before this message,
908 this is a cheap way to ignore autorepeat keys. */
909 if ( !(HIWORD(lParam) & KF_REPEAT) )
910 {
911 if ( ( wParam == VK_MENU ||
912 wParam == VK_LMENU ||
913 wParam == VK_RMENU ) && !(pti->MessageQueue->QF_flags & QF_FMENUSTATUS)) //iMenuSysKey )
914 pti->MessageQueue->QF_flags |= QF_FMENUSTATUS; //iMenuSysKey = 1;
915 else
916 pti->MessageQueue->QF_flags &= ~QF_FMENUSTATUS; //iMenuSysKey = 0;
917 }
918
919 pti->MessageQueue->QF_flags &= ~QF_FF10STATUS; //iF10Key = 0;
920
921 if (wParam == VK_F4) /* Try to close the window */
922 {
924 if (!(top->style & CS_NOCLOSE))
926 }
927 else if (wParam == VK_SNAPSHOT) // Alt-VK_SNAPSHOT?
928 {
929 PWND pwnd = Wnd;
930 while (IntGetParent(pwnd) != NULL)
931 {
932 pwnd = IntGetParent(pwnd);
933 }
934 ERR("DefWndScreenshot\n");
935 DefWndScreenshot(pwnd);
936 }
937 else if ( wParam == VK_ESCAPE || wParam == VK_TAB ) // Alt-Tab/ESC Alt-Shift-Tab/ESC
938 {
939 WPARAM wParamTmp;
940 HWND Active = UserGetActiveWindow(); // Noticed MDI problem.
941 if (!Active)
942 {
943 FIXME("WM_SYSKEYDOWN VK_ESCAPE no active\n");
944 break;
945 }
946 wParamTmp = UserGetKeyState(VK_SHIFT) & 0x8000 ? SC_PREVWINDOW : SC_NEXTWINDOW;
948 }
949 else if (wParam == VK_SHIFT) // Alt+Shift
950 {
951 RTL_ATOM ClassAtom = 0;
952 UNICODE_STRING ustrClass, ustrWindow;
953 HWND hwndSwitch;
954
955 RtlInitUnicodeString(&ustrClass, L"kbswitcher");
956 RtlInitUnicodeString(&ustrWindow, L"");
957
958 IntGetAtomFromStringOrAtom(&ustrClass, &ClassAtom);
959
960 hwndSwitch = IntFindWindow(UserGetDesktopWindow(), NULL, ClassAtom, &ustrWindow);
961 if (hwndSwitch)
962 {
963#define ID_NEXTLAYOUT 10003
965 }
966 }
967 }
968 else if( wParam == VK_F10 )
969 {
970 if (UserGetKeyState(VK_SHIFT) & 0x8000)
972 pti->MessageQueue->QF_flags |= QF_FF10STATUS; //iF10Key = 1;
973 }
974 else if( wParam == VK_ESCAPE && (UserGetKeyState(VK_SHIFT) & 0x8000))
976 break;
977 }
978
979 case WM_KEYUP:
980 case WM_SYSKEYUP:
981 {
982 /* Press and release F10 or ALT */
983 if (((wParam == VK_MENU || wParam == VK_LMENU || wParam == VK_RMENU)
984 && (pti->MessageQueue->QF_flags & (QF_FMENUSTATUS|QF_FMENUSTATUSBREAK)) == QF_FMENUSTATUS /*iMenuSysKey*/) ||
985 ((wParam == VK_F10) && pti->MessageQueue->QF_flags & QF_FF10STATUS /*iF10Key*/))
987 pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK|QF_FF10STATUS); //iMenuSysKey = iF10Key = 0;
988 break;
989 }
990
991 case WM_SYSCHAR:
992 {
993 pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK); //iMenuSysKey = 0;
994 if (wParam == VK_RETURN && (Wnd->style & WS_MINIMIZE) != 0)
995 {
997 break;
998 }
999 if ((HIWORD(lParam) & KF_ALTDOWN) && wParam)
1000 {
1001 if (wParam == VK_TAB || wParam == VK_ESCAPE) break;
1002 if (wParam == VK_SPACE && Wnd->style & WS_CHILD)
1004 else
1006 }
1007 else /* check for Ctrl-Esc */
1008 if (wParam != VK_ESCAPE) UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, 0); //MessageBeep(0);
1009 break;
1010 }
1011
1012 case WM_CANCELMODE:
1013 {
1014 pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK);
1015
1016 MENU_EndMenu( Wnd );
1018 {
1020 }
1021 break;
1022 }
1023
1024 case WM_CLOSE:
1026 break;
1027
1028 case WM_CTLCOLORMSGBOX:
1029 case WM_CTLCOLOREDIT:
1030 case WM_CTLCOLORLISTBOX:
1031 case WM_CTLCOLORBTN:
1032 case WM_CTLCOLORDLG:
1033 case WM_CTLCOLORSTATIC:
1036
1037 case WM_CTLCOLOR:
1039
1040 case WM_SETCURSOR:
1041 {
1042 if (Wnd->style & WS_CHILD)
1043 {
1044 /* with the exception of the border around a resizable wnd,
1045 * give the parent first chance to set the cursor */
1047 {
1048 PWND parent = Wnd->spwndParent;//IntGetParent( Wnd );
1049 if (parent != UserGetDesktopWindow() &&
1051 return TRUE;
1052 }
1053 }
1054 return DefWndHandleSetCursor(Wnd, wParam, lParam);
1055 }
1056
1057 case WM_MOUSEACTIVATE:
1058 if (Wnd->style & WS_CHILD)
1059 {
1060 LONG Ret;
1062 PWND pwndParent = IntGetParent(Wnd);
1063 hwndParent = pwndParent ? UserHMGetHandle(pwndParent) : NULL;
1065 if (Ret) return (Ret);
1066 }
1068
1069 case WM_ACTIVATE:
1070 /* The default action in Windows is to set the keyboard focus to
1071 * the window, if it's being activated and not minimized */
1072 if (LOWORD(wParam) != WA_INACTIVE &&
1073 !(Wnd->style & WS_MINIMIZE))
1074 {
1075 //ERR("WM_ACTIVATE %p\n",hWnd);
1076 co_UserSetFocus(Wnd);
1077 }
1078 break;
1079
1080 case WM_MOUSEWHEEL:
1081 if (Wnd->style & WS_CHILD)
1082 {
1084 PWND pwndParent = IntGetParent(Wnd);
1085 hwndParent = pwndParent ? UserHMGetHandle(pwndParent) : NULL;
1087 }
1088 break;
1089
1090 case WM_ERASEBKGND:
1091 case WM_ICONERASEBKGND:
1092 {
1093 RECT Rect;
1094 HBRUSH hBrush = Wnd->pcls->hbrBackground;
1095 if (!hBrush) return 0;
1096 if (hBrush <= (HBRUSH)COLOR_MENUBAR)
1097 {
1098 hBrush = IntGetSysColorBrush(HandleToUlong(hBrush));
1099 }
1100 if (Wnd->pcls->style & CS_PARENTDC)
1101 {
1102 /* can't use GetClipBox with a parent DC or we fill the whole parent */
1103 IntGetClientRect(Wnd, &Rect);
1105 }
1106 else
1107 {
1108 GdiGetClipBox((HDC)wParam, &Rect);
1109 }
1110 FillRect((HDC)wParam, &Rect, hBrush);
1111 return (1);
1112 }
1113
1114 case WM_GETHOTKEY:
1115 //ERR("WM_GETHOTKEY\n");
1116 return DefWndGetHotKey(Wnd);
1117 case WM_SETHOTKEY:
1118 //ERR("WM_SETHOTKEY\n");
1119 return DefWndSetHotKey(Wnd, wParam);
1120
1121 case WM_NCHITTEST:
1122 {
1123 POINT Point;
1126 return GetNCHitEx(Wnd, Point);
1127 }
1128
1129 case WM_PRINT:
1130 {
1131 DefWndPrint(Wnd, (HDC)wParam, lParam);
1132 return (0);
1133 }
1134
1135 case WM_SYSCOLORCHANGE:
1136 {
1137 /* force to redraw non-client area */
1138 UserPaintCaption(Wnd, DC_NC);
1139 /* Use InvalidateRect to redraw client area, enable
1140 * erase to redraw all subcontrols otherwise send the
1141 * WM_SYSCOLORCHANGE to child windows/controls is required
1142 */
1144 return (0);
1145 }
1146
1147 case WM_PAINTICON:
1148 case WM_PAINT:
1149 {
1150 PAINTSTRUCT Ps;
1151 HDC hDC;
1152
1153 /* If already in Paint and Client area is not empty just return. */
1154 if (Wnd->state2 & WNDS2_STARTPAINT && !RECTL_bIsEmptyRect(&Wnd->rcClient))
1155 {
1156 ERR("In Paint and Client area is not empty!\n");
1157 return 0;
1158 }
1159
1160 hDC = IntBeginPaint(Wnd, &Ps);
1161 if (hDC)
1162 {
1163 if (((Wnd->style & WS_MINIMIZE) != 0) && (Wnd->pcls->spicn))
1164 {
1165 RECT ClientRect;
1166 INT x, y;
1167
1168 ERR("Doing Paint and Client area is empty!\n");
1169 IntGetClientRect(Wnd, &ClientRect);
1170 x = (ClientRect.right - ClientRect.left - UserGetSystemMetrics(SM_CXICON)) / 2;
1171 y = (ClientRect.bottom - ClientRect.top - UserGetSystemMetrics(SM_CYICON)) / 2;
1173 UserDrawIconEx(hDC, x, y, Wnd->pcls->spicn, 0, 0, 0, 0, DI_NORMAL | DI_COMPAT | DI_DEFAULTSIZE);
1175 }
1176
1177 IntEndPaint(Wnd, &Ps);
1178 }
1179 return (0);
1180 }
1181
1182 case WM_SYNCPAINT:
1183 {
1184 HRGN hRgn;
1185 Wnd->state &= ~WNDS_SYNCPAINTPENDING;
1186 TRACE("WM_SYNCPAINT\n");
1187 hRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
1188 if (hRgn)
1189 {
1191 {
1192 PREGION pRgn = REGION_LockRgn(hRgn);
1193 if (pRgn) REGION_UnlockRgn(pRgn);
1194 if (!wParam)
1196 co_UserRedrawWindow(Wnd, NULL, pRgn, wParam);
1197 }
1199 }
1200 return 0;
1201 }
1202
1203 case WM_SETREDRAW:
1204 if (wParam)
1205 {
1206 if (!(Wnd->style & WS_VISIBLE))
1207 {
1208 IntSetStyle( Wnd, WS_VISIBLE, 0 );
1209 Wnd->state |= WNDS_SENDNCPAINT;
1210 }
1211 }
1212 else
1213 {
1214 if (Wnd->style & WS_VISIBLE)
1215 {
1217 IntSetStyle( Wnd, 0, WS_VISIBLE );
1218 }
1219 }
1220 return 0;
1221
1223 {
1225 }
1226
1228 {
1230 }
1231
1232 case WM_NCCALCSIZE:
1233 {
1234 return NC_HandleNCCalcSize( Wnd, wParam, (RECTL *)lParam, FALSE );
1235 }
1236
1237 case WM_NCACTIVATE:
1238 {
1239 return NC_HandleNCActivate( Wnd, wParam, lParam );
1240 }
1241
1242 //
1243 // NC Paint mode.
1244 //
1245 case WM_NCPAINT:
1246 {
1248 Wnd->state |= WNDS_FORCEMENUDRAW;
1249 NC_DoNCPaint(Wnd, hDC, -1);
1250 Wnd->state &= ~WNDS_FORCEMENUDRAW;
1251 UserReleaseDC(Wnd, hDC, FALSE);
1252 return 0;
1253 }
1254 //
1255 // Draw Caption mode.
1256 //
1257 // wParam are DC_* flags.
1258 //
1260 {
1262 TRACE("WM_NCUAHDRAWCAPTION: wParam DC_ flags %08x\n",wParam);
1263 UserDrawCaptionBar(Wnd, hDC, wParam | DC_FRAME); // Include DC_FRAME to comp for drawing glitch.
1264 UserReleaseDC(Wnd, hDC, FALSE);
1265 return 0;
1266 }
1267 //
1268 // Draw Frame mode.
1269 //
1270 // wParam is HDC, lParam are DC_ACTIVE and or DC_REDRAWHUNGWND.
1271 //
1272 case WM_NCUAHDRAWFRAME:
1273 {
1274 TRACE("WM_NCUAHDRAWFRAME: wParam hDC %p lParam DC_ flags %08x\n",wParam,lParam);
1276 return 0;
1277 }
1278
1279 /* ReactOS only. */
1280 case WM_CBT:
1281 {
1282 switch (wParam)
1283 {
1284 case HCBT_MOVESIZE:
1285 {
1286 RECTL rt;
1287
1288 if (lParam)
1289 {
1290 _SEH2_TRY
1291 {
1293 sizeof(RECT),
1294 1);
1295
1296 RtlCopyMemory(&rt,
1297 (PVOID)lParam,
1298 sizeof(RECT));
1299 }
1301 {
1302 lResult = 1;
1303 }
1304 _SEH2_END;
1305 }
1306 if (!lResult)
1307 lResult = co_HOOK_CallHooks(WH_CBT, HCBT_MOVESIZE, (WPARAM)Wnd->head.h, lParam ? (LPARAM)&rt : 0);
1308 }
1309 break;
1310 }
1311 break;
1312 }
1313 break;
1314 }
1315 return lResult;
1316}
#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:1530
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:611
#define WNDS_FORCEMENUDRAW
Definition: ntuser.h:615
#define WNDS2_STARTPAINT
Definition: ntuser.h:638
static HRGN hRgn
Definition: mapping.c:33
unsigned short RTL_ATOM
Definition: atom.c:42
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
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
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
#define ID_NEXTLAYOUT
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:580
HBRUSH hbrBackground
Definition: ntuser.h:582
UINT style
Definition: ntuser.h:575
Definition: region.h:8
struct _USER_MESSAGE_QUEUE * MessageQueue
Definition: win32.h:89
DWORD ExStyle
Definition: ntuser.h:699
DWORD state2
Definition: ntuser.h:697
RECT rcClient
Definition: ntuser.h:712
LARGE_UNICODE_STRING strName
Definition: ntuser.h:731
DWORD state
Definition: ntuser.h:696
struct _WND::@4907 InternalPos
UINT_PTR IDMenu
Definition: ntuser.h:726
RECT rcWindow
Definition: ntuser.h:711
struct _WND * spwndParent
Definition: ntuser.h:708
POINT MousePos
Definition: winuser.h:3307
int iCtrlId
Definition: winuser.h:3304
DWORD_PTR dwContextId
Definition: winuser.h:3306
HANDLE hItemHandle
Definition: winuser.h:3305
int iContextType
Definition: winuser.h:3303
UINT cbSize
Definition: winuser.h:3302
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:1785
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:3349
BOOLEAN co_UserDestroyWindow(PVOID Object)
Definition: window.c:2853
BOOL APIENTRY DefSetText(PWND Wnd, PCWSTR WindowText)
Definition: window.c:4396
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:2374
VOID FASTCALL REGION_UnlockRgn(_In_ PREGION prgn)
Definition: region.c:2389
BOOL UserDrawIconEx(HDC hDc, INT xLeft, INT yTop, PCURICON_OBJECT pIcon, INT cxWidth, INT cyHeight, UINT istepIfAniCur, HBRUSH hbrFlickerFreeDraw, UINT diFlags)
Definition: cursoricon.c:1689
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:99
PMENU FASTCALL IntGetSystemMenu(PWND Window, BOOL bRevert)
Definition: menu.c:5381
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:4559
LONG NTAPI UserGetSystemMetrics(ULONG Index)
Definition: metric.c:208
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:2104
ULONG FASTCALL IntSetStyle(PWND pwnd, ULONG set_bits, ULONG clear_bits)
Definition: window.c:143
HWND FASTCALL IntFindWindow(PWND Parent, PWND ChildAfter, RTL_ATOM ClassAtom, PUNICODE_STRING WindowName)
Definition: window.c:3066
#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:1610
#define WM_GETHOTKEY
Definition: winuser.h:1643
#define WM_CTLCOLORSTATIC
Definition: winuser.h:1762
#define WM_GETTEXTLENGTH
Definition: winuser.h:1609
#define SW_HIDE
Definition: winuser.h:762
#define VK_SNAPSHOT
Definition: winuser.h:2221
#define VK_TAB
Definition: winuser.h:2189
#define GA_ROOT
Definition: winuser.h:2779
#define MAKELPARAM(l, h)
Definition: winuser.h:3998
#define WM_KEYUP
Definition: winuser.h:1706
#define HTCAPTION
Definition: winuser.h:2466
#define DCX_WINDOW
Definition: winuser.h:2103
#define HELPINFO_MENUITEM
Definition: winuser.h:1161
#define VK_F10
Definition: winuser.h:2254
#define WM_SETHOTKEY
Definition: winuser.h:1642
#define WM_WINDOWPOSCHANGING
Definition: winuser.h:1651
#define TPM_RIGHTBUTTON
Definition: winuser.h:2370
#define WM_SYNCPAINT
Definition: winuser.h:1680
#define SC_PREVWINDOW
Definition: winuser.h:2581
#define VK_SPACE
Definition: winuser.h:2209
#define WM_CANCELMODE
Definition: winuser.h:1625
#define WM_LBUTTONDBLCLK
Definition: winuser.h:1768
#define WM_COMMAND
Definition: winuser.h:1730
#define KF_ALTDOWN
Definition: winuser.h:2439
#define HTVSCROLL
Definition: winuser.h:2472
#define MA_ACTIVATE
Definition: winuser.h:2491
#define HTHSCROLL
Definition: winuser.h:2471
#define WM_APPCOMMAND
Definition: winuser.h:1872
#define WM_NCHITTEST
Definition: winuser.h:1676
#define WS_EX_TOOLWINDOW
Definition: winuser.h:404
#define WM_RBUTTONUP
Definition: winuser.h:1770
#define VK_UP
Definition: winuser.h:2215
#define SW_SHOWNOACTIVATE
Definition: winuser.h:768
#define WH_SHELL
Definition: winuser.h:40
#define WM_GETTEXT
Definition: winuser.h:1608
#define RDW_ERASE
Definition: winuser.h:1201
#define WM_CTLCOLORSCROLLBAR
Definition: winuser.h:1761
#define WA_INACTIVE
Definition: winuser.h:2612
#define MA_NOACTIVATE
Definition: winuser.h:2493
#define WM_DEVICECHANGE
Definition: winuser.h:1801
#define WM_SYSCOLORCHANGE
Definition: winuser.h:1616
#define WM_CTLCOLORMSGBOX
Definition: winuser.h:1756
#define WM_NCLBUTTONDBLCLK
Definition: winuser.h:1684
#define WM_ACTIVATE
Definition: winuser.h:1602
#define WM_SHOWWINDOW
Definition: winuser.h:1618
#define WM_CTLCOLORBTN
Definition: winuser.h:1759
#define WM_SETTEXT
Definition: winuser.h:1607
#define SC_NEXTWINDOW
Definition: winuser.h:2580
#define DC_NC
Definition: winuser.h:440
#define DCX_INTERSECTRGN
Definition: winuser.h:2112
#define WM_NCACTIVATE
Definition: winuser.h:1678
#define WM_SYSCHAR
Definition: winuser.h:1711
#define VK_RETURN
Definition: winuser.h:2191
#define SM_CYICON
Definition: winuser.h:967
#define VK_RMENU
Definition: winuser.h:2277
#define RDW_ALLCHILDREN
Definition: winuser.h:1211
#define RDW_ERASENOW
Definition: winuser.h:1209
#define RDW_FRAME
Definition: winuser.h:1202
#define WM_SYSKEYUP
Definition: winuser.h:1710
#define HCBT_MOVESIZE
Definition: winuser.h:55
#define DC_TEXT
Definition: winuser.h:430
#define VK_LWIN
Definition: winuser.h:2225
struct tagHELPINFO HELPINFO
#define WM_MOUSEACTIVATE
Definition: winuser.h:1627
#define TPM_LEFTBUTTON
Definition: winuser.h:2369
#define VK_F4
Definition: winuser.h:2248
#define VK_LEFT
Definition: winuser.h:2214
#define VK_RIGHT
Definition: winuser.h:2216
#define VK_DOWN
Definition: winuser.h:2217
#define WM_SETCURSOR
Definition: winuser.h:1626
#define KF_REPEAT
Definition: winuser.h:2440
#define WM_USER
Definition: winuser.h:1885
#define WM_CTLCOLORLISTBOX
Definition: winuser.h:1758
#define VK_SHIFT
Definition: winuser.h:2192
#define WM_NCRBUTTONUP
Definition: winuser.h:1686
#define WM_KEYDOWN
Definition: winuser.h:1705
#define WM_ICONERASEBKGND
Definition: winuser.h:1632
#define HTSYSMENU
Definition: winuser.h:2467
#define WM_PRINT
Definition: winuser.h:1870
#define WM_NCCALCSIZE
Definition: winuser.h:1675
#define CS_PARENTDC
Definition: winuser.h:651
#define SM_CXICON
Definition: winuser.h:966
#define RDW_VALIDATE
Definition: winuser.h:1208
#define WM_CTLCOLOREDIT
Definition: winuser.h:1757
#define VK_ESCAPE
Definition: winuser.h:2204
#define WM_WINDOWPOSCHANGED
Definition: winuser.h:1652
#define WM_CTLCOLORDLG
Definition: winuser.h:1760
#define CS_NOCLOSE
Definition: winuser.h:649
#define WM_SYSKEYDOWN
Definition: winuser.h:1709
#define WM_NCLBUTTONDOWN
Definition: winuser.h:1682
#define RDW_INVALIDATE
Definition: winuser.h:1204
#define WM_PAINTICON
Definition: winuser.h:1631
#define VK_RWIN
Definition: winuser.h:2226
#define VK_LMENU
Definition: winuser.h:2276
#define VK_MENU
Definition: winuser.h:2194
#define WM_NCPAINT
Definition: winuser.h:1677
#define WM_NCRBUTTONDOWN
Definition: winuser.h:1685
#define WM_SETREDRAW
Definition: winuser.h:1606
_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 SRVINFO_APIHOOK
Definition: ntuser.h:945
#define WNDS_HASCAPTION
Definition: ntuser.h:603
DWORD dwSRVIFlags
Definition: ntuser.h:1046
#define DC_ACTIVE
Definition: winuser.h:427

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