gdiplus_image.cpp

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

GpStatus WINGDIPAPI
GdipImageSelectActiveFrame(GpImage *image, GDIPCONST GUID* dimensionID, UINT frameIndex)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipImageSelectActiveFrame == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipImageSelectActiveFrame);
        }
        if ( g_GdipImageSelectActiveFrame != NULL )
        {
            status = (*g_GdipImageSelectActiveFrame)(image, dimensionID, frameIndex);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipImageRotateFlipPtr)(GpImage *image, RotateFlipType rfType));
DEFINE_MEMBER(GdipImageRotateFlip);

GpStatus WINGDIPAPI
GdipImageRotateFlip(GpImage *image, RotateFlipType rfType)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipImageRotateFlip == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipImageRotateFlip);
        }
        if ( g_GdipImageRotateFlip != NULL )
        {
            status = (*g_GdipImageRotateFlip)(image, rfType);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetImagePalettePtr)(GpImage *image, ColorPalette *palette, INT size));
DEFINE_MEMBER(GdipGetImagePalette);

GpStatus WINGDIPAPI
GdipGetImagePalette(GpImage *image, ColorPalette *palette, INT size)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipGetImagePalette == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetImagePalette);
        }
        if ( g_GdipGetImagePalette != NULL )
        {
            status = (*g_GdipGetImagePalette)(image, palette, size);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipSetImagePalettePtr)(GpImage *image, GDIPCONST ColorPalette *palette));
DEFINE_MEMBER(GdipSetImagePalette);

GpStatus WINGDIPAPI
GdipSetImagePalette(GpImage *image, GDIPCONST ColorPalette *palette)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipSetImagePalette == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipSetImagePalette);
        }
        if ( g_GdipSetImagePalette != NULL )
        {
            status = (*g_GdipSetImagePalette)(image, palette);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetImagePaletteSizePtr)(GpImage *image, INT *size));
DEFINE_MEMBER(GdipGetImagePaletteSize);

GpStatus WINGDIPAPI
GdipGetImagePaletteSize(GpImage *image, INT *size)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipGetImagePaletteSize == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetImagePaletteSize);
        }
        if ( g_GdipGetImagePaletteSize != NULL )
        {
            status = (*g_GdipGetImagePaletteSize)(image, size);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetPropertyCountPtr)(GpImage *image, UINT* numOfProperty));
DEFINE_MEMBER(GdipGetPropertyCount);

GpStatus WINGDIPAPI
GdipGetPropertyCount(GpImage *image, UINT* numOfProperty)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipGetPropertyCount == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetPropertyCount);
        }
        if ( g_GdipGetPropertyCount != NULL )
        {
            status = (*g_GdipGetPropertyCount)(image, numOfProperty);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetPropertyIdListPtr)(GpImage *image, UINT numOfProperty, PROPID* list));
DEFINE_MEMBER(GdipGetPropertyIdList);

GpStatus WINGDIPAPI
GdipGetPropertyIdList(GpImage *image, UINT numOfProperty, PROPID* list)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipGetPropertyIdList == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetPropertyIdList);
        }
        if ( g_GdipGetPropertyIdList != NULL )
        {
            status = (*g_GdipGetPropertyIdList)(image, numOfProperty, list);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetPropertyItemSizePtr)(GpImage *image, PROPID propId, UINT* size));
DEFINE_MEMBER(GdipGetPropertyItemSize);

GpStatus WINGDIPAPI
GdipGetPropertyItemSize(GpImage *image, PROPID propId, UINT* size)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipGetPropertyItemSize == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetPropertyItemSize);
        }
        if ( g_GdipGetPropertyItemSize != NULL )
        {
            status = (*g_GdipGetPropertyItemSize)(image, propId, size);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetPropertyItemPtr)(GpImage *image, PROPID propId,UINT propSize,
                                   PropertyItem* buffer));
DEFINE_MEMBER(GdipGetPropertyItem);

GpStatus WINGDIPAPI
GdipGetPropertyItem(GpImage *image, PROPID propId,UINT propSize,
                    PropertyItem* buffer)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipGetPropertyItem == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetPropertyItem);
        }
        if ( g_GdipGetPropertyItem != NULL )
        {
            status = (*g_GdipGetPropertyItem)(image, propId, propSize, buffer);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetPropertySizePtr)(GpImage *image, UINT* totalBufferSize, 
                                   UINT* numProperties));
DEFINE_MEMBER(GdipGetPropertySize);

GpStatus WINGDIPAPI
GdipGetPropertySize(GpImage *image, UINT* totalBufferSize, 
                    UINT* numProperties)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipGetPropertySize == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetPropertySize);
        }
        if ( g_GdipGetPropertySize != NULL )
        {
            status = (*g_GdipGetPropertySize)(image, totalBufferSize, numProperties);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetAllPropertyItemsPtr)(GpImage *image, UINT totalBufferSize,
                                       UINT numProperties, PropertyItem* allItems));
DEFINE_MEMBER(GdipGetAllPropertyItems);

GpStatus WINGDIPAPI
GdipGetAllPropertyItems(GpImage *image, UINT totalBufferSize,
                        UINT numProperties, PropertyItem* allItems)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipGetAllPropertyItems == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetAllPropertyItems);
        }
        if ( g_GdipGetAllPropertyItems != NULL )
        {
            status = (*g_GdipGetAllPropertyItems)(image, totalBufferSize, numProperties, allItems);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipRemovePropertyItemPtr)(GpImage *image, PROPID propId));
DEFINE_MEMBER(GdipRemovePropertyItem);

GpStatus WINGDIPAPI
GdipRemovePropertyItem(GpImage *image, PROPID propId)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipRemovePropertyItem == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipRemovePropertyItem);
        }
        if ( g_GdipRemovePropertyItem != NULL )
        {
            status = (*g_GdipRemovePropertyItem)(image, propId);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipSetPropertyItemPtr)(GpImage *image, GDIPCONST PropertyItem* item));
DEFINE_MEMBER(GdipSetPropertyItem);

GpStatus WINGDIPAPI
GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipSetPropertyItem == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipSetPropertyItem);
        }
        if ( g_GdipSetPropertyItem != NULL )
        {
            status = (*g_GdipSetPropertyItem)(image, item);
        }
    }
    return status;
}


#if GDIPVER >= 0x0110
DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipFindFirstImageItemPtr)(GpImage *image, ImageItemData* item));
DEFINE_MEMBER(GdipFindFirstImageItem);

GpStatus WINGDIPAPI
GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipFindFirstImageItem == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule,GdipFindFirstImageItem);
        }
        if ( g_GdipFindFirstImageItem != NULL )
        {
            status = (*g_GdipFindFirstImageItem)(image, item);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipFindNextImageItemPtr)(GpImage *image, ImageItemData* item));
DEFINE_MEMBER(GdipFindNextImageItem);

GpStatus WINGDIPAPI
GdipFindNextImageItem(GpImage *image, ImageItemData* item)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipFindNextImageItem == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule,GdipFindNextImageItem);
        }
        if ( g_GdipFindNextImageItem != NULL )
        {
            status = (*g_GdipFindNextImageItem)(image, item);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetImageItemDataPtr)(GpImage *image, ImageItemData* item));
DEFINE_MEMBER(GdipGetImageItemData);

GpStatus WINGDIPAPI
GdipGetImageItemData(GpImage *image, ImageItemData* item)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetImageItemData == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule,GdipGetImageItemData);
        }
        if ( g_GdipGetImageItemData != NULL )
        {
            status = (*g_GdipGetImageItemData)(image, item);
        }
    }
    return status;
}
#endif //#if GDIPVER >= 0x0110


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipImageForceValidationPtr)(GpImage *image));
DEFINE_MEMBER(GdipImageForceValidation);

GpStatus WINGDIPAPI
GdipImageForceValidation(GpImage *image)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != 0 )
    {
        if ( g_GdipImageForceValidation == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipImageForceValidation);
        }
        if ( g_GdipImageForceValidation != NULL )
        {
            status = (*g_GdipImageForceValidation)(image);
        }
    }
    return status;
}

//----------------------------------------------------------------------------
// Bitmap APIs
//----------------------------------------------------------------------------


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipCreateBitmapFromStreamPtr)(IStream* stream, GpBitmap **bitmap));
DEFINE_MEMBER(GdipCreateBitmapFromStream);

#if 0/*defined(UNDER_CE)*/
GpStatus WINGDIPAPI
GdipCreateBitmapFromStreamCE(IStream* stream, GpBitmap **bitmap)
{
	GpStatus status = GenericError;
	HRESULT hr;
	IImage* image = NULL;
	IBitmapImage* ibitmap = NULL;
	ImageInfo imginfo = {0};
	BitmapData bdSrc = {0};
	RECT r;
	Rect gdirect;
	BitmapData bmpdata = {0};


	hr = g_pImgFactory->CreateImageFromStream(stream, &image);
	CHR(hr);

	hr = image->GetImageInfo(&imginfo);
	CHR(hr);

	// We convert our generic image into a new windows bitmap format
	hr = g_pImgFactory->CreateBitmapFromImage(
		image, 
		imginfo.Width, 
		imginfo.Height,
		imginfo.PixelFormat, 
		InterpolationHintDefault, &ibitmap);
	CHR(hr);

	SetRect(&r,0,0,imginfo.Width,imginfo.Height); 
	{ gdirect.X = 0; gdirect.Y = 0; gdirect.Width = imginfo.Width; gdirect.Height = imginfo.Height; }
	hr = ibitmap->LockBits(&r, ImageLockModeRead, imginfo.PixelFormat, &bdSrc);
	CHR(hr);

	// GdipCreateBitmapFromScan0 do not allocate and copy pixels
	// when we pass pixel array - so we pass NULL and then copy
	status = GdipCreateBitmapFromScan0(
		imginfo.Width, 
		imginfo.Height, 
		bdSrc.Stride, 
		imginfo.PixelFormat, 
		(BYTE *)0, bitmap);
	CSR(status);

	
	status = GdipBitmapLockBits(*bitmap, &gdirect, ImageLockModeWrite,imginfo.PixelFormat, &bmpdata);
	CSR(status);

	CopyMemory(bmpdata.Scan0, bdSrc.Scan0, bdSrc.Stride * imginfo.Height);
	status = GdipBitmapUnlockBits(*bitmap, &bmpdata);

	hr = ibitmap->UnlockBits(&bdSrc);
	
Error: