cursoricon.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_CURICON_OBJECT
struct	tagACON
struct	_CURSORACCELERATION_INFO
struct	_SYSTEM_CURSORINFO
struct	SYSTEMCURICO

Macros
#define	MAXCURICONHANDLES   4096
#define	CURSORF_USER_MASK    (CURSORF_FROMRESOURCE | CURSORF_LRSHARED | CURSORF_ACON)
#define	ROIC_SAMPLE   0
#define	ROIC_HAND   1
#define	ROIC_QUES   2
#define	ROIC_BANG   3
#define	ROIC_NOTE   4
#define	ROIC_WINLOGO   5
#define	ROCR_ARROW   0
#define	ROCR_IBEAM   1
#define	ROCR_WAIT   2
#define	ROCR_CROSS   3
#define	ROCR_UP   4
#define	ROCR_SIZE   5
#define	ROCR_ICON   6
#define	ROCR_SIZENWSE   7
#define	ROCR_SIZENESW   8
#define	ROCR_SIZEWE   9
#define	ROCR_SIZENS   10
#define	ROCR_SIZEALL   11
#define	ROCR_NO   12
#define	ROCR_HAND   13
#define	ROCR_APPSTARTING   14
#define	ROCR_HELP   15
#define	SYSTEMCUR(func)   (gasyscur[ROCR_ ## func].handle)
#define	SYSTEMICO(func)   (gasysico[ROIC_ ## func].handle)

Typedefs
typedef struct _CURICON_OBJECT	CURICON_OBJECT
typedef struct _CURICON_OBJECT *	PCURICON_OBJECT
typedef struct tagACON	ACON
typedef struct tagACON *	PACON
typedef struct _CURSORACCELERATION_INFO	CURSORACCELERATION_INFO
typedef struct _CURSORACCELERATION_INFO *	PCURSORACCELERATION_INFO
typedef struct _SYSTEM_CURSORINFO	SYSTEM_CURSORINFO
typedef struct _SYSTEM_CURSORINFO *	PSYSTEM_CURSORINFO

Functions
	C_ASSERT (FIELD_OFFSET(ACON, cpcur)==FIELD_OFFSET(CURICON_OBJECT, xHotspot))
BOOLEAN	IntDestroyCurIconObject (_In_ PVOID Object)
VOID FASTCALL	IntCleanupCurIconCache (PPROCESSINFO Win32Process)
VOID	FreeCurIconObject (_In_ PVOID Object)
VOID	IntLoadSystenIcons (HICON, DWORD)
BOOL	InitCursorImpl (VOID)
HANDLE	IntCreateCurIconHandle (BOOLEAN Anim)
BOOL	UserDrawIconEx (HDC hDc, INT xLeft, INT yTop, PCURICON_OBJECT pIcon, INT cxWidth, INT cyHeight, UINT istepIfAniCur, HBRUSH hbrFlickerFreeDraw, UINT diFlags)
PCURICON_OBJECT FASTCALL	UserGetCurIconObject (HCURSOR hCurIcon)
BOOL	UserSetCursorPos (INT x, INT y, DWORD flags, ULONG_PTR dwExtraInfo, BOOL Hook)
BOOL APIENTRY	UserClipCursor (RECTL *prcl)
PSYSTEM_CURSORINFO	IntGetSysCursorInfo (VOID)
PCURICON_OBJECT	IntSystemSetCursor (PCURICON_OBJECT)

Variables
SYSTEMCURICO	gasysico []
SYSTEMCURICO	gasyscur []

Macro Definition Documentation

CURSORF_USER_MASK

#define CURSORF_USER_MASK    (CURSORF_FROMRESOURCE | CURSORF_LRSHARED | CURSORF_ACON)

Definition at line 6 of file cursoricon.h.

MAXCURICONHANDLES

#define MAXCURICONHANDLES   4096

Definition at line 3 of file cursoricon.h.

ROCR_APPSTARTING

#define ROCR_APPSTARTING   14

Definition at line 126 of file cursoricon.h.

ROCR_ARROW

#define ROCR_ARROW   0

Definition at line 112 of file cursoricon.h.

ROCR_CROSS

#define ROCR_CROSS   3

Definition at line 115 of file cursoricon.h.

ROCR_HAND

#define ROCR_HAND   13

Definition at line 125 of file cursoricon.h.

ROCR_HELP

#define ROCR_HELP   15

Definition at line 127 of file cursoricon.h.

ROCR_IBEAM

#define ROCR_IBEAM   1

Definition at line 113 of file cursoricon.h.

ROCR_ICON

#define ROCR_ICON   6

Definition at line 118 of file cursoricon.h.

ROCR_NO

#define ROCR_NO   12

Definition at line 124 of file cursoricon.h.

ROCR_SIZE

#define ROCR_SIZE   5

Definition at line 117 of file cursoricon.h.

ROCR_SIZEALL

#define ROCR_SIZEALL   11

Definition at line 123 of file cursoricon.h.

ROCR_SIZENESW

#define ROCR_SIZENESW   8

Definition at line 120 of file cursoricon.h.

ROCR_SIZENS

#define ROCR_SIZENS   10

Definition at line 122 of file cursoricon.h.

ROCR_SIZENWSE

#define ROCR_SIZENWSE   7

Definition at line 119 of file cursoricon.h.

ROCR_SIZEWE

#define ROCR_SIZEWE   9

Definition at line 121 of file cursoricon.h.

ROCR_UP

#define ROCR_UP   4

Definition at line 116 of file cursoricon.h.

ROCR_WAIT

#define ROCR_WAIT   2

Definition at line 114 of file cursoricon.h.

ROIC_BANG

#define ROIC_BANG   3

Definition at line 108 of file cursoricon.h.

ROIC_HAND

#define ROIC_HAND   1

Definition at line 106 of file cursoricon.h.

ROIC_NOTE

#define ROIC_NOTE   4

Definition at line 109 of file cursoricon.h.

ROIC_QUES

#define ROIC_QUES   2

Definition at line 107 of file cursoricon.h.

ROIC_SAMPLE

#define ROIC_SAMPLE   0

Definition at line 105 of file cursoricon.h.

ROIC_WINLOGO

#define ROIC_WINLOGO   5

Definition at line 110 of file cursoricon.h.

SYSTEMCUR

#define SYSTEMCUR

(

func

)

(gasyscur[ROCR_ ## func].handle)

Definition at line 129 of file cursoricon.h.

SYSTEMICO

#define SYSTEMICO

(

func

)

(gasysico[ROIC_ ## func].handle)

Definition at line 130 of file cursoricon.h.

Typedef Documentation

ACON

typedef struct tagACON ACON

CURICON_OBJECT

typedef struct _CURICON_OBJECT CURICON_OBJECT

CURSORACCELERATION_INFO

typedef struct _CURSORACCELERATION_INFO CURSORACCELERATION_INFO

PACON

typedef struct tagACON * PACON

PCURICON_OBJECT

typedef struct _CURICON_OBJECT * PCURICON_OBJECT

PCURSORACCELERATION_INFO

typedef struct _CURSORACCELERATION_INFO * PCURSORACCELERATION_INFO

PSYSTEM_CURSORINFO

typedef struct _SYSTEM_CURSORINFO * PSYSTEM_CURSORINFO

SYSTEM_CURSORINFO

typedef struct _SYSTEM_CURSORINFO SYSTEM_CURSORINFO

Function Documentation

C_ASSERT()

C_ASSERT

(

FIELD_OFFSET(ACON, cpcur)

= =FIELD_OFFSET(CURICON_OBJECT, xHotspot)

)

FreeCurIconObject()

VOID FreeCurIconObject

(

_In_ PVOID

Object

)

Definition at line 336 of file cursoricon.c.

{
    PCURICON_OBJECT CurIcon = Object;
 
    if (!(CurIcon->CURSORF_flags & CURSORF_ACON))
    {
        HBITMAP bmpMask = CurIcon->hbmMask;
        HBITMAP bmpColor = CurIcon->hbmColor;
        HBITMAP bmpAlpha = CurIcon->hbmAlpha;
 
        /* Delete bitmaps */
        if (bmpMask)
        {
            GreSetObjectOwner(bmpMask, GDI_OBJ_HMGR_POWNED);
            NT_VERIFY(GreDeleteObject(bmpMask) == TRUE);
            CurIcon->hbmMask = NULL;
        }
        if (bmpColor)
        {
            GreSetObjectOwner(bmpColor, GDI_OBJ_HMGR_POWNED);
            NT_VERIFY(GreDeleteObject(bmpColor) == TRUE);
            CurIcon->hbmColor = NULL;
        }
        if (bmpAlpha)
        {
            GreSetObjectOwner(bmpAlpha, GDI_OBJ_HMGR_POWNED);
            NT_VERIFY(GreDeleteObject(bmpAlpha) == TRUE);
            CurIcon->hbmAlpha = NULL;
        }
    }
    else
    {
        PACON AniCurIcon = (PACON)CurIcon;
        UINT i;
 
        for (i = 0; i < AniCurIcon->cpcur; i++)
        {
            UserDereferenceObject(AniCurIcon->aspcur[i]);
            NT_VERIFY(IntDestroyCurIconObject(AniCurIcon->aspcur[i]) == TRUE);
        }
        ExFreePoolWithTag(AniCurIcon->aspcur, USERTAG_CURSOR);
    }
 
    if (CurIcon->CURSORF_flags & CURSORF_LRSHARED)
    {
        if (!IS_INTRESOURCE(CurIcon->strName.Buffer))
            ExFreePoolWithTag(CurIcon->strName.Buffer, TAG_STRING);
        if (CurIcon->atomModName)
            RtlDeleteAtomFromAtomTable(gAtomTable, CurIcon->atomModName);
        CurIcon->strName.Buffer = NULL;
        CurIcon->atomModName = 0;
    }
 
    /* Finally free the thing */
    FreeProcMarkObject(CurIcon);
}

InitCursorImpl()

BOOL InitCursorImpl

(

VOID

)

Definition at line 64 of file cursoricon.c.

{
    gSysCursorInfo.Enabled = FALSE;
    gSysCursorInfo.ButtonsDown = 0;
    gSysCursorInfo.bClipped = FALSE;
    gSysCursorInfo.LastBtnDown = 0;
    gSysCursorInfo.CurrentCursorObject = NULL;
    gSysCursorInfo.ShowingCursor = -1;
    gSysCursorInfo.ClickLockActive = FALSE;
    gSysCursorInfo.ClickLockTime = 0;
 
    return TRUE;
}

Referenced by IntCreateWindowStation().

IntCleanupCurIconCache()

VOID FASTCALL IntCleanupCurIconCache

(

PPROCESSINFO

Win32Process

)

Definition at line 395 of file cursoricon.c.

{
    PCURICON_OBJECT CurIcon;
 
    /* Run through the list of icon objects */
    while (Win32Process->pCursorCache)
    {
        CurIcon = Win32Process->pCursorCache;
        Win32Process->pCursorCache = CurIcon->pcurNext;
        UserDereferenceObject(CurIcon);
    }
}

Referenced by UserProcessDestroy().

IntCreateCurIconHandle()

HANDLE IntCreateCurIconHandle

(

BOOLEAN

Anim

)

Definition at line 285 of file cursoricon.c.

{
    PCURICON_OBJECT CurIcon;
    HANDLE hCurIcon;
 
    CurIcon = UserCreateObject(
        gHandleTable,
        NULL,
        GetW32ThreadInfo(),
        &hCurIcon,
        TYPE_CURSOR,
        Animated ? sizeof(ACON) : sizeof(CURICON_OBJECT));
 
    if (!CurIcon)
    {
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    if (Animated)
    {
        /* We MUST set this flag, to track whether this is an ACON! */
        CurIcon->CURSORF_flags |= CURSORF_ACON;
    }
 
    NT_ASSERT(CurIcon->pcurNext == NULL);
    UserDereferenceObject(CurIcon);
 
    return hCurIcon;
}

Referenced by IntSetAconData(), and NtUserCallOneParam().

IntDestroyCurIconObject()

BOOLEAN IntDestroyCurIconObject

(

_In_ PVOID

Object

)

Definition at line 317 of file cursoricon.c.

{
    PCURICON_OBJECT CurIcon = Object;
 
    /* Check if the cursor is in a list */
    if (CurIcon->CURSORF_flags & CURSORF_LINKED)
    {
        /* Remove the cursor from it's list */
        IntRemoveCursorFromList(CurIcon);
    }
 
    /* We just mark the handle as being destroyed.
     * Deleting all the stuff will be deferred to the actual struct free. */
    UserDeleteObject(UserHMGetHandle(CurIcon), TYPE_CURSOR);
    return TRUE;
}

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

IntGetSysCursorInfo()

PSYSTEM_CURSORINFO IntGetSysCursorInfo

(

VOID

)

Definition at line 187 of file cursoricon.c.

{
    return &gSysCursorInfo;
}

Referenced by co_IntProcessMouseMessage(), co_MsqInsertMouseMessage(), MsqCleanupMessageQueue(), NtUserGetClipCursor(), NtUserGetCursorInfo(), UserClipCursor(), UserGetMouseButtonsState(), UserSendMouseInput(), UserSetCursor(), UserSetCursorPos(), and UserShowCursor().

IntLoadSystenIcons()

VOID IntLoadSystenIcons	(	HICON	hcur,
		DWORD	id
	)

Definition at line 137 of file cursoricon.c.

{
    PCURICON_OBJECT pcur;
    int i;
    PPROCESSINFO ppi;
 
    if (hcur)
    {
        pcur = UserGetCurIconObject(hcur);
        if (!pcur)
        {
            EngSetLastError(ERROR_INVALID_CURSOR_HANDLE);
            return;
        }
 
        ppi = PsGetCurrentProcessWin32Process();
 
        if (!(ppi->W32PF_flags & W32PF_CREATEDWINORDC))
           return;
 
        // Set Small Window Icon and do not link.
        if ( id == OIC_WINLOGO+1 )
        {
            pcur->CURSORF_flags |= CURSORF_GLOBAL;
            UserReferenceObject(pcur);
            pcur->head.ppi = NULL;
            return;
        }
 
        for (i = 0 ; i < 6; i++)
        {
            if (gasysico[i].type == id)
            {
                gasysico[i].handle = pcur;
                pcur->CURSORF_flags |= CURSORF_GLOBAL;
 
                //
                //  The active switch between LR shared and Global public.
                //  This is hacked around to support this while at the initial system start up.
                //
                pcur->head.ppi = NULL;
 
                IntInsertCursorIntoList(pcur);
                return;
            }
        }
    }
}

Referenced by co_IntSetWndIcons().

IntSystemSetCursor()

PCURICON_OBJECT IntSystemSetCursor

(

PCURICON_OBJECT

pcurNew

)

Definition at line 230 of file cursoricon.c.

{
    PCURICON_OBJECT pcurOld = UserSetCursor(pcurNew, FALSE);
    if (pcurNew) UserReferenceObject(pcurNew);
    if (pcurOld) UserDereferenceObject(pcurOld);
    return pcurOld;
}

Referenced by co_IntProcessMouseMessage(), and DefWndHandleSetCursor().

UserClipCursor()

BOOL APIENTRY UserClipCursor

(

RECTL *

prcl

)

Definition at line 700 of file cursoricon.c.

{
    PSYSTEM_CURSORINFO CurInfo;
    PWND DesktopWindow = NULL;
 
    if (!CheckWinstaAttributeAccess(WINSTA_WRITEATTRIBUTES))
    {
        return FALSE;
    }
 
    CurInfo = IntGetSysCursorInfo();
 
    DesktopWindow = UserGetDesktopWindow();
 
    if (prcl != NULL && DesktopWindow != NULL)
    {
        if (prcl->right < prcl->left || prcl->bottom < prcl->top)
        {
            EngSetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
 
        CurInfo->bClipped = TRUE;
 
        /* Set nw cliping region. Note: we can't use RECTL_bIntersectRect because
           it sets rect to 0 0 0 0 when it's empty. For more info see monitor winetest */
        CurInfo->rcClip.left = max(prcl->left, DesktopWindow->rcWindow.left);
        CurInfo->rcClip.right = min(prcl->right, DesktopWindow->rcWindow.right);
        if (CurInfo->rcClip.right < CurInfo->rcClip.left)
            CurInfo->rcClip.right = CurInfo->rcClip.left;
 
        CurInfo->rcClip.top = max(prcl->top, DesktopWindow->rcWindow.top);
        CurInfo->rcClip.bottom = min(prcl->bottom, DesktopWindow->rcWindow.bottom);
        if (CurInfo->rcClip.bottom < CurInfo->rcClip.top)
            CurInfo->rcClip.bottom = CurInfo->rcClip.top;
 
        /* Make sure cursor is in clipping region */
        UserSetCursorPos(gpsi->ptCursor.x, gpsi->ptCursor.y, 0, 0, FALSE);
    }
    else
    {
        CurInfo->bClipped = FALSE;
    }
 
    return TRUE;
}

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 1689 of file cursoricon.c.

{
    PSURFACE psurfDest, psurfMask, psurfColor; //, psurfOffScreen = NULL;
    PDC pdc = NULL;
    BOOL Ret = FALSE;
    HBITMAP hbmMask, hbmColor, hbmAlpha;
    BOOL bOffScreen;
    RECTL rcDest, rcSrc;
    CLIPOBJ* pdcClipObj = NULL;
    EXLATEOBJ exlo;
 
    /* Stupid case */
    if ((diFlags & DI_NORMAL) == 0)
    {
        ERR("DrawIconEx called without mask or color bitmap to draw.\n");
        return FALSE;
    }
 
    if (pIcon->CURSORF_flags & CURSORF_ACON)
    {
        ACON* pAcon = (ACON*)pIcon;
        if (istepIfAniCur >= pAcon->cicur)
        {
            ERR("NtUserDrawIconEx: istepIfAniCur too big!\n");
            return FALSE;
        }
        pIcon = pAcon->aspcur[pAcon->aicur[istepIfAniCur]];
    }
 
    hbmMask = pIcon->hbmMask;
    hbmColor = pIcon->hbmColor;
    hbmAlpha = pIcon->hbmAlpha;
 
    /*
     * Get our objects.
     * Shared locks are enough, we are only reading those bitmaps
     */
    psurfMask = SURFACE_ShareLockSurface(hbmMask);
    if (psurfMask == NULL)
    {
        ERR("Unable to lock the mask surface.\n");
        return FALSE;
    }
 
    /* Color bitmap is not mandatory */
    if (hbmColor == NULL)
    {
        /* But then the mask bitmap must have the information in it's bottom half */
        ASSERT(psurfMask->SurfObj.sizlBitmap.cy == 2*pIcon->cy);
        psurfColor = NULL;
    }
    else if ((psurfColor = SURFACE_ShareLockSurface(hbmColor)) == NULL)
    {
        ERR("Unable to lock the color bitmap.\n");
        SURFACE_ShareUnlockSurface(psurfMask);
        return FALSE;
    }
 
    pdc = DC_LockDc(hDc);
    if (!pdc)
    {
        ERR("Could not lock the destination DC.\n");
        SURFACE_ShareUnlockSurface(psurfMask);
        if (psurfColor) SURFACE_ShareUnlockSurface(psurfColor);
        return FALSE;
    }
 
    /* Fix width parameter, if needed */
    if (!cxWidth)
    {
        if (diFlags & DI_DEFAULTSIZE)
            cxWidth = is_icon(pIcon) ?
                UserGetSystemMetrics(SM_CXICON) : UserGetSystemMetrics(SM_CXCURSOR);
        else
            cxWidth = pIcon->cx;
    }
 
    /* Fix height parameter, if needed */
    if (!cyHeight)
    {
        if (diFlags & DI_DEFAULTSIZE)
            cyHeight = is_icon(pIcon) ?
                UserGetSystemMetrics(SM_CYICON) : UserGetSystemMetrics(SM_CYCURSOR);
        else
            cyHeight = pIcon->cy;
    }
 
    /* Calculate destination rectangle */
    RECTL_vSetRect(&rcDest, xLeft, yTop, xLeft + cxWidth, yTop + cyHeight);
    IntLPtoDP(pdc, (LPPOINT)&rcDest, 2);
    RECTL_vOffsetRect(&rcDest, pdc->ptlDCOrig.x, pdc->ptlDCOrig.y);
 
    /* Prepare the underlying surface */
    DC_vPrepareDCsForBlit(pdc, &rcDest, NULL, NULL);
 
    /* We now have our destination surface and rectangle */
    psurfDest = pdc->dclevel.pSurface;
 
    if (psurfDest == NULL)
    {
        /* Empty DC */
        DC_vFinishBlit(pdc, NULL);
        DC_UnlockDc(pdc);
        SURFACE_ShareUnlockSurface(psurfMask);
        if (psurfColor) SURFACE_ShareUnlockSurface(psurfColor);
        return FALSE;
    }
 
    /* Set source rect */
    RECTL_vSetRect(&rcSrc, 0, 0, pIcon->cx, pIcon->cy);
 
    /* Should we render off-screen? */
    bOffScreen = hbrFlickerFreeDraw &&
        (GDI_HANDLE_GET_TYPE(hbrFlickerFreeDraw) == GDI_OBJECT_TYPE_BRUSH);
 
    if (bOffScreen)
    {
        /* Yes: Allocate and paint the offscreen surface */
        EBRUSHOBJ eboFill;
        PBRUSH pbrush = BRUSH_ShareLockBrush(hbrFlickerFreeDraw);
 
        TRACE("Performing off-screen rendering.\n");
 
        if (!pbrush)
        {
            ERR("Failed to get brush object.\n");
            goto Cleanup;
        }
 
#if 0 //We lock the hdc surface during the whole function it makes no sense to use an offscreen surface for "flicker free" drawing
        psurfOffScreen = SURFACE_AllocSurface(STYPE_BITMAP,
            cxWidth, cyHeight, psurfDest->SurfObj.iBitmapFormat,
            0, 0, NULL);
        if (!psurfOffScreen)
        {
            ERR("Failed to allocate the off-screen surface.\n");
            BRUSH_ShareUnlockBrush(pbrush);
            goto Cleanup;
        }
 
        /* Paint the brush */
        EBRUSHOBJ_vInit(&eboFill, pbrush, psurfOffScreen, 0x00FFFFFF, 0, NULL);
        RECTL_vSetRect(&rcDest, 0, 0, cxWidth, cyHeight);
 
        Ret = IntEngBitBlt(&psurfOffScreen->SurfObj,
            NULL,
            NULL,
            NULL,
            NULL,
            &rcDest,
            NULL,
            NULL,
            &eboFill.BrushObject,
            &pbrush->ptOrigin,
            ROP4_PATCOPY);
 
        /* Clean up everything */
        EBRUSHOBJ_vCleanup(&eboFill);
        BRUSH_ShareUnlockBrush(pbrush);
 
        if (!Ret)
        {
            ERR("Failed to paint the off-screen surface.\n");
            goto Cleanup;
        }
 
        /* We now have our destination surface */
        psurfDest = psurfOffScreen;
#else
        pdcClipObj = (CLIPOBJ *)&pdc->co;
        /* Paint the brush */
        EBRUSHOBJ_vInit(&eboFill, pbrush, psurfDest, 0x00FFFFFF, 0, NULL);
 
        Ret = IntEngBitBlt(&psurfDest->SurfObj,
            NULL,
            NULL,
            pdcClipObj,
            NULL,
            &rcDest,
            NULL,
            NULL,
            &eboFill.BrushObject,
            &pbrush->ptOrigin,
            ROP4_PATCOPY);
 
        /* Clean up everything */
        EBRUSHOBJ_vCleanup(&eboFill);
        BRUSH_ShareUnlockBrush(pbrush);
 
        if (!Ret)
        {
            ERR("Failed to paint the off-screen surface.\n");
            goto Cleanup;
        }
#endif
    }
    else
    {
        /* We directly draw to the DC */
        TRACE("Performing on screen rendering.\n");
        pdcClipObj = (CLIPOBJ *)&pdc->co;
        // psurfOffScreen = NULL;
    }
 
    /* Now do the rendering */
    if (hbmAlpha && ((diFlags & DI_NORMAL) == DI_NORMAL))
    {
        BLENDOBJ blendobj = { {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA } };
        PSURFACE psurf = NULL;
 
        psurf = SURFACE_ShareLockSurface(hbmAlpha);
        if (!psurf)
        {
            ERR("SURFACE_LockSurface failed!\n");
            goto NoAlpha;
        }
 
        /* Initialize color translation object */
        EXLATEOBJ_vInitialize(&exlo, psurf->ppal, psurfDest->ppal, 0xFFFFFFFF, 0xFFFFFFFF, 0);
 
        /* Now do it */
        Ret = IntEngAlphaBlend(&psurfDest->SurfObj,
                               &psurf->SurfObj,
                               pdcClipObj,
                               &exlo.xlo,
                               &rcDest,
                               &rcSrc,
                               &blendobj);
 
        EXLATEOBJ_vCleanup(&exlo);
        SURFACE_ShareUnlockSurface(psurf);
        if (Ret) goto done;
        ERR("NtGdiAlphaBlend failed!\n");
    }
NoAlpha:
    if (diFlags & DI_MASK)
    {
        DWORD rop4 = (diFlags & DI_IMAGE) ? ROP4_SRCAND : ROP4_SRCCOPY;
 
        EXLATEOBJ_vInitSrcMonoXlate(&exlo, psurfDest->ppal, 0x00FFFFFF, 0);
 
        Ret = IntEngStretchBlt(&psurfDest->SurfObj,
                               &psurfMask->SurfObj,
                               NULL,
                               pdcClipObj,
                               &exlo.xlo,
                               NULL,
                               &rcDest,
                               &rcSrc,
                               NULL,
                               NULL,
                               NULL,
                               rop4);
 
        EXLATEOBJ_vCleanup(&exlo);
 
        if (!Ret)
        {
            ERR("Failed to mask the bitmap data.\n");
            goto Cleanup;
        }
    }
 
    if (diFlags & DI_IMAGE)
    {
        if (psurfColor)
        {
            DWORD rop4 = (diFlags & DI_MASK) ? ROP4_SRCINVERT : ROP4_SRCCOPY ;
 
            EXLATEOBJ_vInitialize(&exlo, psurfColor->ppal, psurfDest->ppal, 0x00FFFFFF, 0x00FFFFFF, 0);
 
            Ret = IntEngStretchBlt(&psurfDest->SurfObj,
                                   &psurfColor->SurfObj,
                                   NULL,
                                   pdcClipObj,
                                   &exlo.xlo,
                                   NULL,
                                   &rcDest,
                                   &rcSrc,
                                   NULL,
                                   NULL,
                                   NULL,
                                   rop4);
 
            EXLATEOBJ_vCleanup(&exlo);
 
            if (!Ret)
            {
                ERR("Failed to render the icon bitmap.\n");
                goto Cleanup;
            }
        }
        else
        {
            /* Mask bitmap holds the information in its bottom half */
            DWORD rop4 = (diFlags & DI_MASK) ? ROP4_SRCINVERT : ROP4_SRCCOPY;
            RECTL_vOffsetRect(&rcSrc, 0, pIcon->cy);
 
            EXLATEOBJ_vInitSrcMonoXlate(&exlo, psurfDest->ppal, 0x00FFFFFF, 0);
 
            Ret = IntEngStretchBlt(&psurfDest->SurfObj,
                                   &psurfMask->SurfObj,
                                   NULL,
                                   pdcClipObj,
                                   &exlo.xlo,
                                   NULL,
                                   &rcDest,
                                   &rcSrc,
                                   NULL,
                                   NULL,
                                   NULL,
                                   rop4);
 
            EXLATEOBJ_vCleanup(&exlo);
 
            if (!Ret)
            {
                ERR("Failed to render the icon bitmap.\n");
                goto Cleanup;
            }
        }
    }
 
done:
#if 0
    /* We're done. Was it a double buffered draw ? */
    if (bOffScreen)
    {
        /* Yes. Draw it back to our DC */
        POINTL ptSrc = {0, 0};
 
        /* Calculate destination rectangle */
        RECTL_vSetRect(&rcDest, xLeft, yTop, xLeft + cxWidth, yTop + cyHeight);
        IntLPtoDP(pdc, (LPPOINT)&rcDest, 2);
        RECTL_vOffsetRect(&rcDest, pdc->ptlDCOrig.x, pdc->ptlDCOrig.y);
 
        /* Get the clip object */
        pdcClipObj = pdc->rosdc.CombinedClip;
 
        /* We now have our destination surface and rectangle */
        psurfDest = pdc->dclevel.pSurface;
 
        /* Color translation */
        EXLATEOBJ_vInitialize(&exlo, psurfOffScreen->ppal, psurfDest->ppal, 0x00FFFFFF, 0x00FFFFFF, 0);
 
        /* Blt it! */
        Ret = IntEngBitBlt(&psurfDest->SurfObj,
                           &psurfOffScreen->SurfObj,
                           NULL,
                           pdcClipObj,
                           &exlo.xlo,
                           &rcDest,
                           &ptSrc,
                           NULL,
                           NULL,
                           NULL,
                           ROP4_SRCCOPY);
 
        EXLATEOBJ_vCleanup(&exlo);
    }
#endif
Cleanup:
    if (pdc)
    {
        DC_vFinishBlit(pdc, NULL);
        DC_UnlockDc(pdc);
    }
 
#if 0
    /* Delete off screen rendering surface */
    if (psurfOffScreen)
        GDIOBJ_vDeleteObject(&psurfOffScreen->BaseObject);
#endif
 
    /* Unlock other surfaces */
    SURFACE_ShareUnlockSurface(psurfMask);
    if (psurfColor) SURFACE_ShareUnlockSurface(psurfColor);
 
    return Ret;
}

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

UserGetCurIconObject()

PCURICON_OBJECT FASTCALL UserGetCurIconObject

(

HCURSOR

hCurIcon

)

Definition at line 200 of file cursoricon.c.

{
    PCURICON_OBJECT CurIcon;
 
    if (!hCurIcon)
    {
        EngSetLastError(ERROR_INVALID_CURSOR_HANDLE);
        return NULL;
    }
 
    if (UserObjectInDestroy(hCurIcon))
    {
        WARN("Requesting invalid/destroyed cursor.\n");
        EngSetLastError(ERROR_INVALID_CURSOR_HANDLE);
        return NULL;
    }
 
    CurIcon = (PCURICON_OBJECT)UserReferenceObjectByHandle(hCurIcon, TYPE_CURSOR);
    if (!CurIcon)
    {
        /* We never set ERROR_INVALID_ICON_HANDLE. lets hope noone ever checks for it */
        EngSetLastError(ERROR_INVALID_CURSOR_HANDLE);
        return NULL;
    }
 
    ASSERT(CurIcon->head.cLockObj >= 1);
    return CurIcon;
}

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

UserSetCursorPos()

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

Definition at line 238 of file cursoricon.c.

{
    PWND DesktopWindow;
    PSYSTEM_CURSORINFO CurInfo;
    MSG Msg;
    RECTL rcClip;
    POINT pt;
 
    if (!(DesktopWindow = UserGetDesktopWindow()))
    {
        return FALSE;
    }
 
    CurInfo = IntGetSysCursorInfo();
 
    /* Clip cursor position */
    if (!CurInfo->bClipped)
        rcClip = DesktopWindow->rcClient;
    else
        rcClip = CurInfo->rcClip;
 
    if (x >= rcClip.right)  x = rcClip.right - 1;
    if (x < rcClip.left)    x = rcClip.left;
    if (y >= rcClip.bottom) y = rcClip.bottom - 1;
    if (y < rcClip.top)     y = rcClip.top;
 
    /* Nothing to do if position did not actually change */
    if (x == gpsi->ptCursor.x && y == gpsi->ptCursor.y)
        return TRUE;
 
    pt.x = x;
    pt.y = y;
 
    /* 1. Generate a mouse move message, this sets the htEx and Track Window too */
    Msg.message = WM_MOUSEMOVE;
    Msg.wParam = UserGetMouseButtonsState();
    Msg.lParam = MAKELPARAM(x, y);
    Msg.pt = pt;
    co_MsqInsertMouseMessage(&Msg, flags, dwExtraInfo, Hook);
 
    /* 2. Store the new cursor position */
    gpsi->ptCursor = pt;
 
    return TRUE;
}

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

Variable Documentation

gasyscur

SYSTEMCURICO gasyscur[]

extern

Definition at line 32 of file cursoricon.c.

Referenced by NtUserSetSystemCursor().

gasysico

SYSTEMCURICO gasysico[]

extern

Definition at line 54 of file cursoricon.c.

Referenced by IntLoadSystenIcons().