1032 lines
47 KiB
C
1032 lines
47 KiB
C
/****************************************************************************/
|
|
// ncmapi.c
|
|
//
|
|
// RDP Cursor Manager API functions.
|
|
//
|
|
// Copyright (C) 1996-2000 Microsoft Corporation
|
|
/****************************************************************************/
|
|
|
|
#include <precmpdd.h>
|
|
#pragma hdrstop
|
|
|
|
#define TRC_FILE "ncmapi"
|
|
#include <adcg.h>
|
|
|
|
#include <ncmdisp.h>
|
|
#include <nschdisp.h>
|
|
|
|
#define DC_INCLUDE_DATA
|
|
#include <ndddata.c>
|
|
#undef DC_INCLUDE_DATA
|
|
|
|
#include <ncmdata.c>
|
|
#include <nchdisp.h>
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Name: CM_DDInit */
|
|
/* */
|
|
/* Purpose: Initialises the display driver component of the cursor */
|
|
/* manager. */
|
|
/* */
|
|
/* Returns: TRUE if successful, FALSE otherwise. */
|
|
/* */
|
|
/* Params: IN ppDev - pointer to pDev for work bitmap */
|
|
/****************************************************************************/
|
|
BOOL RDPCALL CM_DDInit(PDD_PDEV ppDev)
|
|
{
|
|
BOOL rc = TRUE;
|
|
SIZEL bitmapSize;
|
|
|
|
DC_BEGIN_FN("CM_DDInit");
|
|
|
|
/************************************************************************/
|
|
/* Allocate the work bitmap, at the local device resolution. Note that */
|
|
/* we create it "top down" rather than the default of "bottom up" to */
|
|
/* simplify copying data from the bitmap (we don't have to work out */
|
|
/* offsets into the data - we can copy from the beginning). */
|
|
/************************************************************************/
|
|
bitmapSize.cx = CM_MAX_CURSOR_WIDTH;
|
|
bitmapSize.cy = CM_MAX_CURSOR_HEIGHT;
|
|
cmWorkBitmap24 = EngCreateBitmap(bitmapSize,
|
|
TS_BYTES_IN_SCANLINE(bitmapSize.cx, 24), BMF_24BPP, BMF_TOPDOWN,
|
|
NULL);
|
|
|
|
#ifdef DC_HICOLOR
|
|
cmWorkBitmap16 = EngCreateBitmap(bitmapSize,
|
|
TS_BYTES_IN_SCANLINE(bitmapSize.cx, 16), BMF_16BPP, BMF_TOPDOWN,
|
|
NULL);
|
|
if (cmWorkBitmap16 == NULL)
|
|
{
|
|
/********************************************************************/
|
|
/* We can carry on with reduced function without this one */
|
|
/********************************************************************/
|
|
TRC_ERR((TB, "Failed to create 16bpp work bitmap"));
|
|
pddShm->cm.cmSendAnyColor = FALSE;
|
|
}
|
|
#endif
|
|
|
|
if (cmWorkBitmap24 != NULL) {
|
|
TRC_NRM((TB, "Created work bitmap successfully"));
|
|
|
|
// Reset the cursor stamp.
|
|
cmNextCursorStamp = 0;
|
|
}
|
|
else {
|
|
TRC_ERR((TB, "Failed to create work bitmaps"));
|
|
rc = FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
return rc;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Name: CM_Update */
|
|
/* */
|
|
/* Purpose: The capabilities may have changed */
|
|
/****************************************************************************/
|
|
void RDPCALL CM_Update(void)
|
|
{
|
|
PCHCACHEDATA pCacheData;
|
|
|
|
DC_BEGIN_FN("CM_Update");
|
|
|
|
/************************************************************************/
|
|
/* Create the cursor cache. */
|
|
/************************************************************************/
|
|
if (cmCursorCacheHandle == NULL) {
|
|
if (pddShm->cm.cmCacheSize) {
|
|
pCacheData = (PCHCACHEDATA)EngAllocMem(0,
|
|
CH_CalculateCacheSize(pddShm->cm.cmCacheSize),
|
|
DD_ALLOC_TAG);
|
|
|
|
if (pCacheData != NULL) {
|
|
CH_InitCache(pCacheData, pddShm->cm.cmCacheSize, NULL,
|
|
FALSE, FALSE, NULL);
|
|
cmCursorCacheHandle = pCacheData;
|
|
}
|
|
else {
|
|
TRC_ERR((TB, "Failed to create cache: cEntries(%u)",
|
|
pddShm->cm.cmCacheSize));
|
|
}
|
|
}
|
|
else {
|
|
TRC_ERR((TB, "Zero size Cursor Cache"));
|
|
}
|
|
}
|
|
|
|
// Else just clear it for synchonization purposes.
|
|
else {
|
|
CH_ClearCache(cmCursorCacheHandle);
|
|
}
|
|
|
|
DC_END_FN();
|
|
} /* CM_Update */
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Name: CM_DDDisc */
|
|
/* */
|
|
/* Purpose: Disconnects the display driver component of the cursor */
|
|
/* manager. */
|
|
/****************************************************************************/
|
|
void RDPCALL CM_DDDisc(void)
|
|
{
|
|
DC_BEGIN_FN("CM_DDDisc");
|
|
|
|
/************************************************************************/
|
|
/* Free up the cursor cache */
|
|
/************************************************************************/
|
|
if (cmCursorCacheHandle != 0) {
|
|
TRC_NRM((TB, "Destroying CM cache"));
|
|
CH_ClearCache(cmCursorCacheHandle);
|
|
EngFreeMem(cmCursorCacheHandle);
|
|
cmCursorCacheHandle = 0;
|
|
}
|
|
|
|
DC_END_FN();
|
|
} /* CM_DDDisc */
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Name: CM_DDTerm */
|
|
/* */
|
|
/* Purpose: Terminates the display driver component of the cursor */
|
|
/* manager. */
|
|
/* */
|
|
/* Returns: TRUE if successful, FALSE otherwise. */
|
|
/****************************************************************************/
|
|
void RDPCALL CM_DDTerm(void)
|
|
{
|
|
DC_BEGIN_FN("CM_DDTerm");
|
|
|
|
/************************************************************************/
|
|
/* Destroy the work bitmaps. Despite its name, EngDeleteSurface is the */
|
|
/* correct function to do this. */
|
|
/************************************************************************/
|
|
#ifdef DC_HICOLOR
|
|
if (cmWorkBitmap24)
|
|
{
|
|
if (!EngDeleteSurface((HSURF)cmWorkBitmap24))
|
|
{
|
|
TRC_ERR((TB, "Failed to delete 24bpp work bitmap"));
|
|
}
|
|
}
|
|
|
|
if (cmWorkBitmap16)
|
|
{
|
|
if (!EngDeleteSurface((HSURF)cmWorkBitmap16))
|
|
{
|
|
TRC_ERR((TB, "Failed to delete 16bpp work bitmap"));
|
|
}
|
|
}
|
|
#else
|
|
if (cmWorkBitmap24 != NULL) {
|
|
if (!EngDeleteSurface((HSURF)cmWorkBitmap24)) {
|
|
TRC_ERR((TB, "Failed to delete work bitmap"));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/************************************************************************/
|
|
/* Free up the cursor cache */
|
|
/************************************************************************/
|
|
if (cmCursorCacheHandle != 0) {
|
|
TRC_NRM((TB, "Destroying CM cache"));
|
|
CH_ClearCache(cmCursorCacheHandle);
|
|
EngFreeMem(cmCursorCacheHandle);
|
|
cmCursorCacheHandle = 0;
|
|
}
|
|
|
|
TRC_NRM((TB, "CM terminated"));
|
|
|
|
DC_END_FN();
|
|
} /* CM_DDTerm */
|
|
|
|
|
|
/****************************************************************************/
|
|
/* CM_InitShm */
|
|
/* */
|
|
/* Initializes CM Shared Memory. */
|
|
/****************************************************************************/
|
|
void RDPCALL CM_InitShm(void)
|
|
{
|
|
DC_BEGIN_FN("CM_InitShm");
|
|
|
|
// Set up initial contents of Shm memory, since it is not zeroed on
|
|
// init. Don't set up the initially unused cursor shape data.
|
|
// NOTE: cmCursorShapeData is specifically placed at the end of
|
|
// CM_SHARED_DATA to allow this memset to work. If you change
|
|
// the shared mem struct be sure this gets changed.
|
|
memset(&pddShm->cm, 0, (unsigned)FIELDOFFSET(CM_SHARED_DATA,
|
|
cmCursorShapeData.data));
|
|
|
|
// Set the last known position to something impossible. The IM
|
|
// periodic processing will not move the client's mouse until a
|
|
// sensible value is found here, ie until the client has sent us a
|
|
// mouse position and it has percolated through to the DD. This
|
|
// avoids the problem of the mouse leaping to 0,0 on connection.
|
|
pddShm->cm.cmCursorPos.x = 0xffffffff;
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* DrvMovePointer - see NT DDK documentation. */
|
|
/* */
|
|
/****************************************************************************/
|
|
VOID DrvMovePointer(SURFOBJ *pso, LONG x, LONG y, RECTL *prcl)
|
|
{
|
|
DC_BEGIN_FN(("DrvMovePointer"));
|
|
|
|
//
|
|
// Win32k hides the hardware cursor by calling the MovePointer
|
|
// entry point with (-1,-1). Treat this as a procedural move
|
|
// and pass it on to the real worker function
|
|
//
|
|
// All other paths are handled directly by win32k calling
|
|
// DrvMovePointerEx with the right flags
|
|
//
|
|
if (-1 == x && -1 == y) {
|
|
DrvMovePointerEx(pso, x, y, MP_PROCEDURAL);
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
//
|
|
// DrvMovePointerEx
|
|
//
|
|
// Params:
|
|
// x,y - new mouse position.
|
|
// ulFlags - source of move (see winddits.h).
|
|
//
|
|
// This function replaces the regular DrvMovePointer entry point
|
|
// by also sending us an event source parameter.
|
|
//
|
|
// This allows us to determine if we should ignore the update (e.g
|
|
// if it originates from the primary stack). Or send it down to the
|
|
// client in the case of a server initiated move or a shadow move.
|
|
//
|
|
// We ignore updates from the primary stack because by definition
|
|
// those came from the client so it doesn't need feedback from the
|
|
// server.
|
|
//
|
|
BOOL DrvMovePointerEx(SURFOBJ *pso, LONG x, LONG y, ULONG ulFlags)
|
|
{
|
|
BOOL fTriggerUpdate = FALSE;
|
|
PDD_PDEV ppDev = (PDD_PDEV)pso->dhpdev;
|
|
|
|
DC_BEGIN_FN("CM_DrvMovePointerEx");
|
|
|
|
if (pddShm != NULL) {
|
|
if ((ulFlags & MP_TERMSRV_SHADOW) ||
|
|
(ulFlags & MP_PROCEDURAL))
|
|
{
|
|
if (x == -1) {
|
|
// -1 means hide the pointer.
|
|
TRC_NRM((TB, "Hide the pointer"));
|
|
pddShm->cm.cmHidden = TRUE;
|
|
}
|
|
else {
|
|
// Pointer is not hidden.
|
|
if (pddShm->cm.cmHidden) {
|
|
TRC_NRM((TB, "Unhide the pointer"));
|
|
}
|
|
|
|
pddShm->cm.cmHidden = FALSE;
|
|
|
|
//
|
|
// We always update the position for server initated moves.
|
|
//
|
|
pddShm->cm.cmCursorPos.x = x;
|
|
pddShm->cm.cmCursorPos.y = y;
|
|
|
|
//
|
|
// Send an update so we don't need to wait
|
|
// for the next output flush.
|
|
//
|
|
fTriggerUpdate = TRUE;
|
|
|
|
// Set the cursor moved flag.
|
|
pddShm->cm.cmCursorMoved = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TRC_ALT((TB,"Discarding move (%d,%d) - src 0x%x",
|
|
x,y, ulFlags));
|
|
}
|
|
|
|
if (fTriggerUpdate)
|
|
{
|
|
//
|
|
// Tell the scheduler to send an update
|
|
//
|
|
SCH_DDOutputAvailable(ppDev, FALSE);
|
|
}
|
|
}
|
|
else {
|
|
TRC_DBG((TB, "Ignoring move to %d %d as no shr mem yet", x,y));
|
|
}
|
|
|
|
DC_END_FN();
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* DrvSetPointerShape - see winddi.h */
|
|
/* */
|
|
/****************************************************************************/
|
|
ULONG DrvSetPointerShape(SURFOBJ *pso,
|
|
SURFOBJ *psoMask,
|
|
SURFOBJ *psoColor,
|
|
XLATEOBJ *pxlo,
|
|
LONG xHot,
|
|
LONG yHot,
|
|
LONG x,
|
|
LONG y,
|
|
RECTL *prcl,
|
|
FLONG fl)
|
|
{
|
|
ULONG rc = SPS_ACCEPT_NOEXCLUDE;
|
|
SURFOBJ *pWorkSurf;
|
|
PDD_PDEV ppDev = (PDD_PDEV)pso->dhpdev;
|
|
|
|
XLATEOBJ workXlo;
|
|
SURFOBJ *psoToUse;
|
|
|
|
PCM_CURSOR_SHAPE_DATA pCursorShapeData;
|
|
RECTL destRectl;
|
|
POINTL sourcePt;
|
|
unsigned ii;
|
|
LONG lineLen;
|
|
LONG colorLineLen;
|
|
PBYTE srcPtr;
|
|
PBYTE dstPtr;
|
|
#ifdef DC_HICOLOR
|
|
unsigned targetBpp;
|
|
#endif
|
|
|
|
ULONG palMono[2];
|
|
ULONG palBGR[256];
|
|
|
|
unsigned iCacheEntry;
|
|
void *UserDefined;
|
|
CHDataKeyContext CHContext;
|
|
|
|
DC_BEGIN_FN("DrvSetPointerShape");
|
|
|
|
/************************************************************************/
|
|
// Trace useful info about the cursor
|
|
/************************************************************************/
|
|
TRC_DBG((TB, "pso %#hlx psoMask %#hlx psoColor %#hlx pxlo %#hlx",
|
|
pso, psoMask, psoColor, pxlo));
|
|
TRC_DBG((TB, "hot spot (%d, %d) x, y (%d, %d)", xHot, yHot, x, y));
|
|
TRC_DBG((TB, "Flags %#hlx", fl));
|
|
|
|
/************************************************************************/
|
|
/* check for the shared memory */
|
|
/************************************************************************/
|
|
if (pddShm != NULL && cmCursorCacheHandle != NULL)
|
|
{
|
|
/********************************************************************/
|
|
// Check to see if the WD got the last cursor we passed it.
|
|
//
|
|
// Potentially, we might get called and then called again before the
|
|
// WD gets round to sending the first cursor. This doesn't matter
|
|
// for a cursor that is already cached - its just a form of spoiling!
|
|
// But if it was a cursor definition packet that didn't get sent,
|
|
// then later on when we try to use it again, we will send the client
|
|
// instructions to use a cache entry for which it doesn't have any
|
|
// bits!
|
|
/********************************************************************/
|
|
if (pddShm->cm.cmBitsWaiting)
|
|
{
|
|
TRC_ALT((TB, "WD did not pick up cursor bits - removing entry %d",
|
|
pddShm->cm.cmCacheEntry));
|
|
|
|
CH_RemoveCacheEntry(cmCursorCacheHandle,
|
|
pddShm->cm.cmCacheEntry);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* Returning SPS_ACCEPT_NOEXCLUDE means we can ignore prcl. */
|
|
/************************************************************************/
|
|
DC_IGNORE_PARAMETER(prcl);
|
|
DC_IGNORE_PARAMETER(x);
|
|
DC_IGNORE_PARAMETER(y);
|
|
|
|
/************************************************************************/
|
|
/* Set up the position information - in particular, the cursor can be */
|
|
/* unhidden via this function */
|
|
/************************************************************************/
|
|
if (x == -1) {
|
|
/********************************************************************/
|
|
/* -1 means hide the pointer. */
|
|
/********************************************************************/
|
|
TRC_NRM((TB, "Hide the pointer"));
|
|
pddShm->cm.cmHidden = TRUE;
|
|
}
|
|
else {
|
|
if (pddShm->cm.cmHidden) {
|
|
TRC_NRM((TB, "Unhide the pointer"));
|
|
}
|
|
|
|
pddShm->cm.cmHidden = FALSE;
|
|
}
|
|
|
|
// Set up a local pointer to the cursor shape data.
|
|
pCursorShapeData = &(pddShm->cm.cmCursorShapeData);
|
|
|
|
// Check mask pointer and cursor size. For no mask or too-large pointer,
|
|
// we send a null cursor. Note that the bitmap we are passed contains
|
|
// TWO masks, one 'above' the other, and so is in fact twice the
|
|
// height of the cursor, so we divide cy by 2.
|
|
if (psoMask == NULL ||
|
|
(psoMask->sizlBitmap.cx > CM_MAX_CURSOR_WIDTH) ||
|
|
((psoMask->sizlBitmap.cy / 2) > CM_MAX_CURSOR_HEIGHT)) {
|
|
// Note that NULL cursor is not the same as hiding the cursor using
|
|
// DrvMovePointer(), it is a transparent shape that cannot be
|
|
// changed without another DrvSetPointerShape() call.
|
|
TRC_NRM((TB, "Transparent or too-large cursor: psoMask=%p, "
|
|
"width=%u, height=%u", psoMask,
|
|
(psoMask != NULL ? psoMask->sizlBitmap.cx : 0),
|
|
(psoMask != NULL ? psoMask->sizlBitmap.cy / 2 : 0)));
|
|
CM_SET_NULL_CURSOR(pCursorShapeData);
|
|
pddShm->cm.cmHidden = FALSE;
|
|
pddShm->cm.cmCacheHit = FALSE;
|
|
pddShm->cm.cmCursorStamp = cmNextCursorStamp++;
|
|
|
|
// We set a null cursor. Now tell GDI to simulate it.
|
|
// do this if it's alpha or if a mask is specified which
|
|
// means the cursor is too big per the test above
|
|
if ( fl & SPS_ALPHA || psoMask) {
|
|
rc = SPS_DECLINE;
|
|
SCH_DDOutputAvailable(ppDev, TRUE);
|
|
}
|
|
DC_QUIT;
|
|
}
|
|
|
|
/************************************************************************/
|
|
// Now we look to see if the cursor is one we've sent before.
|
|
// We have to cache both the mask and any color information as
|
|
// potentially we could have the same _shape_ cursor but with different
|
|
// colors.
|
|
/************************************************************************/
|
|
CH_CreateKeyFromFirstData(&CHContext, psoMask->pvBits, psoMask->cjBits);
|
|
if (psoColor != NULL)
|
|
CH_CreateKeyFromNextData(&CHContext, psoColor->pvBits,
|
|
psoColor->cjBits);
|
|
|
|
/************************************************************************/
|
|
/* Now we can look for the cursor in the cache */
|
|
/************************************************************************/
|
|
if (CH_SearchCache(cmCursorCacheHandle, CHContext.Key1, CHContext.Key2,
|
|
&UserDefined, &iCacheEntry))
|
|
{
|
|
TRC_NRM((TB, "Found cached cursor %d", iCacheEntry));
|
|
|
|
/********************************************************************/
|
|
/* Flag a cache hit */
|
|
/********************************************************************/
|
|
pddShm->cm.cmCacheHit = TRUE;
|
|
pddShm->cm.cmCacheEntry = iCacheEntry;
|
|
}
|
|
else
|
|
{
|
|
/********************************************************************/
|
|
/* If we didn't find it, then let's cache it */
|
|
/********************************************************************/
|
|
pddShm->cm.cmCacheHit = FALSE;
|
|
iCacheEntry = CH_CacheKey(cmCursorCacheHandle, CHContext.Key1,
|
|
CHContext.Key2, NULL);
|
|
pddShm->cm.cmCacheEntry = iCacheEntry;
|
|
TRC_NRM((TB, "Cache new cursor: iEntry(%u)", iCacheEntry));
|
|
|
|
/********************************************************************/
|
|
// Tell the WD that there are bits waiting for it.
|
|
// We do this here no matter if we DC_QUIT later, to make sure
|
|
// we clean up the new cache entry on the next call if the WD has
|
|
// not picked up the bits.
|
|
/********************************************************************/
|
|
pddShm->cm.cmBitsWaiting = TRUE;
|
|
|
|
/********************************************************************/
|
|
/* We've been passed a system cursor. Fill in the header for our */
|
|
/* local cursor. We can get the hot spot position and cursor size */
|
|
/* and width easily. Note that the bitmap we are passed contains */
|
|
/* TWO masks, one 'above' the other, and so is in fact twice the */
|
|
/* height of the cursor */
|
|
/********************************************************************/
|
|
pCursorShapeData->hdr.ptHotSpot.x = xHot;
|
|
pCursorShapeData->hdr.ptHotSpot.y = yHot;
|
|
|
|
TRC_NRM((TB, "Pointer mask is %#hlx by %#hlx pixels (lDelta: %#hlx)",
|
|
psoMask->sizlBitmap.cx,
|
|
psoMask->sizlBitmap.cy,
|
|
psoMask->lDelta));
|
|
|
|
pCursorShapeData->hdr.cx = (WORD)psoMask->sizlBitmap.cx;
|
|
pCursorShapeData->hdr.cy = (WORD)psoMask->sizlBitmap.cy / 2;
|
|
|
|
/********************************************************************/
|
|
/* lDelta may be negative for an inverted cursor */
|
|
/********************************************************************/
|
|
lineLen = (psoMask->lDelta >= 0 ? psoMask->lDelta : -psoMask->lDelta);
|
|
|
|
/********************************************************************/
|
|
/* set up the common parts of the shape header */
|
|
/********************************************************************/
|
|
pCursorShapeData->hdr.cPlanes = 1;
|
|
|
|
pCursorShapeData->hdr.cbMaskRowWidth =
|
|
(WORD)(((psoMask->sizlBitmap.cx + 15) & ~15) / 8);
|
|
|
|
/********************************************************************/
|
|
/* Check to see what format we want the cursor in */
|
|
/********************************************************************/
|
|
if (pddShm->cm.cmNativeColor)
|
|
{
|
|
TRC_NRM((TB, "Using native bpp %d", ppDev->cClientBitsPerPel));
|
|
|
|
/****************************************************************/
|
|
/* If we've been passed a mono cursor, we just get the bits as */
|
|
/* for the AND mask, flipping as we go */
|
|
/****************************************************************/
|
|
if (NULL == psoColor)
|
|
{
|
|
unsigned targetRowWidth;
|
|
|
|
TRC_NRM((TB, "Monochrome pointer"));
|
|
/************************************************************/
|
|
/* Get the AND mask - this is always mono. Note that we */
|
|
/* have to flip it too */
|
|
/************************************************************/
|
|
TRC_NRM((TB, "Copy %d bytes of 1bpp AND mask",
|
|
psoMask->cjBits));
|
|
|
|
targetRowWidth = ((psoMask->sizlBitmap.cx + 15) & ~15) / 8;
|
|
|
|
dstPtr = pCursorShapeData->data;
|
|
srcPtr = (BYTE *)psoMask->pvScan0
|
|
+ psoMask->cjBits / 2
|
|
- lineLen;
|
|
|
|
for (ii = pCursorShapeData->hdr.cy; ii > 0 ; ii--)
|
|
{
|
|
memcpy(dstPtr, srcPtr, targetRowWidth);
|
|
srcPtr -= lineLen;
|
|
dstPtr += targetRowWidth;
|
|
}
|
|
|
|
/************************************************************/
|
|
/* now the XOR mask */
|
|
/************************************************************/
|
|
pCursorShapeData->hdr.cBitsPerPel = 1;
|
|
dstPtr = &(pCursorShapeData->data[targetRowWidth *
|
|
pCursorShapeData->hdr.cy]);
|
|
srcPtr = (BYTE *)psoMask->pvScan0
|
|
+ psoMask->cjBits - lineLen;
|
|
|
|
pCursorShapeData->hdr.cbColorRowWidth = targetRowWidth;
|
|
|
|
for (ii = pCursorShapeData->hdr.cy; ii > 0 ; ii--)
|
|
{
|
|
memcpy(dstPtr, srcPtr, targetRowWidth);
|
|
srcPtr -= lineLen;
|
|
dstPtr += targetRowWidth;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
unsigned targetMaskRowWidth;
|
|
|
|
TRC_NRM((TB, "Color pointer"));
|
|
|
|
/************************************************************/
|
|
/* Get the AND mask - this is always mono */
|
|
/************************************************************/
|
|
TRC_NRM((TB, "Copy %d bytes of 1bpp AND mask",
|
|
psoMask->cjBits));
|
|
|
|
targetMaskRowWidth = ((psoMask->sizlBitmap.cx + 15) & ~15) / 8;
|
|
|
|
dstPtr = pCursorShapeData->data;
|
|
srcPtr = (BYTE *)psoMask->pvScan0;
|
|
for (ii = pCursorShapeData->hdr.cy; ii > 0 ; ii--)
|
|
{
|
|
memcpy(dstPtr, srcPtr, targetMaskRowWidth);
|
|
srcPtr += lineLen;
|
|
dstPtr += targetMaskRowWidth;
|
|
}
|
|
|
|
/************************************************************/
|
|
/* and the XOR mask */
|
|
/************************************************************/
|
|
#ifndef DC_HICOLOR
|
|
pCursorShapeData->hdr.cBitsPerPel =
|
|
(BYTE)ppDev->cClientBitsPerPel;
|
|
#endif
|
|
colorLineLen = psoColor->lDelta >=0 ? psoColor->lDelta :
|
|
-psoColor->lDelta;
|
|
|
|
pCursorShapeData->hdr.cbColorRowWidth = colorLineLen;
|
|
#ifdef DC_HICOLOR
|
|
|
|
if (psoColor->iBitmapFormat < BMF_24BPP) {
|
|
pCursorShapeData->hdr.cBitsPerPel = 1 << psoColor->iBitmapFormat;
|
|
}
|
|
else if (psoColor->iBitmapFormat == BMF_24BPP) {
|
|
pCursorShapeData->hdr.cBitsPerPel = 24;
|
|
}
|
|
else if (psoColor->iBitmapFormat == BMF_32BPP) {
|
|
pCursorShapeData->hdr.cBitsPerPel = 32;
|
|
}
|
|
else {
|
|
TRC_ASSERT((FALSE), (TB, "Bitmap format not supported"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
/********************************************************/
|
|
/* We've got a number of options at this point: */
|
|
/* */
|
|
/* - old clients only understand 8 or 24bpp cursors, so */
|
|
/* if the cursor is at 15/16bpp and its an old client, */
|
|
/* we need to convert it to 24bpp */
|
|
/* */
|
|
/* - 8bpp cursors assume the color information is in a */
|
|
/* color table; if we're running in hicolor, there */
|
|
/* won't be one, so we have to convert the cursor to a */
|
|
/* hicolor depth */
|
|
/* */
|
|
/* - anything else, we can just copy the bytes across */
|
|
/* and send them */
|
|
/* */
|
|
/********************************************************/
|
|
if ((!pddShm->cm.cmSendAnyColor &&
|
|
((pCursorShapeData->hdr.cBitsPerPel == 15) ||
|
|
(pCursorShapeData->hdr.cBitsPerPel == 16)))
|
|
|| ((pCursorShapeData->hdr.cBitsPerPel == 8) &&
|
|
(ppDev->cClientBitsPerPel > 8)))
|
|
{
|
|
/****************************************************/
|
|
/* if we can send at any old color...
|
|
/****************************************************/
|
|
if (pddShm->cm.cmSendAnyColor)
|
|
{
|
|
/************************************************/
|
|
/* ...we'll convert to the client session color */
|
|
/* depth */
|
|
/************************************************/
|
|
targetBpp = ppDev->cClientBitsPerPel;
|
|
}
|
|
else
|
|
{
|
|
/************************************************/
|
|
/* otherwise we'll convert to 24bpp */
|
|
/************************************************/
|
|
targetBpp = 24;
|
|
}
|
|
|
|
TRC_NRM((TB, "Convert %dbpp cursor to %d...",
|
|
pCursorShapeData->hdr.cBitsPerPel, targetBpp));
|
|
|
|
/****************************************************/
|
|
/* Use the supplied xlate object to convert to the */
|
|
/* client bpp */
|
|
/****************************************************/
|
|
if (targetBpp == 24)
|
|
{
|
|
pWorkSurf = EngLockSurface((HSURF)cmWorkBitmap24);
|
|
pCursorShapeData->hdr.cBitsPerPel = 24;
|
|
}
|
|
else
|
|
{
|
|
pWorkSurf = EngLockSurface((HSURF)cmWorkBitmap16);
|
|
pCursorShapeData->hdr.cBitsPerPel = 16;
|
|
}
|
|
if (NULL == pWorkSurf)
|
|
{
|
|
TRC_ERR((TB, "Failed to lock work surface"));
|
|
DC_QUIT;
|
|
}
|
|
TRC_DBG((TB, "Locked surface"));
|
|
|
|
/****************************************************/
|
|
/* Set up the 'to' rectangle */
|
|
/****************************************************/
|
|
destRectl.top = 0;
|
|
destRectl.left = 0;
|
|
destRectl.right = psoColor->sizlBitmap.cx;
|
|
destRectl.bottom = psoColor->sizlBitmap.cy;
|
|
|
|
/****************************************************/
|
|
/* and the source start point */
|
|
/****************************************************/
|
|
sourcePt.x = 0;
|
|
sourcePt.y = 0;
|
|
|
|
if (!EngBitBlt(pWorkSurf,
|
|
psoColor,
|
|
NULL, /* mask surface */
|
|
NULL, /* clip object */
|
|
pxlo, /* XLATE object */
|
|
&destRectl,
|
|
&sourcePt,
|
|
NULL, /* mask origin */
|
|
NULL, /* brush */
|
|
NULL, /* brush origin */
|
|
0xcccc)) /* SRCCPY */
|
|
{
|
|
TRC_ERR((TB, "Failed to Blt to work bitmap"));
|
|
EngUnlockSurface(pWorkSurf);
|
|
DC_QUIT;
|
|
}
|
|
TRC_DBG((TB, "Got the bits into the work bitmap"));
|
|
|
|
/****************************************************/
|
|
/* Finally we extract the color AND mask from the */
|
|
/* work bitmap */
|
|
/****************************************************/
|
|
TRC_NRM((TB, "Copy %d bytes of color",
|
|
pWorkSurf->cjBits));
|
|
memcpy(&(pCursorShapeData->data[targetMaskRowWidth *
|
|
pCursorShapeData->hdr.cy]),
|
|
pWorkSurf->pvBits,
|
|
pWorkSurf->cjBits);
|
|
pCursorShapeData->hdr.cbColorRowWidth = pWorkSurf->lDelta;
|
|
|
|
EngUnlockSurface(pWorkSurf);
|
|
}
|
|
else
|
|
{
|
|
#endif
|
|
TRC_NRM((TB, "Copy %d bytes of %ubpp AND mask (lDelta %u)",
|
|
colorLineLen * pCursorShapeData->hdr.cy,
|
|
pCursorShapeData->hdr.cBitsPerPel,
|
|
colorLineLen));
|
|
|
|
dstPtr = &(pCursorShapeData->data[targetMaskRowWidth *
|
|
pCursorShapeData->hdr.cy]);
|
|
srcPtr = (BYTE *)psoColor->pvScan0;
|
|
for (ii = pCursorShapeData->hdr.cy; ii > 0 ; ii--)
|
|
{
|
|
memcpy(dstPtr, srcPtr, colorLineLen);
|
|
srcPtr += psoColor->lDelta;
|
|
dstPtr += colorLineLen;
|
|
}
|
|
|
|
|
|
#ifdef DC_HICOLOR
|
|
}
|
|
#endif
|
|
// {
|
|
// memcpy(dstPtr, srcPtr, lineLen);
|
|
// srcPtr += colorLineLen;
|
|
// dstPtr += colorLineLen;
|
|
// }
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/****************************************************************/
|
|
// Now we need to blt the bitmap in to our work bitmap at
|
|
// 24bpp and get the bits from there.
|
|
/****************************************************************/
|
|
TRC_NRM((TB, "Forcing 24bpp"));
|
|
pCursorShapeData->hdr.cBitsPerPel = 24;
|
|
|
|
/****************************************************************/
|
|
/* Get the AND mask - this is always mono */
|
|
/****************************************************************/
|
|
TRC_NRM((TB, "Copy %d bytes of 1bpp AND mask", psoMask->cjBits/2))
|
|
|
|
dstPtr = pCursorShapeData->data;
|
|
srcPtr = (BYTE *)psoMask->pvScan0;
|
|
for (ii = pCursorShapeData->hdr.cy; ii > 0 ; ii--)
|
|
{
|
|
memcpy(dstPtr, srcPtr, lineLen);
|
|
srcPtr += lineLen;
|
|
dstPtr += lineLen;
|
|
}
|
|
|
|
/****************************************************************/
|
|
/* If we've been passed a mono cursor, we need to set up our */
|
|
/* own translation object, complete with color table */
|
|
/****************************************************************/
|
|
if (NULL == psoColor)
|
|
{
|
|
TRC_NRM((TB, "Monochrome pointer"));
|
|
|
|
// Row Width should be LONG aligned
|
|
pCursorShapeData->hdr.cbColorRowWidth =
|
|
(psoMask->sizlBitmap.cx *
|
|
pCursorShapeData->hdr.cBitsPerPel / 8 + 3) & ~3;
|
|
|
|
palMono[0] = 0;
|
|
palMono[1] = 0xFFFFFFFF;
|
|
|
|
workXlo.iUniq = 0;
|
|
workXlo.flXlate = XO_TABLE;
|
|
workXlo.iSrcType = PAL_INDEXED;
|
|
workXlo.iDstType = PAL_RGB;
|
|
workXlo.cEntries = 2;
|
|
workXlo.pulXlate = palMono;
|
|
|
|
/************************************************************/
|
|
/* Set up the 'to' rectangle */
|
|
/************************************************************/
|
|
destRectl.top = 0;
|
|
destRectl.left = 0;
|
|
destRectl.right = psoMask->sizlBitmap.cx;
|
|
destRectl.bottom = psoMask->sizlBitmap.cy / 2;
|
|
|
|
/************************************************************/
|
|
/* the source AND mask is the 'lower' half of the supplied */
|
|
/* bitmap */
|
|
/************************************************************/
|
|
sourcePt.x = 0;
|
|
sourcePt.y = psoMask->sizlBitmap.cy / 2;
|
|
|
|
/************************************************************/
|
|
/* and set up a pointer to the correct SO to use */
|
|
/************************************************************/
|
|
psoToUse = psoMask;
|
|
}
|
|
else
|
|
{
|
|
/************************************************************/
|
|
/* check that we're at 8bpp - this won't work if not */
|
|
/************************************************************/
|
|
TRC_ASSERT( (ppDev->cProtocolBitsPerPel == 8),
|
|
(TB, "Palette at %d bpp",
|
|
ppDev->cProtocolBitsPerPel) );
|
|
|
|
colorLineLen = psoColor->lDelta >= 0 ? psoColor->lDelta :
|
|
-psoColor->lDelta;
|
|
pCursorShapeData->hdr.cbColorRowWidth = colorLineLen *
|
|
pCursorShapeData->hdr.cBitsPerPel / 8;
|
|
|
|
if (psoColor->iBitmapFormat <= BMF_8BPP) {
|
|
|
|
/************************************************************/
|
|
/* For color cursors, the supplied XLATEOBJ is set up to */
|
|
/* convert from the cursor bpp to the screen bpp - which in */
|
|
/* most cases for us is a no-op since we will most often be */
|
|
/* at 8bpp (the maximum color depth we support). However, */
|
|
/* we actually need to convert to 24bpp for the wire */
|
|
/* format, which requires a change to the XLATEOBJ. We */
|
|
/* can't do this in place, since the XLATEOBJ we are passed */
|
|
/* seems to be used elsewhere - not least to display the */
|
|
/* desktop icons - so we set up our own */
|
|
/************************************************************/
|
|
workXlo.iUniq = 0; /* don't cache */
|
|
|
|
/************************************************************/
|
|
/* Set up to use the current palette (which is fortunately */
|
|
/* held in the DD_PDEV structure) */
|
|
/************************************************************/
|
|
workXlo.flXlate = XO_TABLE; /* we provide a lookup table */
|
|
/* to do the translation */
|
|
|
|
workXlo.iSrcType = PAL_INDEXED;/* pel values in the src bmp */
|
|
/* are indices into the table*/
|
|
|
|
workXlo.iDstType = PAL_RGB; /* entries in the table are */
|
|
/* RGB values for the dst bmp*/
|
|
|
|
workXlo.cEntries = 1 << ppDev->cProtocolBitsPerPel;
|
|
/* which has this many entries */
|
|
|
|
/************************************************************/
|
|
/* Now set up the palette to use in the XLATEOBJ. We have */
|
|
/* the current palette stored in the DD_PDEV structure - */
|
|
/* unfortunately it is in RGB format and we need BGR... */
|
|
/************************************************************/
|
|
for (ii = 0 ; ii < workXlo.cEntries; ii++)
|
|
{
|
|
palBGR[ii] = (ppDev->Palette[ii].peRed << 16)
|
|
| (ppDev->Palette[ii].peGreen << 8)
|
|
| (ppDev->Palette[ii].peBlue);
|
|
}
|
|
workXlo.pulXlate = palBGR;
|
|
|
|
/************************************************************/
|
|
/* Set up the 'to' rectangle */
|
|
/************************************************************/
|
|
destRectl.top = 0;
|
|
destRectl.left = 0;
|
|
destRectl.right = psoColor->sizlBitmap.cx;
|
|
destRectl.bottom = psoColor->sizlBitmap.cy;
|
|
|
|
/************************************************************/
|
|
/* and the source start point */
|
|
/************************************************************/
|
|
sourcePt.x = 0;
|
|
sourcePt.y = 0;
|
|
|
|
/************************************************************/
|
|
/* set up a pointer to the correct SO to use */
|
|
/************************************************************/
|
|
psoToUse = psoColor;
|
|
}
|
|
else {
|
|
// We got a high color cursor to translate to 24bpp workbitmap
|
|
// can't easily simulate the XLATEOBJ, since this is TS4 code path
|
|
// only, we will just let it fall back to GDI bitmap cursor!
|
|
CM_SET_NULL_CURSOR(pCursorShapeData);
|
|
pddShm->cm.cmHidden = FALSE;
|
|
pddShm->cm.cmCacheHit = FALSE;
|
|
pddShm->cm.cmCursorStamp = cmNextCursorStamp++;
|
|
|
|
rc = SPS_DECLINE;
|
|
SCH_DDOutputAvailable(ppDev, TRUE);
|
|
DC_QUIT;
|
|
}
|
|
}
|
|
|
|
// Lock the work bitmap to get a surface to pass to EngBitBlt.
|
|
pWorkSurf = EngLockSurface((HSURF)cmWorkBitmap24);
|
|
if (pWorkSurf != NULL) {
|
|
BOOL RetVal;
|
|
|
|
TRC_DBG((TB, "Locked surface"));
|
|
|
|
// Do the blt.
|
|
RetVal = EngBitBlt(pWorkSurf,
|
|
psoToUse,
|
|
NULL, /* mask surface */
|
|
NULL, /* clip object */
|
|
&workXlo, /* XLATE object */
|
|
&destRectl,
|
|
&sourcePt,
|
|
NULL, /* mask origin */
|
|
NULL, /* brush */
|
|
NULL, /* brush origin */
|
|
0xcccc); /* SRCCPY */
|
|
|
|
EngUnlockSurface(pWorkSurf);
|
|
if (RetVal) {
|
|
TRC_DBG((TB, "Got the bits into the work bitmap"));
|
|
}
|
|
else {
|
|
TRC_ERR((TB, "Failed to Blt to work bitmap"));
|
|
goto FailBlt;
|
|
}
|
|
}
|
|
else {
|
|
TRC_ERR((TB, "Failed to lock work surface"));
|
|
|
|
FailBlt:
|
|
// Set the cursor bits to all black. On the client,
|
|
// this will be seen as the correct mask but a black
|
|
// region inside where the cursor color bits would have
|
|
// been.
|
|
memset(pWorkSurf->pvBits, 0, pWorkSurf->cjBits);
|
|
|
|
// We do not DC_QUIT here, we want to complete the cursor
|
|
// creation even if the output is mostly wrong, since
|
|
// we've already cached the bits.
|
|
}
|
|
|
|
/****************************************************************/
|
|
/* Finally we extract the color AND mask from the work bitmap */
|
|
/****************************************************************/
|
|
TRC_NRM((TB, "Copy %d bytes of color", pWorkSurf->cjBits));
|
|
|
|
memcpy(&(pCursorShapeData->data[psoMask->cjBits / 2]),
|
|
pWorkSurf->pvBits,
|
|
pWorkSurf->cjBits);
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* Set the cursor stamp */
|
|
/************************************************************************/
|
|
pddShm->cm.cmCursorStamp = cmNextCursorStamp++;
|
|
|
|
/************************************************************************/
|
|
/* Tell the scheduler that we have some new cursor info */
|
|
/************************************************************************/
|
|
SCH_DDOutputAvailable(ppDev, FALSE);
|
|
}
|
|
else {
|
|
TRC_ERR((TB, "shared memory is not allocated or invalid cursor handle: "
|
|
"pddshm=%p, cmCursorCacheHandle=%p", pddShm, cmCursorCacheHandle));
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DC_END_FN();
|
|
|
|
return(rc);
|
|
} /* DrvSetPointerShape */
|
|
|