gdiplusbitmap.h

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

    IN PixelFormat format,
    IN BYTE *scan0
    )
{
    GpBitmap *bitmap = NULL;

    lastResult = DllExports::GdipCreateBitmapFromScan0(width,
                                                       height,
                                                       stride,
                                                       format,
                                                       scan0,
                                                       &bitmap);
#if defined(UNDER_CE)
	pFileStream = NULL;
	pResStream = NULL;
#endif
    SetNativeImage(bitmap);
}

inline 
Bitmap::Bitmap(
    IN INT width,
    IN INT height,
    IN PixelFormat format
    )
{
    GpBitmap *bitmap = NULL;

    lastResult = DllExports::GdipCreateBitmapFromScan0(width,
                                                       height,
                                                       0,
                                                       format,
                                                       NULL,
                                                       &bitmap);
#if defined(UNDER_CE)
	pFileStream = NULL;
	pResStream = NULL;
#endif

    SetNativeImage(bitmap);
}

inline
Bitmap::Bitmap(
    IN INT width, 
    IN INT height, 
    IN Graphics* target)
{
    GpBitmap *bitmap = NULL;

    lastResult = DllExports::GdipCreateBitmapFromGraphics(width,
                                                          height,
                                                          target->nativeGraphics,
                                                          &bitmap);
#if defined(UNDER_CE)
	pFileStream = NULL;
	pResStream = NULL;
#endif

    SetNativeImage(bitmap);
}

inline 
Bitmap::Bitmap(
    IN IDirectDrawSurface7 * surface
    )
{
    GpBitmap *bitmap = NULL;

    lastResult = DllExports::GdipCreateBitmapFromDirectDrawSurface(surface,
                                                       &bitmap);

#if defined(UNDER_CE)
	pFileStream = NULL;
	pResStream = NULL;
#endif
    SetNativeImage(bitmap);
}

inline 
Bitmap::Bitmap(
    IN const BITMAPINFO* gdiBitmapInfo, 
    IN VOID* gdiBitmapData
    )
{
    GpBitmap *bitmap = NULL;

    lastResult = DllExports::GdipCreateBitmapFromGdiDib(gdiBitmapInfo,
                                                        gdiBitmapData,
                                                        &bitmap);
#if defined(UNDER_CE)
	pFileStream = NULL;
	pResStream = NULL;
#endif
    SetNativeImage(bitmap);
}

inline 
Bitmap::Bitmap(
    IN HBITMAP hbm, 
    IN HPALETTE hpal
    )
{
    GpBitmap *bitmap = NULL;

    lastResult = DllExports::GdipCreateBitmapFromHBITMAP(hbm, hpal, &bitmap);
#if defined(UNDER_CE)
	pFileStream = NULL;
	pResStream = NULL;
#endif
    SetNativeImage(bitmap);
}

inline 
Bitmap::Bitmap(
    IN HICON hicon
    )
{
    GpBitmap *bitmap = NULL;

    lastResult = DllExports::GdipCreateBitmapFromHICON(hicon, &bitmap);
#if defined(UNDER_CE)
	pFileStream = NULL;
	pResStream = NULL;
#endif
    SetNativeImage(bitmap);
}

inline 
Bitmap::Bitmap(
    IN HINSTANCE hInstance, 
    IN const WCHAR *bitmapName
    )
{
    GpBitmap *bitmap = NULL;

    lastResult = DllExports::GdipCreateBitmapFromResource(hInstance,
                                                          bitmapName,
                                                          &bitmap);
#if defined(UNDER_CE)
		if (lastResult == NotImplemented)
		{
			pResStream = new CStreamOnResource(bitmapName);
			if ( pResStream->Init(hInstance, bitmapName) )
			{
				if (pResStream->GetResType() == RT_BITMAP) {
					// code below doesn't work - image is upside down
					/*const BITMAPINFO* pBmi = (BITMAPINFO*)pResStream->GetResData();
					lastResult = DllExports::GdipCreateBitmapFromGdiDib(
					pBmi, (void*)(pBmi+sizeof(BITMAPINFO)), &bitmap);*/
					HBITMAP hBmp = LoadBitmap(hInstance, bitmapName);
					if (hBmp)  
					{
						lastResult = DllExports::GdipCreateBitmapFromHBITMAP(hBmp, NULL, &bitmap);
					}


				}
				else if (pResStream->GetResType() == RT_GROUP_ICON) {
					lastResult = NotImplemented;
				}
				else
					lastResult = DllExports::GdipCreateBitmapFromStreamICM(pResStream, &bitmap);
			}
		}
#endif
    SetNativeImage(bitmap);
}


inline Bitmap* 
Bitmap::FromFile(
    IN const WCHAR *filename,
    IN BOOL useEmbeddedColorManagement
    )
{
    return new Bitmap(
        filename, 
        useEmbeddedColorManagement
    );
}

inline Bitmap* 
Bitmap::FromStream(
    IN IStream *stream,
    IN BOOL useEmbeddedColorManagement
    )
{
    return new Bitmap(
        stream, 
        useEmbeddedColorManagement
    );
}

inline Bitmap* 
Bitmap::FromDirectDrawSurface7(
    IN IDirectDrawSurface7* surface
    )
{
    return new Bitmap(surface);
}

inline Bitmap* 
Bitmap::FromBITMAPINFO(
    IN const BITMAPINFO* gdiBitmapInfo, 
    IN VOID* gdiBitmapData)
{
    return new Bitmap(gdiBitmapInfo, gdiBitmapData);
}

inline Bitmap* 
Bitmap::FromHBITMAP(
    IN HBITMAP hbm, 
    IN HPALETTE hpal
    )
{
    return new Bitmap(hbm, hpal);
}

inline Bitmap* 
Bitmap::FromHICON(
    IN HICON hicon
    )
{
    return new Bitmap(hicon);
}

inline Bitmap* 
Bitmap::FromResource(
    IN HINSTANCE hInstance, 
    IN const WCHAR *bitmapName)
{
    return new Bitmap(hInstance, bitmapName);
}

inline Status 
Bitmap::GetHBITMAP(
    IN const Color& colorBackground,
    OUT HBITMAP* hbmReturn
    )
{
    return SetStatus(DllExports::GdipCreateHBITMAPFromBitmap(
                                        static_cast<GpBitmap*>(nativeImage),
                                        hbmReturn,
                                        colorBackground.GetValue()));
}

inline Status 
Bitmap::GetHICON(
    OUT HICON* hiconReturn
    )
{
    return SetStatus(DllExports::GdipCreateHICONFromBitmap(
                                        static_cast<GpBitmap*>(nativeImage),
                                        hiconReturn));
}

inline Bitmap* 
Bitmap::Clone(
    IN const Rect& rect,
    IN PixelFormat format
    )
{
    return Clone(rect.X, rect.Y, rect.Width, rect.Height, format);
}

inline Bitmap* 
Bitmap::Clone(
    IN INT x,
    IN INT y,
    IN INT width,
    IN INT height,
    IN PixelFormat format
    )
{
   GpBitmap* gpdstBitmap = NULL;
   Bitmap* bitmap;

   if (SetStatus(DllExports::GdipCloneBitmapAreaI(
                               x,
                               y,
                               width,
                               height,
                               format,
                               (GpBitmap *)nativeImage,
                               &gpdstBitmap)) == Ok)
   {
       bitmap = new Bitmap(gpdstBitmap);

       if (bitmap == NULL) 
       {
           DllExports::GdipDisposeImage(gpdstBitmap);
       }

       return bitmap;
   }
   else
       return NULL;
}

inline Bitmap* 
Bitmap::Clone(
    IN const RectF& rect,
    IN PixelFormat format
    )
{
    return Clone(rect.X, rect.Y, rect.Width, rect.Height, format);
}

inline Bitmap*
Bitmap::Clone(
    IN REAL x,
    IN REAL y,
    IN REAL width,
    IN REAL height,
    IN PixelFormat format
    )
{
   GpBitmap* gpdstBitmap = NULL;
   Bitmap* bitmap;

   if (SetStatus(DllExports::GdipCloneBitmapArea(
                               x,
                               y,
                               width,
                               height,
                               format,
                               (GpBitmap *)nativeImage,
                               &gpdstBitmap)) == Ok)
   {
       bitmap = new Bitmap(gpdstBitmap);

       if (bitmap == NULL) 
       {
           DllExports::GdipDisposeImage(gpdstBitmap);
       }

       return bitmap;
   }
   else
       return NULL;
}

inline Bitmap::Bitmap(GpBitmap *nativeBitmap)
{
    lastResult = Ok;

    SetNativeImage(nativeBitmap);
}

inline Status
Bitmap::LockBits(
    IN const Rect* rect,
    IN UINT flags,
    IN PixelFormat format,
    OUT BitmapData* lockedBitmapData
)
{
    return SetStatus(DllExports::GdipBitmapLockBits(
                                    static_cast<GpBitmap*>(nativeImage),
                                    rect,
                                    flags,
                                    format,
                                    lockedBitmapData));
}

inline Status 
Bitmap::UnlockBits(
    IN BitmapData* lockedBitmapData
    )
{
    return SetStatus(DllExports::GdipBitmapUnlockBits(
                                    static_cast<GpBitmap*>(nativeImage),
                                    lockedBitmapData));
}

inline Status 
Bitmap::GetPixel(
    IN INT x, 
    IN INT y, 
    OUT Color *color) 
{
    ARGB argb;

    Status status = SetStatus(DllExports::GdipBitmapGetPixel(
        static_cast<GpBitmap *>(nativeImage),
        x, y,        
        &argb));

    if (status == Ok) 
    {
        color->SetValue(argb);
    }

    return  status;
}

inline Status 
Bitmap::SetPixel(
    IN INT x, 
    IN INT y, 
    IN const Color& color) 
{
    return SetStatus(DllExports::GdipBitmapSetPixel(
        static_cast<GpBitmap *>(nativeImage),
        x, y,
        color.GetValue()));
}

#if (GDIPVER >= 0x0110)
inline Status Image::SetAbort(GdiplusAbort *pIAbort)
{
    return SetStatus(DllExports::GdipImageSetAbort(
        nativeImage,
        pIAbort
        ));
}

inline Status
Bitmap::ConvertFormat(
    PixelFormat format,
    DitherType dithertype,
    PaletteType palettetype,
    ColorPalette *palette,
    REAL alphaThresholdPercent
    )
{
    return SetStatus(DllExports::GdipBitmapConvertFormat(
        static_cast<GpBitmap*>(nativeImage),
        format,
        dithertype,
        palettetype,
        palette,
        alphaThresholdPercent
        ));
}

inline Status 
Bitmap::InitializePalette(
    OUT ColorPalette *palette,   // output palette. must be allocated.
    PaletteType palettetype,     // palette enumeration type.
    INT optimalColors,           // how many optimal colors
    BOOL useTransparentColor,    // add a transparent color to the palette.
    Bitmap *bitmap               // optional bitmap for median cut.
    )
{
    return DllExports::GdipInitializePalette(
        palette,
        palettetype,
        optimalColors,
        useTransparentColor,
        bitmap ? static_cast<GpBitmap*>(bitmap->nativeImage) : NULL
        );
}


inline Status 
Bitmap::ApplyEffect(
    IN  Bitmap **inputs,
    IN  INT numInputs,
    IN  Effect *effect, 
    IN  RECT *ROI,                     // optional parameter.
    OUT RECT *outputRect,              // optional parameter.
    OUT Bitmap **output
)
{
    if (numInputs < 0)
    {
        return InvalidParameter;
    }
    
    GpBitmap *outputNative = NULL;
    GpBitmap **nativeInputs = new GpBitmap * [numInputs];
    
    if (NULL == nativeInputs)
    {
        return OutOfMemory;
    }
    
    for (int i = 0; i < numInputs; i++)
    {
        nativeInputs[i] = static_cast<GpBitmap*>(inputs[i]->nativeImage);
    }
    
    if (effect->auxData)
    {
        DllExports::GdipFree(effect->auxData);
        effect->auxData = NULL;
        effect->auxDataSize = 0;
    }
    
    Status status = DllExports::GdipBitmapCreateApplyEffect(
        nativeInputs,
        numInputs,
        effect->nativeEffect,
        ROI,
        outputRect,
        &outputNative,
        effect->useAuxData,
        &effect->auxData,
        &effect->auxDataSize
        );
    
    if ((Ok == status) && outputNative)
    {
        *output = new Bitmap(outputNative);
        
        if (NULL == *output)
        {
            status = OutOfMemory;
            DllExports::GdipDisposeImage(outputNative);
        }
    }
    else
    {
        *output = NULL;
    }
    
    delete [] nativeInputs;
    
    return status;
}


inline Status
Bitmap::ApplyEffect(
    Effect *effect,
    RECT *ROI
)
{
    if(effect->auxData)
    {
        DllExports::GdipFree(effect->auxData);
        effect->auxData = NULL;
        effect->auxDataSize = 0;
    }
    
    return DllExports::GdipBitmapApplyEffect(
        static_cast<GpBitmap *>(nativeImage),
        effect->nativeEffect,
        ROI,
        effect->useAuxData,
        &effect->auxData,
        &effect->auxDataSize
        );
}

inline Status
Bitmap::GetHistogram(
    IN HistogramFormat format,
    IN UINT NumberOfEntries,
    __out_bcount(sizeof(UINT)*256) UINT *channel0,
    __out_bcount(sizeof(UINT)*256) UINT *channel1,
    __out_bcount(sizeof(UINT)*256) UINT *channel2,
    __out_bcount(sizeof(UINT)*256) UINT *channel3
)
{
    return DllExports::GdipBitmapGetHistogram(
        static_cast<GpBitmap *>(nativeImage),
        format,
        NumberOfEntries,
        channel0,
        channel1,
        channel2,
        channel3
        );
}

inline Status 
Bitmap::GetHistogramSize(
    IN HistogramFormat format,
    OUT UINT *NumberOfEntries
)
{
    return DllExports::GdipBitmapGetHistogramSize(
        format,
        NumberOfEntries
        );
}

#endif // (GDIPVER >= 0x0110)


inline Status 
Bitmap::SetResolution(
    IN REAL xdpi, 
    IN REAL ydpi)
{
    return SetStatus(DllExports::GdipBitmapSetResolution(
        static_cast<GpBitmap *>(nativeImage),
        xdpi, ydpi));
}
#endif