include/gdiplus/gdiplusimpl.h

/*
 * gdiplusimpl.h
 *
 * GDI+ Bitmap, CachedBitmap, CustomLineCap, Font, FontCollection, FontFamily,
 *      Image, InstalledFontCollection, PrivateFontCollection, Region
 *      implementation.  Definitions of these classes are in gdiplusheaders.h.
 *
 * This file is part of the w32api package.
 *
 * Contributors:
 *   Created by Markus Koenig <markus@stber-koenig.de>
 *
 * THIS SOFTWARE IS NOT COPYRIGHTED
 *
 * This source code is offered for use in the public domain. You may
 * use, modify or distribute it freely.
 *
 * This code is distributed in the hope that it will be useful but
 * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
 * DISCLAIMED. This includes but is not limited to warranties of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 */

#ifndef __GDIPLUS_IMPL_H
#define __GDIPLUS_IMPL_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif

#ifndef __cplusplus
#error "A C++ compiler is required to include gdiplusimpl.h."
#endif

/*
 * FIXME: I called this file gdiplusimpl.h, but what should it really be called?
 * Or did Microsoft create separate files for each class implemented here?
 */


// Image

__inline__ Image* Image::FromFile(const WCHAR *filename,
                BOOL useEmbeddedColorManagement)
{
        return new Image(filename, useEmbeddedColorManagement);
}

__inline__ Image* Image::FromStream(IStream *stream,
                BOOL useEmbeddedColorManagement)
{
        return new Image(stream, useEmbeddedColorManagement);
}

__inline__ Image::Image(const WCHAR *filename, BOOL useEmbeddedColorManagement):
        nativeImage(NULL), lastStatus(Ok)
{
        if (useEmbeddedColorManagement) {
                lastStatus = DllExports::GdipLoadImageFromFileICM(
                                filename, &nativeImage);
        } else {
                lastStatus = DllExports::GdipLoadImageFromFile(
                                filename, &nativeImage);
        }
}

__inline__ Image::Image(IStream *stream, BOOL useEmbeddedColorManagement):
        nativeImage(NULL), lastStatus(Ok)
{
        if (useEmbeddedColorManagement) {
                lastStatus = DllExports::GdipLoadImageFromStreamICM(
                                stream, &nativeImage);
        } else {
                lastStatus = DllExports::GdipLoadImageFromStream(
                                stream, &nativeImage);
        }
}

__inline__ Status Image::FindFirstItem(ImageItemData *item)
{
        // FIXME: can't test GdipFindFirstImageItem b/c it isn't exported in 1.0
        return updateStatus(DllExports::GdipFindFirstImageItem(
                        nativeImage, item));
}

__inline__ Status Image::FindNextItem(ImageItemData *item)
{
        // FIXME: can't test GdipFindFirstImageItem b/c it isn't exported in 1.0
        return updateStatus(DllExports::GdipFindNextImageItem(
                        nativeImage, item));
}

__inline__ Status Image::GetAllPropertyItems(UINT totalBufferSize,
                UINT numProperties, PropertyItem *allItems)
{
        return updateStatus(DllExports::GdipGetAllPropertyItems(
                        nativeImage, totalBufferSize, numProperties, allItems));
}

__inline__ Status Image::GetBounds(RectF *srcRect, Unit *srcUnit)
{
        return updateStatus(DllExports::GdipGetImageBounds(
                        nativeImage, srcRect, srcUnit));
}

__inline__ Status Image::GetEncoderParameterList(const CLSID *clsidEncoder,
                UINT size, EncoderParameters *buffer)
{
        return updateStatus(DllExports::GdipGetEncoderParameterList(
                        nativeImage, clsidEncoder, size, buffer));
}

__inline__ UINT Image::GetEncoderParameterListSize(const CLSID *clsidEncoder)
{
        UINT result = 0;
        updateStatus(DllExports::GdipGetEncoderParameterListSize(
                        nativeImage, clsidEncoder, &result));
        return result;
}

__inline__ UINT Image::GetFlags()
{
        UINT result = 0;
        updateStatus(DllExports::GdipGetImageFlags(nativeImage, &result));
        return result;
}

__inline__ UINT Image::GetFrameCount(const GUID *dimensionID)
{
        UINT result = 0;
        updateStatus(DllExports::GdipImageGetFrameCount(
                        nativeImage, dimensionID, &result));
        return result;
}

__inline__ UINT Image::GetFrameDimensionsCount()
{
        UINT result = 0;
        updateStatus(DllExports::GdipImageGetFrameDimensionsCount(
                        nativeImage, &result));
        return result;
}

__inline__ Status Image::GetFrameDimensionsList(GUID *dimensionIDs, UINT count)
{
        return updateStatus(DllExports::GdipImageGetFrameDimensionsList(
                        nativeImage, dimensionIDs, count));
}

__inline__ UINT Image::GetHeight()
{
        UINT result = 0;
        updateStatus(DllExports::GdipGetImageHeight(nativeImage, &result));
        return result;
}

__inline__ REAL Image::GetHorizontalResolution()
{
        REAL result = 0.0f;
        updateStatus(DllExports::GdipGetImageHorizontalResolution(
                        nativeImage, &result));
        return result;
}

__inline__ Status Image::GetItemData(ImageItemData *item)
{
        // FIXME: can't test GdipGetImageItemData b/c it isn't exported in 1.0
        return updateStatus(DllExports::GdipGetImageItemData(
                        nativeImage, item));
}

__inline__ Status Image::GetPalette(ColorPalette *palette, INT size)
{
        return updateStatus(DllExports::GdipGetImagePalette(
                        nativeImage, palette, size));
}

__inline__ INT Image::GetPaletteSize()
{
        INT result = 0;
        updateStatus(DllExports::GdipGetImagePaletteSize(nativeImage, &result));
        return result;
}

__inline__ Status Image::GetPhysicalDimension(SizeF *size)
{
        if (!size) return lastStatus = InvalidParameter;
        return updateStatus(DllExports::GdipGetImageDimension(
                        nativeImage, &size->Width, &size->Height));
}

__inline__ PixelFormat Image::GetPixelFormat()
{
        PixelFormat result = (PixelFormat) 0;
        updateStatus(DllExports::GdipGetImagePixelFormat(nativeImage, &result));
        return result;
}

__inline__ UINT Image::GetPropertyCount()
{
        UINT result = 0;
        updateStatus(DllExports::GdipGetPropertyCount(nativeImage, &result));
        return result;
}

__inline__ Status Image::GetPropertyIdList(UINT numOfProperty, PROPID *list)
{
        return updateStatus(DllExports::GdipGetPropertyIdList(
                        nativeImage, numOfProperty, list));
}

__inline__ Status Image::GetPropertyItem(PROPID propId, UINT propSize,
                PropertyItem *buffer)
{
        return updateStatus(DllExports::GdipGetPropertyItem(
                        nativeImage, propId, propSize, buffer));
}

__inline__ UINT Image::GetPropertyItemSize(PROPID propId)
{
        UINT result = 0;
        updateStatus(DllExports::GdipGetPropertyItemSize(
                        nativeImage, propId, &result));
        return result;
}

__inline__ Status Image::GetPropertySize(
                UINT *totalBufferSize, UINT *numProperties)
{
        return updateStatus(DllExports::GdipGetPropertySize(
                        nativeImage, totalBufferSize, numProperties));
}

__inline__ Status Image::GetRawFormat(GUID *format)
{
        return updateStatus(DllExports::GdipGetImageRawFormat(
                        nativeImage, format));
}

__inline__ Image* Image::GetThumbnailImage(UINT thumbWidth, UINT thumbHeight,
                GetThumbnailImageAbort callback, VOID *callbackData)
{
        GpImage *thumbImage = NULL;
        Status status = updateStatus(DllExports::GdipGetImageThumbnail(
                        nativeImage, thumbWidth, thumbHeight, &thumbImage,
                        callback, callbackData));

        if (status == Ok) {
                Image *result = new Image(thumbImage, Ok);
                if (!result) {
                        DllExports::GdipDisposeImage(thumbImage);
                        lastStatus = OutOfMemory;
                }
                return result;
        } else {
                return NULL;
        }
}

__inline__ ImageType Image::GetType() const
{
        ImageType result = ImageTypeUnknown;
        updateStatus(DllExports::GdipGetImageType(nativeImage, &result));
        return result;
}

__inline__ REAL Image::GetVerticalResolution()
{
        REAL result = 0.0f;
        updateStatus(DllExports::GdipGetImageVerticalResolution(
                        nativeImage, &result));
        return result;
}

__inline__ UINT Image::GetWidth()
{
        UINT result = 0;
        updateStatus(DllExports::GdipGetImageWidth(nativeImage, &result));
        return result;
}

__inline__ Status Image::RemovePropertyItem(PROPID propId)
{
        return updateStatus(DllExports::GdipRemovePropertyItem(
                        nativeImage, propId));
}

__inline__ Status Image::RotateFlip(RotateFlipType rotateFlipType)
{
        return updateStatus(DllExports::GdipImageRotateFlip(
                        nativeImage, rotateFlipType));
}

__inline__ Status Image::Save(const WCHAR *filename, const CLSID *clsidEncoder,
                const EncoderParameters *encoderParams)
{
        return updateStatus(DllExports::GdipSaveImageToFile(
                        nativeImage, filename, clsidEncoder, encoderParams));
}

__inline__ Status Image::Save(IStream *stream, const CLSID *clsidEncoder,
                const EncoderParameters *encoderParams)
{
        return updateStatus(DllExports::GdipSaveImageToStream(
                        nativeImage, stream, clsidEncoder, encoderParams));
}

__inline__ Status Image::SaveAdd(const EncoderParameters *encoderParams)
{
        return updateStatus(DllExports::GdipSaveAdd(
                        nativeImage, encoderParams));
}

__inline__ Status Image::SaveAdd(Image *newImage,
                const EncoderParameters *encoderParams)
{
        return updateStatus(DllExports::GdipSaveAddImage(
                        nativeImage,
                        newImage ? newImage->nativeImage : NULL,
                        encoderParams));
}

__inline__ Status Image::SelectActiveFrame(
                const GUID *dimensionID, UINT frameIndex)
{
        return updateStatus(DllExports::GdipImageSelectActiveFrame(
                        nativeImage, dimensionID, frameIndex));
}

__inline__ Status Image::SetAbort(GdiplusAbort *pIAbort)
{
        // FIXME: can't test GdipImageSetAbort because it isn't exported in 1.0
        return updateStatus(DllExports::GdipImageSetAbort(
                        nativeImage, pIAbort));
}

__inline__ Status Image::SetPalette(const ColorPalette *palette)
{
        return updateStatus(DllExports::GdipSetImagePalette(
                        nativeImage, palette));
}

__inline__ Status Image::SetPropertyItem(const PropertyItem *item)
{
        return updateStatus(DllExports::GdipSetPropertyItem(nativeImage, item));
}


// Bitmap

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

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

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

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

__inline__ Bitmap* Bitmap::FromHICON(HICON icon)
{
        return new Bitmap(icon);
}

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

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

//TODO: [GDI+ 1.1] Bitmap::ApplyEffect
//__inline__ Status Bitmap::ApplyEffect(Bitmap **inputs, INT numInputs,
//              Effect *effect, RECT *ROI, RECT *outputRect, Bitmap **output)
//{
//      return NotImplemented;
//}

__inline__ Status Bitmap::InitializePalette(ColorPalette *palette,
                PaletteType paletteType, INT optimalColors,
                BOOL useTransparentColor, Bitmap *bitmap)
{
        // FIXME: can't test GdipInitializePalette b/c it isn't exported in 1.0
        return DllExports::GdipInitializePalette(palette, paletteType,
                        optimalColors, useTransparentColor,
                        bitmap ? (GpBitmap*) bitmap->nativeImage : NULL);
}

__inline__ Bitmap::Bitmap(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData):
        Image(NULL, Ok)
{
        GpBitmap *nativeBitmap = NULL;
        lastStatus = DllExports::GdipCreateBitmapFromGdiDib(
                        gdiBitmapInfo, gdiBitmapData, &nativeBitmap);
        nativeImage = nativeBitmap;
}

__inline__ Bitmap::Bitmap(IDirectDrawSurface7 *surface): Image(NULL, Ok)
{
        GpBitmap *nativeBitmap = NULL;
        lastStatus = DllExports::GdipCreateBitmapFromDirectDrawSurface(
                        surface, &nativeBitmap);
        nativeImage = nativeBitmap;
}

__inline__ Bitmap::Bitmap(const WCHAR *filename,
                BOOL useEmbeddedColorManagement): Image(NULL, Ok)
{
        GpBitmap *nativeBitmap = NULL;
        if (useEmbeddedColorManagement) {
                lastStatus = DllExports::GdipCreateBitmapFromFileICM(
                                filename, &nativeBitmap);
        } else {
                lastStatus = DllExports::GdipCreateBitmapFromFile(
                                filename, &nativeBitmap);
        }
        nativeImage = nativeBitmap;
}

__inline__ Bitmap::Bitmap(HBITMAP hbm, HPALETTE hpal):
        Image(NULL, Ok)
{
        GpBitmap *nativeBitmap = NULL;
        lastStatus = DllExports::GdipCreateBitmapFromHBITMAP(
                        hbm, hpal, &nativeBitmap);
        nativeImage = nativeBitmap;
}

__inline__ Bitmap::Bitmap(HICON hicon):
        Image(NULL, Ok)
{
        GpBitmap *nativeBitmap = NULL;
        lastStatus = DllExports::GdipCreateBitmapFromHICON(hicon, &nativeBitmap);
        nativeImage = nativeBitmap;
}

__inline__ Bitmap::Bitmap(HINSTANCE hInstance, const WCHAR *bitmapName):
        Image(NULL, Ok)
{
        GpBitmap *nativeBitmap = NULL;
        lastStatus = DllExports::GdipCreateBitmapFromResource(
                        hInstance, bitmapName, &nativeBitmap);
        nativeImage = nativeBitmap;
}

__inline__ Bitmap::Bitmap(IStream *stream, BOOL useEmbeddedColorManagement):
        Image(NULL, Ok)
{
        GpBitmap *nativeBitmap = NULL;
        if (useEmbeddedColorManagement) {
                lastStatus = DllExports::GdipCreateBitmapFromStreamICM(
                                stream, &nativeBitmap);
        } else {
                lastStatus = DllExports::GdipCreateBitmapFromStream(
                                stream, &nativeBitmap);
        }
        nativeImage = nativeBitmap;
}

__inline__ Bitmap::Bitmap(INT width, INT height, Graphics *target):
        Image(NULL, Ok)
{
        GpBitmap *nativeBitmap = NULL;
        lastStatus = DllExports::GdipCreateBitmapFromGraphics(
                        width, height, target ? target->nativeGraphics : NULL,
                        &nativeBitmap);
        nativeImage = nativeBitmap;
}

__inline__ Bitmap::Bitmap(INT width, INT height, PixelFormat format):
        Image(NULL, Ok)
{
        GpBitmap *nativeBitmap = NULL;
        lastStatus = DllExports::GdipCreateBitmapFromScan0(
                        width, height, 0, format, NULL, &nativeBitmap);
        nativeImage = nativeBitmap;
}

__inline__ Bitmap::Bitmap(INT width, INT height, INT stride,
                PixelFormat format, BYTE *scan0): Image(NULL, Ok)
{
        GpBitmap *nativeBitmap = NULL;
        lastStatus = DllExports::GdipCreateBitmapFromScan0(
                        width, height, stride, format, scan0, &nativeBitmap);
        nativeImage = nativeBitmap;
}

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

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

__inline__ Bitmap* Bitmap::Clone(REAL x, REAL y, REAL width, REAL height,
                PixelFormat format) const
{
        GpBitmap *cloneBitmap = NULL;
        Status status = updateStatus(DllExports::GdipCloneBitmapArea(
                        x, y, width, height, format,
                        (GpBitmap*) nativeImage, &cloneBitmap));
        if (status == Ok) {
                Bitmap *result = new Bitmap(cloneBitmap, lastStatus);
                if (!result) {
                        DllExports::GdipDisposeImage(cloneBitmap);
                        lastStatus = OutOfMemory;
                }
                return result;
        } else {
                return NULL;
        }
}

__inline__ Bitmap* Bitmap::Clone(INT x, INT y, INT width, INT height,
                PixelFormat format) const
{
        GpBitmap *cloneBitmap = NULL;
        Status status = updateStatus(DllExports::GdipCloneBitmapAreaI(
                        x, y, width, height, format,
                        (GpBitmap*) nativeImage, &cloneBitmap));
        if (status == Ok) {
                Bitmap *result = new Bitmap(cloneBitmap, lastStatus);
                if (!result) {
                        DllExports::GdipDisposeImage(cloneBitmap);
                        lastStatus = OutOfMemory;
                }
                return result;
        } else {
                return NULL;
        }
}

//TODO: [GDI+ 1.1] Bitmap::ApplyEffect
//__inline__ Status Bitmap::ApplyEffect(Effect *effect, RECT *ROI)
//{
//      return NotImplemented;
//}

__inline__ Status Bitmap::ConvertFormat(PixelFormat format,
                DitherType ditherType, PaletteType paletteType,
                ColorPalette *palette, REAL alphaThresholdPercent)
{
        // FIXME: can't test GdipBitmapConvertFormat b/c it isn't exported in 1.0
        return updateStatus(DllExports::GdipBitmapConvertFormat(
                        (GpBitmap*) nativeImage, format, ditherType,
                        paletteType, palette, alphaThresholdPercent));
}

__inline__ Status Bitmap::GetHBITMAP(
                const Color& colorBackground, HBITMAP *hbmReturn) const
{
        return updateStatus(DllExports::GdipCreateHBITMAPFromBitmap(
                        (GpBitmap*) nativeImage, hbmReturn,
                        colorBackground.GetValue()));
}

__inline__ Status Bitmap::GetHICON(HICON *icon) const
{
        return updateStatus(DllExports::GdipCreateHICONFromBitmap(
                        (GpBitmap*) nativeImage, icon));
}

__inline__ Status Bitmap::GetHistogram(HistogramFormat format,
                UINT numberOfEntries,
                UINT *channel0, UINT *channel1,
                UINT *channel2, UINT *channel3) const
{
        return updateStatus(DllExports::GdipBitmapGetHistogram(
                        (GpBitmap*) nativeImage, format, numberOfEntries,
                        channel0, channel1, channel2, channel3));
}

__inline__ Status Bitmap::GetHistogramSize(HistogramFormat format,
                UINT *numberOfEntries) const
{
        return updateStatus(DllExports::GdipBitmapGetHistogramSize(
                        format, numberOfEntries));
}

__inline__ Status Bitmap::GetPixel(INT x, INT y, Color *color) const
{
        return updateStatus(DllExports::GdipBitmapGetPixel(
                        (GpBitmap*) nativeImage, x, y,
                        color ? &color->Value : NULL));
}

__inline__ Status Bitmap::LockBits(const Rect *rect, UINT flags,
                PixelFormat format, BitmapData *lockedBitmapData)
{
        return updateStatus(DllExports::GdipBitmapLockBits(
                        (GpBitmap*) nativeImage, rect, flags, format,
                        lockedBitmapData));
}

__inline__ Status Bitmap::SetPixel(INT x, INT y, const Color& color)
{
        return updateStatus(DllExports::GdipBitmapSetPixel(
                        (GpBitmap*) nativeImage, x, y, color.GetValue()));
}

__inline__ Status Bitmap::SetResolution(REAL xdpi, REAL ydpi)
{
        return updateStatus(DllExports::GdipBitmapSetResolution(
                        (GpBitmap*) nativeImage, xdpi, ydpi));
}

__inline__ Status Bitmap::UnlockBits(BitmapData *lockedBitmapData)
{
        return updateStatus(DllExports::GdipBitmapUnlockBits(
                        (GpBitmap*) nativeImage, lockedBitmapData));
}


// CachedBitmap

__inline__ CachedBitmap::CachedBitmap(Bitmap *bitmap, Graphics *graphics):
        nativeCachedBitmap(NULL), lastStatus(Ok)
{
        lastStatus = DllExports::GdipCreateCachedBitmap(
                        bitmap ? ((GpBitmap*) bitmap->nativeImage) : NULL,
                        graphics ? graphics->nativeGraphics : NULL,
                        &nativeCachedBitmap);
}

__inline__ CachedBitmap::~CachedBitmap()
{
        DllExports::GdipDeleteCachedBitmap(nativeCachedBitmap);
}


// CustomLineCap

__inline__ CustomLineCap::CustomLineCap(
                const GraphicsPath *fillPath,
                const GraphicsPath *strokePath,
                LineCap baseCap, REAL baseInset):
                nativeCustomLineCap(NULL), lastStatus(Ok)
{
        lastStatus = DllExports::GdipCreateCustomLineCap(
                        fillPath ? fillPath->nativePath : NULL,
                        strokePath ? strokePath->nativePath : NULL,
                        baseCap, baseInset, &nativeCustomLineCap);
}

__inline__ LineCap CustomLineCap::GetBaseCap() const
{
        LineCap result = LineCapFlat;
        updateStatus(DllExports::GdipGetCustomLineCapBaseCap(
                        nativeCustomLineCap, &result));
        return result;
}

__inline__ REAL CustomLineCap::GetBaseInset() const
{
        REAL result = 0.0f;
        updateStatus(DllExports::GdipGetCustomLineCapBaseInset(
                        nativeCustomLineCap, &result));
        return result;
}

__inline__ Status CustomLineCap::GetStrokeCaps(LineCap *startCap,
                LineCap *endCap) const
{
        return updateStatus(DllExports::GdipGetCustomLineCapStrokeCaps(
                        nativeCustomLineCap, startCap, endCap));
}

__inline__ LineJoin CustomLineCap::GetStrokeJoin() const
{
        LineJoin result = LineJoinMiter;
        updateStatus(DllExports::GdipGetCustomLineCapStrokeJoin(
                        nativeCustomLineCap, &result));
        return result;
}

__inline__ REAL CustomLineCap::GetWidthScale() const
{
        REAL result = 0.0f;
        updateStatus(DllExports::GdipGetCustomLineCapWidthScale(
                        nativeCustomLineCap, &result));
        return result;
}

__inline__ Status CustomLineCap::SetBaseCap(LineCap baseCap)
{
        return updateStatus(DllExports::GdipSetCustomLineCapBaseCap(
                        nativeCustomLineCap, baseCap));
}

__inline__ Status CustomLineCap::SetBaseInset(REAL inset)
{
        return updateStatus(DllExports::GdipSetCustomLineCapBaseInset(
                        nativeCustomLineCap, inset));
}

__inline__ Status CustomLineCap::SetStrokeCap(LineCap strokeCap)
{
        return updateStatus(DllExports::GdipSetCustomLineCapStrokeCaps(
                        nativeCustomLineCap, strokeCap, strokeCap));
}

__inline__ Status CustomLineCap::SetStrokeCaps(LineCap startCap, LineCap endCap)
{
        return updateStatus(DllExports::GdipSetCustomLineCapStrokeCaps(
                        nativeCustomLineCap, startCap, endCap));
}

__inline__ Status CustomLineCap::SetStrokeJoin(LineJoin lineJoin)
{
        return updateStatus(DllExports::GdipSetCustomLineCapStrokeJoin(
                        nativeCustomLineCap, lineJoin));
}

__inline__ Status CustomLineCap::SetWidthScale(REAL widthScale)
{
        return updateStatus(DllExports::GdipSetCustomLineCapWidthScale(
                        nativeCustomLineCap, widthScale));
}


// Font

__inline__ Font::Font(const FontFamily *family,
                REAL emSize, INT style, Unit unit):
                nativeFont(NULL), lastStatus(Ok)
{
        lastStatus = DllExports::GdipCreateFont(
                        family ? family->nativeFontFamily : NULL,
                        emSize, style, unit, &nativeFont);
}

__inline__ Font::Font(HDC hdc, HFONT hfont):
        nativeFont(NULL), lastStatus(Ok)
{
        LOGFONTA logfont;
        if (hfont && GetObjectA(hfont, sizeof logfont, &logfont)) {
                lastStatus = DllExports::GdipCreateFontFromLogfontA(
                                hdc, &logfont, &nativeFont);
        } else {
                lastStatus = DllExports::GdipCreateFontFromDC(
                                hdc, &nativeFont);
        }
}

__inline__ Font::Font(HDC hdc, const LOGFONTA *logfont):
        nativeFont(NULL), lastStatus(Ok)
{
        lastStatus = DllExports::GdipCreateFontFromLogfontA(
                        hdc, logfont, &nativeFont);
}

__inline__ Font::Font(HDC hdc, const LOGFONTW *logfont):
        nativeFont(NULL), lastStatus(Ok)
{
        lastStatus = DllExports::GdipCreateFontFromLogfontW(
                        hdc, logfont, &nativeFont);
}

__inline__ Font::Font(HDC hdc):
        nativeFont(NULL), lastStatus(Ok)
{
        lastStatus = DllExports::GdipCreateFontFromDC(hdc, &nativeFont);
}

__inline__ Font::Font(const WCHAR *familyName, REAL emSize, INT style,
                Unit unit, const FontCollection *fontCollection):
                nativeFont(NULL), lastStatus(Ok)
{
        GpFontFamily *nativeFamily = NULL;
        lastStatus = DllExports::GdipCreateFontFamilyFromName(
                        familyName,
                        fontCollection ? fontCollection->nativeFontCollection : NULL,
                        &nativeFamily);

        if (nativeFamily) {
                lastStatus = DllExports::GdipCreateFont(
                                nativeFamily, emSize, style, unit, &nativeFont);
                DllExports::GdipDeleteFontFamily(nativeFamily);
        }
}

__inline__ Font::~Font()
{
        DllExports::GdipDeleteFont(nativeFont);
}

__inline__ Font* Font::Clone() const
{
        GpFont *cloneFont = NULL;
        Status status = updateStatus(DllExports::GdipCloneFont(
                        nativeFont, &cloneFont));
        if (status == Ok) {
                Font *result = new Font(cloneFont, lastStatus);
                if (!result) {
                        DllExports::GdipDeleteFont(cloneFont);
                        lastStatus = OutOfMemory;
                }
                return result;
        } else {
                return NULL;
        }
}

__inline__ Status Font::GetFamily(FontFamily *family) const
{
        if (!family) return lastStatus = InvalidParameter;
        // FIXME: do we need to call GdipDeleteFontFamily first?
        return family->lastStatus = updateStatus(DllExports::GdipGetFamily(
                        nativeFont, &family->nativeFontFamily));
}

__inline__ REAL Font::GetHeight(const Graphics *graphics) const
{
        REAL result = 0.0f;
        updateStatus(DllExports::GdipGetFontHeight(
                        nativeFont, graphics ? graphics->nativeGraphics : NULL,
                        &result));
        return result;
}

__inline__ REAL Font::GetHeight(REAL dpi) const
{
        REAL result = 0.0f;
        updateStatus(DllExports::GdipGetFontHeightGivenDPI(
                        nativeFont, dpi, &result));
        return result;
}

__inline__ Status Font::GetLogFontA(const Graphics *graphics, LOGFONTA *logfontA)
const
{
        return updateStatus(DllExports::GdipGetLogFontA(
                        nativeFont, graphics ? graphics->nativeGraphics : NULL,
                        logfontA));
}

__inline__ Status Font::GetLogFontW(const Graphics *graphics, LOGFONTW *logfontW)
const
{
        return updateStatus(DllExports::GdipGetLogFontW(
                        nativeFont, graphics ? graphics->nativeGraphics : NULL,
                        logfontW));
}

__inline__ REAL Font::GetSize() const
{
        REAL result = 0.0;
        updateStatus(DllExports::GdipGetFontSize(nativeFont, &result));
        return result;
}

__inline__ INT Font::GetStyle() const
{
        INT result = FontStyleRegular;
        updateStatus(DllExports::GdipGetFontStyle(nativeFont, &result));
        return result;
}

__inline__ Unit Font::GetUnit() const
{
        Unit result = UnitPoint;
        updateStatus(DllExports::GdipGetFontUnit(nativeFont, &result));
        return result;
}


// FontCollection

__inline__ FontCollection::FontCollection():
        nativeFontCollection(NULL), lastStatus(Ok)
{
}

__inline__ Status FontCollection::GetFamilies(INT numSought,
                FontFamily *families, INT *numFound) const
{
        if (numSought <= 0 || !families || !numFound)
                return lastStatus = InvalidParameter;

        for (int i = 0; i < numSought; ++i) {
                families[i].nativeFontFamily = NULL;
                families[i].lastStatus = FontFamilyNotFound;
        }
        *numFound = 0;

        GpFontFamily **nativeFamilyArray = (GpFontFamily**)
                DllExports::GdipAlloc(numSought * sizeof (GpFontFamily*));
        if (!nativeFamilyArray)
                return lastStatus = OutOfMemory;

        Status status = updateStatus(DllExports::GdipGetFontCollectionFamilyList(
                        nativeFontCollection, numSought, nativeFamilyArray,
                        numFound));

        // FIXME: must the native GpFontFamily objects be cloned? Seems so.
        // (if this is not done, the "Creating a Private Font Collection"
        // example crashes on "delete[] pFontFamily")

        if (status == Ok) {
                for (int i = 0; i < *numFound; ++i) {
                        families[i].lastStatus =
                                updateStatus(DllExports::GdipCloneFontFamily(
                                        nativeFamilyArray[i],
                                        &families[i].nativeFontFamily));
                }
        }

        DllExports::GdipFree(nativeFamilyArray);
        return status;
}

__inline__ INT FontCollection::GetFamilyCount() const
{
        INT result = 0;
        updateStatus(DllExports::GdipGetFontCollectionFamilyCount(
                        nativeFontCollection, &result));
        return result;
}


// FontFamily

// FIXME: do FontFamily::GenericMonospace() et al. need to be thread safe?
// FIXME: maybe put parts of this in gdiplus.c

extern "C" void *_GdipFontFamilyCachedGenericMonospace;
extern "C" void *_GdipFontFamilyCachedGenericSansSerif;
extern "C" void *_GdipFontFamilyCachedGenericSerif;

__inline__ const FontFamily* FontFamily::GenericMonospace()
{
        if (!_GdipFontFamilyCachedGenericMonospace) {
                GpFontFamily *nativeFontFamily = 0;
                Status status = DllExports::GdipGetGenericFontFamilyMonospace(
                                &nativeFontFamily);
                if (status == Ok && nativeFontFamily) {
                        _GdipFontFamilyCachedGenericMonospace = (void*)
                                new FontFamily(nativeFontFamily, Ok);
                }
        }
        return (FontFamily*) _GdipFontFamilyCachedGenericMonospace;
}

__inline__ const FontFamily* FontFamily::GenericSansSerif()
{
        if (!_GdipFontFamilyCachedGenericSansSerif) {
                GpFontFamily *nativeFontFamily = 0;
                Status status = DllExports::GdipGetGenericFontFamilySansSerif(
                                &nativeFontFamily);
                if (status == Ok && nativeFontFamily) {
                        _GdipFontFamilyCachedGenericSansSerif = (void*)
                                new FontFamily(nativeFontFamily, Ok);
                }
        }
        return (FontFamily*) _GdipFontFamilyCachedGenericSansSerif;
}

__inline__ const FontFamily* FontFamily::GenericSerif()
{
        if (!_GdipFontFamilyCachedGenericSerif) {
                GpFontFamily *nativeFontFamily = 0;
                Status status = DllExports::GdipGetGenericFontFamilySerif(
                                &nativeFontFamily);
                if (status == Ok && nativeFontFamily) {
                        _GdipFontFamilyCachedGenericSerif = (void*)
                                new FontFamily(nativeFontFamily, Ok);
                }
        }
        return (FontFamily*) _GdipFontFamilyCachedGenericSerif;
}

__inline__ FontFamily::FontFamily():
        nativeFontFamily(NULL), lastStatus(Ok)
{
}

__inline__ FontFamily::FontFamily(const WCHAR *name,
                const FontCollection *fontCollection):
                nativeFontFamily(NULL), lastStatus(Ok)
{
        lastStatus = DllExports::GdipCreateFontFamilyFromName(name,
                        fontCollection ? fontCollection->nativeFontCollection : NULL,
                        &nativeFontFamily);
}

__inline__ FontFamily::~FontFamily()
{
        DllExports::GdipDeleteFontFamily(nativeFontFamily);
}

__inline__ FontFamily* FontFamily::Clone() const
{
        GpFontFamily *cloneFontFamily = NULL;
        Status status = updateStatus(DllExports::GdipCloneFontFamily(
                        nativeFontFamily, &cloneFontFamily));
        if (status == Ok) {
                FontFamily *result = new FontFamily(cloneFontFamily, lastStatus);
                if (!result) {
                        DllExports::GdipDeleteFontFamily(cloneFontFamily);
                        lastStatus = OutOfMemory;
                }
                return result;
        } else {
                return NULL;
        }
}

__inline__ UINT16 FontFamily::GetCellAscent(INT style) const
{
        UINT16 result = 0;
        updateStatus(DllExports::GdipGetCellAscent(
                        nativeFontFamily, style, &result));
        return result;
}

__inline__ UINT16 FontFamily::GetCellDescent(INT style) const
{
        UINT16 result = 0;
        updateStatus(DllExports::GdipGetCellDescent(
                        nativeFontFamily, style, &result));
        return result;
}

__inline__ UINT16 FontFamily::GetEmHeight(INT style) const
{
        UINT16 result = 0;
        updateStatus(DllExports::GdipGetEmHeight(
                        nativeFontFamily, style, &result));
        return result;
}

__inline__ Status FontFamily::GetFamilyName(WCHAR name[LF_FACESIZE],
                LANGID language) const
{
        return updateStatus(DllExports::GdipGetFamilyName(
                        nativeFontFamily, name, language));
}

__inline__ UINT16 FontFamily::GetLineSpacing(INT style) const
{
        UINT16 result = 0;
        updateStatus(DllExports::GdipGetLineSpacing(
                        nativeFontFamily, style, &result));
        return result;
}

__inline__ BOOL FontFamily::IsStyleAvailable(INT style) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsStyleAvailable(
                        nativeFontFamily, style, &result));
        return result;
}


// InstalledFontCollection

__inline__ InstalledFontCollection::InstalledFontCollection()
{
        lastStatus = DllExports::GdipNewInstalledFontCollection(
                        &nativeFontCollection);
}


// PrivateFontCollection

__inline__ PrivateFontCollection::PrivateFontCollection()
{
        lastStatus = DllExports::GdipNewPrivateFontCollection(
                        &nativeFontCollection);
}

__inline__ Status PrivateFontCollection::AddFontFile(const WCHAR *filename)
{
        return updateStatus(DllExports::GdipPrivateAddFontFile(
                        nativeFontCollection, filename));
}

__inline__ Status PrivateFontCollection::AddMemoryFont(
                const VOID *memory, INT length)
{
        return updateStatus(DllExports::GdipPrivateAddMemoryFont(
                        nativeFontCollection, memory, length));
}


// Region

__inline__ Region* Region::FromHRGN(HRGN hrgn)
{
        return new Region(hrgn);
}

__inline__ Region::Region(): nativeRegion(NULL), lastStatus(Ok)
{
        lastStatus = DllExports::GdipCreateRegion(&nativeRegion);
}

__inline__ Region::Region(const RectF& rect): nativeRegion(NULL), lastStatus(Ok)
{
        lastStatus = DllExports::GdipCreateRegionRect(&rect, &nativeRegion);
}

__inline__ Region::Region(const Rect& rect): nativeRegion(NULL), lastStatus(Ok)
{
        lastStatus = DllExports::GdipCreateRegionRectI(&rect, &nativeRegion);
}

__inline__ Region::Region(const GraphicsPath *path):
        nativeRegion(NULL), lastStatus(Ok)
{
        lastStatus = DllExports::GdipCreateRegionPath(
                        path ? path->nativePath : NULL, &nativeRegion);
}

__inline__ Region::Region(const BYTE *regionData, INT size):
        nativeRegion(NULL), lastStatus(Ok)
{
        lastStatus = DllExports::GdipCreateRegionRgnData(
                        regionData, size, &nativeRegion);
}

__inline__ Region::Region(HRGN hrgn): nativeRegion(NULL), lastStatus(Ok)
{
        lastStatus = DllExports::GdipCreateRegionHrgn(hrgn, &nativeRegion);
}

__inline__ Region::~Region()
{
        DllExports::GdipDeleteRegion(nativeRegion);
}

__inline__ Region* Region::Clone() const
{
        GpRegion *cloneRegion = NULL;
        Status status = updateStatus(DllExports::GdipCloneRegion(
                        nativeRegion, &cloneRegion));
        if (status == Ok) {
                Region *result = new Region(cloneRegion, lastStatus);
                if (!result) {
                        DllExports::GdipDeleteRegion(cloneRegion);
                        lastStatus = OutOfMemory;
                }
                return result;
        } else {
                return NULL;
        }
}

__inline__ Status Region::Complement(const RectF& rect)
{
        return updateStatus(DllExports::GdipCombineRegionRect(
                        nativeRegion, &rect, CombineModeComplement));
}

__inline__ Status Region::Complement(const Rect& rect)
{
        return updateStatus(DllExports::GdipCombineRegionRectI(
                        nativeRegion, &rect, CombineModeComplement));
}

__inline__ Status Region::Complement(const Region *region)
{
        return updateStatus(DllExports::GdipCombineRegionRegion(
                        nativeRegion, region ? region->nativeRegion : NULL,
                        CombineModeComplement));
}

__inline__ Status Region::Complement(const GraphicsPath *path)
{
        return updateStatus(DllExports::GdipCombineRegionPath(
                        nativeRegion, path ? path->nativePath : NULL,
                        CombineModeComplement));
}

__inline__ BOOL Region::Equals(const Region *region, const Graphics *graphics)
const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsEqualRegion(
                        nativeRegion, region ? region->nativeRegion : NULL,
                        graphics ? graphics->nativeGraphics : NULL, &result));
        return result;
}

__inline__ Status Region::Exclude(const RectF& rect)
{
        return updateStatus(DllExports::GdipCombineRegionRect(
                        nativeRegion, &rect, CombineModeExclude));
}

__inline__ Status Region::Exclude(const Rect& rect)
{
        return updateStatus(DllExports::GdipCombineRegionRectI(
                        nativeRegion, &rect, CombineModeExclude));
}

__inline__ Status Region::Exclude(const Region *region)
{
        return updateStatus(DllExports::GdipCombineRegionRegion(
                        nativeRegion, region ? region->nativeRegion : NULL,
                        CombineModeExclude));
}

__inline__ Status Region::Exclude(const GraphicsPath *path)
{
        return updateStatus(DllExports::GdipCombineRegionPath(
                        nativeRegion, path ? path->nativePath : NULL,
                        CombineModeExclude));
}

__inline__ Status Region::GetBounds(RectF *rect, const Graphics *graphics) const
{
        return updateStatus(DllExports::GdipGetRegionBounds(nativeRegion,
                        graphics ? graphics->nativeGraphics : NULL, rect));
}

__inline__ Status Region::GetBounds(Rect *rect, const Graphics *graphics) const
{
        return updateStatus(DllExports::GdipGetRegionBoundsI(nativeRegion,
                        graphics ? graphics->nativeGraphics : NULL, rect));
}

__inline__ Status Region::GetData(BYTE *buffer, UINT bufferSize,
                UINT *sizeFilled) const
{
        return updateStatus(DllExports::GdipGetRegionData(
                        nativeRegion, buffer, bufferSize, sizeFilled));
}

__inline__ UINT Region::GetDataSize() const
{
        UINT result = 0;
        updateStatus(DllExports::GdipGetRegionDataSize(nativeRegion, &result));
        return result;
}

__inline__ HRGN Region::GetHRGN(const Graphics *graphics) const
{
        HRGN result = NULL;
        updateStatus(DllExports::GdipGetRegionHRgn(nativeRegion,
                        graphics ? graphics->nativeGraphics : NULL, &result));
        return result;
}

__inline__ Status Region::GetRegionScans(const Matrix *matrix,
                RectF *rects, INT *count) const
{
        return updateStatus(DllExports::GdipGetRegionScans(
                        nativeRegion, rects, count,
                        matrix ? matrix->nativeMatrix : NULL));
}

__inline__ Status Region::GetRegionScans(const Matrix *matrix,
                Rect *rects, INT *count) const
{
        return updateStatus(DllExports::GdipGetRegionScansI(
                        nativeRegion, rects, count,
                        matrix ? matrix->nativeMatrix : NULL));
}

__inline__ UINT Region::GetRegionScansCount(const Matrix *matrix) const
{
        UINT result = 0;
        updateStatus(DllExports::GdipGetRegionScansCount(
                        nativeRegion, &result,
                        matrix ? matrix->nativeMatrix : NULL));
        return result;
}

__inline__ Status Region::Intersect(const RectF& rect)
{
        return updateStatus(DllExports::GdipCombineRegionRect(
                        nativeRegion, &rect, CombineModeIntersect));
}

__inline__ Status Region::Intersect(const Rect& rect)
{
        return updateStatus(DllExports::GdipCombineRegionRectI(
                        nativeRegion, &rect, CombineModeIntersect));
}

__inline__ Status Region::Intersect(const Region *region)
{
        return updateStatus(DllExports::GdipCombineRegionRegion(
                        nativeRegion, region ? region->nativeRegion : NULL,
                        CombineModeIntersect));
}

__inline__ Status Region::Intersect(const GraphicsPath *path)
{
        return updateStatus(DllExports::GdipCombineRegionPath(
                        nativeRegion, path ? path->nativePath : NULL,
                        CombineModeIntersect));
}

__inline__ BOOL Region::IsEmpty(const Graphics *graphics) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsEmptyRegion(nativeRegion,
                        graphics ? graphics->nativeGraphics : NULL, &result));
        return result;
}

__inline__ BOOL Region::IsInfinite(const Graphics *graphics) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsInfiniteRegion(nativeRegion,
                        graphics ? graphics->nativeGraphics : NULL, &result));
        return result;
}

__inline__ BOOL Region::IsVisible(REAL x, REAL y,
                const Graphics *graphics) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsVisibleRegionPoint(
                        nativeRegion, x, y,
                        graphics ? graphics->nativeGraphics : NULL, &result));
        return result;
}

__inline__ BOOL Region::IsVisible(INT x, INT y,
                const Graphics *graphics) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsVisibleRegionPointI(
                        nativeRegion, x, y,
                        graphics ? graphics->nativeGraphics : NULL, &result));
        return result;
}

__inline__ BOOL Region::IsVisible(const PointF& point,
                const Graphics *graphics) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsVisibleRegionPoint(
                        nativeRegion, point.X, point.Y,
                        graphics ? graphics->nativeGraphics : NULL, &result));
        return result;
}

__inline__ BOOL Region::IsVisible(const Point& point,
                const Graphics *graphics) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsVisibleRegionPointI(
                        nativeRegion, point.X, point.Y,
                        graphics ? graphics->nativeGraphics : NULL, &result));
        return result;
}

__inline__ BOOL Region::IsVisible(REAL x, REAL y, REAL width, REAL height,
                const Graphics *graphics) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsVisibleRegionRect(
                        nativeRegion, x, y, width, height,
                        graphics ? graphics->nativeGraphics : NULL, &result));
        return result;
}

__inline__ BOOL Region::IsVisible(INT x, INT y, INT width, INT height,
                const Graphics *graphics) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsVisibleRegionRectI(
                        nativeRegion, x, y, width, height,
                        graphics ? graphics->nativeGraphics : NULL, &result));
        return result;
}

__inline__ BOOL Region::IsVisible(const RectF& rect,
                const Graphics *graphics) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsVisibleRegionRect(
                        nativeRegion, rect.X, rect.Y, rect.Width, rect.Height,
                        graphics ? graphics->nativeGraphics : NULL, &result));
        return result;
}

__inline__ BOOL Region::IsVisible(const Rect& rect,
                const Graphics *graphics) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsVisibleRegionRectI(
                        nativeRegion, rect.X, rect.Y, rect.Width, rect.Height,
                        graphics ? graphics->nativeGraphics : NULL, &result));
        return result;
}

__inline__ Status Region::MakeEmpty()
{
        return updateStatus(DllExports::GdipSetEmpty(nativeRegion));
}

__inline__ Status Region::MakeInfinite()
{
        return updateStatus(DllExports::GdipSetInfinite(nativeRegion));
}

__inline__ Status Region::Transform(const Matrix *matrix)
{
        return updateStatus(DllExports::GdipTransformRegion(
                        nativeRegion, matrix ? matrix->nativeMatrix : NULL));
}

__inline__ Status Region::Translate(REAL dx, REAL dy)
{
        return updateStatus(DllExports::GdipTranslateRegion(
                        nativeRegion, dx, dy));
}

__inline__ Status Region::Translate(INT dx, INT dy)
{
        return updateStatus(DllExports::GdipTranslateRegionI(
                        nativeRegion, dx, dy));
}

__inline__ Status Region::Union(const RectF& rect)
{
        return updateStatus(DllExports::GdipCombineRegionRect(
                        nativeRegion, &rect, CombineModeUnion));
}

__inline__ Status Region::Union(const Rect& rect)
{
        return updateStatus(DllExports::GdipCombineRegionRectI(
                        nativeRegion, &rect, CombineModeUnion));
}

__inline__ Status Region::Union(const Region *region)
{
        return updateStatus(DllExports::GdipCombineRegionRegion(
                        nativeRegion, region ? region->nativeRegion : NULL,
                        CombineModeUnion));
}

__inline__ Status Region::Union(const GraphicsPath *path)
{
        return updateStatus(DllExports::GdipCombineRegionPath(
                        nativeRegion, path ? path->nativePath : NULL,
                        CombineModeUnion));
}

__inline__ Status Region::Xor(const RectF& rect)
{
        return updateStatus(DllExports::GdipCombineRegionRect(
                        nativeRegion, &rect, CombineModeXor));
}

__inline__ Status Region::Xor(const Rect& rect)
{
        return updateStatus(DllExports::GdipCombineRegionRectI(
                        nativeRegion, &rect, CombineModeXor));
}

__inline__ Status Region::Xor(const Region *region)
{
        return updateStatus(DllExports::GdipCombineRegionRegion(
                        nativeRegion, region ? region->nativeRegion : NULL,
                        CombineModeXor));
}

__inline__ Status Region::Xor(const GraphicsPath *path)
{
        return updateStatus(DllExports::GdipCombineRegionPath(
                        nativeRegion, path ? path->nativePath : NULL,
                        CombineModeXor));
}


// GraphicsPath

__inline__ BOOL GraphicsPath::IsOutlineVisible(REAL x, REAL y, const Pen *pen,
                const Graphics *g) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsOutlineVisiblePathPoint(
                        nativePath, x, y, pen ? pen->nativePen : NULL,
                        g ? g->nativeGraphics : NULL, &result));
        return result;
}

__inline__ BOOL GraphicsPath::IsOutlineVisible(INT x, INT y, const Pen *pen,
                const Graphics *g) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsOutlineVisiblePathPointI(
                        nativePath, x, y, pen ? pen->nativePen : NULL,
                        g ? g->nativeGraphics : NULL, &result));
        return result;
}

__inline__ BOOL GraphicsPath::IsOutlineVisible(const PointF& point, const Pen *pen,
                const Graphics *g) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsOutlineVisiblePathPoint(
                        nativePath, point.X, point.Y,
                        pen ? pen->nativePen : NULL,
                        g ? g->nativeGraphics : NULL, &result));
        return result;
}

__inline__ BOOL GraphicsPath::IsOutlineVisible(const Point& point, const Pen *pen,
                const Graphics *g) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsOutlineVisiblePathPointI(
                        nativePath, point.X, point.Y,
                        pen ? pen->nativePen : NULL,
                        g ? g->nativeGraphics : NULL, &result));
        return result;
}

__inline__ BOOL GraphicsPath::IsVisible(REAL x, REAL y, const Graphics *g) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsVisiblePathPoint(
                        nativePath, x, y,
                        g ? g->nativeGraphics : NULL, &result));
        return result;
}
__inline__ BOOL GraphicsPath::IsVisible(INT x, INT y, const Graphics *g) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsVisiblePathPointI(
                        nativePath, x, y,
                        g ? g->nativeGraphics : NULL, &result));
        return result;
}

__inline__ BOOL GraphicsPath::IsVisible(const PointF& point,
                const Graphics *g) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsVisiblePathPoint(
                        nativePath, point.X, point.Y,
                        g ? g->nativeGraphics : NULL, &result));
        return result;
}

__inline__ BOOL GraphicsPath::IsVisible(const Point& point, const Graphics *g) const
{
        BOOL result = FALSE;
        updateStatus(DllExports::GdipIsVisiblePathPointI(
                        nativePath, point.X, point.Y,
                        g ? g->nativeGraphics : NULL, &result));
        return result;
}


// PathData

__inline__ Status PathData::AllocateArrays(INT capacity)
{
        if (capacity < 0) {
                return InvalidParameter;
        } else if (Count < capacity) {
                FreeArrays();

                PointF *pointArray = (PointF*)
                        DllExports::GdipAlloc(capacity * sizeof(PointF));
                if (!pointArray)
                        return OutOfMemory;

                BYTE *typeArray = (BYTE*)
                        DllExports::GdipAlloc(capacity * sizeof(BYTE));
                if (!typeArray) {
                        DllExports::GdipFree(pointArray);
                        return OutOfMemory;
                }

                Count = capacity;
                Points = pointArray;
                Types = typeArray;
        }
        return Ok;
}

__inline__ VOID PathData::FreeArrays()
{
        if (Points) DllExports::GdipFree(Points);
        if (Types) DllExports::GdipFree(Types);
        Count = 0;
        Points = NULL;
        Types = NULL;
}

#endif /* __GDIPLUS_IMPL_H */
Revision:	1166
Committed:	Tue Oct 26 14:22:36 2021 UTC (4 years ago) by rossy
Content type:	text/x-chdr
File size:	42911 byte(s)
Log Message:	Daodan: Replace MinGW build env with an up-to-date MSYS2 env