ddi_if.cpp

wince下的源代码集合打包

/*

Copyright (c) 1995-2000 Microsoft Corporation.  All rights reserved.

*/
#include "precomp.h"
#include "swemul.h"

DEFINE_GDI_ENTRY_POINTS(EMPTYPARM,LEFTENTRY,RIGHTENTRY)

void RegisterDDHALAPI();
extern int AllocConverters();
extern void FreeConverters();

EXTERN_C
int
__stdcall
DllMain(
    void *  hmod,
    DWORD dwReason,
    void *  lpvReserved
    )
{
    switch (dwReason) {
    case DLL_PROCESS_ATTACH:
#ifdef DEBUG
		RegisterDbgZones( (HINSTANCE)hmod, &dpCurSettings );
#endif
		RegisterDDHALAPI();
        break;
    case DLL_PROCESS_DETACH:
        break;
    case DLL_THREAD_ATTACH:
        break;
    case DLL_THREAD_DETACH:
        break;
   }

    return TRUE;
}

/******************************Public*Data*********************************\
* MIX translation table
*
* Translates a mix 1-16, into an old style Rop 0-255.
*
\**************************************************************************/

const BYTE gaMix[] =
{
    0xFF,  // R2_WHITE        - Allow rop = gaMix[mix & 0x0F]
    0x00,  // R2_BLACK
    0x05,  // R2_NOTMERGEPEN
    0x0A,  // R2_MASKNOTPEN
    0x0F,  // R2_NOTCOPYPEN
    0x50,  // R2_MASKPENNOT
    0x55,  // R2_NOT
    0x5A,  // R2_XORPEN
    0x5F,  // R2_NOTMASKPEN
    0xA0,  // R2_MASKPEN
    0xA5,  // R2_NOTXORPEN
    0xAA,  // R2_NOP
    0xAF,  // R2_MERGENOTPEN
    0xF0,  // R2_COPYPEN
    0xF5,  // R2_MERGEPENNOT
    0xFA,  // R2_MERGEPEN
    0xFF   // R2_WHITE        - Allow rop = gaMix[mix & 0xFF]
};


#define CLIP_LIMIT 50
typedef struct _CLIPENUM {
    LONG    c;
    RECTL   arcl[CLIP_LIMIT];   // Space for enumerating complex clipping

} CLIPENUM;                         /* ce, pce */


inline GPE *SurfobjToGPE( SURFOBJ *pso )
{
	return (GPE *)(pso->dhpdev);
}

class TmpGPESurf
{
	GPESurf *m_pGPESurf;
	GPESurf m_GPESurf;
public:
	operator GPESurf *() { return m_pGPESurf; }
	TmpGPESurf
	(
		SURFOBJ *pso1,
		SURFOBJ *pso2 = (SURFOBJ *)NULL,
		TmpGPESurf *pTmp2 = (TmpGPESurf *)NULL
	);
	~TmpGPESurf() {}
};

TmpGPESurf::TmpGPESurf
(
	SURFOBJ *pso1,
	SURFOBJ *pso2,
	TmpGPESurf *pTmp2
)
{
	if( !pso1 )
	{
		m_pGPESurf = (GPESurf *)NULL;
	}
	else if( pso1 == pso2 )
	{
		m_pGPESurf = pTmp2->m_pGPESurf;
	}
	else if( pso1->dhsurf )
	{
		m_pGPESurf = (GPESurf *)(pso1->dhsurf);
	}
	else
	{
		m_pGPESurf = &m_GPESurf;
		m_pGPESurf->Init( pso1->sizlBitmap.cx, pso1->sizlBitmap.cy,
    					    pso1->pvScan0, pso1->lDelta,
							IFormatToEGPEFormat[pso1->iBitmapFormat] );
	}
}

const DRVENABLEDATA pDrvFn =
{
    {   DrvEnablePDEV           },
    {   DrvDisablePDEV          },
    {   DrvEnableSurface        },
    {   DrvDisableSurface       },
    {   DrvCreateDeviceBitmap   },
    {   DrvDeleteDeviceBitmap   },
    {   DrvRealizeBrush         },
    {   DrvStrokePath           },
    {   DrvFillPath             },
    {   DrvPaint                },
    {   DrvBitBlt               },
    {   DrvCopyBits             },
    {   DrvAnyBlt               },
    {   DrvTransparentBlt       },
    {   DrvSetPalette           },
    {   DrvSetPointerShape      },
    {   DrvMovePointer          },
    {   DrvGetModes             },
    {   DrvRealizeColor         },
    {   DrvGetMasks             },
    {   DrvUnrealizeColor       },
    {   DrvContrastControl      },
    {   DrvPowerHandler         },
    {   NULL /* DrvEndDoc    */ },
    {   NULL /* DrvStartDoc  */ },
    {   NULL /* DrvStartPage */ },
    {   DrvEscape               }
};

#ifdef FIXED_EXE_EXPORTS

BOOL APIENTRY GPEEnableDriver(
	ULONG          iEngineVersion,
	ULONG          cj,
	DRVENABLEDATA *pded)
{
//	RegisterDbgZones( hmod, &dpCurSettings );
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Entering DrvEnableDriver\r\n")));
	if ( iEngineVersion != DDI_DRIVER_VERSION || cj != sizeof(DRVENABLEDATA) )
	{
		DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvEnableDriver\r\n")));
		return FALSE;
	}
	*pded = pDrvFn;
	
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvEnableDriver\r\n")));
	return TRUE;
}

#else


BOOL APIENTRY GPEEnableDriver(
	ULONG          iEngineVersion,
	ULONG          cj,
	DRVENABLEDATA *pded,
	PENGCALLBACKS  pEngCallbacks)
{
//	RegisterDbgZones( hmod, &dpCurSettings );

	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Entering DrvEnableDriver\r\n")));

	BRUSHOBJ_pvAllocRbrush = pEngCallbacks->BRUSHOBJ_pvAllocRbrush;
	BRUSHOBJ_pvGetRbrush = pEngCallbacks->BRUSHOBJ_pvGetRbrush;
	CLIPOBJ_cEnumStart = pEngCallbacks->CLIPOBJ_cEnumStart;
	CLIPOBJ_bEnum = pEngCallbacks->CLIPOBJ_bEnum;
	PALOBJ_cGetColors = pEngCallbacks->PALOBJ_cGetColors;
	PATHOBJ_vEnumStart = pEngCallbacks->PATHOBJ_vEnumStart;
	PATHOBJ_bEnum = pEngCallbacks->PATHOBJ_bEnum;
	PATHOBJ_vGetBounds = pEngCallbacks->PATHOBJ_vGetBounds;
	XLATEOBJ_cGetPalette = pEngCallbacks->XLATEOBJ_cGetPalette;
	EngCreateDeviceSurface = pEngCallbacks->EngCreateDeviceSurface;
	EngDeleteSurface = pEngCallbacks->EngDeleteSurface;
	EngCreateDeviceBitmap = pEngCallbacks->EngCreateDeviceBitmap;
	EngCreatePalette = pEngCallbacks->EngCreatePalette;

	if ( iEngineVersion != DDI_DRIVER_VERSION || cj != sizeof(DRVENABLEDATA) )
		return FALSE;

	*pded = pDrvFn;
	
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvEnableDriver\r\n")));

	return TRUE;
}


#endif

BOOL APIENTRY DrvContrastControl(
	DHPDEV     dhpdev,
    ULONG      cmd,
    ULONG     *pValue)
{
	GPE *pGPE = (GPE *)dhpdev;
    return pGPE->ContrastControl(cmd, pValue);
}

VOID APIENTRY DrvPowerHandler(
	DHPDEV     dhpdev,
    BOOL       bOff)
{
	GPE *pGPE = (GPE *)dhpdev;
    pGPE->PowerHandler(bOff);
}

ULONG APIENTRY DrvEscape(
	DHPDEV   dhpdev,
    SURFOBJ *pso,
    ULONG    iEsc,
    ULONG    cjIn,
    PVOID    pvIn,
    ULONG    cjOut,
    PVOID    pvOut)
{
	GPE *pGPE = (GPE *)dhpdev;
    return pGPE->DrvEscape(pso, iEsc, cjIn, pvIn, cjOut, pvOut);
}

VOID DrvDisableDriver()
{
	// by the time this is called, the driver has already been shut down.
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Entering DrvDisableDriver\r\n")));
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvDisableDriver\r\n")));
}

// Configuration / Intialization funtions

VOID APIENTRY DrvDisablePDEV(
	DHPDEV dhpdev)
{
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Entering DrvDisablePDEV\r\n")));
	FreeConverters();
	delete ((GPE *)dhpdev);
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvDisablePDEV\r\n")));

}

VOID  APIENTRY DrvDisableSurface(
	DHPDEV dhpdev)
{
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Entering DrvDisableSurface\r\n")));
	EngDeleteSurface( (HSURF)(((GPE *)dhpdev)->GetHSurf()) );
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvDisableSurface\r\n")));
}

HSURF APIENTRY DrvEnableSurface(
	DHPDEV dhpdev)
{
	HSURF hsurf;
	GPE *pGPE = (GPE *)dhpdev;
	SIZEL sizl;
	GPESurf *pSurf;

	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Entering DrvEnableSurface\r\n")));

	pSurf = pGPE->PrimarySurface();
	sizl.cx = pGPE->ScreenWidth();
	sizl.cy = pGPE->ScreenHeight();

	DEBUGMSG(GPE_ZONE_INIT,(TEXT("Primary surface is at 0x%08x\r\n"), pSurf ));
	DEBUGMSG(GPE_ZONE_INIT,(TEXT("Format of primary surface is %d\r\n"),pSurf->Format() ));
	
	hsurf = EngCreateDeviceSurface(
		(DHSURF)pSurf,
		sizl,
		EGPEFormatToIFormat[pSurf->Format()]);
	
	pGPE->SetHSurf( (unsigned long)hsurf );

	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvEnableSurface\r\n")));

	return hsurf;
}

// Surface creation

HBITMAP APIENTRY DrvCreateDeviceBitmap(
	DHPDEV dhpdev,
	SIZEL sizl,
	ULONG iFormat)
{
	GPE *pGPE = (GPE *)dhpdev;
	GPESurf *pSurf;

	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Entering DrvCreateDeviceBitmap\r\n")));

	if( FAILED( pGPE->AllocSurface(
		&pSurf,
		sizl.cx,
		sizl.cy,
		IFormatToEGPEFormat[iFormat],
		GPE_PREFER_VIDEO_MEMORY ) )	)
	{
		DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvEnableSurface\r\n")));

		return (HBITMAP)0xFFFFFFFF;
	}

	HBITMAP hbm = EngCreateDeviceBitmap(
		(DHSURF)pSurf,
		sizl,
		iFormat );

	pSurf->m_nHandle = (unsigned long)hbm;

	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvEnableSurface\r\n")));

	if( !hbm )
		return (HBITMAP)0xFFFFFFFF;
	else
		return hbm;
}

VOID APIENTRY DrvDeleteDeviceBitmap(
	DHSURF dhsurf)
{
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Entering DrvDeleteDeviceBitmap\r\n")));

	GPESurf *pSurf = (GPESurf *)dhsurf;
	HBITMAP hbm = (HBITMAP)(pSurf->m_nHandle);
	EngDeleteSurface( (HSURF)hbm );
	delete pSurf;
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvDeleteDeviceBitmap\r\n")));
}

// Cursor control functions

VOID APIENTRY DrvMovePointer(
	SURFOBJ *pso,
	LONG x,
	LONG y,
	RECTL *prcl)
{
//	unsigned long zones = 1; // dpCurSettings.ulZoneMask;
//	DEBUGMSG(1,(TEXT("Zones = 0x%08x\r\n"),zones ));
//dpCurSettings.ulZoneMask = 0x0000ffff;
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Entering DrvMovePointer\r\n")));

	SurfobjToGPE(pso)->MovePointer(x,y);
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvMovePointer\r\n")));
}

ULONG APIENTRY DrvSetPointerShape(
	SURFOBJ  *pso,
	SURFOBJ  *psoMask,
	SURFOBJ  *psoColor,
	XLATEOBJ *pxlo,
	LONG      xHot,
	LONG      yHot,
	LONG      x,
	LONG      y,
	RECTL    *prcl,
	FLONG     fl)
{

	// dpCurSettings.ulZoneMask = 0x0000ffff;
	
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Entering DrvSetPointerShape\r\n")));

	TmpGPESurf pMask(psoMask);
	TmpGPESurf pColor(psoColor);
	GPE *pGPE = SurfobjToGPE(pso);

	if( !pGPE )
	{
		DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvSetPointerShape\r\n")));

		return SPS_ERROR;
	}
	if( FAILED( pGPE->SetPointerShape(pMask,pColor,xHot,yHot,
		psoMask?(psoMask->sizlBitmap.cx):0, psoMask?(psoMask->sizlBitmap.cy>>1):0 ) ) )
	{
		DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvSetPointerShape\r\n")));

		return SPS_ERROR;
	}
	pGPE->MovePointer(x,y);
	
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvSetPointerShape\r\n")));

	return SPS_ACCEPT_NOEXCLUDE;    // It is up to GPE to avoid cursor interference
}

// Palette Control Functions

BOOL APIENTRY DrvSetPalette(
	DHPDEV  dhpdev,
	PALOBJ *ppalo,
	FLONG   fl,
	ULONG   iStart,
	ULONG   cColors)
{
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Entering DrvSetPalette\r\n")));

	unsigned long Colors[256];
	if( cColors > 256 )
		return FALSE;
	cColors = PALOBJ_cGetColors( ppalo, iStart, cColors, Colors );
	if( !cColors ||
		FAILED( ( (GPE *)dhpdev )->SetPalette( (PALETTEENTRY *)Colors,
			(unsigned short)iStart, (unsigned short)cColors ) ) )
	{
		DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvSetPalette\r\n")));

		return FALSE;
	}
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvSetPalette\r\n")));

	return TRUE;
}