📄 gdiplus_image.cpp

📁 Windows Mobile平台上使用GDI+。GDI+功能很强大
💻 CPP
📖 第 1 页 / 共 5 页
字号:
上一页 1 2 3 45

	 // Normally I should implement EnumResourceTypes  ...
	typedef struct { LPCTSTR resType; LPCTSTR resTypeName;} ResSection;
	ResSection res_section[] = 
	{
		{ (LPCTSTR) RT_BITMAP,		_T("BITMAP") },
		{ (LPCTSTR) RT_GROUP_ICON,	_T("ICON")	},
		{ (LPCTSTR) _T("PNG"),		_T("PNG")	},
		{ (LPCTSTR) _T("JPEG"),		_T("JPEG")	},
		{ (LPCTSTR) _T("GIF"),		_T("GIF")	},
		
	};
	

	ImageInfo imginfo = {0};
	int nBitsPerPix = 0;
	
	if (!lpBitmapName)
		return InvalidParameter;

	int i;
	for (i = 0; i < _countof(res_section); i++)
	{
		if ((hRsrc = FindResource(hInstance, lpBitmapName, res_section[i].resType)))
		{
			 dwResLen = ::SizeofResource(hInstance,hRsrc);
			 if (dwResLen > 0)
			 {
				 hResData = ::LoadResource(hInstance, hRsrc);
				 if (hResData != NULL)
				 {
					 pResourceData = (BYTE*)::LockResource(hResData);
				 }
			 }
			 break;
		}
	}
	
	if (pResourceData)
	{
		if (i == 0)
		{
			// RT_BITMAP
			const BITMAPINFO* pBmi = (BITMAPINFO*)pResourceData;
			status = GdipCreateBitmapFromGdiDib(pBmi, (void*)(pBmi+sizeof(BITMAPINFO)), bitmap);
			
		}
		else if (i == 1)
		{
			//RT_GROUP_ICON - I suppose Gdiplus cannot support icon
			// in this case use LoadIcon
			status = NotImplemented;
		}
		else
		{
			// GIF, JPEG, PNG, ...
			
			hBufferCE = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD, dwResLen);
			BYTE* pDest = reinterpret_cast<BYTE*> ( GlobalLock(hBufferCE) );
			if (pDest)
			{
				CopyMemory(pDest, pResourceData, dwResLen);
				FreeResource(hResData);

				hr = CreateStreamOnHGlobal(hBufferCE,FALSE,&pImageStream);
				if (hr == S_OK)
				{
					status = GdipCreateBitmapFromStreamICM(pImageStream, bitmap);
				}
				
			}
		}
	}
	//// //// DEBUG : Check 
	// BitmapData bmpdata = {0};
	// 
	//if (status == Ok)
	//{
	//
	// status = GdipGetImagePixelFormat((GpImage* )*bitmap, &imginfo.PixelFormat);
	// status = GdipGetImageWidth((GpImage* )*bitmap, &imginfo.Width);
	// status = GdipGetImageHeight((GpImage* )*bitmap, &imginfo.Height);
	// nBitsPerPix= GetPixelFormatSize(imginfo.PixelFormat);
	//	
	// bmpdata.Width = imginfo.Width;
	// bmpdata.Height = imginfo.Height;
	// bmpdata.PixelFormat = imginfo.PixelFormat;

	// Rect gdirect(0, 0, imginfo.Width, imginfo.Height);
	// status = GdipBitmapLockBits(*bitmap, &gdirect, ImageLockModeRead, imginfo.PixelFormat, &bmpdata );
	// status = GdipBitmapUnlockBits(*bitmap, &bmpdata );
	//}


	return status;
}
#endif

GpStatus WINGDIPAPI
GdipCreateBitmapFromResource(HINSTANCE hInstance, GDIPCONST WCHAR* lpBitmapName,
                             GpBitmap** bitmap)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipCreateBitmapFromResource == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipCreateBitmapFromResource);
        }
        if ( g_GdipCreateBitmapFromResource != NULL )
        {
            status = (*g_GdipCreateBitmapFromResource)(hInstance, lpBitmapName, bitmap);
//#if defined(UNDER_CE)
//			if (status == NotImplemented)
//				status = GdipCreateBitmapFromResourceCE(hInstance, lpBitmapName, bitmap);
//#endif
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipCloneBitmapAreaPtr)(REAL x, REAL y, REAL width, REAL height,
                                           PixelFormat format, GpBitmap *srcBitmap, GpBitmap **dstBitmap));
DEFINE_MEMBER(GdipCloneBitmapArea);

GpStatus WINGDIPAPI
GdipCloneBitmapArea(REAL x, REAL y, REAL width, REAL height,
                            PixelFormat format, GpBitmap *srcBitmap, GpBitmap **dstBitmap)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipCloneBitmapArea == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipCloneBitmapArea);
        }
        if ( g_GdipCloneBitmapArea != NULL )
        {
            status = (*g_GdipCloneBitmapArea)(x, y, width, height, format, srcBitmap, dstBitmap);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipCloneBitmapAreaIPtr)(INT x, INT y,
                         INT width, INT height, PixelFormat format,
                         GpBitmap *srcBitmap, GpBitmap **dstBitmap));
DEFINE_MEMBER(GdipCloneBitmapAreaI);

GpStatus WINGDIPAPI
GdipCloneBitmapAreaI(INT x, INT y,
                     INT width, INT height, PixelFormat format,
                     GpBitmap *srcBitmap, GpBitmap **dstBitmap)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipCloneBitmapAreaI == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipCloneBitmapAreaI);
        }
        if ( g_GdipCloneBitmapAreaI != NULL )
        {
            status = (*g_GdipCloneBitmapAreaI)(x, y, width, height, format, srcBitmap, dstBitmap);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipBitmapLockBitsPtr)(GpBitmap* bitmap, GDIPCONST GpRect* rect,
                                  UINT flags, PixelFormat format, BitmapData* lockedBitmapData));
DEFINE_MEMBER(GdipBitmapLockBits);

GpStatus WINGDIPAPI
GdipBitmapLockBits(GpBitmap* bitmap, GDIPCONST GpRect* rect,
                   UINT flags, PixelFormat format, BitmapData* lockedBitmapData)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipBitmapLockBits == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipBitmapLockBits);
        }
        if ( g_GdipBitmapLockBits != NULL )
        {
            status = (*g_GdipBitmapLockBits)(bitmap, rect, flags, format, lockedBitmapData);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipBitmapUnlockBitsPtr)(GpBitmap* bitmap, BitmapData* lockedBitmapData));
DEFINE_MEMBER(GdipBitmapUnlockBits);

GpStatus WINGDIPAPI
GdipBitmapUnlockBits(GpBitmap* bitmap, BitmapData* lockedBitmapData)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipBitmapUnlockBits == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipBitmapUnlockBits);
        }
        if ( g_GdipBitmapUnlockBits != NULL )
        {
            status = (*g_GdipBitmapUnlockBits)(bitmap, lockedBitmapData);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipBitmapGetPixelPtr)(GpBitmap* bitmap, INT x, INT y, ARGB *color));
DEFINE_MEMBER(GdipBitmapGetPixel);

GpStatus WINGDIPAPI
GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y, ARGB *color)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipBitmapGetPixel == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipBitmapGetPixel);
        }
        if ( g_GdipBitmapGetPixel != NULL )
        {
            status = (*g_GdipBitmapGetPixel)(bitmap, x, y, color);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipBitmapSetPixelPtr)(GpBitmap* bitmap, INT x, INT y, ARGB color));
DEFINE_MEMBER(GdipBitmapSetPixel);

GpStatus WINGDIPAPI
GdipBitmapSetPixel(GpBitmap* bitmap, INT x, INT y, ARGB color)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipBitmapSetPixel == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipBitmapSetPixel);
        }
        if ( g_GdipBitmapSetPixel != NULL )
        {
            status = (*g_GdipBitmapSetPixel)(bitmap, x, y, color);
        }
    }
    return status;
}


#if GDIPVER >= 0x0110
DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipImageSetAbortPtr)(
                   GpImage *pImage, GdiplusAbort *pIAbort));
DEFINE_MEMBER(GdipImageSetAbort);

GpStatus WINGDIPAPI GdipImageSetAbort(
    GpImage *pImage, 
    GdiplusAbort *pIAbort
    )
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipImageSetAbort == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule,GdipImageSetAbort);
        }
        if ( g_GdipImageSetAbort != NULL )
        {
            status = (*g_GdipImageSetAbort)(pImage, pIAbort);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGraphicsSetAbortPtr)(
                   GpGraphics *pGraphics, GdiplusAbort *pIAbort));
DEFINE_MEMBER(GdipGraphicsSetAbort);

GpStatus WINGDIPAPI GdipGraphicsSetAbort(
    GpGraphics *pGraphics, 
    GdiplusAbort *pIAbort
    )
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGraphicsSetAbort == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule,GdipGraphicsSetAbort);
        }
        if ( g_GdipGraphicsSetAbort != NULL )
        {
            status = (*g_GdipGraphicsSetAbort)(pGraphics, pIAbort);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipBitmapConvertFormatPtr)(
                   IN GpBitmap *pInputBitmap, PixelFormat format,
                   DitherType dithertype, PaletteType palettetype,
                   ColorPalette *palette, REAL alphaThresholdPercent));
DEFINE_MEMBER(GdipBitmapConvertFormat);

GpStatus WINGDIPAPI
GdipBitmapConvertFormat(
    IN GpBitmap *pInputBitmap,
    PixelFormat format,
    DitherType dithertype,
    PaletteType palettetype,
    ColorPalette *palette,
    REAL alphaThresholdPercent
    )
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipBitmapConvertFormat == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule,GdipBitmapConvertFormat);
        }
        if ( g_GdipBitmapConvertFormat != NULL )
        {
            status = (*g_GdipBitmapConvertFormat)(pInputBitmap, format, dithertype, palettetype, palette, alphaThresholdPercent);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipInitializePalettePtr)(
                   OUT ColorPalette *palette, PaletteType palettetype,
                           INT optimalColors, BOOL useTransparentColor, GpBitmap *bitmap));
DEFINE_MEMBER(GdipInitializePalette);

GpStatus WINGDIPAPI
GdipInitializePalette(
    OUT ColorPalette *palette,
    PaletteType palettetype,
    INT optimalColors,
    BOOL useTransparentColor,
    GpBitmap *bitmap
    )
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipInitializePalette == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule,GdipInitializePalette);
        }
        if ( g_GdipInitializePalette != NULL )
        {
            status = (*g_GdipInitializePalette)(palette, palettetype, optimalColors, useTransparentColor, bitmap);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipBitmapApplyEffectPtr)(
                   GpBitmap* bitmap, CGpEffect *effect, RECT *roi, BOOL useAuxData,
                   VOID **auxData, INT *auxDataSize));
DEFINE_MEMBER(GdipBitmapApplyEffect);


GpStatus WINGDIPAPI
GdipBitmapApplyEffect(
    GpBitmap* bitmap,
    CGpEffect *effect,
    RECT *roi,
    BOOL useAuxData,
    VOID **auxData,
    INT *auxDataSize
    )
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipBitmapApplyEffect == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule,GdipBitmapApplyEffect);
        }
        if ( g_GdipBitmapApplyEffect != NULL )
        {
            status = (*g_GdipBitmapApplyEffect)(bitmap, effect, roi, useAuxData, auxData, auxDataSize);
        }
    }
    return status;
}



DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipBitmapCreateApplyEffectPtr)(
                   GpBitmap **inputBitmaps,
                       INT numInputs, CGpEffect *effect, RECT *roi,
                       RECT *outputRect, GpBitmap **outputBitmap,
                       BOOL useAuxData, VOID **auxData, INT *auxDataSize));
DEFINE_MEMBER(GdipBitmapCreateApplyEffect);

GpStatus WINGDIPAPI
GdipBitmapCreateApplyEffect(
    GpBitmap **inputBitmaps,
    INT numInputs,
    CGpEffect *effect,
    RECT *roi,
    RECT *outputRect,
    GpBitmap **outputBitmap,
    BOOL useAuxData,
    VOID **auxData,
    INT *auxDataSize
)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipBitmapCreateApplyEffect == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule,GdipBitmapCreateApplyEffect);
        }
        if ( g_GdipBitmapCreateApplyEffect != NULL )
        {
            status = (*g_GdipBitmapCreateApplyEffect)(inputBitmaps, numInputs, effect, roi, outputRect, outputBitmap, useAu
上一页 1 2 3 45
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -