gdiplus_image.cpp

Windows Mobile平台上使用GDI+。GDI+功能很强大

	RELEASE_OBJ(image);
	RELEASE_OBJ(ibitmap);
	return status;
}
#endif

GpStatus WINGDIPAPI
GdipCreateBitmapFromStream(IStream* stream, GpBitmap **bitmap)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipCreateBitmapFromStream == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipCreateBitmapFromStream);
        }
        if ( g_GdipCreateBitmapFromStream != NULL )
        {
            status = (*g_GdipCreateBitmapFromStream)(stream, bitmap);
#if defined(UNDER_CE)
			if (status == NotImplemented)
				status = GdipCreateBitmapFromStreamICM(stream, bitmap);
#endif
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipCreateBitmapFromFilePtr)(GDIPCONST WCHAR* filename, GpBitmap **bitmap));
DEFINE_MEMBER(GdipCreateBitmapFromFile);

#if 0
GpStatus WINGDIPAPI
GdipCreateBitmapFromFileCE(GDIPCONST WCHAR* filename, GpBitmap **bitmap)
{
	GpStatus status = GenericError;
	HRESULT hr;
	IImage* image = NULL;
	IBitmapImage* ibitmap = NULL;
	ImageInfo imginfo;
	BitmapData bdSrc = {0};
	BitmapData bdDest = {0};
	RECT r;
	Rect gdirect;
	IStream* pImageStream = NULL;

	if (!filename || !bitmap || !g_pImgFactory)
		return InvalidParameter;
	
	/*CStreamOnFile streamFile(filename, g_hBufferCE);
	GdipCreateBitmapFromStreamICM(&streamFile, bitmap);*/

	HANDLE hFile;
	 hFile = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
				  FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_NORMAL, NULL);
	 if (hFile)
	 {
		 DWORD dwResLen = GetFileSize(hFile, NULL);
		 g_hBufferCE = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD, dwResLen);
		 if (g_hBufferCE)
		 {
			 BYTE* pDest = reinterpret_cast<BYTE*> ( GlobalLock(g_hBufferCE) );
			 if (pDest)
			 {
				 //CopyMemory(pDest, pResourceData, dwResLen);
				 hr = CreateStreamOnHGlobal(g_hBufferCE,FALSE,&pImageStream);
				 if (hr == S_OK)
				 {
					 status = GdipCreateBitmapFromStreamICM(pImageStream, bitmap);
				 }
			 }
		 }
	 }


	return status;
}
#endif

GpStatus WINGDIPAPI
GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename, GpBitmap **bitmap)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipCreateBitmapFromFile == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipCreateBitmapFromFile);
        }
        if ( g_GdipCreateBitmapFromFile != NULL )
        {
            status = (*g_GdipCreateBitmapFromFile)(filename, bitmap);
//#if defined(UNDER_CE)
//			if (status == NotImplemented)
//				status = GdipCreateBitmapFromFileCE(filename, bitmap);
//#endif
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipCreateBitmapFromStreamICMPtr)(IStream* stream, GpBitmap **bitmap));
DEFINE_MEMBER(GdipCreateBitmapFromStreamICM);

GpStatus WINGDIPAPI
GdipCreateBitmapFromStreamICM(IStream* stream, GpBitmap **bitmap)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipCreateBitmapFromStreamICM == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipCreateBitmapFromStreamICM);
        }
        if ( g_GdipCreateBitmapFromStreamICM != NULL )
        {
            status = (*g_GdipCreateBitmapFromStreamICM)(stream, bitmap);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipCreateBitmapFromFileICMPtr)(GDIPCONST WCHAR* filename, GpBitmap **bitmap));
DEFINE_MEMBER(GdipCreateBitmapFromFileICM);

GpStatus WINGDIPAPI
GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename, GpBitmap **bitmap)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipCreateBitmapFromFileICM == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipCreateBitmapFromFileICM);
        }
        if ( g_GdipCreateBitmapFromFileICM != NULL )
        {
            status = (*g_GdipCreateBitmapFromFileICM)(filename, bitmap);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipCreateBitmapFromScan0Ptr)(INT width, INT height,
                         INT stride, PixelFormat format,
                         BYTE* scan0, GpBitmap** bitmap));
DEFINE_MEMBER(GdipCreateBitmapFromScan0);

GpStatus WINGDIPAPI
GdipCreateBitmapFromScan0(INT width, INT height,
                          INT stride, PixelFormat format,
                          BYTE* scan0, GpBitmap** bitmap)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipCreateBitmapFromScan0 == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipCreateBitmapFromScan0);
        }
        if ( g_GdipCreateBitmapFromScan0 != NULL )
        {
            status = (*g_GdipCreateBitmapFromScan0)(width, height, stride, format, scan0, bitmap);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipCreateBitmapFromGraphicsPtr)(INT width, INT height, GpGraphics* target,
                                            GpBitmap** bitmap));
DEFINE_MEMBER(GdipCreateBitmapFromGraphics);

GpStatus WINGDIPAPI
GdipCreateBitmapFromGraphics(INT width, INT height, GpGraphics* target,
                             GpBitmap** bitmap)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipCreateBitmapFromGraphics == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipCreateBitmapFromGraphics);
        }
        if ( g_GdipCreateBitmapFromGraphics != NULL )
        {
            status = (*g_GdipCreateBitmapFromGraphics)(width, height, target, bitmap);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipCreateBitmapFromDirectDrawSurfacePtr)(IDirectDrawSurface7* surface, GpBitmap** bitmap));
DEFINE_MEMBER(GdipCreateBitmapFromDirectDrawSurface);

GpStatus WINGDIPAPI
GdipCreateBitmapFromDirectDrawSurface(IDirectDrawSurface7* surface, GpBitmap** bitmap)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipCreateBitmapFromDirectDrawSurface == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipCreateBitmapFromDirectDrawSurface);
        }
        if ( g_GdipCreateBitmapFromDirectDrawSurface != NULL )
        {
            status = (*g_GdipCreateBitmapFromDirectDrawSurface)(surface, bitmap);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipCreateBitmapFromGdiDibPtr)(GDIPCONST BITMAPINFO* gdiBitmapInfo,
                                          VOID* gdiBitmapData, GpBitmap** bitmap));
DEFINE_MEMBER(GdipCreateBitmapFromGdiDib);

GpStatus WINGDIPAPI
GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* gdiBitmapInfo,
                           VOID* gdiBitmapData, GpBitmap** bitmap)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipCreateBitmapFromGdiDib == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipCreateBitmapFromGdiDib);
        }
        if ( g_GdipCreateBitmapFromGdiDib != NULL )
        {
            status = (*g_GdipCreateBitmapFromGdiDib)(gdiBitmapInfo, gdiBitmapData, bitmap);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipCreateBitmapFromHBITMAPPtr)(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap));
DEFINE_MEMBER(GdipCreateBitmapFromHBITMAP);

GpStatus WINGDIPAPI
GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipCreateBitmapFromHBITMAP == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipCreateBitmapFromHBITMAP);
        }
        if ( g_GdipCreateBitmapFromHBITMAP != NULL )
        {
            status = (*g_GdipCreateBitmapFromHBITMAP)(hbm, hpal, bitmap);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipCreateHBITMAPFromBitmapPtr)(GpBitmap* bitmap, HBITMAP* hbmReturn, ARGB background));
DEFINE_MEMBER(GdipCreateHBITMAPFromBitmap);

#if defined(UNDER_CE)
GpStatus WINGDIPAPI
GdipCreateHBITMAPFromBitmapCE(GpBitmap* bitmap, HBITMAP* hbmReturn, ARGB background)
{
	GpStatus status;
	DIBINFO dibInfo; 
	//BITMAPINFO bmInfo = {0};
	HBITMAP newbmp = 0;
	void *ppvBits = NULL;
	HDC hdc;

	if ((bitmap == NULL) || (hbmReturn == NULL))
		return InvalidParameter;

	memset((void*)&dibInfo, 0, sizeof(dibInfo));


	BitmapData bmpdata = {0};
	GdipGetImagePixelFormat(bitmap, &bmpdata.PixelFormat);
	GdipGetImageWidth(bitmap, &bmpdata.Width);
	GdipGetImageHeight(bitmap, &bmpdata.Height);

	/*int nCorrectedWidth = ( ( bmpdata.Width + 3 ) / 4 ) * 4;
	int nCorrectedWidth2 = BytesPerLine(bih.biWidth, bih.biBitCount) * bih.biHeight;*/

	BITMAPINFOHEADER& bih = dibInfo.bmiHeader;

	bih.biSize			= sizeof(BITMAPINFOHEADER);
	bih.biWidth			=  bmpdata.Width;
	bih.biHeight		=  bmpdata.Height;
	bih.biPlanes		= 1;
	bih.biBitCount		= GetPixelFormatSize(bmpdata.PixelFormat);
	bih.biCompression	= GetBmpCompression(bih.biBitCount);
	bih.biSizeImage		= BytesPerLine(bih.biWidth, bih.biBitCount) * bih.biHeight;
	bih.biXPelsPerMeter = 0;
	bih.biYPelsPerMeter = 0;
	bih.biClrUsed		= 0;
	bih.biClrImportant	= 0;

	dibInfo.bmiColors[0].rgbBlue = 0; 
	dibInfo.bmiColors[0].rgbGreen = 0; 
	dibInfo.bmiColors[0].rgbRed	= 0; 
	dibInfo.bmiColors[0].rgbReserved = 0; 

	// We lock source image to be able to transfer bits
	Rect gdirect(0, 0, bmpdata.Width, bmpdata.Height);
	status = GdipBitmapLockBits(bitmap, &gdirect, ImageLockModeRead |ImageLockModeWrite , bmpdata.PixelFormat, &bmpdata );
	CSR(status);

   //now create a Dib Section
	hdc = ::GetDC(NULL);
	
	newbmp = CreateDIBSection(hdc, (const BITMAPINFO*)dibInfo, DIB_RGB_COLORS, (void**)&ppvBits,0,0);
	if (newbmp != NULL) 
	{
		if ((ppvBits != NULL) && (bmpdata.Scan0 != NULL)) {
			if (bmpdata.Stride < 0)
			{
				bmpdata.Stride = bmpdata.Stride * -1;
				bmpdata.Scan0 = (void*) ( ((DWORD)bmpdata.Scan0 + bmpdata.Stride) - bih.biSizeImage);
			}
			memcpy(ppvBits, bmpdata.Scan0, bih.biSizeImage);
			*hbmReturn = newbmp;
		}
		else
			*hbmReturn = NULL;


		
	}
	::ReleaseDC(NULL, hdc);

	
   status = GdipBitmapUnlockBits(bitmap, &bmpdata );
   CSR(status);

  
Error:
   DeleteDC(hdc);

   return (*hbmReturn ? Ok : GenericError);
}

#endif



GpStatus WINGDIPAPI
GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap, HBITMAP* hbmReturn, ARGB background)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipCreateHBITMAPFromBitmap == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipCreateHBITMAPFromBitmap);
        }
        if ( g_GdipCreateHBITMAPFromBitmap != NULL )
        {
            status = (*g_GdipCreateHBITMAPFromBitmap)(bitmap, hbmReturn, background);
#if defined(UNDER_CE)
			if (status == NotImplemented)
				status = GdipCreateHBITMAPFromBitmapCE(bitmap, hbmReturn, background);
#endif
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipCreateBitmapFromHICONPtr)(HICON hicon, GpBitmap** bitmap));
DEFINE_MEMBER(GdipCreateBitmapFromHICON);

GpStatus WINGDIPAPI
GdipCreateBitmapFromHICON(HICON hicon, GpBitmap** bitmap)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipCreateBitmapFromHICON == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipCreateBitmapFromHICON);
        }
        if ( g_GdipCreateBitmapFromHICON != NULL )
        {
            status = (*g_GdipCreateBitmapFromHICON)(hicon, bitmap);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipCreateHICONFromBitmapPtr)(GpBitmap* bitmap, HICON* hbmReturn));
DEFINE_MEMBER(GdipCreateHICONFromBitmap);

GpStatus WINGDIPAPI
GdipCreateHICONFromBitmap(GpBitmap* bitmap, HICON* hbmReturn)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipCreateHICONFromBitmap == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipCreateHICONFromBitmap);
        }
        if ( g_GdipCreateHICONFromBitmap != NULL )
        {
            status = (*g_GdipCreateHICONFromBitmap)(bitmap, hbmReturn);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipCreateBitmapFromResourcePtr)(HINSTANCE hInstance, GDIPCONST WCHAR* lpBitmapName,
                         GpBitmap** bitmap));
DEFINE_MEMBER(GdipCreateBitmapFromResource);

#if defined(UNDER_CE)
GpStatus WINGDIPAPI
GdipCreateBitmapFromResourceCE(HINSTANCE hInstance, GDIPCONST WCHAR* lpBitmapName,
                             GpBitmap** bitmap)
{
	GpStatus status = GenericError;
	HRESULT hr;
	HBITMAP hbFromRes;
	HICON	hiFromRes;
	HGLOBAL hResData = NULL;
	HGLOBAL hBufferCE = NULL;
	HRSRC	hRsrc;
	DWORD	dwResLen = 0;
	BYTE*	pResourceData = NULL;
	IStream* pImageStream = NULL;