ReactOS 0.4.15-dev-7788-g1ad9096
cursoricon.c File Reference
#include <win32k.h>
Include dependency graph for cursoricon.c:

Go to the source code of this file.

Functions

 DBG_DEFAULT_CHANNEL (UserIcon)
 
BOOL InitCursorImpl (VOID)
 
static VOID IntInsertCursorIntoList (_Inout_ PCURICON_OBJECT pcur)
 
static VOID IntRemoveCursorFromList (_Inout_ PCURICON_OBJECT pcur)
 
VOID IntLoadSystenIcons (HICON hcur, DWORD id)
 
PSYSTEM_CURSORINFO IntGetSysCursorInfo (VOID)
 
FORCEINLINE BOOL is_icon (PCURICON_OBJECT object)
 
PCURICON_OBJECT FASTCALL UserGetCurIconObject (HCURSOR hCurIcon)
 
PCURICON_OBJECT IntSystemSetCursor (PCURICON_OBJECT pcurNew)
 
BOOL UserSetCursorPos (INT x, INT y, DWORD flags, ULONG_PTR dwExtraInfo, BOOL Hook)
 
HANDLE IntCreateCurIconHandle (BOOLEAN Animated)
 
BOOLEAN IntDestroyCurIconObject (_In_ PVOID Object)
 
VOID FreeCurIconObject (_In_ PVOID Object)
 
VOID FASTCALL IntCleanupCurIconCache (PPROCESSINFO Win32Process)
 
 _Success_ (return !=FALSE)
 
BOOL APIENTRY NtUserGetIconSize (HANDLE hCurIcon, UINT istepIfAniCur, PLONG plcx, PLONG plcy)
 
BOOL APIENTRY NtUserGetCursorInfo (PCURSORINFO pci)
 
BOOL APIENTRY UserClipCursor (RECTL *prcl)
 
BOOL APIENTRY NtUserClipCursor (RECTL *prcl)
 
BOOL APIENTRY NtUserDestroyCursor (_In_ HANDLE hCurIcon, _In_ BOOL bForce)
 
HICON NTAPI NtUserFindExistingCursorIcon (_In_ PUNICODE_STRING pustrModule, _In_ PUNICODE_STRING pustrRsrc, _In_ FINDEXISTINGCURICONPARAM *param)
 
BOOL APIENTRY NtUserGetClipCursor (RECTL *lpRect)
 
HCURSOR APIENTRY NtUserSetCursor (HCURSOR hCursor)
 
BOOL APIENTRY NtUserSetCursorContents (HANDLE hCurIcon, PICONINFO UnsafeIconInfo)
 
static BOOL IntSetCursorData (_Inout_ PCURICON_OBJECT pcur, _In_opt_ PUNICODE_STRING pustrName, _In_ ATOM atomModName, _In_ const CURSORDATA *pcursordata)
 
static BOOL IntSetAconData (_Inout_ PACON pacon, _In_opt_ PUNICODE_STRING pustrName, _In_ ATOM atomModName, _In_ const CURSORDATA *pcursordata)
 
BOOL APIENTRY UserSetCursorIconData (_In_ HCURSOR hcursor, _In_opt_ PUNICODE_STRING pustrModule, _In_opt_ PUNICODE_STRING pustrRsrc, _In_ PCURSORDATA pcursordata)
 
__kernel_entry BOOL APIENTRY NtUserSetCursorIconData (_In_ HCURSOR hcursor, _In_opt_ PUNICODE_STRING pustrModule, _In_opt_ PUNICODE_STRING pustrRsrc, _In_ const CURSORDATA *pCursorData)
 
BOOL UserDrawIconEx (HDC hDc, INT xLeft, INT yTop, PCURICON_OBJECT pIcon, INT cxWidth, INT cyHeight, UINT istepIfAniCur, HBRUSH hbrFlickerFreeDraw, UINT diFlags)
 
BOOL APIENTRY NtUserDrawIconEx (HDC hdc, int xLeft, int yTop, HICON hIcon, int cxWidth, int cyHeight, UINT istepIfAniCur, HBRUSH hbrFlickerFreeDraw, UINT diFlags, BOOL bMetaHDC, PVOID pDIXData)
 
HCURSOR NTAPI NtUserGetCursorFrameInfo (HCURSOR hCursor, DWORD istep, INT *rate_jiffies, DWORD *num_steps)
 
BOOL APIENTRY NtUserSetSystemCursor (HCURSOR hcur, DWORD id)
 

Variables

SYSTEM_CURSORINFO gSysCursorInfo
 
PCURICON_OBJECT gcurFirst = NULL
 
SYSTEMCURICO gasyscur []
 
SYSTEMCURICO gasysico []
 

Function Documentation

◆ _Success_()

_Success_ ( return = FALSE)

Definition at line 407 of file cursoricon.c.

417{
418 ICONINFO ii;
419 PCURICON_OBJECT CurIcon;
421 BOOL Ret = FALSE;
422 DWORD colorBpp = 0;
423
424 TRACE("Enter NtUserGetIconInfo\n");
425
426 /* Check if something was actually asked */
427 if (!IconInfo && !lpModule && !lpResName)
428 {
429 WARN("Nothing to fill.\n");
431 return FALSE;
432 }
433
435
436 if (!(CurIcon = UserGetCurIconObject(hCurIcon)))
437 {
438 WARN("UserGetIconObject(0x%p) Failed.\n", hCurIcon);
439 UserLeave();
440 return FALSE;
441 }
442
443 /* Give back the icon information */
444 if (IconInfo)
445 {
446 PCURICON_OBJECT FrameCurIcon = CurIcon;
447 if (CurIcon->CURSORF_flags & CURSORF_ACON)
448 {
449 /* Get information from first frame. */
450 FrameCurIcon = ((PACON)CurIcon)->aspcur[0];
451 }
452
453 /* Fill data */
454 ii.fIcon = is_icon(FrameCurIcon);
455 ii.xHotspot = FrameCurIcon->xHotspot;
456 ii.yHotspot = FrameCurIcon->yHotspot;
457
458 /* Copy bitmaps */
459 ii.hbmMask = BITMAP_CopyBitmap(FrameCurIcon->hbmMask);
461 ii.hbmColor = BITMAP_CopyBitmap(FrameCurIcon->hbmColor);
463 colorBpp = FrameCurIcon->bpp;
464
465 /* Copy fields */
467 {
468 ProbeForWrite(IconInfo, sizeof(ICONINFO), 1);
469 RtlCopyMemory(IconInfo, &ii, sizeof(ICONINFO));
470
471 if (pbpp)
472 {
473 ProbeForWrite(pbpp, sizeof(DWORD), 1);
474 *pbpp = colorBpp;
475 }
476 }
478 {
480 }
482
483 if (!NT_SUCCESS(Status))
484 {
485 WARN("Status: 0x%08lx\n", Status);
487 goto leave;
488 }
489 }
490
491 /* Give back the module name */
492 if (lpModule)
493 {
494 ULONG BufLen = 0;
495 if (!CurIcon->atomModName)
496 goto leave;
497
499 /* Get the module name from the atom table */
501 {
502 BufLen += sizeof(WCHAR);
503 if (BufLen > (lpModule->MaximumLength))
504 {
505 lpModule->Length = 0;
506 lpModule->MaximumLength = BufLen;
507 }
508 else
509 {
510 ProbeForWrite(lpModule->Buffer, lpModule->MaximumLength, 1);
511 BufLen = lpModule->MaximumLength;
512 RtlQueryAtomInAtomTable(gAtomTable, CurIcon->atomModName, NULL, NULL, lpModule->Buffer, &BufLen);
513 lpModule->Length = BufLen;
514 }
515 }
517 {
519 }
521
522 if (!NT_SUCCESS(Status))
523 {
525 goto leave;
526 }
527 }
528
529 if (lpResName)
530 {
531 if (!CurIcon->strName.Buffer)
532 goto leave;
533
534 /* Copy it */
536 {
538 if (IS_INTRESOURCE(CurIcon->strName.Buffer))
539 {
540 lpResName->Buffer = CurIcon->strName.Buffer;
541 lpResName->Length = 0;
542 lpResName->MaximumLength = 0;
543 }
544 else if (lpResName->MaximumLength < CurIcon->strName.MaximumLength)
545 {
546 lpResName->Length = 0;
547 lpResName->MaximumLength = CurIcon->strName.MaximumLength;
548 }
549 else
550 {
551 ProbeForWrite(lpResName->Buffer, lpResName->MaximumLength, 1);
552 RtlCopyMemory(lpResName->Buffer, CurIcon->strName.Buffer, CurIcon->strName.Length);
553 lpResName->Length = CurIcon->strName.Length;
554 }
555 }
557 {
559 }
561 }
562
563 if (!NT_SUCCESS(Status))
564 {
566 goto leave;
567 }
568
569 Ret = TRUE;
570
571leave:
572 UserDereferenceObject(CurIcon);
573
574 TRACE("Leave NtUserGetIconInfo, ret=%i\n", Ret);
575 UserLeave();
576
577 return Ret;
578}
LONG NTSTATUS
Definition: precomp.h:26
HBITMAP FASTCALL BITMAP_CopyBitmap(HBITMAP hBitmap)
Definition: bitmaps.c:714
#define WARN(fmt,...)
Definition: debug.h:112
#define leave
Definition: btrfs_drv.h:138
struct tagACON * PACON
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
#define BufLen
Definition: fatfs.h:167
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
Status
Definition: gdiplustypes.h:25
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
_Out_opt_ PICONINFO IconInfo
Definition: ntuser.h:2294
_Out_opt_ PICONINFO _Inout_opt_ PUNICODE_STRING _Inout_opt_ PUNICODE_STRING lpResName
Definition: ntuser.h:2296
_Out_opt_ PICONINFO _Inout_opt_ PUNICODE_STRING _Inout_opt_ PUNICODE_STRING _Out_opt_ LPDWORD pbpp
Definition: ntuser.h:2297
#define CURSORF_ACON
Definition: ntuser.h:1202
NTSYSAPI NTSTATUS NTAPI RtlQueryAtomInAtomTable(_In_ PRTL_ATOM_TABLE AtomTable, _In_ RTL_ATOM Atom, _Out_opt_ PULONG RefCount, _Out_opt_ PULONG PinCount, _Out_opt_z_bytecap_(*NameLength) PWSTR AtomName, _Inout_opt_ PULONG NameLength)
#define GDI_OBJ_HMGR_POWNED
Definition: ntgdihdl.h:117
VOID FASTCALL UserLeave(VOID)
Definition: ntuser.c:251
VOID FASTCALL UserEnterExclusive(VOID)
Definition: ntuser.c:242
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:159
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
#define STATUS_SUCCESS
Definition: shellext.h:65
#define TRACE(s)
Definition: solgame.cpp:4
HBITMAP hbmColor
Definition: cursoricon.h:20
HBITMAP hbmMask
Definition: cursoricon.h:19
UNICODE_STRING strName
Definition: cursoricon.h:13
USHORT atomModName
Definition: cursoricon.h:14
ULONG CURSORF_flags
Definition: cursoricon.h:16
DWORD yHotspot
Definition: winuser.h:3125
BOOL fIcon
Definition: winuser.h:3123
DWORD xHotspot
Definition: winuser.h:3124
HBITMAP hbmColor
Definition: winuser.h:3127
HBITMAP hbmMask
Definition: winuser.h:3126
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
uint32_t ULONG
Definition: typedefs.h:59
VOID FASTCALL SetLastNtError(_In_ NTSTATUS Status)
Definition: error.c:31
BOOL NTAPI GreSetObjectOwner(HGDIOBJ hobj, ULONG ulOwner)
Definition: gdiobj.c:1255
FORCEINLINE BOOL is_icon(PCURICON_OBJECT object)
Definition: cursoricon.c:194
PCURICON_OBJECT FASTCALL UserGetCurIconObject(HCURSOR hCurIcon)
Definition: cursoricon.c:200
BOOL FASTCALL UserDereferenceObject(PVOID Object)
Definition: object.c:644
PRTL_ATOM_TABLE gAtomTable
Definition: session.c:13
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:22
#define IS_INTRESOURCE(i)
Definition: winuser.h:580
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL ( UserIcon  )

◆ FreeCurIconObject()

VOID FreeCurIconObject ( _In_ PVOID  Object)

Definition at line 332 of file cursoricon.c.

334{
335 PCURICON_OBJECT CurIcon = Object;
336
337 if (!(CurIcon->CURSORF_flags & CURSORF_ACON))
338 {
339 HBITMAP bmpMask = CurIcon->hbmMask;
340 HBITMAP bmpColor = CurIcon->hbmColor;
341 HBITMAP bmpAlpha = CurIcon->hbmAlpha;
342
343 /* Delete bitmaps */
344 if (bmpMask)
345 {
347 NT_VERIFY(GreDeleteObject(bmpMask) == TRUE);
348 CurIcon->hbmMask = NULL;
349 }
350 if (bmpColor)
351 {
353 NT_VERIFY(GreDeleteObject(bmpColor) == TRUE);
354 CurIcon->hbmColor = NULL;
355 }
356 if (bmpAlpha)
357 {
359 NT_VERIFY(GreDeleteObject(bmpAlpha) == TRUE);
360 CurIcon->hbmAlpha = NULL;
361 }
362 }
363 else
364 {
365 PACON AniCurIcon = (PACON)CurIcon;
366 UINT i;
367
368 for (i = 0; i < AniCurIcon->cpcur; i++)
369 {
370 UserDereferenceObject(AniCurIcon->aspcur[i]);
372 }
374 }
375
376 if (CurIcon->CURSORF_flags & CURSORF_LRSHARED)
377 {
378 if (!IS_INTRESOURCE(CurIcon->strName.Buffer))
380 if (CurIcon->atomModName)
382 CurIcon->strName.Buffer = NULL;
383 CurIcon->atomModName = 0;
384 }
385
386 /* Finally free the thing */
387 FreeProcMarkObject(CurIcon);
388}
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define CURSORF_LRSHARED
Definition: ntuser.h:1201
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
static HBITMAP
Definition: button.c:44
unsigned int UINT
Definition: ndis.h:50
NTSYSAPI NTSTATUS NTAPI RtlDeleteAtomFromAtomTable(_In_ PRTL_ATOM_TABLE AtomTable, _In_ RTL_ATOM Atom)
#define TAG_STRING
Definition: oslist.h:22
HBITMAP hbmAlpha
Definition: cursoricon.h:21
UINT cpcur
Definition: cursoricon.h:37
PCURICON_OBJECT * aspcur
Definition: cursoricon.h:39
_Must_inspect_result_ _In_ WDFCOLLECTION _In_ WDFOBJECT Object
BOOL NTAPI GreDeleteObject(HGDIOBJ hobj)
Definition: gdiobj.c:1158
BOOLEAN IntDestroyCurIconObject(_In_ PVOID Object)
Definition: cursoricon.c:313
void FreeProcMarkObject(_In_ PVOID Object)
Definition: object.c:175
#define USERTAG_CURSOR
Definition: tags.h:209
#define NT_VERIFY(exp)
Definition: rtlfuncs.h:3287

◆ InitCursorImpl()

BOOL InitCursorImpl ( VOID  )

◆ IntCleanupCurIconCache()

VOID FASTCALL IntCleanupCurIconCache ( PPROCESSINFO  Win32Process)

Definition at line 391 of file cursoricon.c.

392{
393 PCURICON_OBJECT CurIcon;
394
395 /* Run through the list of icon objects */
396 while (Win32Process->pCursorCache)
397 {
398 CurIcon = Win32Process->pCursorCache;
399 Win32Process->pCursorCache = CurIcon->pcurNext;
400 UserDereferenceObject(CurIcon);
401 }
402}
struct _CURICON_OBJECT * pcurNext
Definition: cursoricon.h:12
struct _CURICON_OBJECT * pCursorCache
Definition: win32.h:272

Referenced by UserProcessDestroy().

◆ IntCreateCurIconHandle()

HANDLE IntCreateCurIconHandle ( BOOLEAN  Animated)

Definition at line 281 of file cursoricon.c.

282{
283 PCURICON_OBJECT CurIcon;
284 HANDLE hCurIcon;
285
286 CurIcon = UserCreateObject(
288 NULL,
290 &hCurIcon,
292 Animated ? sizeof(ACON) : sizeof(CURICON_OBJECT));
293
294 if (!CurIcon)
295 {
297 return FALSE;
298 }
299
300 if (Animated)
301 {
302 /* We MUST set this flag, to track whether this is an ACON! */
303 CurIcon->CURSORF_flags |= CURSORF_ACON;
304 }
305
306 NT_ASSERT(CurIcon->pcurNext == NULL);
307 UserDereferenceObject(CurIcon);
308
309 return hCurIcon;
310}
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
struct _THREADINFO * GetW32ThreadInfo(VOID)
Definition: misc.c:805
@ TYPE_CURSOR
Definition: ntuser.h:43
PUSER_HANDLE_TABLE gHandleTable
Definition: object.c:13
PVOID FASTCALL UserCreateObject(PUSER_HANDLE_TABLE ht, PDESKTOP pDesktop, PTHREADINFO pti, HANDLE *h, HANDLE_TYPE type, ULONG size)
Definition: object.c:568
#define NT_ASSERT
Definition: rtlfuncs.h:3310

Referenced by IntSetAconData(), and NtUserCallOneParam().

◆ IntDestroyCurIconObject()

BOOLEAN IntDestroyCurIconObject ( _In_ PVOID  Object)

Definition at line 313 of file cursoricon.c.

315{
316 PCURICON_OBJECT CurIcon = Object;
317
318 /* Check if the cursor is in a list */
319 if (CurIcon->CURSORF_flags & CURSORF_LINKED)
320 {
321 /* Remove the cursor from it's list */
323 }
324
325 /* We just mark the handle as being destroyed.
326 * Deleting all the stuff will be deferred to the actual struct free. */
328 return TRUE;
329}
#define UserHMGetHandle(obj)
Definition: ntuser.h:230
#define CURSORF_LINKED
Definition: ntuser.h:1206
static VOID IntRemoveCursorFromList(_Inout_ PCURICON_OBJECT pcur)
Definition: cursoricon.c:101
BOOL FASTCALL UserDeleteObject(HANDLE h, HANDLE_TYPE type)
Definition: object.c:717

Referenced by FreeCurIconObject(), IntDestroyClass(), IntSetAconData(), NtUserDestroyCursor(), and UserSetClassLongPtr().

◆ IntGetSysCursorInfo()

◆ IntInsertCursorIntoList()

static VOID IntInsertCursorIntoList ( _Inout_ PCURICON_OBJECT  pcur)
static

Definition at line 80 of file cursoricon.c.

82{
83 PPROCESSINFO ppi = pcur->head.ppi;
84 PCURICON_OBJECT *ppcurHead;
85 NT_ASSERT((pcur->CURSORF_flags & (CURSORF_GLOBAL|CURSORF_LRSHARED)) != 0);
86 NT_ASSERT((pcur->CURSORF_flags & CURSORF_LINKED) == 0);
87
88 /* Get the right list head */
89 ppcurHead = (pcur->CURSORF_flags & CURSORF_GLOBAL) ?
90 &gcurFirst : &ppi->pCursorCache;
91
93 pcur->pcurNext = *ppcurHead;
94 *ppcurHead = pcur;
96}
#define CURSORF_GLOBAL
Definition: ntuser.h:1200
PCURICON_OBJECT gcurFirst
Definition: cursoricon.c:27
VOID FASTCALL UserReferenceObject(PVOID obj)
Definition: object.c:731

Referenced by IntLoadSystenIcons(), NtUserSetSystemCursor(), and UserSetCursorIconData().

◆ IntLoadSystenIcons()

VOID IntLoadSystenIcons ( HICON  hcur,
DWORD  id 
)

Definition at line 137 of file cursoricon.c.

138{
139 PCURICON_OBJECT pcur;
140 int i;
141 PPROCESSINFO ppi;
142
143 if (hcur)
144 {
145 pcur = UserGetCurIconObject(hcur);
146 if (!pcur)
147 {
149 return;
150 }
151
153
154 if (!(ppi->W32PF_flags & W32PF_CREATEDWINORDC))
155 return;
156
157 // Set Small Window Icon and do not link.
158 if ( id == OIC_WINLOGO+1 )
159 {
162 pcur->head.ppi = NULL;
163 return;
164 }
165
166 for (i = 0 ; i < 6; i++)
167 {
168 if (gasysico[i].type == id)
169 {
170 gasysico[i].handle = pcur;
172
173 //
174 // The active switch between LR shared and Global public.
175 // This is hacked around to support this while at the initial system start up.
176 //
177 pcur->head.ppi = NULL;
178
180 return;
181 }
182 }
183 }
184}
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
PVOID NTAPI PsGetCurrentProcessWin32Process(VOID)
Definition: process.c:1183
PCURICON_OBJECT handle
Definition: cursoricon.h:99
PROCMARKHEAD head
Definition: cursoricon.h:11
struct _PROCESSINFO * ppi
Definition: ntuser.h:227
#define W32PF_CREATEDWINORDC
Definition: win32.h:34
static VOID IntInsertCursorIntoList(_Inout_ PCURICON_OBJECT pcur)
Definition: cursoricon.c:80
SYSTEMCURICO gasysico[]
Definition: cursoricon.c:54
#define ERROR_INVALID_CURSOR_HANDLE
Definition: winerror.h:883

Referenced by co_IntSetWndIcons().

◆ IntRemoveCursorFromList()

static VOID IntRemoveCursorFromList ( _Inout_ PCURICON_OBJECT  pcur)
static

Definition at line 101 of file cursoricon.c.

103{
104 PPROCESSINFO ppi = pcur->head.ppi;
105 PCURICON_OBJECT *ppcurHead;
106 PCURICON_OBJECT *ppcur;
107 NT_ASSERT((pcur->CURSORF_flags & (CURSORF_GLOBAL|CURSORF_LRSHARED)) != 0);
108 NT_ASSERT((pcur->CURSORF_flags & CURSORF_LINKED) != 0);
109
110 /* Get the right list head */
111 ppcurHead = (pcur->CURSORF_flags & CURSORF_GLOBAL) ?
112 &gcurFirst : &ppi->pCursorCache;
113
114 /* Loop all cursors in the cache */
115 for (ppcur = ppcurHead;
116 (*ppcur) != NULL;
117 ppcur = &(*ppcur)->pcurNext)
118 {
119 /* Check if this is the one we are looking for */
120 if ((*ppcur) == pcur)
121 {
122 /* Remove it from the list */
123 (*ppcur) = pcur->pcurNext;
124
125 /* Dereference it */
127 pcur->CURSORF_flags &= ~CURSORF_LINKED;
128 return;
129 }
130 }
131
132 /* We did not find it, this must not happen */
134}
#define for
Definition: utility.h:88

Referenced by IntDestroyCurIconObject().

◆ IntSetAconData()

static BOOL IntSetAconData ( _Inout_ PACON  pacon,
_In_opt_ PUNICODE_STRING  pustrName,
_In_ ATOM  atomModName,
_In_ const CURSORDATA pcursordata 
)
static

Definition at line 1234 of file cursoricon.c.

1239{
1240 PCURICON_OBJECT *aspcur;
1241 DWORD *aicur;
1242 INT *ajifRate;
1243 PCURSORDATA pcdFrame;
1244 HCURSOR hcurFrame;
1245 UINT cjSize, i;
1246
1247 NT_ASSERT((pacon->CURSORF_flags & CURSORF_ACON) != 0);
1248 NT_ASSERT((pacon->CURSORF_flags & CURSORF_ACONFRAME) == 0);
1249 NT_ASSERT((ULONG_PTR)pcursordata->aspcur > MmUserProbeAddress);
1250 NT_ASSERT((ULONG_PTR)pcursordata->aicur > MmUserProbeAddress);
1251 NT_ASSERT((ULONG_PTR)pcursordata->ajifRate > MmUserProbeAddress);
1252 NT_ASSERT((pcursordata->CURSORF_flags & ~CURSORF_USER_MASK) == 0);
1253 NT_ASSERT(pcursordata->cpcur > 0);
1254 NT_ASSERT(pcursordata->cicur > 0);
1255
1256 /* Check if the CURSORF_ACON is also set in the cursor data */
1257 if (!(pcursordata->CURSORF_flags & CURSORF_ACON))
1258 {
1259 ERR("Mismatch in CURSORF_flags! acon: 0x%08lx, data: 0x%08lx\n",
1260 pacon->CURSORF_flags, pcursordata->CURSORF_flags);
1261 return FALSE;
1262 }
1263
1264 /* Check if this acon was already set */
1265 if (pacon->aspcur != NULL)
1266 {
1267 ERR("Acon data already set!\n");
1268 return FALSE;
1269 }
1270
1271 /* Loop all frames indexes */
1272 for (i = 0; i < pcursordata->cicur; i++)
1273 {
1274 /* Check if the index is within the range of the frames */
1275 if (pcursordata->aicur[i] >= pcursordata->cpcur)
1276 {
1277 ERR("aicur[%lu] is out or range. Got %lu, cpcur = %u\n",
1278 i, pcursordata->aicur[i], pcursordata->cpcur);
1279 return FALSE;
1280 }
1281
1282 /* FIXME: check the JIF rates? */
1283 }
1284
1285 /* Calculate size: one cursor object for each frame, and a frame
1286 index and jiffies for each "step" */
1287 cjSize = (pcursordata->cpcur * sizeof(CURICON_OBJECT*)) +
1288 (pcursordata->cicur * sizeof(DWORD)) +
1289 (pcursordata->cicur * sizeof(INT));
1290
1291 /* Allocate a buffer */
1293 if (aspcur == NULL)
1294 {
1295 ERR("Failed to allocate memory (cpcur = %u, cicur = %u)\n",
1296 pcursordata->cpcur, pcursordata->cicur);
1297 return FALSE;
1298 }
1299
1300 /* Set the pointers */
1301 aicur = (DWORD*)&aspcur[pcursordata->cpcur];
1302 ajifRate = (INT*)&aicur[pcursordata->cicur];
1303
1304 /* Copy the values */
1305 RtlCopyMemory(aicur, pcursordata->aicur, pcursordata->cicur * sizeof(DWORD));
1306 RtlCopyMemory(ajifRate, pcursordata->ajifRate, pcursordata->cicur * sizeof(INT));
1307
1308 /* Zero out the array, so we can handle cleanup */
1309 RtlZeroMemory(aspcur, pcursordata->cpcur * sizeof(PCURICON_OBJECT));
1310
1311 /* Get a pointer to the cursor data for each frame */
1312 pcdFrame = pcursordata->aspcur;
1313
1314 /* Create the cursors */
1315 for (i = 0; i < pcursordata->cpcur; i++)
1316 {
1317 /* Create a cursor for this frame */
1318 hcurFrame = IntCreateCurIconHandle(FALSE);
1319 if (hcurFrame == NULL)
1320 {
1321 ERR("Failed to create a cursor for frame %u\n", i);
1322 goto Cleanup;
1323 }
1324
1325 /* Get a pointer to the frame cursor */
1326 aspcur[i] = UserGetCurIconObject(hcurFrame);
1328 NT_ASSERT(aspcur[i] != NULL);
1329
1330 /* Check if the flags are valid */
1332 {
1333 ERR("Invalid flags for acon frame %u: 0x%08lx\n",
1334 i, pcdFrame->CURSORF_flags);
1335 goto Cleanup;
1336 }
1337
1338 /* Set the cursor data for this frame */
1339 if (!IntSetCursorData(aspcur[i], NULL, 0, &pcdFrame[i]))
1340 {
1341 ERR("Failed to set cursor data for frame %u\n", i);
1342 goto Cleanup;
1343 }
1344
1345 /* Mark this cursor as an acon frame */
1346 aspcur[i]->CURSORF_flags |= CURSORF_ACONFRAME;
1347 }
1348
1349 /* Free the old name (Must be NULL atm.) */
1350 NT_ASSERT(pacon->strName.Buffer == NULL);
1351 if (pacon->strName.Buffer != NULL)
1352 {
1353 if (!IS_INTRESOURCE(pacon->strName.Buffer))
1354 {
1355 ExFreePoolWithTag(pacon->strName.Buffer, TAG_STRING);
1356 }
1357 RtlInitEmptyUnicodeString(&pacon->strName, NULL, 0);
1358 }
1359
1360 /* Free the module atom */
1361 if (pacon->atomModName != 0)
1362 {
1364 }
1365
1366 /* Free the previous frames */
1367 if (pacon->aspcur != NULL)
1368 {
1369 for (i = 0; i < pacon->cpcur; i++)
1370 {
1371 UserDereferenceObject(pacon->aspcur[i]);
1372 NT_VERIFY(IntDestroyCurIconObject(pacon->aspcur[i]) == TRUE);
1373 }
1374 ExFreePoolWithTag(pacon->aspcur, USERTAG_CURSOR);
1375 }
1376
1377 /* Finally set the data in the acon */
1378 pacon->atomModName = atomModName;
1379 pacon->rt = pcursordata->rt;
1380 pacon->CURSORF_flags = pcursordata->CURSORF_flags & CURSORF_USER_MASK;
1381 pacon->cpcur = pcursordata->cpcur;
1382 pacon->cicur = pcursordata->cicur;
1383 pacon->aspcur = aspcur;
1384 pacon->aicur = aicur;
1385 pacon->ajifRate = ajifRate;
1386 pacon->iicur = 0;
1387 if (pustrName != NULL)
1388 {
1389 pacon->strName = *pustrName;
1390 }
1391
1392 return TRUE;
1393
1394Cleanup:
1395
1396 /* Clean up the cursors we created */
1397 for (i = 0; i < pcursordata->cpcur; i++)
1398 {
1399 if (aspcur[i] == NULL)
1400 break;
1401
1402 /* Destroy this cursor */
1403 UserDereferenceObject(aspcur[i]);
1405 }
1406
1407 /* Delete the allocated structure */
1409
1410 return FALSE;
1411}
#define ERR(fmt,...)
Definition: debug.h:110
#define CURSORF_USER_MASK
Definition: cursoricon.h:6
static const WCHAR Cleanup[]
Definition: register.c:80
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define PagedPool
Definition: env_spec_w32.h:308
#define CURSORF_ACONFRAME
Definition: ntuser.h:1204
#define DWORD
Definition: nt_native.h:44
ULONG MmUserProbeAddress
Definition: init.c:50
#define INT
Definition: polytest.cpp:20
ULONG CURSORF_flags
Definition: ntuser.h:1179
struct tagCURSORDATA * aspcur
Definition: ntuser.h:1192
#define __WARNING_READ_OVERRUN
Definition: suppress.h:142
#define _PRAGMA_WARNING_SUPPRESS(x)
Definition: suppress.h:28
int32_t INT
Definition: typedefs.h:58
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
uint32_t ULONG_PTR
Definition: typedefs.h:65
HANDLE IntCreateCurIconHandle(BOOLEAN Animated)
Definition: cursoricon.c:281
static BOOL IntSetCursorData(_Inout_ PCURICON_OBJECT pcur, _In_opt_ PUNICODE_STRING pustrName, _In_ ATOM atomModName, _In_ const CURSORDATA *pcursordata)
Definition: cursoricon.c:1126
_In_ ULONG cjSize
Definition: winddi.h:3634
HICON HCURSOR
Definition: windef.h:299

Referenced by UserSetCursorIconData().

◆ IntSetCursorData()

static BOOL IntSetCursorData ( _Inout_ PCURICON_OBJECT  pcur,
_In_opt_ PUNICODE_STRING  pustrName,
_In_ ATOM  atomModName,
_In_ const CURSORDATA pcursordata 
)
static

Definition at line 1126 of file cursoricon.c.

1131{
1132 /* Check if the CURSORF_ACON is also set in the cursor data */
1133 if (pcursordata->CURSORF_flags & CURSORF_ACON)
1134 {
1135 ERR("Mismatch in CURSORF_flags! cursor: 0x%08lx, data: 0x%08lx\n",
1136 pcur->CURSORF_flags, pcursordata->CURSORF_flags);
1137 return FALSE;
1138 }
1139
1140 /* Check if this cursor was already set */
1141 if (pcur->hbmMask != NULL)
1142 {
1143 ERR("Cursor data already set!\n");
1144 return FALSE;
1145 }
1146
1147 /* We need a mask */
1148 if (pcursordata->hbmMask == NULL)
1149 {
1150 ERR("NtUserSetCursorIconData was got no hbmMask.\n");
1152 return FALSE;
1153 }
1154
1155 /* Take ownership of the mask bitmap */
1156 if (!GreSetBitmapOwner(pcursordata->hbmMask, GDI_OBJ_HMGR_PUBLIC))
1157 {
1158 ERR("Failed to set ownership of hbmMask %p.\n", pcursordata->hbmMask);
1159 return FALSE;
1160 }
1161
1162 /* Check if we have a color bitmap */
1163 if (pcursordata->hbmColor)
1164 {
1165 /* Take ownership of the color bitmap */
1166 if (!GreSetBitmapOwner(pcursordata->hbmColor, GDI_OBJ_HMGR_PUBLIC))
1167 {
1168 ERR("Failed to set ownership of hbmColor %p.\n", pcursordata->hbmColor);
1169 GreSetBitmapOwner(pcursordata->hbmMask, GDI_OBJ_HMGR_POWNED);
1170 return FALSE;
1171 }
1172 }
1173
1174 /* Check if we have an alpha bitmap */
1175 if (pcursordata->hbmAlpha)
1176 {
1177 /* Take ownership of the alpha bitmap */
1178 if (!GreSetBitmapOwner(pcursordata->hbmAlpha, GDI_OBJ_HMGR_PUBLIC))
1179 {
1180 ERR("Failed to set ownership of hbmAlpha %p.\n", pcursordata->hbmAlpha);
1181 GreSetBitmapOwner(pcursordata->hbmMask, GDI_OBJ_HMGR_POWNED);
1182 if (pcursordata->hbmColor)
1183 {
1184 GreSetBitmapOwner(pcursordata->hbmColor, GDI_OBJ_HMGR_POWNED);
1185 }
1186 return FALSE;
1187 }
1188 }
1189
1190 /* Free the old name (Must be NULL atm, but later we might allow this) */
1191 NT_ASSERT(pcur->strName.Buffer == NULL);
1192 if (pcur->strName.Buffer != NULL)
1193 {
1194 if (!IS_INTRESOURCE(pcur->strName.Buffer))
1195 {
1196 ExFreePoolWithTag(pcur->strName.Buffer, TAG_STRING);
1197 }
1198 RtlInitEmptyUnicodeString(&pcur->strName, NULL, 0);
1199 }
1200
1201 /* Free the module atom */
1202 if (pcur->atomModName != 0)
1203 {
1205 }
1206
1207 /* Now set the new cursor data */
1208 pcur->atomModName = atomModName;
1209 pcur->rt = pcursordata->rt;
1210 pcur->CURSORF_flags = pcursordata->CURSORF_flags & CURSORF_USER_MASK;
1211 pcur->xHotspot = pcursordata->xHotspot;
1212 pcur->yHotspot = pcursordata->yHotspot;
1213 pcur->hbmMask = pcursordata->hbmMask;
1214 pcur->hbmColor = pcursordata->hbmColor;
1215 pcur->hbmAlpha = pcursordata->hbmAlpha;
1216 pcur->rcBounds.left = 0;
1217 pcur->rcBounds.top = 0;
1218 pcur->rcBounds.right = pcursordata->cx;
1219 pcur->rcBounds.bottom = pcursordata->cy;
1220 pcur->hbmUserAlpha = pcursordata->hbmUserAlpha;
1221 pcur->bpp = pcursordata->bpp;
1222 pcur->cx = pcursordata->cx;
1223 pcur->cy = pcursordata->cy;
1224 if (pustrName != NULL)
1225 {
1226 pcur->strName = *pustrName;
1227 }
1228
1229 return TRUE;
1230}
BOOL NTAPI GreSetBitmapOwner(_In_ HBITMAP hbmp, _In_ ULONG ulOwner)
Definition: bitmaps.c:17
#define GDI_OBJ_HMGR_PUBLIC
Definition: ntgdihdl.h:116

Referenced by IntSetAconData(), and UserSetCursorIconData().

◆ IntSystemSetCursor()

PCURICON_OBJECT IntSystemSetCursor ( PCURICON_OBJECT  pcurNew)

Definition at line 230 of file cursoricon.c.

231{
232 PCURICON_OBJECT pcurOld = UserSetCursor(pcurNew, FALSE);
233 if (pcurNew) UserReferenceObject(pcurNew);
234 if (pcurOld) UserDereferenceObject(pcurOld);
235 return pcurOld;
236}
PCURICON_OBJECT FASTCALL UserSetCursor(PCURICON_OBJECT NewCursor, BOOL ForceChange)
Definition: msgqueue.c:93

Referenced by co_IntProcessMouseMessage(), and DefWndHandleSetCursor().

◆ is_icon()

FORCEINLINE BOOL is_icon ( PCURICON_OBJECT  object)

Definition at line 194 of file cursoricon.c.

195{
196 return MAKEINTRESOURCE(object->rt) == RT_ICON;
197}
#define RT_ICON
Definition: pedump.c:365
#define MAKEINTRESOURCE
Definition: winuser.h:591

Referenced by _Success_(), LISTVIEW_DeleteItem(), NtUserFindExistingCursorIcon(), and UserDrawIconEx().

◆ NtUserClipCursor()

BOOL APIENTRY NtUserClipCursor ( RECTL prcl)

Definition at line 749 of file cursoricon.c.

751{
752 RECTL rclLocal;
753 BOOL bResult;
754
755 if (prcl)
756 {
758 {
759 /* Probe and copy rect */
760 ProbeForRead(prcl, sizeof(RECTL), 1);
761 rclLocal = *prcl;
762 }
764 {
766 _SEH2_YIELD(return FALSE;)
767 }
769
770 prcl = &rclLocal;
771 }
772
774
775 /* Call the internal function */
776 bResult = UserClipCursor(prcl);
777
778 UserLeave();
779
780 return bResult;
781}
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:162
BOOL APIENTRY UserClipCursor(RECTL *prcl)
Definition: cursoricon.c:696
_In_ ULONG _In_ CLIPOBJ _In_ RECTL * prcl
Definition: winddi.h:3531

◆ NtUserDestroyCursor()

BOOL APIENTRY NtUserDestroyCursor ( _In_ HANDLE  hCurIcon,
_In_ BOOL  bForce 
)

Definition at line 789 of file cursoricon.c.

792{
793 BOOL ret;
794 PCURICON_OBJECT CurIcon = NULL;
795
796 TRACE("Enter NtUserDestroyCursorIcon (%p, %i)\n", hCurIcon, bForce);
798
799 CurIcon = UserGetCurIconObject(hCurIcon);
800 if (!CurIcon)
801 {
802 ret = FALSE;
803 goto leave;
804 }
805
806 if (!bForce)
807 {
808 /* Can not destroy global objects */
809 if (CurIcon->head.ppi == NULL)
810 {
811 ERR("Trying to delete global cursor!\n");
812 ret = TRUE;
813 goto leave;
814 }
815
816 /* Maybe we have good reasons not to destroy this object */
817 if (CurIcon->head.ppi != PsGetCurrentProcessWin32Process())
818 {
819 /* No way, you're not touching my cursor */
820 ret = FALSE;
821 goto leave;
822 }
823
824 if (CurIcon->CURSORF_flags & CURSORF_CURRENT)
825 {
826 WARN("Trying to delete current cursor!\n");
827 ret = FALSE;
828 goto leave;
829 }
830
831 if (CurIcon->CURSORF_flags & CURSORF_LRSHARED)
832 {
833 WARN("Trying to delete shared cursor.\n");
834 /* This one is not an error */
835 ret = TRUE;
836 goto leave;
837 }
838 }
839
840 /* Destroy the handle */
841 ret = IntDestroyCurIconObject(CurIcon);
842
843leave:
844 if (CurIcon)
845 UserDereferenceObject(CurIcon);
846 TRACE("Leave NtUserDestroyCursorIcon, ret=%i\n", ret);
847 UserLeave();
848 return ret;
849}
#define CURSORF_CURRENT
Definition: ntuser.h:1207
int ret

Referenced by CreateIconFromResourceEx(), CreateIconIndirect(), CURSORICON_CopyImage(), CURSORICON_LoadFromFileW(), CURSORICON_LoadImageW(), DestroyCursor(), DestroyIcon(), START_TEST(), and Test_OneParamRoutine_CreateEmptyCurObject().

◆ NtUserDrawIconEx()

BOOL APIENTRY NtUserDrawIconEx ( HDC  hdc,
int  xLeft,
int  yTop,
HICON  hIcon,
int  cxWidth,
int  cyHeight,
UINT  istepIfAniCur,
HBRUSH  hbrFlickerFreeDraw,
UINT  diFlags,
BOOL  bMetaHDC,
PVOID  pDIXData 
)

Definition at line 2080 of file cursoricon.c.

2092{
2093 PCURICON_OBJECT pIcon;
2094 BOOL Ret;
2095
2096 TRACE("Enter NtUserDrawIconEx\n");
2098
2099 if (!(pIcon = UserGetCurIconObject(hIcon)))
2100 {
2101 ERR("UserGetCurIconObject(0x%p) failed!\n", hIcon);
2102 UserLeave();
2103 return FALSE;
2104 }
2105
2106 Ret = UserDrawIconEx(hdc,
2107 xLeft,
2108 yTop,
2109 pIcon,
2110 cxWidth,
2111 cyHeight,
2112 istepIfAniCur,
2113 hbrFlickerFreeDraw,
2114 diFlags);
2115
2116 UserDereferenceObject(pIcon);
2117
2118 UserLeave();
2119 return Ret;
2120}
HDC hdc
Definition: main.c:9
HICON hIcon
Definition: msconfig.c:44
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

Referenced by DrawIconEx().

◆ NtUserFindExistingCursorIcon()

HICON NTAPI NtUserFindExistingCursorIcon ( _In_ PUNICODE_STRING  pustrModule,
_In_ PUNICODE_STRING  pustrRsrc,
_In_ FINDEXISTINGCURICONPARAM param 
)

Definition at line 857 of file cursoricon.c.

861{
862 PCURICON_OBJECT CurIcon;
863 HICON Ret = NULL;
864 UNICODE_STRING ustrModuleSafe, ustrRsrcSafe;
865 FINDEXISTINGCURICONPARAM paramSafe;
868 RTL_ATOM atomModName;
869
870 TRACE("Enter NtUserFindExistingCursorIcon\n");
871
873 {
874 ProbeForRead(param, sizeof(*param), 1);
875 RtlCopyMemory(&paramSafe, param, sizeof(paramSafe));
876 }
878 {
880 }
882
883 /* Capture resource name (it can be an INTRESOURCE == ATOM) */
884 Status = ProbeAndCaptureUnicodeStringOrAtom(&ustrRsrcSafe, pustrRsrc);
885 if (!NT_SUCCESS(Status))
886 return NULL;
887 Status = ProbeAndCaptureUnicodeString(&ustrModuleSafe, UserMode, pustrModule);
888 if (!NT_SUCCESS(Status))
889 goto done;
890 Status = RtlLookupAtomInAtomTable(gAtomTable, ustrModuleSafe.Buffer, &atomModName);
891 ReleaseCapturedUnicodeString(&ustrModuleSafe, UserMode);
892 if (!NT_SUCCESS(Status))
893 {
894 /* The module is not in the atom table. No chance to find the cursor */
895 goto done;
896 }
897
899 CurIcon = pProcInfo->pCursorCache;
900 while (CurIcon)
901 {
902 /* Icon/cursor */
903 if (paramSafe.bIcon != is_icon(CurIcon))
904 {
905 CurIcon = CurIcon->pcurNext;
906 continue;
907 }
908 /* See if module names match */
909 if (atomModName == CurIcon->atomModName)
910 {
911 /* They do. Now see if this is the same resource */
912 if (IS_INTRESOURCE(CurIcon->strName.Buffer) != IS_INTRESOURCE(ustrRsrcSafe.Buffer))
913 {
914 /* One is an INT resource and the other is not -> no match */
915 CurIcon = CurIcon->pcurNext;
916 continue;
917 }
918
919 if (IS_INTRESOURCE(CurIcon->strName.Buffer))
920 {
921 if (CurIcon->strName.Buffer == ustrRsrcSafe.Buffer)
922 {
923 /* INT resources match */
924 break;
925 }
926 }
927 else if (RtlCompareUnicodeString(&ustrRsrcSafe, &CurIcon->strName, TRUE) == 0)
928 {
929 /* Resource name strings match */
930 break;
931 }
932 }
933 CurIcon = CurIcon->pcurNext;
934 }
935
936 /* Now search Global Cursors or Icons. */
937 if (CurIcon == NULL)
938 {
939 CurIcon = gcurFirst;
940 while (CurIcon)
941 {
942 /* Icon/cursor */
943 if (paramSafe.bIcon != is_icon(CurIcon))
944 {
945 CurIcon = CurIcon->pcurNext;
946 continue;
947 }
948 /* See if module names match */
949 if (atomModName == CurIcon->atomModName)
950 {
951 /* They do. Now see if this is the same resource */
952 if (IS_INTRESOURCE(CurIcon->strName.Buffer) != IS_INTRESOURCE(ustrRsrcSafe.Buffer))
953 {
954 /* One is an INT resource and the other is not -> no match */
955 CurIcon = CurIcon->pcurNext;
956 continue;
957 }
958 if (IS_INTRESOURCE(CurIcon->strName.Buffer))
959 {
960 if (CurIcon->strName.Buffer == ustrRsrcSafe.Buffer)
961 {
962 /* INT resources match */
963 break;
964 }
965 }
966 else if (RtlCompareUnicodeString(&ustrRsrcSafe, &CurIcon->strName, TRUE) == 0)
967 {
968 /* Resource name strings match */
969 break;
970 }
971 }
972 CurIcon = CurIcon->pcurNext;
973 }
974 }
975 if (CurIcon)
976 Ret = UserHMGetHandle(CurIcon);
977 UserLeave();
978
979done:
980 if (!IS_INTRESOURCE(ustrRsrcSafe.Buffer))
981 ExFreePoolWithTag(ustrRsrcSafe.Buffer, TAG_STRING);
982
983 return Ret;
984}
ULONG RtlCompareUnicodeString(PUNICODE_STRING s1, PUNICODE_STRING s2, BOOLEAN UpCase)
Definition: string_lib.cpp:31
GLfloat param
Definition: glext.h:5796
static HICON
Definition: imagelist.c:84
unsigned short RTL_ATOM
Definition: atom.c:42
#define UserMode
Definition: asm.h:35
NTSYSAPI NTSTATUS NTAPI RtlLookupAtomInAtomTable(_In_ PRTL_ATOM_TABLE AtomTable, _In_ PWSTR AtomName, _Out_ PRTL_ATOM Atom)
VOID FASTCALL UserEnterShared(VOID)
Definition: ntuser.c:235
static __inline NTSTATUS ProbeAndCaptureUnicodeString(OUT PUNICODE_STRING Dest, IN KPROCESSOR_MODE CurrentMode, IN const UNICODE_STRING *UnsafeSrc)
Definition: probe.h:142
static __inline VOID ReleaseCapturedUnicodeString(IN PUNICODE_STRING CapturedString, IN KPROCESSOR_MODE CurrentMode)
Definition: probe.h:239
_Must_inspect_result_ NTSTATUS NTAPI ProbeAndCaptureUnicodeStringOrAtom(_Out_ _When_(return >=0, _At_(pustrOut->Buffer, _Post_ _Notnull_)) PUNICODE_STRING pustrOut, __in_data_source(USER_MODE) _In_ PUNICODE_STRING pustrUnsafe)
Definition: class.c:150

Referenced by CURSORICON_LoadImageW().

◆ NtUserGetClipCursor()

BOOL APIENTRY NtUserGetClipCursor ( RECTL lpRect)

Definition at line 992 of file cursoricon.c.

994{
995 PSYSTEM_CURSORINFO CurInfo;
996 RECTL Rect;
998 BOOL Ret = FALSE;
999
1000 TRACE("Enter NtUserGetClipCursor\n");
1002
1004 {
1005 goto Exit; // Return FALSE
1006 }
1007
1008 if (!lpRect)
1009 goto Exit; // Return FALSE
1010
1011 CurInfo = IntGetSysCursorInfo();
1012 if (CurInfo->bClipped)
1013 {
1014 Rect = CurInfo->rcClip;
1015 }
1016 else
1017 {
1018 Rect.left = 0;
1019 Rect.top = 0;
1022 }
1023
1024 Status = MmCopyToCaller(lpRect, &Rect, sizeof(RECT));
1025 if (!NT_SUCCESS(Status))
1026 {
1028 goto Exit; // Return FALSE
1029 }
1030
1031 Ret = TRUE;
1032
1033Exit:
1034 TRACE("Leave NtUserGetClipCursor, ret=%i\n", Ret);
1035 UserLeave();
1036 return Ret;
1037}
#define MmCopyToCaller(x, y, z)
Definition: mmcopy.h:19
BOOL FASTCALL CheckWinstaAttributeAccess(ACCESS_MASK DesiredAccess)
Definition: winsta.c:377
static void Exit(void)
Definition: sock.c:1330
PSYSTEM_CURSORINFO IntGetSysCursorInfo(VOID)
Definition: cursoricon.c:187
LONG NTAPI UserGetSystemMetrics(ULONG Index)
Definition: metric.c:213
#define SM_CYSCREEN
Definition: winuser.h:960
#define WINSTA_READATTRIBUTES
Definition: winuser.h:414
#define SM_CXSCREEN
Definition: winuser.h:959

◆ NtUserGetCursorFrameInfo()

HCURSOR NTAPI NtUserGetCursorFrameInfo ( HCURSOR  hCursor,
DWORD  istep,
INT rate_jiffies,
DWORD num_steps 
)

Definition at line 2127 of file cursoricon.c.

2132{
2133 PCURICON_OBJECT CurIcon;
2134 HCURSOR ret;
2135 INT jiffies = 0;
2136 DWORD steps = 1;
2138
2139 TRACE("Enter NtUserGetCursorFrameInfo\n");
2141
2142 if (!(CurIcon = UserGetCurIconObject(hCursor)))
2143 {
2144 UserLeave();
2145 return NULL;
2146 }
2147
2148 ret = UserHMGetHandle(CurIcon);
2149
2150 if (CurIcon->CURSORF_flags & CURSORF_ACON)
2151 {
2152 PACON AniCurIcon = (PACON)CurIcon;
2153 if (istep >= AniCurIcon->cicur)
2154 {
2155 UserDereferenceObject(CurIcon);
2156 UserLeave();
2157 return NULL;
2158 }
2159 jiffies = AniCurIcon->ajifRate[istep];
2160 steps = AniCurIcon->cicur;
2161 ret = UserHMGetHandle(AniCurIcon->aspcur[AniCurIcon->aicur[istep]]);
2162 }
2163
2164 _SEH2_TRY
2165 {
2166 ProbeForWrite(rate_jiffies, sizeof(INT), 1);
2167 ProbeForWrite(num_steps, sizeof(DWORD), 1);
2168 *rate_jiffies = jiffies;
2169 *num_steps = steps;
2170 }
2172 {
2174 }
2175 _SEH2_END
2176
2177 if (!NT_SUCCESS(Status))
2178 {
2179 WARN("Status: 0x%08lx\n", Status);
2181 ret = NULL;
2182 }
2183
2184 UserDereferenceObject(CurIcon);
2185 UserLeave();
2186
2187 TRACE("Leaving NtUserGetCursorFrameInfo, ret = 0x%p\n", ret);
2188
2189 return ret;
2190}
#define jiffies
Definition: module.h:1085
static DWORD DWORD DWORD DWORD * steps
Definition: cursoricon.c:1638
static DWORD DWORD istep
Definition: cursoricon.c:1638
UINT cicur
Definition: cursoricon.h:38
DWORD * aicur
Definition: cursoricon.h:40
INT * ajifRate
Definition: cursoricon.h:41

Referenced by GetCursorFrameInfo().

◆ NtUserGetCursorInfo()

BOOL APIENTRY NtUserGetCursorInfo ( PCURSORINFO  pci)

Definition at line 645 of file cursoricon.c.

647{
648 CURSORINFO SafeCi;
649 PSYSTEM_CURSORINFO CurInfo;
651 PCURICON_OBJECT CurIcon;
652 BOOL Ret = FALSE;
653
654 TRACE("Enter NtUserGetCursorInfo\n");
656
657 CurInfo = IntGetSysCursorInfo();
658 CurIcon = (PCURICON_OBJECT)CurInfo->CurrentCursorObject;
659
660 SafeCi.cbSize = sizeof(CURSORINFO);
661 SafeCi.flags = ((CurIcon && CurInfo->ShowingCursor >= 0) ? CURSOR_SHOWING : 0);
662 SafeCi.hCursor = (CurIcon ? UserHMGetHandle(CurIcon) : NULL);
663
664 SafeCi.ptScreenPos = gpsi->ptCursor;
665
667 {
668 if (pci->cbSize == sizeof(CURSORINFO))
669 {
670 ProbeForWrite(pci, sizeof(CURSORINFO), 1);
671 RtlCopyMemory(pci, &SafeCi, sizeof(CURSORINFO));
672 Ret = TRUE;
673 }
674 else
675 {
677 }
678 }
680 {
682 }
683 _SEH2_END;
684 if (!NT_SUCCESS(Status))
685 {
687 }
688
689 TRACE("Leave NtUserGetCursorInfo, ret=%i\n", Ret);
690 UserLeave();
691 return Ret;
692}
struct _CURICON_OBJECT * PCURICON_OBJECT
PSERVERINFO gpsi
Definition: imm.c:18
DWORD flags
Definition: winuser.h:3720
DWORD cbSize
Definition: winuser.h:3719
HCURSOR hCursor
Definition: winuser.h:3721
POINT ptScreenPos
Definition: winuser.h:3722
#define CURSOR_SHOWING
Definition: winuser.h:2658

Referenced by GetCursorInfo().

◆ NtUserGetIconSize()

BOOL APIENTRY NtUserGetIconSize ( HANDLE  hCurIcon,
UINT  istepIfAniCur,
PLONG  plcx,
PLONG  plcy 
)

Definition at line 586 of file cursoricon.c.

591{
592 PCURICON_OBJECT CurIcon;
594 BOOL bRet = FALSE;
595
596 TRACE("Enter NtUserGetIconSize\n");
598
599 if (!(CurIcon = UserGetCurIconObject(hCurIcon)))
600 {
601 goto cleanup;
602 }
603
604 if (CurIcon->CURSORF_flags & CURSORF_ACON)
605 {
606 /* Use first frame for animated cursors */
607 PACON AniCurIcon = (PACON)CurIcon;
608 CurIcon = AniCurIcon->aspcur[0];
609 UserDereferenceObject(AniCurIcon);
610 UserReferenceObject(CurIcon);
611 }
612
614 {
615 ProbeForWrite(plcx, sizeof(LONG), 1);
616 *plcx = CurIcon->cx;
617 ProbeForWrite(plcy, sizeof(LONG), 1);
618 *plcy = CurIcon->cy;
619 }
621 {
623 }
625
626 if (NT_SUCCESS(Status))
627 bRet = TRUE;
628 else
629 SetLastNtError(Status); // Maybe not, test this
630
631 UserDereferenceObject(CurIcon);
632
633cleanup:
634 TRACE("Leave NtUserGetIconSize, ret=%i\n", bRet);
635 UserLeave();
636 return bRet;
637}
static void cleanup(void)
Definition: main.c:1335
long LONG
Definition: pedump.c:60

Referenced by get_icon_size().

◆ NtUserSetCursor()

HCURSOR APIENTRY NtUserSetCursor ( HCURSOR  hCursor)

Definition at line 1045 of file cursoricon.c.

1047{
1048 PCURICON_OBJECT pcurOld, pcurNew;
1049 HCURSOR hOldCursor = NULL;
1050
1051 TRACE("Enter NtUserSetCursor: %p\n", hCursor);
1053
1054 if (hCursor)
1055 {
1056 pcurNew = UserGetCurIconObject(hCursor);
1057 if (!pcurNew)
1058 {
1060 goto leave;
1061 }
1062 pcurNew->CURSORF_flags |= CURSORF_CURRENT;
1063 }
1064 else
1065 {
1066 pcurNew = NULL;
1067 }
1068
1069 pcurOld = UserSetCursor(pcurNew, FALSE);
1070
1071 // If returning an old cursor than validate it, Justin Case!
1072 if ( pcurOld &&
1074 {
1075 hOldCursor = UserHMGetHandle(pcurOld);
1076 /*
1077 Problem:
1078
1079 System Global Cursors start out having at least 2 lock counts. If a system
1080 cursor is the default cursor and is returned to the caller twice in its
1081 life, the count will reach zero. Causing an assert to occur in objects.
1082
1083 This fixes a SeaMonkey crash while the mouse crosses a boundary.
1084 */
1085 if (pcurOld->CURSORF_flags & CURSORF_GLOBAL)
1086 {
1087 TRACE("Returning Global Cursor hcur %p\n",hOldCursor);
1088
1089 /*if (pcurOld->head.cLockObj > 2) // Throttle down to 2.
1090 {
1091 UserDereferenceObject(pcurOld);
1092 }
1093
1094 goto leave;*/
1095 }
1096
1097 /* See if it was destroyed in the meantime */
1098 if (UserObjectInDestroy(hOldCursor))
1099 hOldCursor = NULL;
1100 pcurOld->CURSORF_flags &= ~CURSORF_CURRENT;
1101 UserDereferenceObject(pcurOld);
1102 }
1103
1104leave:
1105 UserLeave();
1106 return hOldCursor;
1107}
BOOL FASTCALL UserObjectInDestroy(HANDLE h)
Definition: object.c:703
PVOID UserGetObjectNoErr(PUSER_HANDLE_TABLE ht, HANDLE handle, HANDLE_TYPE type)
Definition: object.c:481

Referenced by SetCursor().

◆ NtUserSetCursorContents()

BOOL APIENTRY NtUserSetCursorContents ( HANDLE  hCurIcon,
PICONINFO  UnsafeIconInfo 
)

Definition at line 1115 of file cursoricon.c.

1118{
1119 FIXME(" is UNIMPLEMENTED.\n");
1120 return FALSE;
1121}
#define FIXME(fmt,...)
Definition: debug.h:111

◆ NtUserSetCursorIconData()

__kernel_entry BOOL APIENTRY NtUserSetCursorIconData ( _In_ HCURSOR  hcursor,
_In_opt_ PUNICODE_STRING  pustrModule,
_In_opt_ PUNICODE_STRING  pustrRsrc,
_In_ const CURSORDATA pCursorData 
)

Definition at line 1506 of file cursoricon.c.

1511{
1512 CURSORDATA cursordata;
1513 UNICODE_STRING ustrModule, ustrRsrc;
1514 _SEH2_VOLATILE PVOID pvBuffer;
1515 CURSORDATA* aspcur;
1516 DWORD* aicur;
1517 PINT ajifRate;
1518 UINT cjSize;
1520 BOOL bResult = FALSE;
1521
1522 TRACE("Enter NtUserSetCursorIconData\n");
1523
1524 /* Initialize buffer, so we can handle cleanup */
1525 ustrRsrc.Buffer = NULL;
1526 ustrModule.Buffer = NULL;
1527 pvBuffer = NULL;
1528
1529 _SEH2_TRY
1530 {
1531 /* Probe and capture the cursor data structure */
1532 ProbeForRead(pCursorData, sizeof(*pCursorData), 1);
1533 cursordata = *pCursorData;
1534
1535 /* Check if this is an animated cursor */
1536 if (cursordata.CURSORF_flags & CURSORF_ACON)
1537 {
1538 /* Check of the range is ok */
1539 if ((cursordata.cpcur == 0) || (cursordata.cicur == 0) ||
1540 (cursordata.cpcur > 1000) || (cursordata.cicur > 1000))
1541 {
1542 ERR("Range error (cpcur = %u, cicur = %u)\n",
1543 cursordata.cpcur, cursordata.cicur);
1544 goto Exit;
1545 }
1546
1547 /* Calculate size: one cursor data structure for each frame,
1548 and a frame index and jiffies for each "step" */
1549 cjSize = (cursordata.cpcur * sizeof(CURSORDATA)) +
1550 (cursordata.cicur * sizeof(DWORD)) +
1551 (cursordata.cicur * sizeof(INT));
1552
1553 /* Allocate a buffer */
1555 if (pvBuffer == NULL)
1556 {
1557 ERR("Failed to allocate memory (cpcur = %u, cicur = %u)\n",
1558 cursordata.cpcur, cursordata.cicur);
1559 goto Exit;
1560 }
1561
1562 /* Calculate the kernel mode pointers */
1563 aspcur = (CURSORDATA*)pvBuffer;
1564 aicur = (DWORD*)&aspcur[cursordata.cpcur];
1565 ajifRate = (INT*)&aicur[cursordata.cicur];
1566
1567 /* Probe and copy aspcur */
1568 ProbeForRead(cursordata.aspcur, cursordata.cpcur * sizeof(CURSORDATA), 1);
1569 RtlCopyMemory(aspcur,
1570 cursordata.aspcur,
1571 cursordata.cpcur * sizeof(CURSORDATA));
1572
1573 /* Probe and copy aicur */
1574 ProbeForRead(cursordata.aicur, cursordata.cicur * sizeof(DWORD), 1);
1575 RtlCopyMemory(aicur,
1576 cursordata.aicur,
1577 cursordata.cicur * sizeof(DWORD));
1578
1579 /* Probe and copy ajifRate */
1580 ProbeForRead(cursordata.ajifRate, cursordata.cicur * sizeof(INT), 1);
1581 RtlCopyMemory(ajifRate,
1582 cursordata.ajifRate,
1583 cursordata.cicur * sizeof(INT));
1584
1585 /* Set the new pointers */
1586 cursordata.aspcur = aspcur;
1587 cursordata.aicur = aicur;
1588 cursordata.ajifRate = ajifRate;
1589 }
1590 else
1591 {
1592 /* This is a standard cursor, we don't use the pointers */
1593 cursordata.aspcur = NULL;
1594 cursordata.aicur = NULL;
1595 cursordata.ajifRate = NULL;
1596 }
1597 }
1599 {
1601 goto Exit;
1602 }
1603 _SEH2_END
1604
1605 /* Check if we got a module name */
1606 if (pustrModule != NULL)
1607 {
1608 /* Capture the name */
1609 status = ProbeAndCaptureUnicodeString(&ustrModule, UserMode, pustrModule);
1610 if (!NT_SUCCESS(status))
1611 {
1612 ERR("Failed to copy pustrModule: status 0x%08lx\n", status);
1613 goto Exit;
1614 }
1615 }
1616
1617 /* Check if we got a resource name */
1618 if (pustrRsrc != NULL)
1619 {
1620 /* We use this function, because INTRESOURCEs and ATOMs are the same */
1621 status = ProbeAndCaptureUnicodeStringOrAtom(&ustrRsrc, pustrRsrc);
1622 if (!NT_SUCCESS(status))
1623 {
1624 ERR("Failed to copy pustrRsrc: status 0x%08lx\n", status);
1625 goto Exit;
1626 }
1627 }
1628
1629 /* Make sure the caller doesn't give us invalid flags */
1630 if (cursordata.CURSORF_flags & ~CURSORF_USER_MASK)
1631 {
1632 ERR("Invalid cursor flags: 0x%08lx\n", cursordata.CURSORF_flags);
1633 goto Exit;
1634 }
1635
1636 /* Acquire the global user lock */
1638
1639 /* Call the internal function */
1640 bResult = UserSetCursorIconData(hcursor,
1641 pustrModule ? &ustrModule : NULL,
1642 pustrRsrc ? &ustrRsrc : NULL,
1643 &cursordata);
1644
1645 /* Release the global user lock */
1646 UserLeave();
1647
1648Exit:
1649
1650 /* Free the captured module name */
1651 if ((ustrModule.Buffer != NULL) && !IS_INTRESOURCE(ustrModule.Buffer))
1652 {
1654 }
1655
1656 if (pvBuffer != NULL)
1657 {
1659 }
1660
1661 /* Additional cleanup on failure */
1662 if (bResult == FALSE)
1663 {
1664 if ((ustrRsrc.Buffer != NULL) &&
1665 !IS_INTRESOURCE(ustrRsrc.Buffer))
1666 {
1668 }
1669 }
1670
1671 TRACE("Leave NtUserSetCursorIconData, bResult = %i\n", bResult);
1672
1673 return bResult;
1674}
struct tagCURSORDATA CURSORDATA
#define _SEH2_VOLATILE
Definition: pseh2_64.h:163
Definition: ps.c:97
DWORD * aicur
Definition: ntuser.h:1193
INT * ajifRate
Definition: ntuser.h:1194
UINT cpcur
Definition: ntuser.h:1190
UINT cicur
Definition: ntuser.h:1191
BOOL APIENTRY UserSetCursorIconData(_In_ HCURSOR hcursor, _In_opt_ PUNICODE_STRING pustrModule, _In_opt_ PUNICODE_STRING pustrRsrc, _In_ PCURSORDATA pcursordata)
Definition: cursoricon.c:1415
int * PINT
Definition: windef.h:177

Referenced by CreateIconFromResourceEx(), CreateIconIndirect(), CURSORICON_CopyImage(), CURSORICON_LoadFromFileW(), and CURSORICON_LoadImageW().

◆ NtUserSetSystemCursor()

BOOL APIENTRY NtUserSetSystemCursor ( HCURSOR  hcur,
DWORD  id 
)

Definition at line 2197 of file cursoricon.c.

2200{
2201 PCURICON_OBJECT pcur, pcurOrig = NULL;
2202 int i;
2203 PPROCESSINFO ppi;
2204 BOOL Ret = FALSE;
2206
2208 {
2209 goto Exit;
2210 }
2211
2212 if (hcur)
2213 {
2214 pcur = UserGetCurIconObject(hcur);
2215 if (!pcur)
2216 {
2218 goto Exit;
2219 }
2220
2222
2223 for (i = 0 ; i < 16; i++)
2224 {
2225 if (gasyscur[i].type == id)
2226 {
2227 pcurOrig = gasyscur[i].handle;
2228
2229 if (pcurOrig) break;
2230
2231 if (ppi->W32PF_flags & W32PF_CREATEDWINORDC)
2232 {
2233 gasyscur[i].handle = pcur;
2235 pcur->head.ppi = NULL;
2237 Ret = TRUE;
2238 }
2239 break;
2240 }
2241 }
2242 if (pcurOrig)
2243 {
2244 FIXME("Need to copy cursor data or do something! pcurOrig %p new pcur %p\n",pcurOrig,pcur);
2245 }
2246 }
2247Exit:
2248 UserLeave();
2249 return Ret;
2250}
SYSTEMCURICO gasyscur[]
Definition: cursoricon.c:32
#define WINSTA_WRITEATTRIBUTES
Definition: winuser.h:416

Referenced by LoadSystemCursors(), and SetSystemCursor().

◆ UserClipCursor()

BOOL APIENTRY UserClipCursor ( RECTL prcl)

Definition at line 696 of file cursoricon.c.

698{
699 PSYSTEM_CURSORINFO CurInfo;
701
703 {
704 return FALSE;
705 }
706
707 CurInfo = IntGetSysCursorInfo();
708
710
711 if (prcl != NULL && DesktopWindow != NULL)
712 {
713 if (prcl->right < prcl->left || prcl->bottom < prcl->top)
714 {
716 return FALSE;
717 }
718
719 CurInfo->bClipped = TRUE;
720
721 /* Set nw cliping region. Note: we can't use RECTL_bIntersectRect because
722 it sets rect to 0 0 0 0 when it's empty. For more info see monitor winetest */
723 CurInfo->rcClip.left = max(prcl->left, DesktopWindow->rcWindow.left);
724 CurInfo->rcClip.right = min(prcl->right, DesktopWindow->rcWindow.right);
725 if (CurInfo->rcClip.right < CurInfo->rcClip.left)
726 CurInfo->rcClip.right = CurInfo->rcClip.left;
727
728 CurInfo->rcClip.top = max(prcl->top, DesktopWindow->rcWindow.top);
729 CurInfo->rcClip.bottom = min(prcl->bottom, DesktopWindow->rcWindow.bottom);
730 if (CurInfo->rcClip.bottom < CurInfo->rcClip.top)
731 CurInfo->rcClip.bottom = CurInfo->rcClip.top;
732
733 /* Make sure cursor is in clipping region */
734 UserSetCursorPos(gpsi->ptCursor.x, gpsi->ptCursor.y, 0, 0, FALSE);
735 }
736 else
737 {
738 CurInfo->bClipped = FALSE;
739 }
740
741 return TRUE;
742}
#define min(a, b)
Definition: monoChain.cc:55
Implementation of the Explorer desktop window.
Definition: desktop.h:52
long bottom
Definition: polytest.cpp:53
long right
Definition: polytest.cpp:53
long top
Definition: polytest.cpp:53
long left
Definition: polytest.cpp:53
Definition: ntuser.h:694
#define max(a, b)
Definition: svc.c:63
BOOL UserSetCursorPos(INT x, INT y, DWORD flags, ULONG_PTR dwExtraInfo, BOOL Hook)
Definition: cursoricon.c:238
PWND FASTCALL UserGetDesktopWindow(VOID)
Definition: desktop.c:1386

Referenced by DefWndDoSizeMove(), NtUserClipCursor(), and UserChangeDisplaySettings().

◆ UserDrawIconEx()

BOOL UserDrawIconEx ( HDC  hDc,
INT  xLeft,
INT  yTop,
PCURICON_OBJECT  pIcon,
INT  cxWidth,
INT  cyHeight,
UINT  istepIfAniCur,
HBRUSH  hbrFlickerFreeDraw,
UINT  diFlags 
)

Definition at line 1685 of file cursoricon.c.

1695{
1696 PSURFACE psurfDest, psurfMask, psurfColor; //, psurfOffScreen = NULL;
1697 PDC pdc = NULL;
1698 BOOL Ret = FALSE;
1699 HBITMAP hbmMask, hbmColor, hbmAlpha;
1700 BOOL bOffScreen;
1701 RECTL rcDest, rcSrc;
1702 CLIPOBJ* pdcClipObj = NULL;
1703 EXLATEOBJ exlo;
1704
1705 /* Stupid case */
1706 if ((diFlags & DI_NORMAL) == 0)
1707 {
1708 ERR("DrawIconEx called without mask or color bitmap to draw.\n");
1709 return FALSE;
1710 }
1711
1712 if (pIcon->CURSORF_flags & CURSORF_ACON)
1713 {
1714 ACON* pAcon = (ACON*)pIcon;
1715 if (istepIfAniCur >= pAcon->cicur)
1716 {
1717 ERR("NtUserDrawIconEx: istepIfAniCur too big!\n");
1718 return FALSE;
1719 }
1720 pIcon = pAcon->aspcur[pAcon->aicur[istepIfAniCur]];
1721 }
1722
1723 hbmMask = pIcon->hbmMask;
1724 hbmColor = pIcon->hbmColor;
1725 hbmAlpha = pIcon->hbmAlpha;
1726
1727 /*
1728 * Get our objects.
1729 * Shared locks are enough, we are only reading those bitmaps
1730 */
1731 psurfMask = SURFACE_ShareLockSurface(hbmMask);
1732 if (psurfMask == NULL)
1733 {
1734 ERR("Unable to lock the mask surface.\n");
1735 return FALSE;
1736 }
1737
1738 /* Color bitmap is not mandatory */
1739 if (hbmColor == NULL)
1740 {
1741 /* But then the mask bitmap must have the information in it's bottom half */
1742 ASSERT(psurfMask->SurfObj.sizlBitmap.cy == 2*pIcon->cy);
1743 psurfColor = NULL;
1744 }
1745 else if ((psurfColor = SURFACE_ShareLockSurface(hbmColor)) == NULL)
1746 {
1747 ERR("Unable to lock the color bitmap.\n");
1748 SURFACE_ShareUnlockSurface(psurfMask);
1749 return FALSE;
1750 }
1751
1752 pdc = DC_LockDc(hDc);
1753 if (!pdc)
1754 {
1755 ERR("Could not lock the destination DC.\n");
1756 SURFACE_ShareUnlockSurface(psurfMask);
1757 if (psurfColor) SURFACE_ShareUnlockSurface(psurfColor);
1758 return FALSE;
1759 }
1760
1761 /* Fix width parameter, if needed */
1762 if (!cxWidth)
1763 {
1764 if (diFlags & DI_DEFAULTSIZE)
1765 cxWidth = is_icon(pIcon) ?
1767 else
1768 cxWidth = pIcon->cx;
1769 }
1770
1771 /* Fix height parameter, if needed */
1772 if (!cyHeight)
1773 {
1774 if (diFlags & DI_DEFAULTSIZE)
1775 cyHeight = is_icon(pIcon) ?
1777 else
1778 cyHeight = pIcon->cy;
1779 }
1780
1781 /* Calculate destination rectangle */
1782 RECTL_vSetRect(&rcDest, xLeft, yTop, xLeft + cxWidth, yTop + cyHeight);
1783 IntLPtoDP(pdc, (LPPOINT)&rcDest, 2);
1784 RECTL_vOffsetRect(&rcDest, pdc->ptlDCOrig.x, pdc->ptlDCOrig.y);
1785
1786 /* Prepare the underlying surface */
1787 DC_vPrepareDCsForBlit(pdc, &rcDest, NULL, NULL);
1788
1789 /* We now have our destination surface and rectangle */
1790 psurfDest = pdc->dclevel.pSurface;
1791
1792 if (psurfDest == NULL)
1793 {
1794 /* Empty DC */
1795 DC_vFinishBlit(pdc, NULL);
1796 DC_UnlockDc(pdc);
1797 SURFACE_ShareUnlockSurface(psurfMask);
1798 if (psurfColor) SURFACE_ShareUnlockSurface(psurfColor);
1799 return FALSE;
1800 }
1801
1802 /* Set source rect */
1803 RECTL_vSetRect(&rcSrc, 0, 0, pIcon->cx, pIcon->cy);
1804
1805 /* Should we render off-screen? */
1806 bOffScreen = hbrFlickerFreeDraw &&
1807 (GDI_HANDLE_GET_TYPE(hbrFlickerFreeDraw) == GDI_OBJECT_TYPE_BRUSH);
1808
1809 if (bOffScreen)
1810 {
1811 /* Yes: Allocate and paint the offscreen surface */
1812 EBRUSHOBJ eboFill;
1813 PBRUSH pbrush = BRUSH_ShareLockBrush(hbrFlickerFreeDraw);
1814
1815 TRACE("Performing off-screen rendering.\n");
1816
1817 if (!pbrush)
1818 {
1819 ERR("Failed to get brush object.\n");
1820 goto Cleanup;
1821 }
1822
1823#if 0 //We lock the hdc surface during the whole function it makes no sense to use an offscreen surface for "flicker free" drawing
1824 psurfOffScreen = SURFACE_AllocSurface(STYPE_BITMAP,
1825 cxWidth, cyHeight, psurfDest->SurfObj.iBitmapFormat,
1826 0, 0, NULL);
1827 if (!psurfOffScreen)
1828 {
1829 ERR("Failed to allocate the off-screen surface.\n");
1830 BRUSH_ShareUnlockBrush(pbrush);
1831 goto Cleanup;
1832 }
1833
1834 /* Paint the brush */
1835 EBRUSHOBJ_vInit(&eboFill, pbrush, psurfOffScreen, 0x00FFFFFF, 0, NULL);
1836 RECTL_vSetRect(&rcDest, 0, 0, cxWidth, cyHeight);
1837
1838 Ret = IntEngBitBlt(&psurfOffScreen->SurfObj,
1839 NULL,
1840 NULL,
1841 NULL,
1842 NULL,
1843 &rcDest,
1844 NULL,
1845 NULL,
1846 &eboFill.BrushObject,
1847 &pbrush->ptOrigin,
1848 ROP4_PATCOPY);
1849
1850 /* Clean up everything */
1851 EBRUSHOBJ_vCleanup(&eboFill);
1852 BRUSH_ShareUnlockBrush(pbrush);
1853
1854 if (!Ret)
1855 {
1856 ERR("Failed to paint the off-screen surface.\n");
1857 goto Cleanup;
1858 }
1859
1860 /* We now have our destination surface */
1861 psurfDest = psurfOffScreen;
1862#else
1863 pdcClipObj = (CLIPOBJ *)&pdc->co;
1864 /* Paint the brush */
1865 EBRUSHOBJ_vInit(&eboFill, pbrush, psurfDest, 0x00FFFFFF, 0, NULL);
1866
1867 Ret = IntEngBitBlt(&psurfDest->SurfObj,
1868 NULL,
1869 NULL,
1870 pdcClipObj,
1871 NULL,
1872 &rcDest,
1873 NULL,
1874 NULL,
1875 &eboFill.BrushObject,
1876 &pbrush->ptOrigin,
1877 ROP4_PATCOPY);
1878
1879 /* Clean up everything */
1880 EBRUSHOBJ_vCleanup(&eboFill);
1881 BRUSH_ShareUnlockBrush(pbrush);
1882
1883 if (!Ret)
1884 {
1885 ERR("Failed to paint the off-screen surface.\n");
1886 goto Cleanup;
1887 }
1888#endif
1889 }
1890 else
1891 {
1892 /* We directly draw to the DC */
1893 TRACE("Performing on screen rendering.\n");
1894 pdcClipObj = (CLIPOBJ *)&pdc->co;
1895 // psurfOffScreen = NULL;
1896 }
1897
1898 /* Now do the rendering */
1899 if (hbmAlpha && ((diFlags & DI_NORMAL) == DI_NORMAL))
1900 {
1901 BLENDOBJ blendobj = { {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA } };
1902 PSURFACE psurf = NULL;
1903
1904 psurf = SURFACE_ShareLockSurface(hbmAlpha);
1905 if (!psurf)
1906 {
1907 ERR("SURFACE_LockSurface failed!\n");
1908 goto NoAlpha;
1909 }
1910
1911 /* Initialize color translation object */
1912 EXLATEOBJ_vInitialize(&exlo, psurf->ppal, psurfDest->ppal, 0xFFFFFFFF, 0xFFFFFFFF, 0);
1913
1914 /* Now do it */
1915 Ret = IntEngAlphaBlend(&psurfDest->SurfObj,
1916 &psurf->SurfObj,
1917 pdcClipObj,
1918 &exlo.xlo,
1919 &rcDest,
1920 &rcSrc,
1921 &blendobj);
1922
1923 EXLATEOBJ_vCleanup(&exlo);
1925 if (Ret) goto done;
1926 ERR("NtGdiAlphaBlend failed!\n");
1927 }
1928NoAlpha:
1929 if (diFlags & DI_MASK)
1930 {
1931 DWORD rop4 = (diFlags & DI_IMAGE) ? ROP4_SRCAND : ROP4_SRCCOPY;
1932
1933 EXLATEOBJ_vInitSrcMonoXlate(&exlo, psurfDest->ppal, 0x00FFFFFF, 0);
1934
1935 Ret = IntEngStretchBlt(&psurfDest->SurfObj,
1936 &psurfMask->SurfObj,
1937 NULL,
1938 pdcClipObj,
1939 &exlo.xlo,
1940 NULL,
1941 &rcDest,
1942 &rcSrc,
1943 NULL,
1944 NULL,
1945 NULL,
1946 rop4);
1947
1948 EXLATEOBJ_vCleanup(&exlo);
1949
1950 if (!Ret)
1951 {
1952 ERR("Failed to mask the bitmap data.\n");
1953 goto Cleanup;
1954 }
1955 }
1956
1957 if (diFlags & DI_IMAGE)
1958 {
1959 if (psurfColor)
1960 {
1961 DWORD rop4 = (diFlags & DI_MASK) ? ROP4_SRCINVERT : ROP4_SRCCOPY ;
1962
1963 EXLATEOBJ_vInitialize(&exlo, psurfColor->ppal, psurfDest->ppal, 0x00FFFFFF, 0x00FFFFFF, 0);
1964
1965 Ret = IntEngStretchBlt(&psurfDest->SurfObj,
1966 &psurfColor->SurfObj,
1967 NULL,
1968 pdcClipObj,
1969 &exlo.xlo,
1970 NULL,
1971 &rcDest,
1972 &rcSrc,
1973 NULL,
1974 NULL,
1975 NULL,
1976 rop4);
1977
1978 EXLATEOBJ_vCleanup(&exlo);
1979
1980 if (!Ret)
1981 {
1982 ERR("Failed to render the icon bitmap.\n");
1983 goto Cleanup;
1984 }
1985 }
1986 else
1987 {
1988 /* Mask bitmap holds the information in its bottom half */
1989 DWORD rop4 = (diFlags & DI_MASK) ? ROP4_SRCINVERT : ROP4_SRCCOPY;
1990 RECTL_vOffsetRect(&rcSrc, 0, pIcon->cy);
1991
1992 EXLATEOBJ_vInitSrcMonoXlate(&exlo, psurfDest->ppal, 0x00FFFFFF, 0);
1993
1994 Ret = IntEngStretchBlt(&psurfDest->SurfObj,
1995 &psurfMask->SurfObj,
1996 NULL,
1997 pdcClipObj,
1998 &exlo.xlo,
1999 NULL,
2000 &rcDest,
2001 &rcSrc,
2002 NULL,
2003 NULL,
2004 NULL,
2005 rop4);
2006
2007 EXLATEOBJ_vCleanup(&exlo);
2008
2009 if (!Ret)
2010 {
2011 ERR("Failed to render the icon bitmap.\n");
2012 goto Cleanup;
2013 }
2014 }
2015 }
2016
2017done:
2018#if 0
2019 /* We're done. Was it a double buffered draw ? */
2020 if (bOffScreen)
2021 {
2022 /* Yes. Draw it back to our DC */
2023 POINTL ptSrc = {0, 0};
2024
2025 /* Calculate destination rectangle */
2026 RECTL_vSetRect(&rcDest, xLeft, yTop, xLeft + cxWidth, yTop + cyHeight);
2027 IntLPtoDP(pdc, (LPPOINT)&rcDest, 2);
2028 RECTL_vOffsetRect(&rcDest, pdc->ptlDCOrig.x, pdc->ptlDCOrig.y);
2029
2030 /* Get the clip object */
2031 pdcClipObj = pdc->rosdc.CombinedClip;
2032
2033 /* We now have our destination surface and rectangle */
2034 psurfDest = pdc->dclevel.pSurface;
2035
2036 /* Color translation */
2037 EXLATEOBJ_vInitialize(&exlo, psurfOffScreen->ppal, psurfDest->ppal, 0x00FFFFFF, 0x00FFFFFF, 0);
2038
2039 /* Blt it! */
2040 Ret = IntEngBitBlt(&psurfDest->SurfObj,
2041 &psurfOffScreen->SurfObj,
2042 NULL,
2043 pdcClipObj,
2044 &exlo.xlo,
2045 &rcDest,
2046 &ptSrc,
2047 NULL,
2048 NULL,
2049 NULL,
2050 ROP4_SRCCOPY);
2051
2052 EXLATEOBJ_vCleanup(&exlo);
2053 }
2054#endif
2055Cleanup:
2056 if (pdc)
2057 {
2058 DC_vFinishBlit(pdc, NULL);
2059 DC_UnlockDc(pdc);
2060 }
2061
2062#if 0
2063 /* Delete off screen rendering surface */
2064 if (psurfOffScreen)
2065 GDIOBJ_vDeleteObject(&psurfOffScreen->BaseObject);
2066#endif
2067
2068 /* Unlock other surfaces */
2069 SURFACE_ShareUnlockSurface(psurfMask);
2070 if (psurfColor) SURFACE_ShareUnlockSurface(psurfColor);
2071
2072 return Ret;
2073}
static BOOLEAN IntLPtoDP(DC *pdc, PPOINTL ppt, UINT count)
Definition: coord.h:182
VOID FASTCALL DC_vPrepareDCsForBlit(PDC pdcDest, const RECT *rcDest, PDC pdcSrc, const RECT *rcSrc)
Definition: dclife.c:505
VOID FASTCALL DC_vFinishBlit(PDC pdc1, PDC pdc2)
Definition: dclife.c:614
FORCEINLINE VOID DC_UnlockDc(PDC pdc)
Definition: dc.h:238
FORCEINLINE PDC DC_LockDc(HDC hdc)
Definition: dc.h:220
VOID NTAPI EBRUSHOBJ_vCleanup(EBRUSHOBJ *pebo)
Definition: engbrush.c:153
VOID NTAPI EBRUSHOBJ_vInit(EBRUSHOBJ *pebo, PBRUSH pbrush, PSURFACE psurf, COLORREF crBackgroundClr, COLORREF crForegroundClr, PPALETTE ppalDC)
Definition: engbrush.c:52
#define BRUSH_ShareLockBrush(hBrush)
Definition: brush.h:117
#define BRUSH_ShareUnlockBrush(pBrush)
Definition: brush.h:118
#define GDI_OBJECT_TYPE_BRUSH
Definition: gdi.h:52
#define GDI_HANDLE_GET_TYPE(h)
Definition: gdi.h:31
BOOL APIENTRY IntEngStretchBlt(SURFOBJ *DestObj, SURFOBJ *SourceObj, SURFOBJ *Mask, CLIPOBJ *ClipRegion, XLATEOBJ *ColorTranslation, COLORADJUSTMENT *pca, RECTL *DestRect, RECTL *SourceRect, POINTL *pMaskOrigin, BRUSHOBJ *Brush, POINTL *BrushOrigin, ULONG Mode)
#define ASSERT(a)
Definition: mode.c:44
#define AC_SRC_ALPHA
Definition: alphablend.c:9
Definition: polytest.cpp:41
CLIPOBJ CombinedClip
Definition: polytest.cpp:42
Definition: types.h:101
BRUSHOBJ BrushObject
Definition: brush.h:71
XLATEOBJ xlo
Definition: xlateobj.h:21
LONG cy
Definition: kdterminal.h:28
SURFOBJ SurfObj
Definition: surface.h:8
struct _PALETTE *const ppal
Definition: surface.h:11
SIZEL sizlBitmap
Definition: winddi.h:1209
ULONG iBitmapFormat
Definition: winddi.h:1215
#define ROP4_SRCCOPY
Definition: dib.h:13
#define ROP4_PATCOPY
Definition: dib.h:15
#define ROP4_SRCINVERT
Definition: dib.h:9
#define ROP4_SRCAND
Definition: dib.h:10
BOOL APIENTRY IntEngAlphaBlend(_Inout_ SURFOBJ *psoDest, _In_ SURFOBJ *psoSource, _In_opt_ CLIPOBJ *pco, _In_opt_ XLATEOBJ *pxlo, _In_ RECTL *prclDest, _In_ RECTL *prclSrc, _In_ BLENDOBJ *pBlendObj)
Definition: alphablend.c:197
BOOL APIENTRY IntEngBitBlt(SURFOBJ *psoTrg, SURFOBJ *psoSrc, SURFOBJ *psoMask, CLIPOBJ *pco, XLATEOBJ *pxlo, RECTL *prclTrg, POINTL *pptlSrc, POINTL *pptlMask, BRUSHOBJ *pbo, POINTL *pptlBrush, ROP4 Rop4)
Definition: bitblt.c:656
PSURFACE NTAPI SURFACE_AllocSurface(_In_ USHORT iType, _In_ ULONG cx, _In_ ULONG cy, _In_ ULONG iFormat, _In_ ULONG fjBitmap, _In_opt_ ULONG cjWidth, _In_opt_ ULONG cjBufSize, _In_opt_ PVOID pvBits)
Definition: surface.c:116
#define SURFACE_ShareUnlockSurface(pBMObj)
Definition: surface.h:102
#define SURFACE_ShareLockSurface(hBMObj)
Definition: surface.h:91
VOID NTAPI GDIOBJ_vDeleteObject(POBJ pobj)
Definition: gdiobj.c:1111
FORCEINLINE VOID RECTL_vSetRect(_Out_ RECTL *prcl, _In_ LONG left, _In_ LONG top, _In_ LONG right, _In_ LONG bottom)
Definition: rect.h:5
FORCEINLINE VOID RECTL_vOffsetRect(_Inout_ RECTL *prcl, _In_ INT cx, _In_ INT cy)
Definition: rect.h:31
#define STYPE_BITMAP
Definition: winddi.h:1175
_In_opt_ SURFOBJ _In_opt_ SURFOBJ _In_ CLIPOBJ _In_opt_ XLATEOBJ _In_ RECTL _In_opt_ POINTL _In_opt_ POINTL _In_opt_ BRUSHOBJ _In_opt_ POINTL _In_ ROP4 rop4
Definition: winddi.h:3442
#define AC_SRC_OVER
Definition: wingdi.h:1369
#define DI_NORMAL
Definition: wingdi.h:72
#define DI_IMAGE
Definition: wingdi.h:70
#define DI_MASK
Definition: wingdi.h:71
#define DI_DEFAULTSIZE
Definition: wingdi.h:69
#define SM_CYICON
Definition: winuser.h:973
#define SM_CYCURSOR
Definition: winuser.h:975
#define SM_CXICON
Definition: winuser.h:972
#define SM_CXCURSOR
Definition: winuser.h:974
VOID NTAPI EXLATEOBJ_vInitialize(_Out_ PEXLATEOBJ pexlo, _In_opt_ PALETTE *ppalSrc, _In_opt_ PALETTE *ppalDst, _In_ COLORREF crSrcBackColor, _In_ COLORREF crDstBackColor, _In_ COLORREF crDstForeColor)
Definition: xlateobj.c:358
VOID NTAPI EXLATEOBJ_vCleanup(_Inout_ PEXLATEOBJ pexlo)
Definition: xlateobj.c:649
VOID NTAPI EXLATEOBJ_vInitSrcMonoXlate(PEXLATEOBJ pexlo, PPALETTE ppalDst, COLORREF crBackgroundClr, COLORREF crForegroundClr)
Definition: xlateobj.c:632

Referenced by IntDefWindowProc(), MENU_DrawBitmapItem(), NtUserDrawIconEx(), UserDrawCaption(), and UserDrawSysMenuButton().

◆ UserGetCurIconObject()

PCURICON_OBJECT FASTCALL UserGetCurIconObject ( HCURSOR  hCurIcon)

Definition at line 200 of file cursoricon.c.

201{
202 PCURICON_OBJECT CurIcon;
203
204 if (!hCurIcon)
205 {
207 return NULL;
208 }
209
210 if (UserObjectInDestroy(hCurIcon))
211 {
212 WARN("Requesting invalid/destroyed cursor.\n");
214 return NULL;
215 }
216
218 if (!CurIcon)
219 {
220 /* We never set ERROR_INVALID_ICON_HANDLE. lets hope noone ever checks for it */
222 return NULL;
223 }
224
225 ASSERT(CurIcon->head.cLockObj >= 1);
226 return CurIcon;
227}
PVOID FASTCALL UserReferenceObjectByHandle(HANDLE handle, HANDLE_TYPE type)
Definition: object.c:741

Referenced by _Success_(), DefWndDoSizeMove(), DesktopWindowProc(), IntCreateClass(), IntCreateWindow(), IntLoadSystenIcons(), IntSetAconData(), NtUserDestroyCursor(), NtUserDrawIconEx(), NtUserGetCursorFrameInfo(), NtUserGetIconSize(), NtUserSetCursor(), NtUserSetSystemCursor(), UserDrawCaption(), UserSetClassLongPtr(), and UserSetCursorIconData().

◆ UserSetCursorIconData()

BOOL APIENTRY UserSetCursorIconData ( _In_ HCURSOR  hcursor,
_In_opt_ PUNICODE_STRING  pustrModule,
_In_opt_ PUNICODE_STRING  pustrRsrc,
_In_ PCURSORDATA  pcursordata 
)

Definition at line 1415 of file cursoricon.c.

1420{
1421 PCURICON_OBJECT pcur;
1422 ATOM atomModName;
1424 BOOL bResult;
1425
1426 /* Do we have a module name? */
1427 if (pustrModule != NULL)
1428 {
1429 /* Create an atom for the module name */
1431 pustrModule->Buffer,
1432 &atomModName);
1433 if (!NT_SUCCESS(status))
1434 {
1435 ERR("Failed to create atom from module name '%wZ': 0x%08lx\n",
1436 pustrModule, status);
1437 return FALSE;
1438 }
1439 }
1440 else
1441 {
1442 /* No module name atom */
1443 atomModName = 0;
1444 }
1445
1446 /* Reference the cursor */
1447 pcur = UserGetCurIconObject(hcursor);
1448 if (pcur == NULL)
1449 {
1450 ERR("Failed to reference cursor %p\n", hcursor);
1451 bResult = FALSE;
1452 goto Exit;
1453 }
1454
1455 /* Check if this is an acon */
1456 if (pcur->CURSORF_flags & CURSORF_ACON)
1457 {
1458 bResult = IntSetAconData((PACON)pcur,
1459 pustrRsrc,
1460 atomModName,
1461 pcursordata);
1462 }
1463 else
1464 {
1465 bResult = IntSetCursorData(pcur,
1466 pustrRsrc,
1467 atomModName,
1468 pcursordata);
1469 }
1470
1471Exit:
1472
1473 /* Check if we had success */
1474 if (bResult != FALSE)
1475 {
1476 /* Check if this is an LRSHARED cursor now */
1477 if (pcur->CURSORF_flags & CURSORF_LRSHARED)
1478 {
1479 /* Insert the cursor into the list. */
1481 }
1482 }
1483 else
1484 {
1485 /* Cleanup on failure */
1486 if (atomModName != 0)
1487 {
1489 }
1490 }
1491
1492 /* Dereference the cursor and return the result */
1493 if (pcur)
1495
1496 return bResult;
1497}
WORD ATOM
Definition: dimm.idl:113
NTSYSAPI NTSTATUS NTAPI RtlAddAtomToAtomTable(_In_ PRTL_ATOM_TABLE AtomTable, _In_ PWSTR AtomName, _Out_ PRTL_ATOM Atom)
static BOOL IntSetAconData(_Inout_ PACON pacon, _In_opt_ PUNICODE_STRING pustrName, _In_ ATOM atomModName, _In_ const CURSORDATA *pcursordata)
Definition: cursoricon.c:1234

Referenced by NtUserSetCursorIconData().

◆ UserSetCursorPos()

BOOL UserSetCursorPos ( INT  x,
INT  y,
DWORD  flags,
ULONG_PTR  dwExtraInfo,
BOOL  Hook 
)

Definition at line 238 of file cursoricon.c.

239{
241 PSYSTEM_CURSORINFO CurInfo;
242 MSG Msg;
243 RECTL rcClip;
244 POINT pt;
245
247 {
248 return FALSE;
249 }
250
251 CurInfo = IntGetSysCursorInfo();
252
253 /* Clip cursor position */
254 if (!CurInfo->bClipped)
255 rcClip = DesktopWindow->rcClient;
256 else
257 rcClip = CurInfo->rcClip;
258
259 if (x >= rcClip.right) x = rcClip.right - 1;
260 if (x < rcClip.left) x = rcClip.left;
261 if (y >= rcClip.bottom) y = rcClip.bottom - 1;
262 if (y < rcClip.top) y = rcClip.top;
263
264 pt.x = x;
265 pt.y = y;
266
267 /* 1. Generate a mouse move message, this sets the htEx and Track Window too. */
268 Msg.message = WM_MOUSEMOVE;
269 Msg.wParam = UserGetMouseButtonsState();
270 Msg.lParam = MAKELPARAM(x, y);
271 Msg.pt = pt;
272 co_MsqInsertMouseMessage(&Msg, flags, dwExtraInfo, Hook);
273
274 /* 2. Store the new cursor position */
275 gpsi->ptCursor = pt;
276
277 return TRUE;
278}
struct @1627 Msg[]
#define pt(x, y)
Definition: drawing.c:79
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLbitfield flags
Definition: glext.h:7161
VOID FASTCALL co_MsqInsertMouseMessage(MSG *Msg, DWORD flags, ULONG_PTR dwExtraInfo, BOOL Hook)
Definition: msgqueue.c:580
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
WORD FASTCALL UserGetMouseButtonsState(VOID)
Definition: mouse.c:22
#define MAKELPARAM(l, h)
Definition: winuser.h:4008
#define WM_MOUSEMOVE
Definition: winuser.h:1775

Referenced by DefWndDoSizeMove(), DefWndStartSizeMove(), NtUserCallTwoParam(), UserClipCursor(), and UserSendMouseInput().

Variable Documentation

◆ gasyscur

SYSTEMCURICO gasyscur[]
Initial value:
= {
{OCR_NORMAL, NULL},
{OCR_IBEAM, NULL},
{OCR_WAIT, NULL},
{OCR_CROSS, NULL},
{OCR_UP, NULL},
{OCR_ICON, NULL},
{OCR_SIZE, NULL},
{OCR_SIZENWSE, NULL},
{OCR_SIZENESW, NULL},
{OCR_SIZEWE, NULL},
{OCR_SIZENS, NULL},
{OCR_SIZEALL, NULL},
{OCR_NO, NULL},
{OCR_HAND, NULL},
{OCR_APPSTARTING,NULL},
{OCR_HELP, NULL},
}

Definition at line 32 of file cursoricon.c.

Referenced by NtUserSetSystemCursor().

◆ gasysico

SYSTEMCURICO gasysico[]
Initial value:
= {
{OIC_SAMPLE, NULL},
{OIC_HAND, NULL},
{OIC_QUES, NULL},
{OIC_BANG, NULL},
{OIC_NOTE, NULL},
{OIC_WINLOGO,NULL},
}

Definition at line 54 of file cursoricon.c.

Referenced by IntLoadSystenIcons().

◆ gcurFirst

◆ gSysCursorInfo

SYSTEM_CURSORINFO gSysCursorInfo

Definition at line 25 of file cursoricon.c.

Referenced by InitCursorImpl(), and IntGetSysCursorInfo().