mouse.h File Reference

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

Go to the source code of this file.

Functions
_Requires_lock_held_ ppdev BOOL NTAPI	MouseSafetyOnDrawStart (_Inout_ PPDEVOBJ ppdev, _In_ LONG HazardX1, _In_ LONG HazardY1, _In_ LONG HazardX2, _In_ LONG HazardY2)
_Requires_lock_held_ ppdev BOOL NTAPI	MouseSafetyOnDrawEnd (_Inout_ PPDEVOBJ ppdev)
ULONG NTAPI	IntEngSetPointerShape (_In_ SURFOBJ *pso, _In_opt_ SURFOBJ *psoMask, _In_opt_ SURFOBJ *psoColor, _In_opt_ XLATEOBJ *pxlo, _In_ LONG xHot, _In_ LONG yHot, _In_ LONG x, _In_ LONG y, _In_ RECTL *prcl, _In_ FLONG fl)
ULONG NTAPI	GreSetPointerShape (_In_ HDC hdc, _In_opt_ HBITMAP hbmMask, _In_opt_ HBITMAP hbmColor, _In_ LONG xHot, _In_ LONG yHot, _In_ LONG x, _In_ LONG y, _In_ FLONG fl)
VOID NTAPI	GreMovePointer (_In_ HDC hdc, _In_ LONG x, _In_ LONG y)

Function Documentation

GreMovePointer()

VOID NTAPI GreMovePointer	(	_In_ HDC	hdc,
		_In_ LONG	x,
		_In_ LONG	y
	)

Definition at line 799 of file mouse.c.

{
    PDC pdc;
    PRECTL prcl;
 
    /* Lock the DC */
    pdc = DC_LockDc(hdc);
    if (!pdc)
    {
        DPRINT1("Failed to lock the DC.\n");
        return;
    }
    ASSERT(pdc->dctype == DCTYPE_DIRECT);
 
    /* Acquire PDEV lock */
    EngAcquireSemaphore(pdc->ppdev->hsemDevLock);
 
    /* Check if we need to move it */
    if(pdc->ppdev->SafetyRemoveLevel == 0)
    {
        SURFOBJ* pso = &pdc->ppdev->pSurface->SurfObj;
 
        /* Store the cursor exclude position in the PDEV */
        prcl = &pdc->ppdev->Pointer.Exclude;
 
        /* Send new position of the hot spot of the pointer (will likely redraw cursor) */
        if (pdc->ppdev->flFlags & PDEV_HARDWARE_POINTER)
            pdc->ppdev->pfnMovePointer(pso, x, y, prcl);
        else if (pdc->ppdev->flFlags & PDEV_SOFTWARE_POINTER)
            EngMovePointer(pso, x, y, prcl);
 
        /* If panning device, and we're not hiding the cursor, notify cursor's current position.
         * (driver may already have been called if it also supports hardware pointers) */
        if (pdc->ppdev->devinfo.flGraphicsCaps & GCAPS_PANNING && y >= 0)
            pdc->ppdev->pfnMovePointer(pso, x, y - pso->sizlBitmap.cy, NULL);
    }
 
    /* Release PDEV lock */
    EngReleaseSemaphore(pdc->ppdev->hsemDevLock);
 
    /* Unlock the DC */
    DC_UnlockDc(pdc);
}

Referenced by co_MsqInsertMouseMessage(), MsqCleanupMessageQueue(), UserSetCursor(), and UserShowCursor().

GreSetPointerShape()

ULONG NTAPI GreSetPointerShape	(	_In_ HDC	hdc,
		_In_opt_ HBITMAP	hbmMask,
		_In_opt_ HBITMAP	hbmColor,
		_In_ LONG	xHot,
		_In_ LONG	yHot,
		_In_ LONG	x,
		_In_ LONG	y,
		_In_ FLONG	fl
	)

Definition at line 703 of file mouse.c.

{
    PDC pdc;
    PSURFACE psurf, psurfMask, psurfColor;
    EXLATEOBJ exlo;
    ULONG ulResult = 0;
 
    pdc = DC_LockDc(hdc);
    if (!pdc)
    {
        DPRINT1("Failed to lock the DC.\n");
        return 0;
    }
 
    ASSERT(pdc->dctype == DCTYPE_DIRECT);
    EngAcquireSemaphore(pdc->ppdev->hsemDevLock);
    /* We're not sure DC surface is the good one */
    psurf = pdc->ppdev->pSurface;
    if (!psurf)
    {
        DPRINT1("DC has no surface.\n");
        EngReleaseSemaphore(pdc->ppdev->hsemDevLock);
        DC_UnlockDc(pdc);
        return 0;
    }
 
    /* Lock the mask bitmap */
    if (hbmMask)
    {
        psurfMask = SURFACE_ShareLockSurface(hbmMask);
    }
    else
    {
        //ASSERT(fl & SPS_ALPHA);
        psurfMask = NULL;
    }
 
    /* Check for color bitmap */
    if (hbmColor)
    {
        /* We have one, lock it */
        psurfColor = SURFACE_ShareLockSurface(hbmColor);
 
        if (psurfColor)
        {
            /* Create an XLATEOBJ, no mono support */
            EXLATEOBJ_vInitialize(&exlo, psurfColor->ppal, psurf->ppal, 0, 0, 0);
        }
    }
    else
        psurfColor = NULL;
 
    /* We must have a valid surface in case of alpha bitmap */
    ASSERT(((fl & SPS_ALPHA) && psurfColor) || !(fl & SPS_ALPHA));
 
    /* Call the driver or eng function */
    ulResult = IntEngSetPointerShape(&psurf->SurfObj,
                                     psurfMask ? &psurfMask->SurfObj : NULL,
                                     psurfColor ? &psurfColor->SurfObj : NULL,
                                     psurfColor ? &exlo.xlo : NULL,
                                     xHot,
                                     yHot,
                                     x,
                                     y,
                                     &pdc->ppdev->Pointer.Exclude,
                                     fl | SPS_CHANGE);
 
    /* Cleanup */
    if (psurfColor)
    {
        EXLATEOBJ_vCleanup(&exlo);
        SURFACE_ShareUnlockSurface(psurfColor);
    }
 
    if (psurfMask)
        SURFACE_ShareUnlockSurface(psurfMask);
 
    EngReleaseSemaphore(pdc->ppdev->hsemDevLock);
 
    /* Unlock the DC */
    DC_UnlockDc(pdc);
 
    /* Return result */
    return ulResult;
}

Referenced by co_MsqInsertMouseMessage(), and UserSetCursor().

IntEngSetPointerShape()

ULONG NTAPI IntEngSetPointerShape	(	_In_ SURFOBJ *	pso,
		_In_opt_ SURFOBJ *	psoMask,
		_In_opt_ SURFOBJ *	psoColor,
		_In_opt_ XLATEOBJ *	pxlo,
		_In_ LONG	xHot,
		_In_ LONG	yHot,
		_In_ LONG	x,
		_In_ LONG	y,
		_In_ RECTL *	prcl,
		_In_ FLONG	fl
	)

Definition at line 615 of file mouse.c.

{
    ULONG ulResult = SPS_DECLINE;
    PFN_DrvSetPointerShape pfnSetPointerShape;
    PPDEVOBJ ppdev = GDIDEV(pso);
    BOOL bHardwarePointer = FALSE;
    BOOL bSoftwarePointer = TRUE;
 
    pfnSetPointerShape = GDIDEVFUNCS(pso).SetPointerShape;
 
    if (pfnSetPointerShape)
    {
        /* Drivers expect to get an XLATEOBJ */
        if (pxlo == NULL)
            pxlo = &gexloTrivial.xlo;
 
        /* Call the driver */
        ulResult = pfnSetPointerShape(pso,
                                      psoMask,
                                      psoColor,
                                      pxlo,
                                      xHot,
                                      yHot,
                                      x,
                                      y,
                                      prcl,
                                      fl);
 
        /* Check if the driver accepted it */
        if (ulResult == SPS_ACCEPT_NOEXCLUDE)
            bHardwarePointer = TRUE;
 
        bSoftwarePointer = !bHardwarePointer;
    }
 
    if (bSoftwarePointer)
    {
        /* Set software pointer */
        ulResult = EngSetPointerShape(pso,
                                      psoMask,
                                      psoColor,
                                      pxlo,
                                      xHot,
                                      yHot,
                                      x,
                                      y,
                                      prcl,
                                      fl);
    }
 
    if (!bSoftwarePointer && ppdev->flFlags & PDEV_SOFTWARE_POINTER)
    {
        /* Disable software pointer */
        EngMovePointer(pso, -1, -1, NULL);
    }
 
    if (!bHardwarePointer && ppdev->flFlags & PDEV_HARDWARE_POINTER)
    {
        /* Disable hardware pointer */
        ppdev->pfnMovePointer(pso, -1, -1, NULL);
    }
 
    /* Update flags */
    if (bSoftwarePointer)
        ppdev->flFlags |= PDEV_SOFTWARE_POINTER;
    else
        ppdev->flFlags &= ~PDEV_SOFTWARE_POINTER;
 
    if (bHardwarePointer)
        ppdev->flFlags |= PDEV_HARDWARE_POINTER;
    else
        ppdev->flFlags &= ~PDEV_HARDWARE_POINTER;
 
    return ulResult;
}

Referenced by GreSetPointerShape().

MouseSafetyOnDrawEnd()

_Requires_lock_held_ ppdev BOOL NTAPI MouseSafetyOnDrawEnd

(

_Inout_ PPDEVOBJ

ppdev

)

Definition at line 102 of file mouse.c.

{
    GDIPOINTER *pgp;
 
    ASSERT(ppdev != NULL);
    ASSERT(ppdev->pSurface != NULL);
 
    pgp = &ppdev->Pointer;
 
    if (pgp->Exclude.right == -1)
    {
        return FALSE;
    }
 
    if (--ppdev->SafetyRemoveCount >= ppdev->SafetyRemoveLevel)
    {
        return FALSE;
    }
 
    if (ppdev->flFlags & PDEV_HARDWARE_POINTER)
        ppdev->pfnMovePointer(&ppdev->pSurface->SurfObj,
                              gpsi->ptCursor.x,
                              gpsi->ptCursor.y,
                              &pgp->Exclude);
    else if (ppdev->flFlags & PDEV_SOFTWARE_POINTER)
        EngMovePointer(&ppdev->pSurface->SurfObj,
                       gpsi->ptCursor.x,
                       gpsi->ptCursor.y,
                       &pgp->Exclude);
 
    ppdev->SafetyRemoveLevel = 0;
 
    return TRUE;
}

Referenced by DC_vFinishBlit().

MouseSafetyOnDrawStart()

_Requires_lock_held_ ppdev BOOL NTAPI MouseSafetyOnDrawStart	(	_Inout_ PPDEVOBJ	ppdev,
		_In_ LONG	HazardX1,
		_In_ LONG	HazardY1,
		_In_ LONG	HazardX2,
		_In_ LONG	HazardY2
	)

Definition at line 41 of file mouse.c.

{
    LONG tmp;
    GDIPOINTER *pgp;
 
    ASSERT(ppdev != NULL);
    ASSERT(ppdev->pSurface != NULL);
 
    pgp = &ppdev->Pointer;
 
    if (pgp->Exclude.right == -1)
    {
        return FALSE;
    }
 
    ppdev->SafetyRemoveCount++;
 
    if (ppdev->SafetyRemoveLevel != 0)
    {
        return FALSE;
    }
 
    if (HazardX1 > HazardX2)
    {
        tmp = HazardX2;
        HazardX2 = HazardX1;
        HazardX1 = tmp;
    }
    if (HazardY1 > HazardY2)
    {
        tmp = HazardY2;
        HazardY2 = HazardY1;
        HazardY1 = tmp;
    }
 
    if (pgp->Exclude.right >= HazardX1
        && pgp->Exclude.left <= HazardX2
        && pgp->Exclude.bottom >= HazardY1
        && pgp->Exclude.top <= HazardY2)
    {
        ppdev->SafetyRemoveLevel = ppdev->SafetyRemoveCount;
        if (ppdev->flFlags & PDEV_HARDWARE_POINTER)
            ppdev->pfnMovePointer(&ppdev->pSurface->SurfObj, -1, -1, NULL);
        else if (ppdev->flFlags & PDEV_SOFTWARE_POINTER)
            EngMovePointer(&ppdev->pSurface->SurfObj, -1, -1, NULL);
    }
 
    return TRUE;
}

Referenced by DC_vPrepareDCsForBlit().