m_CursorSize.y = cY;
			m_CursorHotspot.x = xHot;
			m_CursorHotspot.y = yHot;

			andPtr = (UCHAR*)pMask->Buffer();
			xorPtr = (UCHAR*)pMask->Buffer() + (cY * pMask->Stride());

			// store OR and AND mask for new cursor
			for (row = 0; row < cY; row++)
			{
				andLine = &m_CursorAndShape[cX * row];
				xorLine = &m_CursorXorShape[cX * row];

				for (col = 0; col < cX / 8; col++)
				{
					bAnd = andPtr[row * pMask->Stride() + col];
					bXor = xorPtr[row * pMask->Stride() + col];

					for (bitMask = 0x0080, i = 0; i < 8; bitMask >>= 1, i++)
					{
						andLine[(col * 8) + i] = bAnd & bitMask ? 0xFF : 0x00;
						xorLine[(col * 8) + i] = bXor & bitMask ? 0xFF : 0x00;
					}
				}
			}
		}
	}

	return	S_OK;
}

SCODE	XSLGPE::MovePointer(INT xPosition, INT yPosition)
{
	DEBUGMSG(GPE_ZONE_CURSOR, (TEXT("XSLGPE::MovePointer(%d, %d)\r\n"), xPosition, yPosition));

	CursorOff();

	if (xPosition != -1 || yPosition != -1)
	{
		// compute new cursor rect
		m_CursorRect.left = xPosition - m_CursorHotspot.x;
		m_CursorRect.right = m_CursorRect.left + m_CursorSize.x;
		m_CursorRect.top = yPosition - m_CursorHotspot.y;
		m_CursorRect.bottom = m_CursorRect.top + m_CursorSize.y;

		CursorOn();
	}

	return	S_OK;
}

void	XSLGPE::WaitForNotBusy(void)
{
	DEBUGMSG (GPE_ZONE_INIT, (TEXT("XSLGPE::WaitForNotBusy\r\n")));
	return;
}

int		XSLGPE::IsBusy(void)
{
	DEBUGMSG (GPE_ZONE_INIT, (TEXT("XSLGPE::IsBusy\r\n")));
	return	0;
}

void	XSLGPE::GetPhysicalVideoMemory(unsigned long *physicalMemoryBase, unsigned long *videoMemorySize)
{
	DEBUGMSG (GPE_ZONE_INIT, (TEXT("XSLGPE::GetPhysicalVideoMemory\r\n")));

	*physicalMemoryBase = m_pvFlatFrameBuffer;
	*videoMemorySize = m_cbScanLineLength * m_cyPhysicalScreen;
}

#ifdef	DD_ENABLE
void	XSLGPE::GetVirtualVideoMemory(unsigned long *virtualMemoryBase, unsigned long *videoMemorySize)
{
	DEBUGMSG (GPE_ZONE_INIT, (TEXT("XSLGPE::GetVirtualVideoMemory\r\n")));

	*virtualMemoryBase = m_VirtualFrameBuffer;
	*videoMemorySize = m_cbScanLineLength * m_cyPhysicalScreen;
}
#endif	// DD_ENABLE

SCODE	XSLGPE::WrappedEmulatedLine (GPELineParms *lineParameters)
{
	SCODE	retval;
	RECT	bounds;
	int		N_plus_1;				// Minor length of bounding rect + 1

	// calculate the bounding-rect to determine overlap with cursor
	if (lineParameters->dN)			// The line has a diagonal component (we'll refresh the bounding rect)
	{
		N_plus_1 = 2 + ((lineParameters->cPels * lineParameters->dN) / lineParameters->dM);
	}
	else
	{
		N_plus_1 = 1;
	}

	switch(lineParameters->iDir)
	{
		case 0:
			bounds.left = lineParameters->xStart;
			bounds.top = lineParameters->yStart;
			bounds.right = lineParameters->xStart + lineParameters->cPels + 1;
			bounds.bottom = bounds.top + N_plus_1;
			break;
		case 1:
			bounds.left = lineParameters->xStart;
			bounds.top = lineParameters->yStart;
			bounds.bottom = lineParameters->yStart + lineParameters->cPels + 1;
			bounds.right = bounds.left + N_plus_1;
			break;
		case 2:
			bounds.right = lineParameters->xStart + 1;
			bounds.top = lineParameters->yStart;
			bounds.bottom = lineParameters->yStart + lineParameters->cPels + 1;
			bounds.left = bounds.right - N_plus_1;
			break;
		case 3:
			bounds.right = lineParameters->xStart + 1;
			bounds.top = lineParameters->yStart;
			bounds.left = lineParameters->xStart - lineParameters->cPels;
			bounds.bottom = bounds.top + N_plus_1;
			break;
		case 4:
			bounds.right = lineParameters->xStart + 1;
			bounds.bottom = lineParameters->yStart + 1;
			bounds.left = lineParameters->xStart - lineParameters->cPels;
			bounds.top = bounds.bottom - N_plus_1;
			break;
		case 5:
			bounds.right = lineParameters->xStart + 1;
			bounds.bottom = lineParameters->yStart + 1;
			bounds.top = lineParameters->yStart - lineParameters->cPels;
			bounds.left = bounds.right - N_plus_1;
			break;
		case 6:
			bounds.left = lineParameters->xStart;
			bounds.bottom = lineParameters->yStart + 1;
			bounds.top = lineParameters->yStart - lineParameters->cPels;
			bounds.right = bounds.left + N_plus_1;
			break;
		case 7:
			bounds.left = lineParameters->xStart;
			bounds.bottom = lineParameters->yStart + 1;
			bounds.right = lineParameters->xStart + lineParameters->cPels + 1;
			bounds.top = bounds.bottom - N_plus_1;
			break;
		default:
			DEBUGMSG(GPE_ZONE_ERROR,(TEXT("Invalid direction: %d\r\n"), lineParameters->iDir));
			return E_INVALIDARG;
	}

	// check for line overlap with cursor and turn off cursor if overlaps
	if (m_CursorVisible && !m_CursorDisabled &&
		m_CursorRect.top < bounds.bottom && m_CursorRect.bottom > bounds.top &&
		m_CursorRect.left < bounds.right && m_CursorRect.right > bounds.left)
	{
		CursorOff();
		m_CursorForcedOff = TRUE;
	}

	// do emulated line
	retval = EmulatedLine (lineParameters);

	// se if cursor was forced off because of overlap with line bouneds and turn back on
	if (m_CursorForcedOff)
	{
		m_CursorForcedOff = FALSE;
		CursorOn();
	}

	return	retval;

}

SCODE	XSLGPE::Line(GPELineParms *lineParameters, EGPEPhase phase)
{
	DEBUGMSG (GPE_ZONE_INIT, (TEXT("XSLGPE::Line\r\n")));

	if (phase == gpeSingle || phase == gpePrepare)
	{

		if ((lineParameters->pDst != m_pPrimarySurface))
		{
			lineParameters->pLine = EmulatedLine;
		}
		else
		{
			lineParameters->pLine = (SCODE (GPE::*)(struct GPELineParms *)) WrappedEmulatedLine;
		}
	}
	return S_OK;
}

SCODE	XSLGPE::BltPrepare(GPEBltParms *blitParameters)
{
	RECTL	rectl;

	DEBUGMSG (GPE_ZONE_INIT, (TEXT("XSLGPE::BltPrepare\r\n")));

	// default to base EmulatedBlt routine
	blitParameters->pBlt = EmulatedBlt;

	// see if we need to deal with cursor
	if (m_CursorVisible && !m_CursorDisabled)
	{
		// check for destination overlap with cursor and turn off cursor if overlaps
		if (blitParameters->pDst == m_pPrimarySurface)	// only care if dest is main display surface
		{
			if (blitParameters->prclDst != NULL)		// make sure there is a valid prclDst
			{
				rectl = *blitParameters->prclDst;		// if so, use it
			}
			else
			{
				rectl = m_CursorRect;					// if not, use the Cursor rect - this forces the cursor to be turned off in this case
			}

			if (m_CursorRect.top < rectl.bottom && m_CursorRect.bottom > rectl.top &&
				m_CursorRect.left < rectl.right && m_CursorRect.right > rectl.left)
			{
				CursorOff();
				m_CursorForcedOff = TRUE;
			}
		}

		// check for source overlap with cursor and turn off cursor if overlaps
		if (blitParameters->pSrc == m_pPrimarySurface)	// only care if source is main display surface
		{
			if (blitParameters->prclSrc != NULL)		// make sure there is a valid prclSrc
			{
				rectl = *blitParameters->prclSrc;		// if so, use it
			}
			else
			{
				rectl = m_CursorRect;					// if not, use the CUrsor rect - this forces the cursor to be turned off in this case
			}
			if (m_CursorRect.top < rectl.bottom && m_CursorRect.bottom > rectl.top &&
				m_CursorRect.left < rectl.right && m_CursorRect.right > rectl.left)
			{
				CursorOff();
				m_CursorForcedOff = TRUE;
			}
		}
	}

#ifdef CLEARTYPE
	if (((blitParameters->rop4 & 0xffff) == 0xaaf0 ) && (blitParameters->pMask->Format() == gpe8Bpp))
	{
	    switch (m_colorDepth)
	    {
	    case 16:
	 	blitParameters->pBlt = (SCODE (GPE::*)(struct GPEBltParms *)) ClearTypeBlt::ClearTypeBltDst16;
		return S_OK;
	    case 24:
		blitParameters->pBlt = (SCODE (GPE::*)(struct GPEBltParms *)) ClearTypeBlt::ClearTypeBltDst24;
		return S_OK;
	    case 32:
		blitParameters->pBlt = (SCODE (GPE::*)(struct GPEBltParms *)) ClearTypeBlt::ClearTypeBltDst32;
		return S_OK;
	    default:
		break;
	    }
	}
#endif //CLEARTYPE
	
	// see if there are any optimized software blits available
	EmulatedBltSelect02(blitParameters);
	EmulatedBltSelect08(blitParameters);
	EmulatedBltSelect16(blitParameters);

	return S_OK;
}

SCODE	XSLGPE::BltComplete(GPEBltParms *blitParameters)
{
	DEBUGMSG (GPE_ZONE_INIT, (TEXT("XSLGPE::BltComplete\r\n")));

	// see if cursor was forced off because of overlap with source or destination and turn back on
	if (m_CursorForcedOff)
	{
		m_CursorForcedOff = FALSE;
		CursorOn();
	}

	return S_OK;
}

INT		XSLGPE::InVBlank(void)
{
	static	BOOL	value = FALSE;
	DEBUGMSG (GPE_ZONE_INIT, (TEXT("XSLGPE::InVBlank\r\n")));
	value = !value;
	return value;
}


ULONG	XSLGPE::GetGraphicsCaps()
{
	if (m_pMode)
	{
#ifdef CLEARTYPE
		if (m_pMode->Bpp >= 16)		// if in 16bpp mode, return GCAPS_GRAY16 to denote that we support anti-aliased fonts
		{
			return	GCAPS_CLEARTYPE | GCAPS_GRAY16;
		}
#else
		if (m_pMode->Bpp == 16)
		{
		        return GCAPS_GRAY16;
		}
#endif
	}
	return	0;
}


#ifndef	DD_ENABLE	// if not a DDraw driver, then include dummy versions of these function
void	RegisterDDHALAPI(void)
{
	return;	// no DDHAL support
}

void HALInit()
{
	DEBUGMSG( 0,(TEXT("HALInit: Stub, Shouldn't have come in hereX\n")));
	RETAILMSG( 1,(TEXT("HALInit: Stub, Shouldn't have come in hereX\n")));
}
#endif //DD_SUPPORT

ULONG *APIENTRY DrvGetMasks(DHPDEV dhpdev)
{
	return gBitMasks;
}