cursor.cpp

Lido PXA270平台开发板的最新BSP,包括源代码

#endif // LOCAL_MEMORY_SELF_REFRESH
#ifndef USE_SW_CURSOR
	PDP_CURSOR_SHAPEINFO sCursorShapeInfo;

	////DPFENTER((L"->DrvSetPointerShape"));
	DPFX (PVR_ZONE_CURSOR,(L"MBX::SetPointerShape(0x%X, 0x%X, %d, %d, %d, %d)",pclMask, pclColorSurf, nHotX, nHotY, nX, nY));

	// release memory associated with old cursor
	if (!pclMask)						// do we have a new cursor shape
	{
		memset(&sCursorShapeInfo, sizeof(sCursorShapeInfo), 0);
	}
	else
	{
		// store size and hotspot for new cursor
		m_sCursorSize.x = nX;
		m_sCursorSize.y = nY;
		m_sCursorHotspot.x = nHotX;
		m_sCursorHotspot.y = nHotY;

		sCursorShapeInfo.Width       = pclMask->Width();
		sCursorShapeInfo.Height      = pclMask->Height();
		sCursorShapeInfo.StrideBytes = pclMask->Stride();
		sCursorShapeInfo.pvScan0     = pclMask->Buffer();

		sCursorShapeInfo.wCursor_Attribs = PDP_CURSOR_ENABLE;
	}

	sCursorShapeInfo.Colors = (BOOL)(pclColorSurf != NULL);

	m_clDisplay.PDP_CursorProperties(&sCursorShapeInfo, FALSE);

#ifdef LOCAL_MEMORY_SELF_REFRESH
	SysLocalMemoryDisable(m_sDevData.psDevInfoKM);
#endif // LOCAL_MEMORY_SELF_REFRESH
//////	DPFEXIT((L"<-DrvSetPointerShape"));
	return (S_OK);
}
#else // USE_SW_CURSOR
	PBYTE	pbyAndPtr;		// input pointer
	PBYTE	pbyXorPtr;		// input pointer
	PBYTE	pbyAndLine;		// output pointer
	PBYTE	pbyXorLine;		// output pointer
	BYTE	bAnd;
	BYTE	bXor;
	BYTE	bBitMask;
	INT		nRow;
	INT		nCol;
	INT		n;

	DPFX (PVR_ZONE_CURSOR,(L"MBX::SetPointerShape(0x%X, 0x%X, %d, %d, %d, %d)",pclMask, pclColorSurf, nHotX, nHotY, nX, nY));

	// turn current cursor off
	CursorOff();

	// release memory associated with old cursor
	if (!pclMask)							// do we have a new cursor shape
	{
		m_bCursorDisabled = TRUE;		// no, so tag as disabled
	}
	else
	{
		m_bCursorDisabled = FALSE;		// yes, so tag as not disabled

		// store size and hotspot for new cursor
		m_sCursorSize.x = nX;
		m_sCursorSize.y = nY;
		m_sCursorHotspot.x = nHotX;
		m_sCursorHotspot.y = nHotY;

		pbyAndPtr = (PBYTE)pclMask->Buffer();
		pbyXorPtr = (PBYTE)pclMask->Buffer() + (nY * pclMask->Stride());

		// store OR and AND mask for new cursor
		for (nRow = 0; nRow < nY; nRow++)
		{
			pbyAndLine = &m_byCursorAndShape[nX * nRow];
			pbyXorLine = &m_byCursorXorShape[nX * nRow];

			for (nCol = 0; nCol < nX / 8; nCol++)
			{
				bAnd = pbyAndPtr[nRow * pclMask->Stride() + nCol];
				bXor = pbyXorPtr[nRow * pclMask->Stride() + nCol];

				for (bBitMask = 0x0080, n = 0; n < 8; bBitMask >>= 1, n++)
				{
					pbyAndLine[(nCol * 8) + n] = bAnd & bBitMask ? 0xFF : 0x00;
					pbyXorLine[(nCol * 8) + n] = bXor & bBitMask ? 0xFF : 0x00;
				}
			}
		}
	}

#ifdef LOCAL_MEMORY_SELF_REFRESH
	SysLocalMemoryDisable(m_sDevData.psDevInfoKM);
#endif // LOCAL_MEMORY_SELF_REFRESH
	return (S_OK);
}
#endif // USE_SW_CURSOR

SCODE	MBX::MovePointer(INT nPositionX, INT nPositionY)
{
#ifndef USE_SW_CURSOR
	INT nCorrectX, nCorrectY;
#endif

	DPFX(PVR_ZONE_CURSOR, (L"MBX::MovePointer(%d, %d)", nPositionX, nPositionY));
#ifdef LOCAL_MEMORY_SELF_REFRESH
	SysLocalMemoryEnable(m_sDevData.psDevInfoKM);
#endif // LOCAL_MEMORY_SELF_REFRESH

#ifndef USE_SW_CURSOR
//	// apply hotspot offset
//	nPositionX -= m_sCursorHotspot.x;
//	nPositionY -= m_sCursorHotspot.y;

#ifdef ROTATE_ENABLE
	INT	nTmp = nPositionX;

	if (m_iRotate == DMDO_90)
	{
		nPositionX = nPositionY; // - m_sCursorSize.y;
		nPositionY = m_nScreenHeightSave - nTmp;
		nCorrectY  = DeviceHWCursorSize - m_sCursorHotspot.y;
		nCorrectX  = m_sCursorHotspot.y;
	}
	else if (m_iRotate == DMDO_180)
	{
		nPositionX = m_nScreenWidthSave - nPositionX; // - m_sCursorSize.x;
		nPositionY = m_nScreenHeightSave - nPositionY; // - m_sCursorSize.y;
		nCorrectX  = DeviceHWCursorSize - m_sCursorHotspot.x;
		nCorrectY  = DeviceHWCursorSize - m_sCursorHotspot.y;
	}
	else if (m_iRotate == DMDO_270)
	{
		nPositionX = m_nScreenWidthSave - nPositionY;
		nPositionY = nTmp; // - m_sCursorSize.x;
		nCorrectX  = DeviceHWCursorSize - m_sCursorHotspot.y;
		nCorrectY  = m_sCursorHotspot.x;
	}
	else
#endif
	{
		nCorrectX = m_sCursorHotspot.x;
		nCorrectY = m_sCursorHotspot.y;
	}

#ifndef SUPPORT_KYRO_AS_MBX_DEVICE
	MoveVisiblePort (nPositionX, nPositionY);
#endif

	// apply virtual desktop port offset
	nPositionX -= (m_lVisibleX + nCorrectX);
	nPositionY -= (m_lVisibleY + nCorrectY);

	PDP_CURSORPOS	sCursorPos;

	DPFX(PVR_ZONE_CURSOR, (L"MBX::MovePointer relative to desktop %d, %d", nPositionX, nPositionY));

	sCursorPos.nXpos = nPositionX;
	sCursorPos.nYpos = nPositionY;

	// Write the X/Y position.
	m_clDisplay.PDP_CursorPos(&sCursorPos, FALSE);
#else //USE_SW_CURSOR
	CursorOff();

	if (nPositionX != -1 || nPositionY != -1)
	{
		// compute new cursor rect
		m_sCursorRect.left   = nPositionX - m_sCursorHotspot.x;
		m_sCursorRect.top    = nPositionY - m_sCursorHotspot.y;

		m_sCursorRect.right  = m_sCursorRect.left + m_sCursorSize.x;
		m_sCursorRect.bottom = m_sCursorRect.top + m_sCursorSize.y;

#ifndef SUPPORT_KYRO_AS_MBX_DEVICE
#ifdef ROTATE_ENABLE
		INT	nTmp = nPositionX;

		if (m_iRotate == DMDO_90)
		{
			nPositionX = nPositionY;
			nPositionY = m_nScreenHeightSave - nTmp;
		}
		else if (m_iRotate == DMDO_180)
		{
			nPositionX = m_nScreenWidthSave - nPositionX;
			nPositionY = m_nScreenHeightSave - nPositionY;
		}
		else if (m_iRotate == DMDO_270)
		{
			nPositionX = m_nScreenWidthSave - nPositionY;
			nPositionY = nTmp;
		}
#endif

		MoveVisiblePort (nPositionX, nPositionY);
#endif //SUPPORT_KYRO_AS_MBX_DEVICE

		CursorOn();
	}
#endif //USE_SW_CURSOR

#ifdef LOCAL_MEMORY_SELF_REFRESH
	SysLocalMemoryDisable(m_sDevData.psDevInfoKM);
#endif // LOCAL_MEMORY_SELF_REFRESH
	return (S_OK);
}


#ifndef SUPPORT_KYRO_AS_MBX_DEVICE
/*****************************************************************************
 FUNCTION	: 	MoveVisiblePort
 PURPOSE	:	
 PARAMETERS	: 	
 RETURNS	: 	
*****************************************************************************/
void MBX::MoveVisiblePort (LONG lX, LONG lY)
{
	LONG  lNewX = m_lVisibleX, lNewY = m_lVisibleY;
	ULONG ulOffset;
	ULONG ulBytesPP;
//	ULONG ulPhysAddr;

	if (lX < m_lVisibleX)
	{
		lNewX = lX;
	}
	else if (lX >= (LONG)(m_lVisibleX + m_ulPhysicalScreenX))
	{
		lNewX = lX - m_ulPhysicalScreenX;
	}

	if (lY < m_lVisibleY)
	{
		lNewY = lY;
	}
	else if (lY >= (LONG)(m_lVisibleY + m_ulPhysicalScreenY))
	{
		lNewY = lY - m_ulPhysicalScreenY;
	}

	if (lNewX < 0)
	{
		lNewX = 0;
	}

	if (lNewY < 0)
	{
		lNewY = 0;
	}

	ulBytesPP = (m_ulColorDepth + 1)/8;		// include 15bpp

	// for 1, 2 and 3 bytes per pixel
	switch( ulBytesPP & 3)
	{
		case 1 :
		case 3 :
			// round to nearest 4 pixel unit
			lNewX = (lNewX + 3) & ~0x3L;
			break;
		case 2 :
			// round to nearest 2 pixel unit
			lNewX = (lNewX + 1) & ~0x1L;
			break;
	}

	if ((m_lVisibleX != lNewX) || (m_lVisibleY != lNewY))
	{
		ulOffset = (m_ulScanLineLength * lNewY) +( ulBytesPP * lNewX);

		////////DPFX (PVR_ZONE_CURSOR, (L"MBX::MoveVisiblePort to %d, %d", lNewX, lNewY));

//		ulPhysAddr = (ULONG)m_pbyFBPhysBase + ulOffset;
//		m_clDisplay.PDP_FlipDisplay(&ulPhysAddr, TRUE);
		m_clDisplay.PDP_FlipDisplay(&ulOffset, TRUE);
		m_lVisibleX = lNewX;
		m_lVisibleY = lNewY;
	}
}
#endif


/********************************** end of file ******************************/